code-context-control 2.28.0__py3-none-any.whl

cli/hook_auto_snapshot.py

@@ -0,0 +1,142 @@
+"""Stop hook: auto-snapshot + auto-memory on session end.
+
+Triggered by the Claude Code 'Stop' event. Fires after hook_session_stats.
+Looks up the running C3 UI server via ~/.c3/registry.json and calls
+POST /api/auto-snapshot to capture context before it is lost.
+
+Falls back to a lightweight file-based snapshot if the server is unreachable.
+"""
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cli._hook_utils import log_hook_error  # noqa: E402
+
+_REGISTRY_FILE = Path.home() / ".c3" / "registry.json"
+_TIMEOUT_SECS = 4
+
+
+def _find_server_port(project_path: str) -> int | None:
+    """Look up the C3 UI server port for this project from the global registry."""
+    try:
+        if not _REGISTRY_FILE.exists():
+            return None
+        with open(_REGISTRY_FILE, encoding="utf-8") as f:
+            entries = json.load(f)
+        resolved = str(Path(project_path).resolve())
+        for entry in entries:
+            if str(Path(entry.get("project_path", "")).resolve()) == resolved:
+                return entry.get("port")
+    except Exception:
+        pass
+    return None
+
+
+def _call_server(port: int, stop_hook_data: dict) -> bool:
+    """POST to the running C3 server's auto-snapshot endpoint."""
+    try:
+        url = f"http://127.0.0.1:{port}/api/auto-snapshot"
+        body = json.dumps({
+            "session_id": stop_hook_data.get("session_id", ""),
+            "stop_reason": stop_hook_data.get("stop_reason", ""),
+        }).encode("utf-8")
+        req = Request(url, data=body, headers={"Content-Type": "application/json"})
+        resp = urlopen(req, timeout=_TIMEOUT_SECS)
+        return resp.status == 200
+    except (URLError, OSError):
+        return False
+
+
+def _fallback_snapshot(stop_hook_data: dict) -> None:
+    """Lightweight file-based snapshot when the UI server is not running."""
+    c3_dir = Path(".c3")
+    if not c3_dir.exists():
+        return
+
+    snap_dir = c3_dir / "snapshots"
+    snap_dir.mkdir(parents=True, exist_ok=True)
+
+    # Read the latest session file for context
+    sessions_dir = c3_dir / "sessions"
+    session_data = {}
+    if sessions_dir.exists():
+        session_files = sorted(sessions_dir.glob("session_*.json"), reverse=True)
+        if session_files:
+            try:
+                with open(session_files[0], encoding="utf-8") as f:
+                    session_data = json.load(f)
+            except Exception:
+                pass
+
+    # Read budget if available
+    budget = {}
+    budget_file = c3_dir / "context_budget.json"
+    if budget_file.exists():
+        try:
+            with open(budget_file, encoding="utf-8") as f:
+                budget = json.load(f)
+        except Exception:
+            pass
+
+    snap_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    snapshot = {
+        "schema_version": 3,
+        "snapshot_id": snap_id,
+        "created": datetime.now(timezone.utc).isoformat(),
+        "session_id": stop_hook_data.get("session_id", session_data.get("id", "")),
+        "task_description": session_data.get("description", "auto-snapshot on stop"),
+        "trigger": "stop_hook",
+        "stop_reason": stop_hook_data.get("stop_reason", ""),
+        "working_files": [ft["file"] for ft in session_data.get("files_touched", [])[:8]
+                          if isinstance(ft, dict) and ft.get("file")],
+        "decisions": session_data.get("decisions", []),
+        "files_touched": session_data.get("files_touched", []),
+        "context_notes": session_data.get("context_notes", []),
+        "context_budget": {
+            "response_tokens": budget.get("response_tokens", 0),
+            "call_count": budget.get("call_count", 0),
+        },
+        "state": {
+            "task_description": session_data.get("description", ""),
+            "working_files": [ft["file"] for ft in session_data.get("files_touched", [])[:8]
+                              if isinstance(ft, dict) and ft.get("file")],
+            "decisions": session_data.get("decisions", []),
+            "files_touched": session_data.get("files_touched", []),
+            "context_notes": session_data.get("context_notes", []),
+        },
+    }
+
+    snap_path = snap_dir / f"snap_{snap_id}.json"
+    with open(snap_path, "w", encoding="utf-8") as f:
+        json.dump(snapshot, f, indent=2)
+
+
+def main() -> None:
+    try:
+        data = json.load(sys.stdin)
+    except Exception as exc:
+        log_hook_error("hook_auto_snapshot", exc)
+        sys.exit(0)
+
+    try:
+        project_path = str(Path.cwd())
+        port = _find_server_port(project_path)
+
+        if port and _call_server(port, data):
+            sys.exit(0)
+
+        # Server not running or unreachable — fallback
+        _fallback_snapshot(data)
+    except Exception as exc:
+        log_hook_error("hook_auto_snapshot", exc)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

