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

oracle/services/ollama_bridge.py

@@ -0,0 +1,332 @@
+"""OllamaBridge — Ollama cloud API client with Bearer auth for Oracle.
+
+Uses the Ollama cloud service (https://ollama.com) by default.
+Falls back to local Ollama (http://localhost:11434) if no API key is set.
+API key can come from config or OLLAMA_API_KEY env var.
+"""
+
+import hashlib
+import json
+import logging
+import os
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+_ORACLE_CACHE_DIR = Path.home() / ".c3" / "oracle" / "cache" / "llm"
+_TIMEOUT = 30
+
+
+class _Cache:
+    """Simple disk cache for LLM responses."""
+
+    def __init__(self, cache_dir: Path = _ORACLE_CACHE_DIR):
+        self._dir = cache_dir
+        self._dir.mkdir(parents=True, exist_ok=True)
+
+    def _key(self, prompt: str, model: str, system: str = "", **opts) -> str:
+        raw = f"{model}:{system}:{prompt}:{json.dumps(opts, sort_keys=True)}"
+        return hashlib.md5(raw.encode()).hexdigest()
+
+    def get(self, prompt: str, model: str, system: str = "", **opts) -> Optional[str]:
+        path = self._dir / f"{self._key(prompt, model, system, **opts)}.json"
+        if path.exists():
+            try:
+                return json.loads(path.read_text(encoding="utf-8")).get("response")
+            except Exception:
+                pass
+        return None
+
+    def set(self, prompt: str, model: str, response: str, system: str = "", **opts):
+        path = self._dir / f"{self._key(prompt, model, system, **opts)}.json"
+        try:
+            path.write_text(json.dumps({
+                "model": model, "prompt": prompt[:200],
+                "response": response,
+            }, indent=2), encoding="utf-8")
+        except Exception:
+            pass
+
+
+class OllamaBridge:
+    """Ollama cloud (or local) API client with Bearer token auth.
+
+    Priority for API key:
+      1. Explicit api_key parameter
+      2. OLLAMA_API_KEY environment variable
+    If neither is set, requests are sent without auth (works for local Ollama).
+    """
+
+    def __init__(
+        self,
+        base_url: str = "https://ollama.com",
+        model: str = "gemma4:31b-cloud",
+        api_key: str = "",
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        self.api_key = api_key or os.environ.get("OLLAMA_API_KEY", "")
+        self._cache = _Cache()
+
+    def _headers(self) -> dict:
+        h = {"Content-Type": "application/json"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        return h
+
+    def _request(self, path: str, data: dict | None = None, timeout: int = _TIMEOUT):
+        """Make an HTTP request to the Ollama API."""
+        url = f"{self.base_url}{path}"
+        if data is not None:
+            payload = json.dumps(data).encode()
+            req = urllib.request.Request(url, data=payload, headers=self._headers(), method="POST")
+        else:
+            req = urllib.request.Request(url, headers=self._headers())
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+
+    # ── Availability ──────────────────────────────────────
+
+    def is_available(self, timeout: int | None = None) -> bool:
+        """Check if Ollama API is reachable."""
+        t = timeout or 5
+        try:
+            self._request("/api/tags", timeout=t)
+            return True
+        except Exception:
+            pass
+        # Cloud endpoints may not support /api/tags — try a HEAD-style chat
+        try:
+            url = f"{self.base_url}/api/chat"
+            req = urllib.request.Request(url, headers=self._headers(), method="HEAD")
+            urllib.request.urlopen(req, timeout=t)
+            return True
+        except urllib.error.HTTPError:
+            # Any HTTP response (even 4xx/5xx) means the server is reachable
+            return True
+        except Exception:
+            return False
+
+    # ── Models ────────────────────────────────────────────
+
+    def list_models(self) -> list[str] | None:
+        """Return list of available model names."""
+        try:
+            data = self._request("/api/tags")
+            return [m["name"] for m in data.get("models", [])]
+        except Exception:
+            return None
+
+    def has_model(self, model: str | None = None) -> bool:
+        """Check if a model is available.
+
+        Cloud models (name contains 'cloud') won't appear in /api/tags,
+        so we skip the tags check and rely on verify_model() instead.
+        """
+        target = model or self.model
+        if "cloud" in target.lower():
+            # Cloud models are not listed in /api/tags — can't check there
+            return True  # defer to verify_model for actual reachability
+        models = self.list_models()
+        if models is None:
+            return False
+        return any(target in m or m.startswith(target) for m in models)
+
+    def verify_model(self, model: str | None = None) -> bool:
+        """Verify a model works by attempting a minimal generation.
+
+        Cloud models may not appear in /api/tags and may only support
+        /api/chat (not /api/generate). Try chat first (works for both
+        local and cloud), fall back to generate for legacy endpoints.
+        """
+        log = logging.getLogger("oracle.bridge")
+        use_model = model or self.model
+        is_cloud = "cloud" in use_model.lower()
+        # Cloud models need longer timeout for cold start
+        timeout = 60 if is_cloud else 20
+
+        # Try /api/chat first — works for both local and cloud models
+        try:
+            result = self.chat(
+                [{"role": "user", "content": "Reply with only: OK"}],
+                model=use_model, max_tokens=4, timeout=timeout,
+            )
+            if result is not None and len(result.strip()) > 0:
+                log.info("Model %s verified via /api/chat", use_model)
+                return True
+            log.warning("Model %s: /api/chat returned empty response", use_model)
+        except Exception as e:
+            log.warning("Model %s: /api/chat failed: %s", use_model, e)
+
+        # Fallback: /api/generate (some local-only or specific cloud models need this)
+        try:
+            result = self.generate("Reply with only: OK", model=use_model, max_tokens=4, timeout=timeout)
+            if result is not None and len(result.strip()) > 0:
+                log.info("Model %s verified via /api/generate", use_model)
+                return True
+            log.warning("Model %s: /api/generate returned empty response", use_model)
+        except Exception as e:
+            log.warning("Model %s: /api/generate failed: %s", use_model, e)
+
+        log.error("Model %s: verification FAILED — model may not be available or needs longer timeout", use_model)
+        return False
+
+    # ── Generation ────────────────────────────────────────
+
+    def generate(
+        self,
+        prompt: str,
+        system: str = "",
+        temperature: float = 0.3,
+        max_tokens: int = 1024,
+        num_ctx: int = 8192,
+        model: str | None = None,
+        timeout: int = 120,
+        think: bool = True,
+    ) -> str | None:
+        """Generate text completion via Ollama API."""
+        use_model = model or self.model
+        options = {"temperature": temperature, "num_predict": max_tokens, "num_ctx": num_ctx}
+
+        # Check cache
+        cached = self._cache.get(prompt, use_model, system, **options)
+        if cached:
+            return cached
+
+        try:
+            body: dict = {
+                "model": use_model,
+                "prompt": prompt,
+                "stream": False,
+                "options": options,
+            }
+            if system:
+                body["system"] = system
+            if "cloud" in use_model.lower():
+                body["think"] = think
+
+            data = self._request("/api/generate", data=body, timeout=timeout)
+            response = data.get("response") or data.get("content")
+            if response:
+                self._cache.set(prompt, use_model, response, system, **options)
+            return response
+        except Exception as e:
+            logging.getLogger("oracle.bridge").warning("generate(%s) failed: %s", use_model, e)
+            return None
+
+    # ── Chat (alternative API) ────────────────────────────
+
+    def chat(
+        self,
+        messages: list[dict],
+        model: str | None = None,
+        temperature: float = 0.3,
+        max_tokens: int = 1024,
+        num_ctx: int = 16384,
+        timeout: int = 120,
+        think: bool = True,
+    ) -> str | None:
+        """Chat completion via Ollama /api/chat endpoint."""
+        use_model = model or self.model
+        try:
+            body = {
+                "model": use_model,
+                "messages": messages,
+                "stream": False,
+                "options": {
+                    "temperature": temperature,
+                    "num_predict": max_tokens,
+                    "num_ctx": num_ctx
+                },
+            }
+            if "cloud" in use_model.lower():
+                body["think"] = think
+
+            data = self._request("/api/chat", data=body, timeout=timeout)
+            msg = data.get("message", {})
+            # Return content if present, otherwise thinking (for R1-style models)
+            content = msg.get("content")
+            if not content:
+                content = msg.get("thinking")
+            return content
+        except Exception as e:
+            logging.getLogger("oracle.bridge").warning("chat(%s) failed: %s", use_model, e)
+            return None
+
+    # ── Streaming Chat ────────────────────────────────────
+
+    def stream_chat(
+        self,
+        messages: list[dict],
+        model: str | None = None,
+        temperature: float = 0.3,
+        max_tokens: int = 2048,
+        num_ctx: int = 16384,
+        timeout: int = 120,
+        think: bool | None = True,
+    ):
+        """Streaming chat completion — yields text chunks as they arrive."""
+        use_model = model or self.model
+        body = {
+            "model": use_model,
+            "messages": messages,
+            "stream": True,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens,
+                "num_ctx": num_ctx,
+            },
+        }
+        if think is not None:
+            body["think"] = think
+        url = f"{self.base_url}/api/chat"
+        payload = json.dumps(body).encode()
+        req = urllib.request.Request(
+            url, data=payload, headers=self._headers(), method="POST"
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            for line in resp:
+                if not line:
+                    continue
+                chunk = json.loads(line.decode("utf-8"))
+                msg = chunk.get("message", {})
+                # Models with think=True put reasoning in "thinking" field.
+                thinking = msg.get("thinking", "")
+                if thinking:
+                    yield ("thinking", thinking)
+                content = msg.get("content", "")
+                if content:
+                    yield ("text", content)
+                if chunk.get("done"):
+                    # Final chunk carries token stats from Ollama
+                    stats = {}
+                    for key in (
+                        "total_duration", "load_duration",
+                        "prompt_eval_count", "prompt_eval_duration",
+                        "eval_count", "eval_duration",
+                    ):
+                        if key in chunk:
+                            stats[key] = chunk[key]
+                    if stats:
+                        yield ("stats", stats)
+                    break
+
+    # ── Embeddings ────────────────────────────────────────
+
+    def embed(self, text: str, model: str = "nomic-embed-text") -> list[float] | None:
+        """Generate embedding vector."""
+        try:
+            data = self._request("/api/embed", data={"model": model, "input": text})
+            embeddings = data.get("embeddings")
+            return embeddings[0] if embeddings else None
+        except Exception:
+            return None
+
+    def embed_batch(self, texts: list[str], model: str = "nomic-embed-text") -> list[list[float]] | None:
+        """Embed multiple texts in one call."""
+        try:
+            data = self._request("/api/embed", data={"model": model, "input": texts}, timeout=_TIMEOUT * 3)
+            return data.get("embeddings")
+        except Exception:
+            return None

oracle/services/project_scanner.py

@@ -0,0 +1,87 @@
+"""Discovers C3 projects via hub API or direct file read."""
+
+import json
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+_GLOBAL_C3_DIR = Path.home() / ".c3"
+_PROJECTS_FILE = _GLOBAL_C3_DIR / "projects.json"
+
+
+class ProjectScanner:
+    """Discovers registered C3 projects."""
+
+    def __init__(self, hub_url: str = "http://localhost:3330"):
+        self.hub_url = hub_url.rstrip("/")
+
+    def discover(self) -> list[dict]:
+        """Return list of project dicts with memory metadata.
+
+        Tries hub API first, falls back to reading ~/.c3/projects.json directly.
+        """
+        projects = self._from_hub() or self._from_file()
+        return [self._enrich(p) for p in projects]
+
+    def _from_hub(self) -> list[dict] | None:
+        """Try fetching projects from the hub REST API."""
+        try:
+            req = urllib.request.Request(f"{self.hub_url}/api/projects")
+            with urllib.request.urlopen(req, timeout=2) as resp:
+                data = json.loads(resp.read())
+            raw = data if isinstance(data, list) else data.get("projects", [])
+            return [{
+                "path": p.get("path", ""), "name": p.get("name", ""),
+                "tags": p.get("tags", []), "notes": p.get("notes", ""),
+                "active": p.get("active", False), "ide": p.get("ide", ""),
+            } for p in raw if p.get("path")]
+        except Exception:
+            return None
+
+    def _from_file(self) -> list[dict]:
+        """Fallback: read ~/.c3/projects.json directly."""
+        try:
+            if _PROJECTS_FILE.exists():
+                with open(_PROJECTS_FILE, encoding="utf-8") as f:
+                    data = json.load(f)
+                return [{
+                    "path": p.get("path", ""), "name": p.get("name", ""),
+                    "tags": p.get("tags", []), "notes": p.get("notes", ""),
+                } for p in data.get("projects", []) if p.get("path")]
+        except Exception:
+            pass
+        return []
+
+    def _enrich(self, project: dict) -> dict:
+        """Add C3 metadata to a project entry."""
+        path = Path(project["path"])
+        c3_dir = path / ".c3"
+        facts_file = c3_dir / "facts" / "facts.json"
+
+        has_c3 = c3_dir.is_dir()
+        has_facts = facts_file.is_file()
+        fact_count = 0
+        last_modified = None
+
+        if has_facts:
+            try:
+                stat = facts_file.stat()
+                last_modified = stat.st_mtime
+                with open(facts_file, encoding="utf-8") as f:
+                    facts = json.load(f)
+                fact_count = len(facts) if isinstance(facts, list) else 0
+            except Exception:
+                pass
+
+        return {
+            "path": project["path"],
+            "name": project.get("name") or path.name,
+            "tags": project.get("tags", []),
+            "notes": project.get("notes", ""),
+            "active": project.get("active", False),
+            "ide": project.get("ide", ""),
+            "has_c3": has_c3,
+            "has_facts": has_facts,
+            "fact_count": fact_count,
+            "facts_mtime": last_modified,
+        }

oracle/services/review_agent.py

@@ -0,0 +1,206 @@
+"""Background daemon that periodically reviews all C3 projects."""
+
+import json
+import logging
+import threading
+from datetime import datetime, timezone
+
+from oracle.config import ORACLE_DIR
+from oracle.services.cross_memory import CrossMemory
+from oracle.services.health_checker import HealthChecker
+from oracle.services.insight_engine import InsightEngine
+from oracle.services.memory_reader import MemoryReader
+from oracle.services.memory_writer import MemoryWriter
+from oracle.services.project_scanner import ProjectScanner
+
+_STATE_FILE = ORACLE_DIR / "review_state.json"
+_REPORTS_DIR = ORACLE_DIR / "project_reports"
+
+log = logging.getLogger("oracle.review")
+
+
+def _load_state() -> dict:
+    try:
+        if _STATE_FILE.is_file():
+            with open(_STATE_FILE, encoding="utf-8") as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {"projects": {}}
+
+
+def _save_state(state: dict):
+    ORACLE_DIR.mkdir(parents=True, exist_ok=True)
+    with open(_STATE_FILE, "w", encoding="utf-8") as f:
+        json.dump(state, f, indent=2)
+
+
+def _save_report(project_path: str, report: dict):
+    _REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+    import hashlib
+    key = hashlib.sha256(project_path.encode()).hexdigest()[:16]
+    with open(_REPORTS_DIR / f"{key}.json", "w", encoding="utf-8") as f:
+        json.dump(report, f, indent=2)
+
+
+def _load_report(project_path: str) -> dict | None:
+    import hashlib
+    key = hashlib.sha256(project_path.encode()).hexdigest()[:16]
+    rfile = _REPORTS_DIR / f"{key}.json"
+    if not rfile.is_file():
+        return None
+    try:
+        with open(rfile, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+class ReviewAgent:
+    """Background daemon thread that reviews projects periodically."""
+
+    def __init__(
+        self,
+        scanner: ProjectScanner,
+        reader: MemoryReader,
+        health_checker: HealthChecker,
+        insight_engine: InsightEngine,
+        cross_memory: CrossMemory,
+        writer: MemoryWriter,
+        interval: int = 1800,
+        federated_graph=None,
+    ):
+        self.scanner = scanner
+        self.reader = reader
+        self.health_checker = health_checker
+        self.insight_engine = insight_engine
+        self.cross_memory = cross_memory
+        self.writer = writer
+        self.interval = interval
+        self.federated_graph = federated_graph
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._state = _load_state()
+        self._last_run: str | None = None
+        self._running = False
+
+    @property
+    def status(self) -> dict:
+        return {
+            "running": self._running,
+            "last_run": self._last_run,
+            "interval_seconds": self.interval,
+            "projects_tracked": len(self._state.get("projects", {})),
+        }
+
+    def start(self):
+        if self._thread and self._thread.is_alive():
+            return
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._loop, daemon=True, name="oracle-review")
+        self._thread.start()
+        self._running = True
+        log.info("Review agent started (interval=%ds)", self.interval)
+
+    def stop(self):
+        self._stop.set()
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=5)
+        log.info("Review agent stopped")
+
+    def run_now(self):
+        """Trigger one immediate review cycle in a background thread."""
+        threading.Thread(target=self._review_cycle, daemon=True, name="oracle-review-now").start()
+
+    def _loop(self):
+        self._stop.wait(10)  # initial delay
+        while not self._stop.is_set():
+            try:
+                self._review_cycle()
+            except Exception as e:
+                log.error("Review cycle failed: %s", e)
+            self._stop.wait(self.interval)
+
+    def _review_cycle(self):
+        log.info("Starting review cycle")
+        projects = self.scanner.discover()
+        changed = []
+
+        for proj in projects:
+            path = proj["path"]
+            old_mtime = (self._state.get("projects", {}).get(path, {}).get("facts_mtime"))
+            current_mtime = proj.get("facts_mtime")
+
+            if current_mtime and current_mtime != old_mtime:
+                changed.append(proj)
+
+            # Always cache health report
+            try:
+                report = self.health_checker.check(path)
+                _save_report(path, report)
+            except Exception as e:
+                log.warning("Health check failed for %s: %s", path, e)
+
+        # Update state
+        for proj in projects:
+            self._state.setdefault("projects", {})[proj["path"]] = {
+                "last_reviewed": datetime.now(timezone.utc).isoformat(),
+                "facts_mtime": proj.get("facts_mtime"),
+                "fact_count": proj.get("fact_count", 0),
+            }
+        _save_state(self._state)
+
+        # Refresh federated graph cache (no auto cross-insights — on-demand only)
+        if len(changed) >= 2 and self.federated_graph is not None:
+            try:
+                all_paths = [p["path"] for p in projects if p.get("has_facts")]
+                self.federated_graph.invalidate()
+                self.federated_graph.build(all_paths, force=True)
+                log.info("Federated graph refreshed (%d projects, %d changed)",
+                         len(all_paths), len(changed))
+            except Exception as e:
+                log.warning("Federated graph refresh failed: %s", e)
+
+        # Auto-suggest consolidation for projects with many facts
+        for proj in changed:
+            if proj.get("fact_count", 0) > 30:
+                try:
+                    suggestions = self.insight_engine.suggest_consolidation(proj["path"])
+                    for s in suggestions:
+                        if s.get("action") == "merge":
+                            self.writer.suggest(proj["path"], "merge_facts", {
+                                "survivor_id": s.get("survivor_id"),
+                                "merge_ids": s.get("fact_ids", []),
+                                "merged_text": s.get("merged_text", ""),
+                            })
+                        elif s.get("action") == "archive":
+                            self.writer.suggest(proj["path"], "archive_facts", {
+                                "fact_ids": s.get("fact_ids", []),
+                            })
+                except Exception as e:
+                    log.warning("Consolidation suggestion failed for %s: %s", proj["path"], e)
+
+        self._last_run = datetime.now(timezone.utc).isoformat()
+        log.info("Review cycle complete: %d projects, %d changed", len(projects), len(changed))
+
+    def get_report(self, project_path: str) -> dict | None:
+        return _load_report(project_path)
+
+    def review_single(self, project_path: str) -> dict:
+        """Run a manual review for one project. Saves report + updates state."""
+        report = self.health_checker.check(project_path)
+        _save_report(project_path, report)
+        self._state.setdefault("projects", {})[project_path] = {
+            "last_reviewed": datetime.now(timezone.utc).isoformat(),
+            "facts_mtime": report.get("fact_stats", {}).get("total"),
+            "fact_count": report.get("fact_stats", {}).get("total", 0),
+        }
+        _save_state(self._state)
+        return report
+
+    def get_last_reviewed(self, project_path: str) -> str | None:
+        """Return ISO timestamp of last review for a project."""
+        return (self._state.get("projects", {})
+                .get(project_path, {})
+                .get("last_reviewed"))

services/__init__.py

@@ -0,0 +1 @@
+"""C3 Services — Code Compression, Indexing, Session Management, CLAUDE.md Management, Protocol, Activity Log."""