code-context-control 2.34.0__tar.gz → 2.35.0__tar.gz

{code_context_control-2.34.0 → code_context_control-2.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.34.0
+Version: 2.35.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -245,7 +245,7 @@ C3 exposes 16 tools as a native MCP server. Your IDE calls them directly:
 | `c3_impact` | Blast-radius analysis before edits to shared symbols |
 | `c3_delegate` | Offload heavy work to local Ollama / Codex / Gemini / etc. |
 | `c3_agent` | Multi-step agentic workflows (review, investigate, refactor) |
-| `c3_edits` | Edit-ledger queries + version diffs + restore points |
+| `c3_edits` | Edit-ledger queries + version diffs + restore points + per-branch filter |
 | `c3_bitbucket` | Bitbucket Data Center integration — PRs, branches, builds, repo admin (v2.30.0) |
 | `c3_project` | Cross-project — discover & operate on other c3-installed projects; guarded writes (v2.31.0) |
 

{code_context_control-2.34.0 → code_context_control-2.35.0}/README.md

@@ -183,7 +183,7 @@ C3 exposes 16 tools as a native MCP server. Your IDE calls them directly:
 | `c3_impact` | Blast-radius analysis before edits to shared symbols |
 | `c3_delegate` | Offload heavy work to local Ollama / Codex / Gemini / etc. |
 | `c3_agent` | Multi-step agentic workflows (review, investigate, refactor) |
-| `c3_edits` | Edit-ledger queries + version diffs + restore points |
+| `c3_edits` | Edit-ledger queries + version diffs + restore points + per-branch filter |
 | `c3_bitbucket` | Bitbucket Data Center integration — PRs, branches, builds, repo admin (v2.30.0) |
 | `c3_project` | Cross-project — discover & operate on other c3-installed projects; guarded writes (v2.31.0) |
 

{code_context_control-2.34.0 → code_context_control-2.35.0}/cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.34.0"
+__version__ = "2.35.0"
 
 
 def _command_deps() -> CommandDeps:

{code_context_control-2.34.0 → code_context_control-2.35.0}/cli/mcp_server.py

@@ -604,9 +604,10 @@ async def c3_edit(file_path: str, old_string: str = "", new_string: str = "",
 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 = "", ctx: Context = None) -> str:
+             tag: str = "", branch: str = "", 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)."""
+    actions: log (append entry), history (recent edits), versions (per-file), stats, tag (mark edit_id).
+    branch: filter history to edits stamped with a given git branch."""
     svc = _svc(ctx)
 
     def finalize(name, args, resp, summ, **kw):
@@ -615,7 +616,7 @@ async def c3_edits(action: str, file: str = "", change_type: str = "modified",
     from cli.tools.edits import handle_edits
     return await asyncio.to_thread(handle_edits, action, file, change_type, summary,
                                    lines_changed, tags, limit, since, edit_id, tag,
-                                   svc, finalize)
+                                   svc, finalize, branch)
 
 
 @mcp.tool()

{code_context_control-2.34.0 → code_context_control-2.35.0}/cli/tools/edits.py

@@ -3,7 +3,7 @@
 
 def handle_edits(action: str, file: str, change_type: str, summary: str,
                  lines_changed: str, tags: str, limit: int, since: str,
-                 edit_id: str, tag: str, svc, finalize) -> str:
+                 edit_id: str, tag: str, svc, finalize, branch: str = "") -> str:
     """Route c3_edits actions."""
     ledger = svc.edit_ledger
     if ledger is None:
@@ -64,12 +64,17 @@ def handle_edits(action: str, file: str, change_type: str, summary: str,
             file=file or None,
             limit=limit or 50,
             since=since or None,
+            branch=branch or None,
         )
         if not entries:
             return finalize("c3_edits", {"action": "history"}, "No edits found", "0 edits")