cli/hook_c3_signal.py

@@ -0,0 +1,61 @@
+"""PostToolUse hook: record c3_* tool call signal for enforcement.
+
+Fires after: c3_search, c3_compress, c3_filter, c3_memory, c3_validate,
+             c3_session, c3_status, c3_impact, c3_agent, c3_shell.
+
+Writes .c3/last_c3_call.json:
+  {
+    "timestamp": "...",           ISO UTC timestamp
+    "tool": "c3_search",          short tool name (without mcp__c3__ prefix)
+    "read_unlocked": true/false   true for search/compress/filter
+  }
+
+hook_pretool_enforce.py reads this file as the primary recency check.
+It replaces the fragile LOOKBACK-3 activity-log scan in long sessions.
+"""
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cli._hook_utils import log_hook_error  # noqa: E402
+
+# Tools that unlock generic read operations (Grep/Glob without a file path)
+_READ_UNLOCK_TOOLS = {"c3_search", "c3_compress", "c3_filter", "c3_read", "c3_impact", "c3_validate"}
+
+_SIGNAL_FILE = ".c3/last_c3_call.json"
+
+
+def main() -> None:
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return
+
+        data = json.loads(raw)
+        raw_tool = data.get("tool_name", "")
+
+        # Strip mcp__c3__ prefix → short name (e.g. "c3_search")
+        short_name = raw_tool.replace("mcp__c3__", "") if "mcp__c3__" in raw_tool else raw_tool
+
+        if not short_name.startswith("c3_"):
+            return
+
+        signal = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "tool": short_name,
+            "read_unlocked": short_name in _READ_UNLOCK_TOOLS,
+        }
+
+        signal_path = Path.cwd() / _SIGNAL_FILE
+        signal_path.parent.mkdir(parents=True, exist_ok=True)
+        signal_path.write_text(json.dumps(signal, indent=2), encoding="utf-8")
+
+    except Exception as exc:
+        log_hook_error("hook_c3_signal", exc)
+
+
+if __name__ == "__main__":
+    main()

