mirror of
https://github.com/agentscope-ai/ReMe.git
synced 2026-09-07 08:26:06 +00:00
041f957a7f
* refactor(components): extract shared component state into mixin - Introduce ComponentMixin class with shared state for components and steps - Move identity, config, and vault path functionality to ComponentMixin - Update BaseComponent to inherit from ComponentMixin - Update BaseStep to inherit from ComponentMixin - Consolidate vault path helper methods in ComponentMixin - Remove duplicate vault path implementations from BaseComponent and BaseStep - Add ComponentMixin to components module exports * refactor(file_io): implement path locks cache eviction mechanism - Add _PATH_LOCKS_MAX constant set to 1024 for cache size limit - Implement cache eviction logic when locks exceed maximum capacity - Remove half of unlocked entries when cache limit is reached - Use list comprehension to identify unlocked locks for removal - Maintain existing path normalization and locking behavior fix(edit): correct method call from public to private fail method - Change self.fail to self._fail for internal error handling - Maintain consistent private method usage within class fix(mcp_client): change pop to get for optional command and args - Replace kwargs.pop with kwargs.get to avoid removing keys - Preserve original kwargs dictionary contents - Maintain default empty string and list values feat(reme): add client backend validation with error raising - Check if client_cls is None before instantiation - Raise ValueError with descriptive message for unknown backends - Provide clear error feedback for invalid backend configurations * fix(components): move directory creation to start method - Moved component_metadata_path.mkdir call from __init__ to _start in base_keyword_index - Moved component_metadata_path.mkdir call from __init__ to _start in local_file_graph - Moved component_metadata_path.mkdir call from __init__ to _start in local_file_store - Ensures directory creation happens after component initialization - Prevents potential issues with path creation during object construction * fix(steps): replace assertions with runtime errors for app_context validation - Replace assert statements with explicit RuntimeError exceptions when app_context is None - Add descriptive error messages for better debugging when resolving components - Replace assert in resolve_component method with proper exception handling - Replace assert in get_file_parser method with proper exception handling - Maintain same functionality while improving error reporting clarity * refactor(file_io): split file IO utilities into modular components - Move daily note helpers to separate _daily_index module - Extract path validation and resolution to new _path module - Remove unused code and imports from _file_io module - Update import statements across affected modules - Introduce WikilinkHandler utility for link parsing - Replace regex-based link extraction with WikilinkHandler - Add integration JSONL files to gitignore - Consolidate file locking mechanism in _file_io module * style(formatter): fix spacing issues in file IO and chunked file parser - Fixed whitespace around colon in slice notation in file_io.py - Corrected spacing around colon in slice notation in chunked_file_parser.py - Applied consistent formatting for array slicing operations - Improved code readability by standardizing space placement in ranges * refactor(steps): replace property-based component resolution with Ref descriptor - Introduce Ref descriptor class for lazy component dependency resolution - Replace _resolve method and individual properties with Ref descriptors - Add as_llm, as_llm_formatter, as_token_counter, file_store, and embedding Ref attributes - Remove legacy property methods and resolve logic from BaseStep - Add cache clearing mechanism for Ref values during step calls - Update UpdateCatalogStep to use Ref instead of property-based resolution
107 lines
4.1 KiB
Python
107 lines
4.1 KiB
Python
"""Write a markdown file with a small, fixed front matter (``name``, ``description``)."""
|
|
|
|
import frontmatter
|
|
|
|
from ._file_io import detect_file_encoding, get_path_lock, write_file_safe
|
|
from ._path import NON_MD_WARNING, gate_md, resolve_path
|
|
from ..base_step import BaseStep
|
|
from ...components import R
|
|
|
|
|
|
@R.register("write_step")
|
|
class WriteStep(BaseStep):
|
|
"""Write (create or overwrite) a markdown file.
|
|
|
|
Frontmatter accepts two reserved string fields (``name`` / ``description``)
|
|
plus an optional free-form ``metadata`` dict whose entries are expanded
|
|
into the frontmatter as-is. ``name`` / ``description`` keys inside
|
|
``metadata`` are ignored — only the top-level explicit parameters are
|
|
honored for those two reserved fields.
|
|
|
|
Concurrency: in-process per-path ``asyncio.Lock`` serializes concurrent
|
|
writes to the same file (multi-worker / multi-process safety is out of
|
|
scope).
|
|
"""
|
|
|
|
def _fail(self, message: str, **meta) -> None:
|
|
assert self.context is not None
|
|
self.context.response.success = False
|
|
self.context.response.answer = f"Error: {message}"
|
|
if meta:
|
|
self.context.response.metadata.update(meta)
|
|
|
|
async def execute(self): # pylint: disable=too-many-return-statements
|
|
assert self.context is not None
|
|
raw = str(self.context.get("path") or "")
|
|
content = self.context.get("content")
|
|
content = "" if content is None else str(content)
|
|
metadata_raw = self.context.get("metadata")
|
|
|
|
target, err = resolve_path(self.vault_path, raw)
|
|
if err:
|
|
self._fail(err)
|
|
return None
|
|
|
|
target, is_md = gate_md(target)
|
|
|
|
# Non-markdown files have no frontmatter convention: name/description
|
|
# and metadata are silently dropped and the body is written verbatim.
|
|
if is_md:
|
|
meta: dict = {}
|
|
# Expand `metadata` dict first, skipping the two reserved keys.
|
|
if isinstance(metadata_raw, dict):
|
|
for k, v in metadata_raw.items():
|
|
if k in ("name", "description"):
|
|
continue
|
|
if v is None:
|
|
continue
|
|
meta[str(k)] = v
|
|
# Layer explicit name/description on top (always wins).
|
|
for key in ("name", "description"):
|
|
value = self.context.get(key)
|
|
if value is None:
|
|
continue
|
|
s = str(value).strip()
|
|
if not s:
|
|
continue
|
|
meta[key] = s
|
|
|
|
if meta:
|
|
post = frontmatter.Post(content, **meta)
|
|
body = frontmatter.dumps(post)
|
|
else:
|
|
body = content
|
|
if not body.endswith("\n"):
|
|
body += "\n"
|
|
else:
|
|
body = content
|
|
|
|
lock = await get_path_lock(target)
|
|
async with lock:
|
|
existed = target.exists()
|
|
# Preserve the existing file's encoding when overwriting (e.g. GBK
|
|
# CSV stays GBK). New files are written as UTF-8.
|
|
encoding = await detect_file_encoding(target) if existed else "utf-8"
|
|
try:
|
|
await write_file_safe(target, body, encoding=encoding)
|
|
except Exception as e: # pylint: disable=broad-except
|
|
self._fail(f"write failed: {e}", path=str(target))
|
|
return None
|
|
|
|
try:
|
|
nbytes = len(body.encode(encoding))
|
|
except (UnicodeEncodeError, LookupError):
|
|
nbytes = len(body.encode("utf-8"))
|
|
self.context.response.success = True
|
|
if existed:
|
|
answer = f"Wrote {target} ({nbytes} bytes) [system notice: target already existed and was overwritten]"
|
|
else:
|
|
answer = f"Wrote {target} ({nbytes} bytes)"
|
|
if not is_md:
|
|
answer = f"{answer} [system notice: {NON_MD_WARNING}]"
|
|
self.context.response.answer = answer
|
|
self.logger.info(
|
|
f"[{self.name}] wrote path={target} bytes={nbytes} encoding={encoding} "
|
|
f"overwritten={existed} is_md={is_md}",
|
|
)
|
|
return self.context.response
|