-        lines = [f"[edits:history] {len(entries)} entries" + (f" for {file}" if file else "")]
+        scope = (f" for {file}" if file else "") + (f" on {branch}" if branch else "")
+        lines = [f"[edits:history] {len(entries)} entries" + scope]
         for e in entries:
             ln = f"  {e['timestamp'][:19]} | {e['file']} {e['version']} | {e['change_type']} | {e['summary']}"
+            br = (e.get("git") or {}).get("branch")
+            if br:
+                ln += f" @{br}"
             if e.get("tags"):
                 ln += f" [{','.join(e['tags'])}]"
             lines.append(ln)

{code_context_control-2.34.0 → code_context_control-2.35.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.34.0
+Version: 2.35.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -245,7 +245,7 @@ C3 exposes 16 tools as a native MCP server. Your IDE calls them directly:
 | `c3_impact` | Blast-radius analysis before edits to shared symbols |
 | `c3_delegate` | Offload heavy work to local Ollama / Codex / Gemini / etc. |
 | `c3_agent` | Multi-step agentic workflows (review, investigate, refactor) |
-| `c3_edits` | Edit-ledger queries + version diffs + restore points |
+| `c3_edits` | Edit-ledger queries + version diffs + restore points + per-branch filter |
 | `c3_bitbucket` | Bitbucket Data Center integration — PRs, branches, builds, repo admin (v2.30.0) |
 | `c3_project` | Cross-project — discover & operate on other c3-installed projects; guarded writes (v2.31.0) |
 

{code_context_control-2.34.0 → code_context_control-2.35.0}/code_context_control.egg-info/SOURCES.txt

@@ -112,6 +112,7 @@ services/edit_ledger.py
 services/embedding_index.py
 services/error_reporting.py
 services/file_memory.py
+services/git_context.py
 services/hub_service.py
 services/indexer.py
 services/memory.py
@@ -157,6 +158,7 @@ tests/test_edit_normalization.py
 tests/test_enforcement_flip.py
 tests/test_federated_graph.py
 tests/test_ghost_files.py
+tests/test_git_branch_awareness.py
 tests/test_hub_server_smoke.py
 tests/test_mcp_host_guard.py
 tests/test_mcp_server_smoke.py

{code_context_control-2.34.0 → code_context_control-2.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.34.0"
+version = "2.35.0"
 description = "Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.34.0 → code_context_control-2.35.0}/services/agents.py

@@ -11,6 +11,7 @@ from collections import Counter
 from pathlib import Path
 
 from services.agent_base import BackgroundAgent  # noqa: F401 — re-exported for consumers
+from services.git_context import GitContext
 
 
 class IndexStalenessAgent(BackgroundAgent):
@@ -922,6 +923,137 @@ class FileMemoryAgent(BackgroundAgent):
         return status
 
 
+class BranchWatchAgent(BackgroundAgent):
+    """Detects branch / HEAD changes and queues a scoped, targeted re-index.
+
+    Change detection keys on the HEAD sha, so it fires on checkout, switch,
+    pull, and merge — but NOT on ``git fetch`` (which only moves remote refs;
+    the working tree is untouched). On a move it queues exactly the files that
+    differ between the old and new HEAD (from ``git diff``), restricted to files
+    C3 already tracks and that genuinely need re-indexing, then notifies
+    (warning on a branch switch, info on a same-branch HEAD move).
+
+    Every cycle it also queues tracked files that are dirty on disk, catching
+    edits made outside C3 (rebase, ``git restore``, another editor) that the
+    lazy mtime-on-access path would only notice later. The actual re-extraction
+    is done by FileMemoryAgent, which drains the same queue.
+    """
+
+    def __init__(self, file_memory, notifications, project_path,
+                 enabled=True, interval=30, max_queue=200, **kwargs):
+        super().__init__("BranchWatch", interval, notifications, enabled, **kwargs)
+        self.file_memory = file_memory
+        self.project_path = project_path
+        self.max_queue = max_queue
+        self._git = GitContext(project_path)
+        self._state_path = Path(project_path) / ".c3" / "branch_state.json"
+        self._loaded = False
+        self._last = {"branch": None, "head_sha": ""}
+
+    def _load_state(self):
+        if self._loaded:
+            return
+        self._loaded = True
+        try:
+            if self._state_path.exists():
+                data = json.loads(self._state_path.read_text(encoding="utf-8"))
+                self._last = {"branch": data.get("branch"),
+                              "head_sha": data.get("head_sha", "")}
+        except Exception:
+            pass
+
+    def _save_state(self, branch, head_sha):
+        self._last = {"branch": branch, "head_sha": head_sha}
+        try:
+            self._state_path.write_text(
+                json.dumps({"branch": branch, "head_sha": head_sha}),
+                encoding="utf-8",
+            )
+        except Exception:
+            pass
+
+    def _queue_changed(self, paths) -> int:
+        """Queue tracked files that still need re-indexing; return count queued.
+
+        Paths are compared slash-agnostically against the file-memory store and
+        filtered through ``needs_update`` so unchanged files (e.g. after a local
+        commit where the working tree already matches) are not re-processed.
+        """
+        if not paths:
+            return 0
+        tracked = {t.replace("\\", "/"): t for t in self.file_memory.list_tracked()}
+        queued = 0
+        for p in paths:
+            canonical = tracked.get(p.replace("\\", "/"))
+            if canonical is None:
+                continue
+            try:
+                if not self.file_memory.needs_update(canonical):
+                    continue
+            except Exception:
+                pass
+            self.file_memory.queue_for_update(canonical)
+            queued += 1
+            if queued >= self.max_queue:
+                break
+        return queued
+
+    def check(self):
+        st = self._git.state(force=True)
+        if not st.get("available"):
+            return False  # no git here — idle backoff
+        self._load_state()
+        cur_branch = st.get("branch")
+        cur_head = st.get("head_sha", "")
+        if not cur_head:
+            return False
+        prev_branch = self._last.get("branch")
+        prev_head = self._last.get("head_sha", "")
+
+        # Catch out-of-band working-tree edits every cycle.
+        dirty_queued = self._queue_changed(self._git.dirty_files())
+
+        # First run for this project — record the baseline without notifying.
+        if not prev_head:
+            self._save_state(cur_branch, cur_head)
+            return False if dirty_queued == 0 else None
+
+        if cur_head == prev_head and cur_branch == prev_branch:
+            return False if dirty_queued == 0 else None
+
+        # HEAD or branch moved — scope the re-index to what actually differs.
+        changed = self._git.changed_files(prev_head, cur_head)
+        if not changed:
+            # Old commit unreachable / diff failed — fall back to dirty set.
+            changed = self._git.dirty_files()
+        queued = self._queue_changed(changed)
+
+        switched = (cur_branch != prev_branch)
+        self._save_state(cur_branch, cur_head)
+
+        new_label = cur_branch or "(detached)"
+        if switched:
+            old_label = prev_branch or (prev_head[:8] if prev_head else "?")
+            self.notify(
+                "warning", "Branch changed",
+                f"{old_label} → {new_label}; queued {queued} tracked file(s) for re-index",
+                replace_if_unacked=True,
+            )
+        else:
+            self.notify(
+                "info", "Index refresh",
+                f"HEAD {prev_head[:8]}→{cur_head[:8]} on {new_label}; "
+                f"queued {queued} file(s) for re-index",
+                replace_if_unacked=True,
+            )
+        return None
+
+    def get_status(self) -> dict:
+        status = super().get_status()
+        status["branch"] = self._git.label()
+        return status
+
+
 class AutonomyPlannerAgent(BackgroundAgent):
     """Builds a prioritized autonomous action plan from recent tool telemetry."""
 
@@ -1511,6 +1643,19 @@ def create_agents(services, notifications, config=None, ollama=None) -> list:
             )
         )
 
