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

oracle/services/c3_bridge.py

@@ -0,0 +1,210 @@
+"""C3Bridge — gives Oracle full read-only access to C3 tool handlers.
+
+Manages an LRU cache of C3Runtime instances (one per project) and wraps
+each handler with project_path dispatch + read-only enforcement.
+"""
+
+import asyncio
+import logging
+import threading
+from pathlib import Path
+
+from services.runtime import C3Runtime, build_runtime, stop_runtime
+
+log = logging.getLogger("oracle.c3_bridge")
+
+# Actions that are blocked in Oracle context (read-only).
+_BLOCKED_EDITS_ACTIONS = {"log"}
+_BLOCKED_MEMORY_ACTIONS = {"add", "update", "delete", "consolidate", "consolidate_deep", "ground"}
+_BLOCKED_STATUS_VIEWS = {"ghost_files"}
+
+
+def _noop_finalize(_name: str, _args: dict, resp: str, _summ: str = "", **_kw) -> str:
+    """No-op finalize — Oracle doesn't track MCP budgets."""
+    return resp
+
+
+def _noop_facts(*_a, **_kw) -> str:
+    """Stub for maybe_facts callback (currently disabled in C3 too)."""
+    return ""
+
+
+class C3Bridge:
+    """Bridge between Oracle and C3 tool handlers with per-project runtime cache."""
+
+    MAX_CACHED = 3
+
+    def __init__(self, scanner):
+        self.scanner = scanner
+        self._runtimes: dict[str, C3Runtime] = {}
+        self._access_order: list[str] = []
+        self._lock = threading.Lock()
+
+    # ── Runtime cache ──────────────────────────────────────────────
+
+    def get_runtime(self, project_path: str) -> C3Runtime:
+        """Return cached runtime or build a new one.  LRU eviction at MAX_CACHED."""
+        project_path = str(Path(project_path).resolve())
+        with self._lock:
+            if project_path in self._runtimes:
+                self._access_order.remove(project_path)
+                self._access_order.append(project_path)
+                return self._runtimes[project_path]
+
+        # Validate before building (outside lock to avoid holding it long).
+        p = Path(project_path)
+        if not p.exists():
+            raise ValueError(f"Project path does not exist: {project_path}")
+        if not (p / ".c3").is_dir():
+            raise ValueError(f"No .c3 directory in {project_path}. Run 'c3 install' first.")
+
+        runtime = build_runtime(project_path, ide_name="claude-code")
+        log.info("Built C3Runtime for %s", project_path)
+
+        with self._lock:
+            # Double-check after build (another thread may have built it).
+            if project_path in self._runtimes:
+                stop_runtime(runtime)
+                self._access_order.remove(project_path)
+                self._access_order.append(project_path)
+                return self._runtimes[project_path]
+
+            self._runtimes[project_path] = runtime
+            self._access_order.append(project_path)
+
+            # Evict oldest if over limit.
+            while len(self._access_order) > self.MAX_CACHED:
+                evict = self._access_order.pop(0)
+                evicted = self._runtimes.pop(evict, None)
+                if evicted:
+                    stop_runtime(evicted)
+                    log.info("Evicted C3Runtime for %s", evict)
+
+        return runtime
+
+    def shutdown(self):
+        """Stop all cached runtimes."""
+        with self._lock:
+            for path, rt in self._runtimes.items():
+                stop_runtime(rt)
+                log.info("Shutdown C3Runtime for %s", path)
+            self._runtimes.clear()
+            self._access_order.clear()
+
+    # ── Helpers ────────────────────────────────────────────────────
+
+    def _discover_c3_projects(self) -> list[dict]:
+        """Return projects that have a .c3 directory."""
+        projects = self.scanner.discover()
+        return [p for p in projects if p.get("has_c3")]
+
+    # ── Per-project tool wrappers ─────────────────────────────────
+
+    def c3_search(self, project_path: str, query: str, action: str = "code",
+                  top_k: int = 3, max_tokens: int = 1200) -> dict:
+        from cli.tools.search import handle_search
+        svc = self.get_runtime(project_path)
+        result = handle_search(query, action, top_k, max_tokens,
+                               svc, _noop_finalize, _noop_facts)
+        return {"project": project_path, "result": result}
+
+    def c3_read(self, project_path: str, file_path: str,
+                symbols=None, lines=None) -> dict:
+        from cli.tools.read import handle_read
+        svc = self.get_runtime(project_path)
+        result = handle_read(file_path, symbols=symbols, lines=lines, svc=svc,
+                             finalize=_noop_finalize)
+        return {"project": project_path, "result": result}
+
+    def c3_edits(self, project_path: str, action: str = "history",
+                 file: str = "", change_type: str = "", summary: str = "",
+                 lines_changed: str = "", tags: str = "", limit: int = 50,
+                 since: str = "", edit_id: str = "", tag: str = "") -> dict:
+        if action in _BLOCKED_EDITS_ACTIONS:
+            return {"error": f"Action '{action}' is write-only and blocked in Oracle. "
+                             "Use suggest_action for write operations."}
+        from cli.tools.edits import handle_edits
+        svc = self.get_runtime(project_path)
+        result = handle_edits(action, file, change_type, summary,
+                              lines_changed, tags, limit, since,
+                              edit_id, tag, svc, _noop_finalize)
+        return {"project": project_path, "result": result}
+
+    def c3_memory(self, project_path: str, action: str = "query",
+                  query: str = "", fact: str = "", category: str = "",
+                  top_k: int = 10, fact_id: str = "") -> dict:
+        if action in _BLOCKED_MEMORY_ACTIONS:
+            return {"error": f"Action '{action}' is blocked in Oracle (read-only). "
+                             "Use suggest_action to propose memory changes."}
+        from cli.tools.memory import handle_memory
+        svc = self.get_runtime(project_path)
+        result = handle_memory(action, query, fact, category, top_k,
+                               svc, _noop_finalize, fact_id=fact_id)
+        return {"project": project_path, "result": result}
+
+    def c3_compress(self, project_path: str, file_path: str,
+                    mode: str = "map") -> dict:
+        from cli.tools.compress import handle_compress
+        svc = self.get_runtime(project_path)
+        result = handle_compress(file_path, mode, svc, _noop_finalize, _noop_facts)
+        return {"project": project_path, "result": result}
+
+    def c3_validate(self, project_path: str, file_path: str) -> dict:
+        from cli.tools.validate import handle_validate
+        svc = self.get_runtime(project_path)
+        result = asyncio.run(handle_validate(file_path, svc, _noop_finalize))
+        return {"project": project_path, "result": result}
+
+    def c3_status(self, project_path: str, view: str = "health",
+                  detailed: bool = False) -> dict:
+        if view in _BLOCKED_STATUS_VIEWS:
+            return {"error": f"View '{view}' has side effects and is blocked in Oracle."}
+        from cli.tools.status import handle_status
+        svc = self.get_runtime(project_path)
+        result = handle_status(view, detailed, svc, _noop_finalize)
+        return {"project": project_path, "result": result}
+
+    def c3_filter(self, project_path: str, file_path: str = "", text: str = "",
+                  pattern: str = "", max_lines: int = 100,
+                  depth: str = "smart") -> dict:
+        from cli.tools.filter import handle_filter
+        svc = self.get_runtime(project_path)
+        result = handle_filter(file_path, text, pattern, max_lines,
+                               depth, False, svc, _noop_finalize)
+        return {"project": project_path, "result": result}
+
+    # ── Cross-project aggregation ─────────────────────────────────
+
+    def c3_search_cross(self, query: str, action: str = "code",
+                        top_k: int = 3) -> dict:
+        """Search code across ALL registered projects."""
+        projects = self._discover_c3_projects()
+        results = []
+        for proj in projects:
+            path = proj.get("path", "")
+            if not path:
+                continue
+            try:
+                r = self.c3_search(path, query, action, top_k)
+                results.append({"project": path, "result": r.get("result", "")})
+            except Exception as e:
+                results.append({"project": path, "error": str(e)})
+        return {"projects_queried": len(results), "results": results}
+
+    def c3_edits_cross(self, action: str = "history", tag: str = "",
+                       limit: int = 20) -> dict:
+        """Query edit ledgers across ALL registered projects."""
+        if action in _BLOCKED_EDITS_ACTIONS:
+            return {"error": f"Action '{action}' is write-only and blocked in Oracle."}
+        projects = self._discover_c3_projects()
+        results = []
+        for proj in projects:
+            path = proj.get("path", "")
+            if not path:
+                continue
+            try:
+                r = self.c3_edits(path, action=action, tag=tag, limit=limit)
+                results.append({"project": path, "result": r.get("result", "")})
+            except Exception as e:
+                results.append({"project": path, "error": str(e)})
+        return {"projects_queried": len(results), "results": results}