deepy-cli 0.2.11__tar.gz → 0.2.12__tar.gz

{deepy_cli-0.2.11 → deepy_cli-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.2.11
+Version: 0.2.12
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko

{deepy_cli-0.2.11 → deepy_cli-0.2.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.2.11"
+version = "0.2.12"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.2.11 → deepy_cli-0.2.12}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.2.11"
+__version__ = "0.2.12"
 
 
 def main() -> None:

deepy_cli-0.2.12/src/deepy/data/tools/apply_patch.md

@@ -0,0 +1,68 @@
+## apply_patch
+
+Batch structured file operations in one call.
+
+Args: `operations`.
+
+Use this when a change has multiple edits in one file, touches multiple files,
+creates/deletes/moves files, replaces a larger block, or needs one all-or-nothing
+preflight before writing. Use `edit_text` only for one small single-file exact
+edit where `old_string` and `new_string` are straightforward.
+
+Each operation is an object with a `type` and the fields relevant to that type.
+Set unrelated nullable fields to `null` when required by the schema.
+
+Supported operation types:
+
+- `create_file`: create a new text file with `file_path` and `content`.
+- `replace_file`: explicitly replace a whole existing file with `file_path`,
+  `content`, `overwrite=true`, and either `snapshot_id` or `expected_hash`.
+- `delete_file`: delete `file_path`.
+- `move_file`: move `file_path` to `destination_path`.
+- `replace_block`: replace exact `old_text` with `new_text`.
+- `insert_before`: insert `content` before exact `anchor`.
+- `insert_after`: insert `content` after exact `anchor`.
+- `replace_all`: replace every exact `old_text` match with `new_text`.
+
+Example:
+
+```json
+{
+  "operations": [
+    {
+      "type": "replace_block",
+      "file_path": "portfolio/index.html",
+      "old_text": "<p>Old bio</p>",
+      "new_text": "<p>New bio</p>",
+      "expected_occurrences": 1,
+      "destination_path": null,
+      "content": null,
+      "anchor": null,
+      "replace_all": null,
+      "overwrite": null,
+      "snapshot_id": null,
+      "expected_hash": null
+    },
+    {
+      "type": "insert_after",
+      "file_path": "portfolio/styles.css",
+      "anchor": ".about {\\n  display: grid;\\n}\\n",
+      "content": "\\n.about-tags {\\n  display: flex;\\n}\\n",
+      "expected_occurrences": 1,
+      "destination_path": null,
+      "old_text": null,
+      "new_text": null,
+      "replace_all": null,
+      "overwrite": null,
+      "snapshot_id": null,
+      "expected_hash": null
+    }
+  ]
+}
+```
+
+Deepy preflights all operations before committing file side effects, preserves
+existing encodings and line endings on updates, writes new text files as UTF-8
+without BOM, and returns per-operation, changed-file, diff, and diff-preview
+metadata. Exact text and anchor operations reject absent, ambiguous, no-op, and
+unexpected-count matches with structured diagnostics.

deepy_cli-0.2.12/src/deepy/data/tools/edit_text.md

@@ -0,0 +1,21 @@
+## edit_text
+
+Make a small exact/string edit to an existing text file.
+
+Args: `file_path`, `old_string`, `new_string`, `replace_all`,
+`expected_occurrences`, optional `snippet_id`.
+
+Use this for focused edits where the current text is known. Prefer
+`expected_occurrences` as a safety check, especially with `replace_all`. If a
+partial `read_file` returned a `snippet_id`, pass it only when you intentionally
+want to restrict the replacement to that snippet. For ordinary single-file exact
+edits, pass `file_path` and omit `snippet_id`; Deepy can internally promote a
+fresh partial read to a full-file exact edit when needed. Do not pass
+`snapshot_id` as `snippet_id`; snapshots are for stale protection, while
+snippets are only returned by partial reads.
+
+Deepy preserves the existing file encoding and line endings, rejects stale files,
+rejects no-op edits, and returns structured error metadata for missing,
+ambiguous, or count-mismatched replacements. Use `apply_patch` when there are
+multiple edits in one file, multiple files, create/delete/move operations, or a
+larger block replacement.

deepy_cli-0.2.12/src/deepy/data/tools/read_file.md

@@ -0,0 +1,16 @@
+## read_file
+
+Read files or list directories before changes.
+
+Args: `file_path`, optional `offset`, optional `limit`, optional `pages`.
+
+Text output includes line numbers. Full text reads record a managed snapshot with
+encoding, line-ending, snapshot id, and content hash metadata for later
+`edit_text`, `write_file`, or `apply_patch` calls. Partial reads return snippet
+metadata that can scope later `edit_text` calls but do not authorize unrestricted
+whole-file replacement. For normal single-file exact edits after a partial read,
+prefer `edit_text` with `file_path` and no `snippet_id`; use the snippet only
+when you need to constrain the replacement to that line range.
+
+Non-text files such as images, notebooks, and PDFs may return descriptive
+metadata, but they are not tracked for text mutation.

deepy_cli-0.2.12/src/deepy/data/tools/write_file.md

@@ -0,0 +1,13 @@
+## write_file
+
+Create a new text file or explicitly replace a whole file.
+
+Args: `file_path`, `content`, `overwrite`, optional `snapshot_id`, optional
+`expected_hash`.
+
+For new files, Deepy writes UTF-8 without BOM by default. For existing files,
+whole-file replacement requires `overwrite=true` and a fresh `snapshot_id` or
+`expected_hash` from `read_file`; this prevents accidental stale rewrites.
+
+Prefer `edit_text` for small targeted edits and `apply_patch` for structured or
+multi-file edits.

{deepy_cli-0.2.11 → deepy_cli-0.2.12}/src/deepy/prompts/system.py

@@ -43,10 +43,10 @@ def build_system_prompt(
     return f"""You are Deepy, a terminal coding agent in the user's project.
 
 Core rules:
-- Work in the repo with tools: inspect, modify, test, verify.
+- Work in the repo with tools: inspect, edit, test, verify.
 - Preserve user changes. Prefer small, verifiable edits.
-- Read existing files when you need context; exact `modify` edits can establish the managed snapshot internally.
-- Use `modify` for file changes: `content` only creates new files; existing files use `old_string`/`new_string`.
+- Read existing files when you need context; exact `edit_text` edits can establish the managed snapshot internally.
+- Use `edit_text` for one small single-file exact edit. Use structured `apply_patch.operations` when a change has multiple edits in one file, touches multiple files, creates/deletes/moves files, or replaces a larger block. Use `write_file` for new files or explicit whole-file replacement.
 - After project generators create scaffold files, read and edit the generated block instead of replacing the file.
 - Run shell commands using the Runtime context's command dialect and path style: `powershell` -> PowerShell with Windows paths; `cmd` -> cmd; `posix` -> POSIX shell.
 - Match visible thinking/reasoning language to the user's latest natural language. If the user asks in Chinese, you MUST write visible thinking/reasoning in Chinese unless they explicitly request another language. Do not switch visible thinking/reasoning to English for Chinese requests.

{deepy_cli-0.2.11 → deepy_cli-0.2.12}/src/deepy/prompts/tool_docs.py

@@ -5,8 +5,10 @@ from importlib import resources
 
 TOOL_DOC_FILES = (
     "shell.md",
-    "read.md",
-    "modify.md",
+    "read_file.md",
+    "edit_text.md",
+    "write_file.md",
+    "apply_patch.md",
     "AskUserQuestion.md",
     "WebSearch.md",
     "WebFetch.md",

{deepy_cli-0.2.11 → deepy_cli-0.2.12}/src/deepy/tools/agents.py

@@ -26,26 +26,40 @@ def build_function_tools(
         questions = args.get("questions")
         return runtime.ask_user_question(questions if isinstance(questions, list) else [])
 
-    async def invoke_read(_context: object, raw_input: str) -> str:
+    async def invoke_read_file(_context: object, raw_input: str) -> str:
         args = _tool_args(raw_input)
-        return runtime.read(
+        return runtime.read_file(
             _string_arg(args, "file_path"),
             start_line=_int_arg(args, "offset", 1),
             limit=_optional_int_arg(args, "limit"),
             pages=_optional_string_arg(args, "pages"),
         )
 
-    async def invoke_modify(_context: object, raw_input: str) -> str:
+    async def invoke_edit_text(_context: object, raw_input: str) -> str:
         args = _tool_args(raw_input)
-        return runtime.modify(
+        return runtime.edit_text(
             _optional_string_arg(args, "file_path"),
-            content=args.get("content"),
-            old=_nullable_string_arg(args, "old_string"),
-            new=_nullable_string_arg(args, "new_string"),
+            _string_arg(args, "old_string"),
+            _string_arg(args, "new_string"),
             replace_all=_bool_arg(args, "replace_all", False),
             snippet_id=_optional_string_arg(args, "snippet_id"),
+            expected_occurrences=_optional_int_arg(args, "expected_occurrences"),
         )
 
+    async def invoke_write_file(_context: object, raw_input: str) -> str:
+        args = _tool_args(raw_input)
+        return runtime.write_file(
+            _string_arg(args, "file_path"),
+            args.get("content"),
+            overwrite=_bool_arg(args, "overwrite", False),
+            snapshot_id=_optional_string_arg(args, "snapshot_id"),
+            expected_hash=_optional_string_arg(args, "expected_hash"),
+        )
+
+    async def invoke_apply_patch(_context: object, raw_input: str) -> str:
+        args = _tool_args(raw_input)
+        return runtime.apply_patch(args.get("operations"))
+
     async def invoke_web_search(_context: object, raw_input: str) -> str:
         args = _tool_args(raw_input)
         return runtime.web_search(_string_arg(args, "query"))
@@ -101,22 +115,47 @@ def build_function_tools(
             strict_json_schema=False,
         ),
         FunctionTool(
-            name="read",
-            description="Read files from the filesystem (text, images, PDFs, notebooks).",
-            params_json_schema=READ_SCHEMA,
-            on_invoke_tool=invoke_read,
-            strict_json_schema=False,
+            name="read_file",
+            description=(
+                "Read a file or directory and record managed text snapshots for later edits. "
+                "Use this before whole-file replacement or when you need context."
+            ),
+            params_json_schema=READ_FILE_SCHEMA,
+            on_invoke_tool=invoke_read_file,
+            strict_json_schema=True,
         ),
         FunctionTool(
-            name="modify",
+            name="edit_text",
             description=(
-                "Create new files or edit existing files. Use content only for files that do not "
-                "exist. For existing files, use old_string/new_string; read first when you need "
-                "to inspect context."
+                "Preferred tool for small single-file exact/string edits. Use file_path "
+                "with old_string/new_string and expected_occurrences when possible; use "
+                "snippet_id only to intentionally scope a partial-read range."
             ),
-            params_json_schema=MODIFY_SCHEMA,
-            on_invoke_tool=invoke_modify,
-            strict_json_schema=False,
+            params_json_schema=EDIT_TEXT_SCHEMA,
+            on_invoke_tool=invoke_edit_text,
+            strict_json_schema=True,
+        ),
+        FunctionTool(
+            name="write_file",
+            description=(
+                "Create a new text file or explicitly replace a whole file. Existing-file "
+                "replacement requires overwrite intent plus snapshot_id or expected_hash."
+            ),
+            params_json_schema=WRITE_FILE_SCHEMA,
+            on_invoke_tool=invoke_write_file,
+            strict_json_schema=True,
+        ),
+        FunctionTool(
+            name="apply_patch",
+            description=(
+                "Batch structured file operations. Best for multiple edits in one file, "
+                "multi-file edits, create/delete/move, or larger block replacements. "
+                "Provide an operations array using create_file, replace_file, delete_file, "
+                "move_file, replace_block, insert_before, insert_after, or replace_all."
+            ),
+            params_json_schema=APPLY_PATCH_SCHEMA,
+            on_invoke_tool=invoke_apply_patch,
+            strict_json_schema=True,
         ),
         FunctionTool(
             name="WebSearch",
@@ -172,12 +211,12 @@ def _string_arg(args: dict[str, Any], name: str) -> str:
 
 def _optional_string_arg(args: dict[str, Any], name: str) -> str | None:
     value = args.get(name)
-    return value if isinstance(value, str) and value else None
-
-
-def _nullable_string_arg(args: dict[str, Any], name: str) -> str | None:
-    value = args.get(name)
-    return value if isinstance(value, str) else None
+    if not isinstance(value, str):
+        return None
+    stripped = value.strip()
+    if not stripped or stripped.casefold() in {"null", "none", "undefined"}:
+        return None
+    return value
 
 
 def _int_arg(args: dict[str, Any], name: str, default: int) -> int:
@@ -264,111 +303,186 @@ ASK_USER_QUESTION_SCHEMA: dict[str, Any] = {
     "additionalProperties": False,
 }
 
-READ_SCHEMA: dict[str, Any] = {
+READ_FILE_SCHEMA: dict[str, Any] = {
     "type": "object",
     "properties": {
         "file_path": {
             "type": "string",
-            "description": "UNIX-style path to file",
+            "description": "Path to file or directory under the current project",
         },
         "offset": {
-            "type": "number",
-            "description": "Line number to start reading from",
+            "type": ["number", "null"],
+            "description": "Line number to start reading from; null means start at line 1",
         },
         "limit": {
-            "type": "number",
-            "description": "Number of lines to read",
+            "type": ["number", "null"],
+            "description": "Number of lines to read; null means the default limit",
         },
         "pages": {
-            "type": "string",
-            "description": (
-                'Page range for PDF files (e.g., "1-5", "3", "10-20"). Only applicable to PDF files.'
-            ),
+            "type": ["string", "null"],
+            "description": "Page range for PDF files; null for non-PDF reads",
         },
     },
-    "required": ["file_path"],
+    "required": ["file_path", "offset", "limit", "pages"],
     "additionalProperties": False,
 }
 
-MODIFY_SCHEMA: dict[str, Any] = {
+EDIT_TEXT_SCHEMA: dict[str, Any] = {
     "type": "object",
     "properties": {
         "file_path": {
-            "type": "string",
-            "description": "Absolute path to file. Optional when snippet_id scopes an existing edit.",
+            "type": ["string", "null"],
+            "description": "Path to file. Use null when snippet_id scopes the edit.",
         },
         "snippet_id": {
-            "type": "string",
-            "description": (
-                "Snippet id returned by the Read or Modify tool to scope the search range after "
-                "a partial read."
-            ),
-        },
-        "content": {
-            "type": "string",
-            "description": (
-                "Complete content for a new file only. Do not use for existing files; read the file "
-                "and use old_string/new_string instead."
-            ),
+            "type": ["string", "null"],
+            "description": "Snippet id returned by read_file to scope the edit.",
         },
         "old_string": {
             "type": "string",
-            "description": "Exact existing text to replace inside the file or snippet scope",
+            "description": "Exact existing text to replace.",
         },
         "new_string": {
             "type": "string",
-            "description": "Replacement text for old_string",
+            "description": "Replacement text. Must change file content.",
         },
         "replace_all": {
             "type": "boolean",
-            "description": "Replace all occurrences of old_string (default false)",
-            "default": False,
+            "description": "Replace all occurrences of old_string.",
         },
         "expected_occurrences": {
-            "type": "number",
-            "description": (
-                "Expected number of matches, especially useful as a safety check with replace_all"
-            ),
+            "type": ["number", "null"],
+            "description": "Expected number of matches; null skips this safety check.",
         },
     },
-    "required": [],
+    "required": [
+        "file_path",
+        "snippet_id",
+        "old_string",
+        "new_string",
+        "replace_all",
+        "expected_occurrences",
+    ],
     "additionalProperties": False,
 }
 
-EDIT_SCHEMA: dict[str, Any] = {
+WRITE_FILE_SCHEMA: dict[str, Any] = {
     "type": "object",
     "properties": {
         "file_path": {
             "type": "string",
-            "description": "Absolute path to file. Optional when snippet_id is provided.",
+            "description": "Path to the file under the current project.",
         },
-        "snippet_id": {
+        "content": {
             "type": "string",
-            "description": (
-                "Snippet id returned by the Read or Edit tool to scope the search range after a partial read."
-            ),
+            "description": "Complete file content.",
         },
-        "old_string": {
+        "overwrite": {
+            "type": "boolean",
+            "description": "Explicit intent to replace an existing file.",
+        },
+        "snapshot_id": {
+            "type": ["string", "null"],
+            "description": "Snapshot id returned by read_file for existing-file replacement.",
+        },
+        "expected_hash": {
+            "type": ["string", "null"],
+            "description": "Content hash returned by read_file for existing-file replacement.",
+        },
+    },
+    "required": ["file_path", "content", "overwrite", "snapshot_id", "expected_hash"],
+    "additionalProperties": False,
+}
+
+APPLY_PATCH_OPERATION_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "type": {
             "type": "string",
-            "description": "Exact text to replace inside the file or snippet scope",
+            "enum": [
+                "create_file",
+                "replace_file",
+                "delete_file",
+                "move_file",
+                "replace_block",
+                "insert_before",
+                "insert_after",
+                "replace_all",
+            ],
+            "description": "Structured file operation type.",
         },
-        "new_string": {
+        "file_path": {
             "type": "string",
-            "description": "Replacement text (must differ from old_string)",
+            "description": "Path to the source or target file under the current project.",
         },
-        "replace_all": {
-            "type": "boolean",
-            "description": "Replace all occurences of old_string (default false)",
-            "default": False,
+        "destination_path": {
+            "type": ["string", "null"],
+            "description": "Destination path for move_file; null for other operations.",
+        },
+        "content": {
+            "type": ["string", "null"],
+            "description": "File content for create_file/replace_file or inserted content for insert operations.",
+        },
+        "old_text": {
+            "type": ["string", "null"],
+            "description": "Exact text to replace for replace_block or replace_all.",
+        },
+        "new_text": {
+            "type": ["string", "null"],
+            "description": "Replacement text for replace_block or replace_all.",
+        },
+        "anchor": {
+            "type": ["string", "null"],
+            "description": "Exact anchor text for insert_before or insert_after.",
         },
         "expected_occurrences": {
-            "type": "number",
-            "description": (
-                "Expected number of matches, especially useful as a safety check with replace_all"
-            ),
+            "type": ["integer", "null"],
+            "description": "Expected match count for exact text or anchor operations.",
+        },
+        "replace_all": {
+            "type": ["boolean", "null"],
+            "description": "Whether to apply a block or insertion operation to every matching occurrence.",
+        },
+        "overwrite": {
+            "type": ["boolean", "null"],
+            "description": "Explicit overwrite intent for replace_file.",
+        },
+        "snapshot_id": {
+            "type": ["string", "null"],
+            "description": "Snapshot id returned by read_file for replace_file.",
+        },
+        "expected_hash": {
+            "type": ["string", "null"],
+            "description": "Content hash returned by read_file for replace_file.",
+        },
+    },
+    "required": [
+        "type",
+        "file_path",
+        "destination_path",
+        "content",
+        "old_text",
+        "new_text",
+        "anchor",
+        "expected_occurrences",
+        "replace_all",
+        "overwrite",
+        "snapshot_id",
+        "expected_hash",
+    ],
+    "additionalProperties": False,
+}
+
+APPLY_PATCH_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "operations": {
+            "type": "array",
+            "description": "Structured file operations to preflight and commit as one logical patch.",
+            "items": APPLY_PATCH_OPERATION_SCHEMA,
         },
     },
-    "required": ["old_string", "new_string"],
+    "required": ["operations"],
     "additionalProperties": False,
 }