+    # BranchWatchAgent — needs file_memory's re-index queue.
+    if hasattr(services, 'file_memory') and services.file_memory:
+        agents.append(
+            BranchWatchAgent(
+                file_memory=services.file_memory,
+                notifications=notifications,
+                project_path=getattr(services, 'project_path', None),
+                **_cfg("BranchWatch", {
+                    "enabled": True, "interval": 30, "max_queue": 200,
+                }),
+            )
+        )
+
     # EditLedgerEnricherAgent — only if edit_ledger is available
     if getattr(services, 'edit_ledger', None):
         agents.append(

{code_context_control-2.34.0 → code_context_control-2.35.0}/services/context_snapshot.py

@@ -9,6 +9,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from core import count_tokens
+from services.git_context import GitContext
 
 # Max characters per file structural map stored in snapshot
 _FILE_MAP_MAX_CHARS = 600
@@ -21,6 +22,7 @@ class ContextSnapshot:
         self.project_path = Path(project_path)
         self.data_dir = self.project_path / data_dir
         self.data_dir.mkdir(parents=True, exist_ok=True)
+        self._git = GitContext(self.project_path)
 
     def capture(self, session_mgr, memory_store,
                 task_description: str = "",
@@ -88,11 +90,23 @@ class ContextSnapshot:
         # Context budget snapshot
         budget = session.get("context_budget", {})
 
+        # Git working-tree state — lets restore flag a branch change.
+        try:
+            gstate = self._git.state(force=True)
+            git_info = {
+                "branch": gstate.get("branch"),
+                "head_sha": gstate.get("head_sha", ""),
+                "detached": gstate.get("detached", False),
+            }
+        except Exception:
+            git_info = {"branch": None, "head_sha": "", "detached": False}
+
         snapshot = {
             "schema_version": 3,
             "snapshot_id": datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S"),
             "created": datetime.now(timezone.utc).isoformat(),
             "session_id": session_id,
+            "git": git_info,
             "task_description": task_description,
             "working_files": working_files or [],
             "custom_notes": custom_notes,
@@ -152,6 +166,20 @@ class ContextSnapshot:
         if "error" in snap:
             return snap
 
+        # Flag when the working tree has moved off the branch this was taken on.
+        snap_git = snap.get("git") or {}
+        if snap_git.get("branch"):
+            try:
+                cur = self._git.state(force=True)
+                if (cur.get("available") and cur.get("branch")
+                        and cur["branch"] != snap_git["branch"]):
+                    snap["_branch_warning"] = (
+                        f"snapshot taken on '{snap_git['branch']}', "
+                        f"now on '{cur['branch']}'"
+                    )
+            except Exception:
+                pass
+
         # Enrich with live memory recall so cross-session facts are surfaced immediately
         if memory_store and snap.get("task_description"):
             try:
@@ -252,6 +280,13 @@ class ContextSnapshot:
         parts = [f"# Context Restore: {snap.get('task_description', 'N/A')}"]
         parts.append(f"Snapshot: {snap['snapshot_id']} | Session: {snap.get('session_id', '?')}")
 
+        git = snap.get("git") or {}
+        if git.get("head_sha"):
+            label = (git.get("branch") or "(detached)") + " @ " + git["head_sha"][:8]
+            parts.append(f"Branch: {label}")
+        if snap.get("_branch_warning"):
+            parts.append(f"\n⚠️ Branch changed since snapshot — {snap['_branch_warning']}")
+
         if snap.get("custom_notes"):
             parts.append(f"\n## Notes\n{snap['custom_notes']}")
 
@@ -328,6 +363,8 @@ class ContextSnapshot:
     def _compact_briefing(self, snap: dict) -> str:
         """Level 1: Compact briefing — top decisions + file list."""
         parts = [f"[restore:{snap['snapshot_id']}] {snap.get('task_description', '')}"]
+        if snap.get("_branch_warning"):
+            parts.append(f"⚠️ branch changed — {snap['_branch_warning']}")
 
         plans = snap.get("plans", [])
         if plans:

{code_context_control-2.34.0 → code_context_control-2.35.0}/services/edit_ledger.py

@@ -15,6 +15,8 @@ from collections import Counter
 from datetime import datetime, timezone
 from pathlib import Path
 
+from services.git_context import GitContext
+
 
 class EditLedger:
     """Tracks every AI edit with version numbering and git context."""
@@ -23,7 +25,8 @@ class EditLedger:
         self.project_path = Path(project_path).resolve()
         self.ledger_file = self.project_path / ".c3" / "edit_ledger.jsonl"
         self.ledger_file.parent.mkdir(parents=True, exist_ok=True)
-        self._git_root = self._detect_git_root()
+        self._git = GitContext(self.project_path)
+        self._git_root = self._git.git_root
         # In-memory caches — loaded lazily on first use, updated on writes
         self._version_cache: dict[str, int] | None = None  # {file: max_version}
         self._total_count: int | None = None
@@ -75,7 +78,8 @@ class EditLedger:
         self._seq_counter += 1
 
         # Git info — single combined command when enabled
-        git_info = {"commit": "", "author": "", "subject": "", "dirty": False}
+        git_info = {"commit": "", "author": "", "subject": "", "dirty": False,
+                    "branch": None, "head_sha": ""}
         diff_summary = ""
         if include_git and self._git_root:
             git_info, diff_summary = self._git_combined(rel)
@@ -107,9 +111,10 @@ class EditLedger:
         return entry
 
     def get_history(self, file: str = None, limit: int = 50,
-                    since: str = None) -> list:
-        """Query edits, optionally filtered by file and/or time."""
-        results = self._load_merged(file_filter=file, since_filter=since)
+                    since: str = None, branch: str = None) -> list:
+        """Query edits, optionally filtered by file, time, and/or branch."""
+        results = self._load_merged(file_filter=file, since_filter=since,
+                                    branch_filter=branch)
         return results[-limit:]
 
     def get_file_versions(self, file: str) -> list:
@@ -208,31 +213,13 @@ class EditLedger:
                 continue
         return results[-limit:]
 
-    def _detect_git_root(self):
-        """Find git root directory."""
-        try:
-            kwargs = {}
-            if sys.platform == "win32":
-                kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
-            result = subprocess.run(
-                ["git", "rev-parse", "--show-toplevel"],
-                cwd=self.project_path,
-                capture_output=True, text=True, timeout=3,
-                stdin=subprocess.DEVNULL,
-                **kwargs,
-            )
-            if result.returncode == 0:
-                return Path(result.stdout.strip()).resolve()
-        except Exception:
-            pass
-        return None
-
     def _git_combined(self, rel_path: str) -> tuple:
         """Capture git info + diff in a single subprocess call.
 
         Returns (git_info_dict, diff_summary_str).
         """
-        info = {"commit": "", "author": "", "subject": "", "dirty": False}
+        info = {"commit": "", "author": "", "subject": "", "dirty": False,
+                "branch": None, "head_sha": ""}
         diff_summary = ""
         abs_path = (self.project_path / rel_path).resolve()
         try:
@@ -296,11 +283,20 @@ class EditLedger:
         except Exception:
             pass
 
+        # Branch + HEAD from the cached GitContext (cheap; shared TTL cache).
+        try:
+            gstate = self._git.state()
+            info["branch"] = gstate.get("branch")
+            info["head_sha"] = gstate.get("head_sha", "")
+        except Exception:
+            pass
+
         return info, diff_summary
 
     # ── Async enrichment ──────────────────────────────────────────────
 
-    def _load_merged(self, file_filter: str = None, since_filter: str = None) -> list:
+    def _load_merged(self, file_filter: str = None, since_filter: str = None,
+                     branch_filter: str = None) -> list:
         """Read all base entries with any appended patches merged in.
 
         Patch entries are identified by having a 'target_id' field.
@@ -348,6 +344,8 @@ class EditLedger:
                 continue
             if since_filter and entry.get("timestamp", "") < since_filter:
                 continue
+            if branch_filter and (entry.get("git") or {}).get("branch") != branch_filter:
+                continue
             results.append(entry)
         results.sort(key=lambda e: e.get("timestamp", ""))
         return results