code-context-control 2.152.0__tar.gz → 2.153.0__tar.gz

{code_context_control-2.152.0 → code_context_control-2.153.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.152.0
+Version: 2.153.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.152.0 → code_context_control-2.153.0}/cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.152.0"
+__version__ = "2.153.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"

{code_context_control-2.152.0 → code_context_control-2.153.0}/cli/guide/tools.html

@@ -481,7 +481,13 @@ c3_filter(text=<span class="str">"&lt;webpack build output&gt;"</span>, pattern=
                 <td class="param-name">edits</td>
                 <td class="param-type">array</td>
                 <td class="param-default">null</td>
-                <td class="param-desc">List of <code>{old_string, new_string}</code> objects for batch edits to the same file</td>
+                <td class="param-desc">List of <code>{old_string, new_string}</code> objects for batch edits to the same file. Applied in order, all or none: if one patch cannot be placed, nothing is written</td>
+              </tr>
+              <tr>
+                <td class="param-name">overwrite</td>
+                <td class="param-type">bool</td>
+                <td class="param-default">false</td>
+                <td class="param-desc">Replace all of an existing file with <code>new_string</code>. Refused unless this session has read the file with c3_read and the file has not changed since. Keeps the file's line endings and BOM, stores a pre-image, and can be reverted</td>
               </tr>
             </tbody>
           </table>
@@ -514,7 +520,7 @@ c3_filter(text=<span class="str">"&lt;webpack build output&gt;"</span>, pattern=
           <div class="callout callout-info">
             <span class="callout-icon">💡</span>
             <div class="callout-body">
-              <strong>Unicode lookalikes are matched automatically.</strong> If <code>old_string</code> uses straight quotes but the file has curly quotes (or vice versa), or the two differ only by ASCII vs. unicode dashes (<code>-</code>/<code>–</code>/<code>—</code>) or non-breaking spaces, c3_edit retries with a normalized match and splices your <code>new_string</code> in at the matched offsets; unrelated lookalikes elsewhere are left intact. The response is tagged <code>[unicode-normalized]</code> when the fallback was used.
+              <strong>Unicode lookalikes are reported, not applied.</strong> If <code>old_string</code> uses straight quotes but the file has curly quotes (or vice versa), or the two differ only by ASCII vs. unicode dashes (<code>-</code>/<code>–</code>/<code>—</code>) or non-breaking spaces, c3_edit writes nothing and answers <code>[c3_edit:lookalike]</code> with the file's exact text for that region, so the retry can copy it. Applying such a match would replace the file's characters with the retyped ones.
             </div>
           </div>
         </div>

{code_context_control-2.152.0 → code_context_control-2.153.0}/cli/guide/workflow.html

@@ -623,7 +623,7 @@ c3_impact(target=<span class="str">'MemoryStore'</span>, mode=<span class="str">
         </div>
         <div class="workflow-step-body">
 
-          <p><code>c3_edit</code> does read + patch + write + edit ledger log in one step. It also validates the old_string match before writing. If the literal match fails but the strings differ only by unicode lookalikes (curly quotes, em/en-dashes, NBSP), c3_edit retries with a 1:1 normalized match and tags the response <code>[unicode-normalized]</code>.</p>
+          <p><code>c3_edit</code> does read + patch + write + edit ledger log in one step. It also validates the old_string match before writing. If the literal match fails but the strings differ only by unicode lookalikes (curly quotes, em/en-dashes, NBSP), c3_edit writes nothing and returns the file's exact text under <code>[c3_edit:lookalike]</code>.</p>
 
           <pre><code>c3_edit(
   file_path=<span class="str">'services/auth.py'</span>,

{code_context_control-2.152.0 → code_context_control-2.153.0}/cli/mcp_server.py

@@ -543,7 +543,9 @@ def _with_hint(resp, make_hint) -> str:
 
 def _finalize_response(ctx: Context, tool_name: str, args: dict,
                        response: str, summary: str = "",
-                       response_tokens: int = 0) -> str:
+                       response_tokens: int = 0,
+                       ok: bool | None = None) -> str:
+    """ok: the tool's own verdict on the call; None reads it off the response text."""
     global _last_tool_call_time, _last_badge_count
 
     deferred_snapshot = False
@@ -586,11 +588,14 @@ def _finalize_response(ctx: Context, tool_name: str, args: dict,
     svc.session_mgr.log_tool_call(tool_name, args, summary)
     # ok=False lets hook_pretool_enforce's activity scan skip a failed call
     # (ISSUE-3: "Error: File not found" used to count as "c3 was used").
-    try:
-        from cli._hook_utils import response_text_failed as _failed
-        call_ok = not _failed(response)
-    except Exception:
-        call_ok = True
+    if ok is not None:
+        call_ok = ok
+    else:
+        try:
+            from cli._hook_utils import response_text_failed as _failed
+            call_ok = not _failed(response)
+        except Exception:
+            call_ok = True
     # Both session ids on every tool_call row (D0b): C3's own id joins the
     # row to session_start / the saved session file, the host id joins it to
     # the hooks' session_open / session_end rows. Either may be absent.
@@ -903,12 +908,13 @@ async def c3_agent(workflow: str, scope: str = "", context: str = "",
 @mcp.tool()
 async def c3_edit(file_path: str, old_string: str = "", new_string: str = "",
                   summary: str = "", tags: str = "", replace_all: bool = False,
-                  edits: str | list[dict] = "",
+                  edits: str | list[dict] = "", overwrite: bool = False,
                   ctx: Context = None) -> str:
     """EDIT — read+patch+write+log in one step. Primary code-change tool; always prefer over native Edit.
     old_string: text to replace. new_string: replacement. summary: ledger description.
-    edits: list (or JSON string) of {old_string, new_string, summary?} for multi-hunk batch on one file.
-    Parallel across files. Create new file: non-existent file_path + old_string='' + new_string=<content>.
+    edits: list (or JSON string) of {old_string, new_string, summary?} for multi-hunk batch on one file,
+    applied all or none. Parallel across files. Create new file: non-existent file_path + old_string='' + new_string=<content>.
+    Rewrite a whole existing file: overwrite=true + new_string=<content>, after a c3_read of it.
     If this call ERRORS OR TIMES OUT, do not retry blind — a failed c3_edit may still have
     written the file. Re-send the same args to c3_edits(action='verify') for a verdict."""
     path_err = validate_file_path(file_path)
@@ -920,7 +926,8 @@ async def c3_edit(file_path: str, old_string: str = "", new_string: str = "",
         return _finalize_response(ctx, name, args, resp, summ, **kw)
 
     resp = await asyncio.to_thread(handle_edit, file_path, old_string, new_string,
-                                   summary, tags, replace_all, svc, finalize, edits)
+                                   summary, tags, replace_all, svc, finalize, edits,
+                                   overwrite)
     return _with_hint(resp, lambda: delegate_hints.after_edit(
         svc, file_path, delegate_hints.edit_chars(new_string, edits)))
 

{code_context_control-2.152.0 → code_context_control-2.153.0}/cli/tools/_edit_report.py

@@ -4,8 +4,9 @@ Two concerns, both read-only:
 - ``locate``: a RELATIVE file_path resolves against the project root, which is
   the main checkout. When the repo has other git worktrees, the caller may have
   meant one of them, so the response names the resolved path and any worktree
-  holding the same relative path, and refuses outright when the path exists only
-  in a worktree.
+  holding the same relative path. It refuses outright when the path exists only
+  in a worktree, or when this process last wrote to a worktree that the path
+  could equally mean.
 - ``diff_block``: a compact unified diff of the whole file, before → after.
 """
 import difflib
@@ -19,6 +20,7 @@ from pathlib import Path
 _WORKTREE_TTL_S = 60.0
 _GIT_TIMEOUT_S = 3.0
 _worktree_cache: dict[str, tuple[float, list[Path]]] = {}
+_last_tree: dict[str, Path] = {}
 _cache_lock = threading.Lock()
 
 DIFF_MAX_LINES = 24
@@ -98,13 +100,26 @@ def _other_trees(project_root: Path, roots: list[Path]) -> list[tuple[Path, Path
     return [(root, root / prefix) for root in roots if root != own]
 
 
+def note_write(path: Path, project_path: str) -> None:
+    """Record the worktree a write landed in, for ``locate`` to compare the
+    next relative path against."""
+    holding = [r for r in worktree_roots(project_path)
+               if r == path or r in path.parents]
+    if holding:
+        with _cache_lock:
+            _last_tree[str(Path(project_path).resolve())] = max(
+                holding, key=lambda r: len(r.parts))
+
+
 def locate(file_path: str, path: Path, project_path: str) -> tuple[str, str]:
     """Check a resolved edit target against the repo's other worktrees.
 
     Returns ``(refusal, note)``, at most one non-empty. ``refusal`` is set when a
     relative ``file_path`` does not exist in this checkout but does in another
-    worktree. ``note`` is extra response text for a relative path in a repo
-    with other worktrees. Absolute paths always return ``("", "")``.
+    worktree, or when the last write went to another worktree where the path
+    exists or would be created. ``note`` is extra response text for a relative
+    path in a repo with other worktrees. Absolute paths always return
+    ``("", "")``.
     """
     if Path(file_path).is_absolute():
         return "", ""
@@ -117,6 +132,18 @@ def locate(file_path: str, path: Path, project_path: str) -> tuple[str, str]:
     except ValueError:
         return "", ""
     hits = [proj / rel for _, proj in others if (proj / rel).exists()]
+    with _cache_lock:
+        last = _last_tree.get(str(project_root))
+    recent = next((proj / rel for root, proj in others if root == last), None)
+    if recent is not None and (recent.exists() or not path.exists()):
+        there = ("where the same path is" if recent.exists()
+                 else "where this path would be")
+        return (f"[c3_edit:wrong-tree] {file_path} is relative, so it means "
+                f"{path} in this checkout, but this session's last edit went "
+                f"to another git worktree, {there}:\n"
+                f"    {recent}\n"
+                f"  Nothing was written. Pass the absolute path of the one "
+                f"you mean."), ""
     if not path.exists() and hits:
         listed = "\n".join(f"    {h}" for h in hits)
         return (f"[c3_edit:wrong-tree] {file_path} does not exist in this checkout "