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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.149.1
+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.149.1 → 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.149.1"
+__version__ = "2.153.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"

{code_context_control-2.149.1 → 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>
@@ -1507,6 +1513,7 @@ c3_agent(workflow=<span class="str">'investigate'</span>, context=<span class="s
               <tr><td class="param-name">stats</td><td class="param-desc">Aggregate stats: most-edited files, change frequency</td></tr>
               <tr><td class="param-name">tag</td><td class="param-desc">Tag an edit entry with a label</td></tr>
               <tr><td class="param-name">verify</td><td class="param-desc"><strong>v2.75.0</strong> — did an edit land? Pass the SAME <code>file</code>/<code>old_string</code>/<code>new_string</code> (or <code>edits</code>) a failed or timed-out <code>c3_edit</code> call took. Answers APPLIED (do not retry) / NOT_APPLIED (safe to retry) / INCONCLUSIVE (read the file)</td></tr>
+              <tr><td class="param-name">revert</td><td class="param-desc">Put a file back to the bytes it had before <code>edit_id</code>, from the pre-image <code>c3_edit</code> stored in <code>.c3/edit_blobs/</code>. Refuses if the file changed since (lists the later edit ids to revert first) or if no pre-image was kept (native Edit/shell rows, files over 5 MB, read-denied or masked paths, evicted blobs). Logs its own <code>reverted</code> row, which can itself be reverted.</td></tr>
             </tbody>
           </table>
 

{code_context_control-2.149.1 → 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.149.1 → 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 = "",
+                  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: JSON list 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)))
 
