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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.2.10
+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.10 → deepy_cli-0.2.12}/pyproject.toml

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

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

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.2.10"
+__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.10 → 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.10 → 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.12/src/deepy/session_cost.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import urllib.parse
+from decimal import Decimal, InvalidOperation
+from typing import Any, Mapping
+
+from deepy.config import Settings
+
+
+def should_track_session_cost(settings: Settings) -> bool:
+    if not settings.model.api_key:
+        return False
+    parsed = urllib.parse.urlparse(settings.model.base_url)
+    return parsed.scheme in {"http", "https"} and parsed.hostname == "api.deepseek.com"
+
+
+def balance_snapshot_to_dict(balance: Any, *, captured_at_ms: int) -> dict[str, Any]:
+    unavailable_reason = _string_or_none(_field(balance, "unavailable_reason"))
+    if unavailable_reason:
+        return {
+            "capturedAt": captured_at_ms,
+            "unavailableReason": unavailable_reason,
+        }
+
+    infos: list[dict[str, str]] = []
+    for item in _field(balance, "balance_infos") or ():
+        currency = _string_or_none(_field(item, "currency"))
+        total = _string_or_none(_field(item, "total_balance"))
+        granted = _string_or_none(_field(item, "granted_balance"))
+        topped_up = _string_or_none(_field(item, "topped_up_balance"))
+        if None in (currency, total, granted, topped_up):
+            return {
+                "capturedAt": captured_at_ms,
+                "unavailableReason": "invalid balance snapshot",
+            }
+        infos.append(
+            {
+                "currency": currency or "",
+                "totalBalance": total or "",
+                "grantedBalance": granted or "",
+                "toppedUpBalance": topped_up or "",
+            }
+        )
+    is_available = _field(balance, "is_available")
+    return {
+        "capturedAt": captured_at_ms,
+        "isAvailable": is_available if isinstance(is_available, bool) else None,
+        "balanceInfos": infos,
+    }
+
+
+def start_session_cost(snapshot: Mapping[str, Any]) -> dict[str, Any]:
+    cost: dict[str, Any] = {
+        "attempted": True,
+        "start": dict(snapshot),
+    }
+    if reason := _snapshot_unavailable_reason(snapshot):
+        cost["unavailableReason"] = f"start {reason}"
+    return cost
+
+
+def complete_session_cost(
+    existing: Mapping[str, Any] | None,
+    end_snapshot: Mapping[str, Any],
+) -> dict[str, Any]:
+    cost: dict[str, Any] = dict(existing or {})
+    cost["attempted"] = True
+    cost["end"] = dict(end_snapshot)
+    start = cost.get("start")
+    if not isinstance(start, Mapping):
+        cost["amounts"] = []
+        cost["unavailableReason"] = "start snapshot missing"
+        return cost
+    amounts, reason = compute_session_cost_amounts(start, end_snapshot)
+    cost["amounts"] = amounts
+    if reason:
+        cost["unavailableReason"] = reason
+    else:
+        cost.pop("unavailableReason", None)
+    return cost
+
+
+def compute_session_cost_amounts(
+    start_snapshot: Mapping[str, Any],
+    end_snapshot: Mapping[str, Any],
+) -> tuple[list[dict[str, str]], str | None]:
+    if reason := _snapshot_unavailable_reason(start_snapshot):
+        return [], f"start {reason}"
+    if reason := _snapshot_unavailable_reason(end_snapshot):
+        return [], f"end {reason}"
+
+    start_infos = _snapshot_infos_by_currency(start_snapshot)
+    end_infos = _snapshot_infos_by_currency(end_snapshot)
+    if start_infos is None or end_infos is None:
+        return [], "invalid balance snapshot"
+    shared = [currency for currency in start_infos if currency in end_infos]
+    if not shared:
+        return [], "currency mismatch"
+
+    amounts: list[dict[str, str]] = []
+    for currency in shared:
+        start_total_text = start_infos[currency]
+        end_total_text = end_infos[currency]
+        start_total = _decimal(start_total_text)
+        end_total = _decimal(end_total_text)
+        if start_total is None or end_total is None:
+            return [], "invalid balance amount"
+        spent = start_total - end_total
+        if spent > 0:
+            amounts.append(
+                {
+                    "currency": currency,
+                    "startTotal": start_total_text,
+                    "endTotal": end_total_text,
+                    "spent": _format_decimal(spent),
+                }
+            )
+    if not amounts:
+        return [], "no measurable spend"
+    return amounts, None
+
+
+def format_session_cost(cost: Any) -> str | None:
+    if not isinstance(cost, Mapping) or not cost.get("attempted"):
+        return None
+    amounts = cost.get("amounts")
+    if isinstance(amounts, list) and amounts:
+        parts: list[str] = []
+        for item in amounts:
+            if not isinstance(item, Mapping):
+                continue
+            currency = _string_or_none(item.get("currency"))
+            spent = _string_or_none(item.get("spent"))
+            if currency and spent:
+                parts.append(f"{currency} {spent}")
+        if parts:
+            return f"{', '.join(parts)} (DeepSeek balance delta)"
+    reason = _string_or_none(cost.get("unavailableReason")) or "unknown"
+    return f"unavailable ({reason})"
+
+
+def _field(value: Any, name: str) -> Any:
+    if isinstance(value, Mapping):
+        return value.get(name)
+    return getattr(value, name, None)
+
+
+def _string_or_none(value: Any) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def _snapshot_unavailable_reason(snapshot: Mapping[str, Any]) -> str | None:
+    return _string_or_none(snapshot.get("unavailableReason"))
+
+
+def _snapshot_infos_by_currency(snapshot: Mapping[str, Any]) -> dict[str, str] | None:
+    raw_infos = snapshot.get("balanceInfos")
+    if not isinstance(raw_infos, list):
+        return None
+    infos: dict[str, str] = {}
+    for item in raw_infos:
+        if not isinstance(item, Mapping):
+            return None
+        currency = _string_or_none(item.get("currency"))
+        total = _string_or_none(item.get("totalBalance"))
+        if not currency or total is None:
+            return None
+        infos[currency] = total
+    return infos
+
+
+def _decimal(value: str) -> Decimal | None:
+    try:
+        return Decimal(value)
+    except (InvalidOperation, ValueError):
+        return None
+
+
+def _format_decimal(value: Decimal) -> str:
+    text = format(value.normalize(), "f")
+    if "." not in text:
+        return text
+    return text.rstrip("0").rstrip(".") or "0"