cli/hook_c3read.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""PostToolUse/AfterTool hook for mcp__c3__c3_read.
+
+After c3_read completes on a code/config file, records a sticky unlock so
+the enforcement hook allows future native Edit calls on those files.
+
+Directs the model to use c3_edit (preferred) or native Edit (unlocked).
+
+Supports both Claude Code (PostToolUse) and Gemini CLI (AfterTool).
+"""
+
+import json
+import sys
+from pathlib import Path
+
+_JSON_UNLOCK_FILE = ".c3/unlocked_files.json"
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cli._hook_utils import emit_additional_context, log_hook_error  # noqa: E402
+
+EDITABLE_EXTS = {
+    ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java",
+    ".rb", ".c", ".cpp", ".h", ".cs", ".html", ".css",
+    ".json", ".yaml", ".yml", ".toml", ".sql", ".md", ".txt",
+    ".sh", ".bat", ".ps1",
+}
+
+UNLOCK_FILE = ".c3/unlocked_files.txt"
+
+
+def _record_unlocks(editable: list[str]):
+    """Record file paths as unlocked for the enforcement hook."""
+    unlock_path = Path.cwd() / UNLOCK_FILE
+    try:
+        existing = set(
+            line.strip() for line in
+            unlock_path.read_text(encoding="utf-8").splitlines()
+            if line.strip()
+        ) if unlock_path.exists() else set()
+        for fp in editable:
+            existing.add(str(Path(fp).resolve()))
+        unlock_path.parent.mkdir(parents=True, exist_ok=True)
+        unlock_path.write_text(
+            "\n".join(sorted(existing)) + "\n",
+            encoding="utf-8",
+        )
+    except Exception:
+        pass
+    # Fix 2: also write to unlocked_files.json (read by hook_pretool_enforce.py)
+    _record_json_unlocks(editable)
+
+
+def _record_json_unlocks(editable: list[str]):
+    """Sync c3_read unlocks into unlocked_files.json for hook_pretool_enforce.py."""
+    json_path = Path.cwd() / _JSON_UNLOCK_FILE
+    try:
+        existing: dict = {}
+        if json_path.exists():
+            try:
+                existing = json.loads(json_path.read_text(encoding="utf-8"))
+                if not isinstance(existing, dict):
+                    existing = {}
+            except Exception:
+                existing = {}
+        for fp in editable:
+            normalized = str(Path(fp).resolve())
+            cats = set(existing.get(normalized, []))
+            cats.update({"read", "edit"})
+            existing[normalized] = sorted(cats)
+        json_path.parent.mkdir(parents=True, exist_ok=True)
+        json_path.write_text(json.dumps(existing), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return
+
+        data = json.loads(raw)
+        if data.get("tool_name") != "mcp__c3__c3_read":
+            return
+
+        # Detect IDE format: Gemini wraps tool_response in a dict
+        is_gemini = isinstance(data.get("tool_response", ""), dict)
+
+        tool_input = data.get("tool_input", {})
+        file_path = (tool_input.get("file_path") or "").strip()
+        if not file_path:
+            return
+
+        # Support comma-separated multi-file reads
+        paths = [p.strip() for p in file_path.split(",") if p.strip()]
+        editable = [p for p in paths if Path(p).suffix.lower() in EDITABLE_EXTS]
+        if not editable:
+            return
+
+        # Record sticky unlocks so Edit is allowed without Read(limit=1)
+        _record_unlocks(editable)
+
+        files_str = ", ".join(f'"{p}"' for p in editable)
+        emit_additional_context(
+            f"[c3:edit-ready] {len(editable)} file(s) unlocked for editing: {files_str}. "
+            f"Use c3_edit(file_path=..., old_string=..., new_string=..., summary=...) — preferred. "
+            f"Native Edit is also unlocked for these files.",
+            is_gemini,
+        )
+    except Exception as _e:
+        log_hook_error("hook_c3read", _e)
+
+
+if __name__ == "__main__":
+    main()

cli/hook_edit_ledger.py

@@ -0,0 +1,213 @@
+"""PostToolUse hook: auto-log Edit/Write tool calls to the Edit Ledger.
+
+Intercepts Edit and Write tool calls, extracts the file path, and appends
+an entry to .c3/edit_ledger.jsonl — same format as EditLedger.log_edit().
+
+Performance: logs immediately with git_pending=True (no subprocess).
+Git info and syntax validation are enriched asynchronously by
+EditLedgerEnricherAgent running in the MCP server background.
+"""
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+# Add project root to path for imports
+_project_root = str(Path(__file__).resolve().parent.parent)
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+from cli._hook_utils import get_tool_input_path, log_hook_error, normalize_tool_name  # noqa: E402
+from core.config import load_hybrid_config  # noqa: E402
+
+EDITABLE_EXTS = {
+    ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java",
+    ".rb", ".c", ".cpp", ".h", ".cs", ".html", ".css",
+    ".json", ".yaml", ".yml", ".toml", ".sql", ".md", ".txt",
+    ".sh", ".bat", ".ps1", ".r",
+}
+
+# How many tail lines to scan for version/seq (avoids full-file parse)
+_TAIL_SCAN = 50
+
+
+def _tail_lines(ledger_file: Path, n: int = _TAIL_SCAN) -> list[str]:
+    """Read the last n non-empty lines from the ledger file efficiently."""
+    try:
+        raw = ledger_file.read_bytes()
+    except Exception:
+        return []
+    lines = []
+    pos = len(raw)
+    while pos > 0 and len(lines) < n:
+        nl = raw.rfind(b"\n", 0, pos - 1)
+        chunk = raw[nl + 1:pos]
+        if chunk.strip():
+            lines.append(chunk.decode("utf-8", errors="replace"))
+        pos = nl if nl >= 0 else 0
+    return list(reversed(lines))
+
+
+def _next_version(ledger_file: Path, rel_path: str) -> str:
+    """Get next version for a file by scanning only the tail of the ledger."""
+    max_v = 0
+    for line in _tail_lines(ledger_file, _TAIL_SCAN):
+        try:
+            entry = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
+        if entry.get("file") == rel_path:
+            v_str = entry.get("version", "v0")
+            try:
+                max_v = max(max_v, int(v_str.lstrip("v")))
+            except (ValueError, AttributeError):
+                pass
+    # If nothing found in tail, file might have older entries — do a quick check
+    if max_v == 0 and ledger_file.exists():
+        try:
+            for line in ledger_file.read_text(encoding="utf-8").splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    entry = json.loads(line)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+                if entry.get("file") == rel_path:
+                    v_str = entry.get("version", "v0")
+                    try:
+                        max_v = max(max_v, int(v_str.lstrip("v")))
+                    except (ValueError, AttributeError):
+                        pass
+        except Exception:
+            pass
+    return f"v{max_v + 1}"
+
+
+def _next_seq(ledger_file: Path, now: datetime) -> int:
+    """Sequence number — scan only tail lines for same-second collisions."""
+    prefix = f"edit_{now.strftime('%Y%m%d_%H%M%S')}_"
+    max_seq = 0
+    for line in _tail_lines(ledger_file, 10):  # Same-second entries are always recent
+        try:
+            entry = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
+        eid = entry.get("id", "")
+        if eid.startswith(prefix):
+            try:
+                max_seq = max(max_seq, int(eid[len(prefix):]))
+            except ValueError:
+                pass
+    return max_seq + 1
+
+
+
+def _extract_summary(tool_name: str, tool_input: dict) -> str:
+    """Build a short summary from tool input."""
+    if tool_name == "Edit":
+        old = (tool_input.get("old_string") or "")[:60]
+        new = (tool_input.get("new_string") or "")[:60]
+        if old and new:
+            return f"Replaced: {old!r} → {new!r}"
+        return "Edit"
+    elif tool_name == "Write":
+        return "File written"
+    return "Modified"
+
+
+def _detect_change_type(tool_name: str, tool_input: dict) -> str:
+    if tool_name == "Write":
+        return "created" if tool_input.get("_is_new") else "modified"
+    return "modified"
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return
+
+        data = json.loads(raw)
+        tool_name = normalize_tool_name(data.get("tool_name", ""))
+
+        if tool_name not in ("Edit", "Write", "NotebookEdit"):
+            return
+
+        file_path = get_tool_input_path(data)
+        if not file_path:
+            return
+
+        # Filter to editable extensions
+        if Path(file_path).suffix.lower() not in EDITABLE_EXTS:
+            return
+
+        project_path = Path.cwd()
+        c3_dir = project_path / ".c3"
+        if not c3_dir.exists():
+            return  # Not a C3 project
+
+        # Load config and check if edit ledger is enabled
+        config = load_hybrid_config(str(project_path))
+        ledger_cfg = config.get("edit_ledger", {})
+        if not ledger_cfg.get("enabled", True):
+            return
+        tracking_level = ledger_cfg.get("tracking_level", "standard")
+
+        ledger_file = c3_dir / "edit_ledger.jsonl"
+
+        # Make file path relative
+        try:
+            rel = str(Path(file_path).resolve().relative_to(project_path.resolve()))
+        except ValueError:
+            rel = file_path
+        rel = rel.replace("\\", "/")
+
+        now = datetime.now(timezone.utc)
+        tool_input = data.get("tool_input", {})
+        change_type = _detect_change_type(tool_name, tool_input)
+
+        # Git info is enriched asynchronously by EditLedgerEnricherAgent.
+        # Mark as pending so the enricher knows to process this entry.
+        git_pending = tracking_level != "minimal"
+
+        entry = {
+            "id": f"edit_{now.strftime('%Y%m%d_%H%M%S')}_{_next_seq(ledger_file, now):03d}",
+            "timestamp": now.isoformat(),
+            "session_id": "",
+            "file": rel,
+            "change_type": change_type,
+            "summary": change_type if tracking_level == "minimal" else _extract_summary(tool_name, tool_input),
+            "lines_changed": None,
+            "version": _next_version(ledger_file, rel),
+            "git": {},
+            "diff_summary": "",
+            "git_pending": git_pending,
+            "tags": ["auto"] if ledger_cfg.get("auto_tag", True) else [],
+        }
+
+        # Detailed mode: include code snippets for richer diffs
+        if tracking_level == "detailed":
+            detail = {}
+            old_str = tool_input.get("old_string")
+            new_str = tool_input.get("new_string")
+            if old_str is not None:
+                detail["old_string"] = old_str[:200]
+            if new_str is not None:
+                detail["new_string"] = new_str[:200]
+            if detail:
+                entry["detail"] = detail
+
+        with open(ledger_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry) + "\n")
+
+        print(f"[c3:ledger] {rel} {entry['version']} auto-logged. "
+              f"Call c3_edits(action='log', file='{rel}', summary='...', tags='...') "
+              f"to add a semantic summary.")
+
+    except Exception as _e:
+        log_hook_error("hook_edit_ledger", _e)
+
+
+if __name__ == "__main__":
+    main()