@@ -930,10 +937,13 @@ async def c3_edits(action: str, file: str = "", change_type: str = "modified",
              summary: str = "", lines_changed: str = "", tags: str = "",
              limit: int = 50, since: str = "", edit_id: str = "",
              tag: str = "", branch: str = "", old_string: str = "",
-             new_string: str = "", edits: str = "", ctx: Context = None) -> str:
+             new_string: str = "", edits: str | list[dict] = "",
+             ctx: Context = None) -> str:
     """EDIT HISTORY — inspect the ledger. Different from c3_edit (which writes); this one reads.
     actions: log (append entry), history (recent edits), versions (per-file), stats, tag (mark edit_id),
-    verify (did an edit land?).
+    verify (did an edit land?), revert (edit_id: put the file back to that c3_edit's pre-image).
+    revert refuses when the file changed since that edit (revert the later edit_ids it lists first)
+    or when no pre-image was kept (native Edit/shell rows, big or read-denied files, evicted).
     branch: filter history to edits stamped with a given git branch.
     verify: pass the SAME file/old_string/new_string (or edits) you gave the c3_edit that errored or
     timed out. Answers APPLIED (do not retry) / NOT_APPLIED (safe to retry) / INCONCLUSIVE (read the

code_context_control-2.153.0/cli/tools/_edit_report.py

@@ -0,0 +1,213 @@
+"""What c3_edit says about an edit besides the ✓ line: where it landed, what changed.
+
+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. 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
+import json
+import subprocess
+import sys
+import threading
+import time
+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
+DIFF_MAX_CHARS = 1500
+_LINE_MAX_CHARS = 200
+
+
+def _git_worktree_roots(cwd: Path) -> list[Path]:
+    """Every non-bare worktree root of the repo containing ``cwd``, main first.
+
+    Returns [] when git is missing, times out, or ``cwd`` is not in a repo.
+    """
+    kwargs = {}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+    try:
+        proc = subprocess.Popen(
+            ["git", "worktree", "list", "--porcelain"], cwd=str(cwd),
+            stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL, text=True, encoding="utf-8",
+            errors="replace", **kwargs)
+    except OSError:
+        return []
+    try:
+        out, _ = proc.communicate(timeout=_GIT_TIMEOUT_S)
+    except subprocess.TimeoutExpired:
+        if sys.platform == "win32":
+            subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                           capture_output=True, stdin=subprocess.DEVNULL, **kwargs)
+        else:
+            proc.kill()
+        proc.communicate()
+        return []
+    if proc.returncode != 0:
+        return []
+    roots, current, bare = [], None, False
+    for line in (out or "").splitlines() + [""]:
+        if line.startswith("worktree "):
+            current, bare = line[len("worktree "):].strip(), False
+        elif line == "bare":
+            bare = True
+        elif not line and current:
+            if not bare:
+                roots.append(Path(current).resolve())
+            current = None
+    return roots
+
+
+def worktree_roots(project_path: str) -> list[Path]:
+    """Cached ``_git_worktree_roots`` for a project, refreshed every 60s."""
+    key = str(Path(project_path).resolve())
+    now = time.monotonic()
+    with _cache_lock:
+        hit = _worktree_cache.get(key)
+        if hit and now - hit[0] < _WORKTREE_TTL_S:
+            return hit[1]
+    roots = _git_worktree_roots(Path(key))
+    with _cache_lock:
+        _worktree_cache[key] = (now, roots)
+    return roots
+
+
+def _other_trees(project_root: Path, roots: list[Path]) -> list[tuple[Path, Path]]:
+    """(worktree root, project dir inside it) for every worktree but our own.
+
+    A project that is a subdirectory of its repo maps to the same subdirectory
+    in each worktree.
+    """
+    own = None
+    for root in roots:
+        if (project_root == root or root in project_root.parents) and (
+                own is None or len(root.parts) > len(own.parts)):
+            own = root
+    if own is None:
+        return []
+    prefix = project_root.relative_to(own)
+    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, 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 "", ""
+    project_root = Path(project_path).resolve()
+    others = _other_trees(project_root, worktree_roots(project_path))
+    if not others:
+        return "", ""
+    try:
+        rel = path.relative_to(project_root)
+    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 "
+                f"({project_root}) but does in another git worktree:\n{listed}\n"
+                f"  Nothing was written. Pass the absolute path of the copy you mean; "
+                f"to create a new file here, pass its absolute path in this checkout."), ""
+    if not path.exists():
+        return "", (f"\n  ⚠ created in the MAIN checkout: {path} — this repo has "
+                    f"{len(others)} other worktree(s). If you meant one of them, "
+                    f"delete this file and pass an absolute path.")
+    note = f"\n  → {path}"
+    if hits:
+        note += (f"\n  ⚠ relative path edited this checkout; the same path also exists "
+                 f"in: {', '.join(str(h) for h in hits)}. Pass an absolute path to "
+                 f"edit a worktree.")
+    return "", note
+
+
+def show_diff(project_path: str) -> bool:
+    """``.c3/config.json`` key ``edit.show_diff``; true unless set to false."""
+    cfg = Path(project_path) / ".c3" / "config.json"
+    if not cfg.is_file():
+        return True
+    try:
+        section = (json.loads(cfg.read_text(encoding="utf-8")) or {}).get("edit")
+    except (OSError, ValueError, AttributeError):
+        return True
+    if isinstance(section, dict) and isinstance(section.get("show_diff"), bool):
+        return section["show_diff"]
+    return True
+
+
+def _lines(text: str) -> list[str]:
+    lines = text.split("\n")
+    if lines[-1] == "":
+        lines.pop()
+    return [ln[:-1] if ln.endswith("\r") else ln for ln in lines]
+
+
+def _clip(line: str) -> str:
+    return line if len(line) <= _LINE_MAX_CHARS else line[:_LINE_MAX_CHARS] + "…"
+
+
+def diff_block(before: str, after: str, project_path: str) -> str:
+    """Response text for a whole-file before → after diff, or "" when disabled/unchanged.
+
+    Unified diff, 2 context lines, ``@@`` hunk headers with real line numbers,
+    no file headers, EOL-stripped lines, capped at DIFF_MAX_LINES lines and
+    DIFF_MAX_CHARS characters with a trailing count of what was cut.
+    """
+    if not show_diff(project_path):
+        return ""
+    body = list(difflib.unified_diff(_lines(before), _lines(after), n=2,
+                                     lineterm=""))[2:]
+    if not body:
+        return ""
+    shown, used = [], 0
+    for line in body:
+        line = _clip(line)
+        if len(shown) >= DIFF_MAX_LINES or used + len(line) + 3 > DIFF_MAX_CHARS:
+            break
+        shown.append("  " + line)
+        used += len(line) + 3
+    out = "\n" + "\n".join(shown)
+    if len(shown) < len(body):
+        out += f"\n  … {len(body) - len(shown)} more diff lines"
+    return out