{deepy_cli-0.2.10 → deepy_cli-0.2.12}/src/deepy/sessions/jsonl.py

@@ -40,6 +40,7 @@ class SessionEntry:
     pending_tokens: int = 0
     last_usage_record_count: int | None = None
     todo_state: list[dict[str, str]] | None = None
+    session_cost: dict[str, Any] | None = None
 
 
 def project_code(project_root: Path) -> str:
@@ -160,6 +161,7 @@ class DeepyJsonlSession:
             pending_tokens=0,
             last_usage_record_count=0,
             todo_state=[],
+            session_cost=None,
         )
 
     def record_usage(self, usage: TokenUsage | dict[str, Any] | None) -> None:
@@ -207,6 +209,32 @@ class DeepyJsonlSession:
             ) + max(elapsed_ms, 0)
         self._touch_index(input_suggestion_usage=accumulated)
 
+    def record_session_cost_start(self, snapshot: dict[str, Any]) -> None:
+        from deepy.session_cost import start_session_cost
+
+        previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        previous_cost = previous.get("sessionCost") if previous else None
+        if isinstance(previous_cost, dict) and isinstance(previous_cost.get("start"), dict):
+            return
+        self._touch_index(session_cost=start_session_cost(snapshot))
+
+    def record_session_cost_end(self, snapshot: dict[str, Any]) -> None:
+        from deepy.session_cost import complete_session_cost
+
+        previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        previous_cost = previous.get("sessionCost") if previous else None
+        self._touch_index(
+            session_cost=complete_session_cost(
+                previous_cost if isinstance(previous_cost, dict) else None,
+                snapshot,
+            )
+        )
+
+    def session_cost(self) -> dict[str, Any] | None:
+        previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        cost = previous.get("sessionCost") if previous else None
+        return cost if isinstance(cost, dict) else None
+
     def context_token_state(
         self,
         records: list[dict[str, Any]] | None = None,
@@ -361,6 +389,7 @@ class DeepyJsonlSession:
         last_usage_record_count: int | None = None,
         todo_state: object = _UNSET,
         input_suggestion_usage: dict[str, Any] | None = None,
+        session_cost: object = _UNSET,
     ) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         index_path = self.path.parent / "sessions-index.json"
@@ -432,6 +461,11 @@ class DeepyJsonlSession:
             ),
             **({"processes": previous["processes"]} if "processes" in previous else {}),
         }
+        if session_cost is _UNSET:
+            if isinstance(previous.get("sessionCost"), dict):
+                entry["sessionCost"] = previous["sessionCost"]
+        elif isinstance(session_cost, dict):
+            entry["sessionCost"] = session_cost
         if todo_state is _UNSET:
             if "todoState" in previous:
                 entry["todoState"] = previous["todoState"]
@@ -498,6 +532,7 @@ def list_session_entries(project_root: Path, deepy_home: Path | None = None) ->
             path = f"{session_id}.jsonl"
         usage = item.get("usage")
         input_suggestion_usage = item.get("inputSuggestionUsage")
+        session_cost = item.get("sessionCost")
         entries.append(
             SessionEntry(
                 id=session_id,
@@ -515,6 +550,7 @@ def list_session_entries(project_root: Path, deepy_home: Path | None = None) ->
                 pending_tokens=_coerce_int(item.get("pendingTokens"), 0),
                 last_usage_record_count=_optional_int(item.get("lastUsageRecordCount")),
                 todo_state=normalize_persisted_todo_state(item.get("todoState")),
+                session_cost=session_cost if isinstance(session_cost, dict) else None,
             )
         )
     return entries