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

oracle/services/chat_store.py

@@ -0,0 +1,155 @@
+"""File-based conversation persistence for Oracle Chat."""
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+_STORE_DIR = Path.home() / ".c3" / "oracle" / "conversations"
+
+
+class ChatStore:
+    """Stores chat conversations as JSON files in ~/.c3/oracle/conversations/."""
+
+    def __init__(self, store_dir: Path = _STORE_DIR):
+        self.store_dir = store_dir
+        self.store_dir.mkdir(parents=True, exist_ok=True)
+        self._index_path = self.store_dir / "index.json"
+
+    # ── Index ─────────────────────────────────────────────
+
+    def _load_index(self) -> list[dict]:
+        if self._index_path.exists():
+            try:
+                return json.loads(self._index_path.read_text("utf-8"))
+            except (json.JSONDecodeError, OSError):
+                pass
+        return []
+
+    def _save_index(self, index: list[dict]):
+        self._index_path.write_text(json.dumps(index, indent=2), "utf-8")
+
+    def _touch_index(self, conv_id: str, **updates):
+        """Update an index entry in-place."""
+        index = self._load_index()
+        for entry in index:
+            if entry["id"] == conv_id:
+                entry["updated"] = datetime.now(timezone.utc).isoformat()
+                entry.update(updates)
+                break
+        self._save_index(index)
+
+    # ── Conversations ─────────────────────────────────────
+
+    def list_conversations(self, limit: int = 50) -> list[dict]:
+        """Return index entries sorted by most recent first."""
+        index = self._load_index()
+        index.sort(key=lambda e: e.get("updated", ""), reverse=True)
+        return index[:limit]
+
+    def create_conversation(self, title: str | None = None) -> str:
+        """Create a new empty conversation. Returns its ID."""
+        conv_id = uuid.uuid4().hex[:12]
+        now = datetime.now(timezone.utc).isoformat()
+        entry = {
+            "id": conv_id,
+            "title": title or "New chat",
+            "created": now,
+            "updated": now,
+            "message_count": 0,
+        }
+        index = self._load_index()
+        index.insert(0, entry)
+        self._save_index(index)
+        self._conv_path(conv_id).write_text("[]", "utf-8")
+        return conv_id
+
+    def get_conversation(self, conv_id: str) -> list[dict]:
+        """Return full message list for a conversation."""
+        path = self._conv_path(conv_id)
+        if not path.exists():
+            return []
+        try:
+            return json.loads(path.read_text("utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return []
+
+    def append_message(self, conv_id: str, message: dict):
+        """Append a message and update the index."""
+        path = self._conv_path(conv_id)
+        messages = self.get_conversation(conv_id)
+        if "timestamp" not in message:
+            message["timestamp"] = datetime.now(timezone.utc).isoformat()
+        messages.append(message)
+        path.write_text(json.dumps(messages, indent=2), "utf-8")
+
+        updates = {"message_count": len(messages)}
+        # Auto-title from first user message
+        if len(messages) == 1 and message.get("role") == "user":
+            updates["title"] = self._auto_title(message.get("content", ""))
+        self._touch_index(conv_id, **updates)
+
+    def append_messages(self, conv_id: str, new_messages: list[dict]):
+        """Append multiple messages at once."""
+        path = self._conv_path(conv_id)
+        messages = self.get_conversation(conv_id)
+        now = datetime.now(timezone.utc).isoformat()
+        for msg in new_messages:
+            if "timestamp" not in msg:
+                msg["timestamp"] = now
+            messages.append(msg)
+        path.write_text(json.dumps(messages, indent=2), "utf-8")
+
+        updates = {"message_count": len(messages)}
+        if len(messages) == len(new_messages) and new_messages and new_messages[0].get("role") == "user":
+            updates["title"] = self._auto_title(new_messages[0].get("content", ""))
+        self._touch_index(conv_id, **updates)
+
+    def delete_conversation(self, conv_id: str):
+        """Delete a conversation, its state, and its index entry."""
+        for path in (self._conv_path(conv_id), self._state_path(conv_id)):
+            if path.exists():
+                path.unlink()
+        index = [e for e in self._load_index() if e["id"] != conv_id]
+        self._save_index(index)
+
+    def update_title(self, conv_id: str, title: str):
+        self._touch_index(conv_id, title=title)
+
+    # ── Per-conversation state ────────────────────────────
+
+    _DEFAULT_STATE = {"focused_projects": [], "model": None, "depth": "normal"}
+
+    def get_state(self, conv_id: str) -> dict:
+        """Get conversation session state (focused projects, model, depth)."""
+        path = self._state_path(conv_id)
+        if path.exists():
+            try:
+                state = json.loads(path.read_text("utf-8"))
+                return {**self._DEFAULT_STATE, **state}
+            except (json.JSONDecodeError, OSError):
+                pass
+        return dict(self._DEFAULT_STATE)
+
+    def set_state(self, conv_id: str, state: dict):
+        """Persist full conversation session state."""
+        self._state_path(conv_id).write_text(json.dumps(state, indent=2), "utf-8")
+
+    def update_state(self, conv_id: str, **updates):
+        """Merge updates into existing state."""
+        state = self.get_state(conv_id)
+        state.update(updates)
+        self.set_state(conv_id, state)
+
+    # ── Helpers ───────────────────────────────────────────
+
+    def _conv_path(self, conv_id: str) -> Path:
+        return self.store_dir / f"{conv_id}.json"
+
+    def _state_path(self, conv_id: str) -> Path:
+        return self.store_dir / f"{conv_id}_state.json"
+
+    @staticmethod
+    def _auto_title(text: str) -> str:
+        text = text.strip().replace("\n", " ")
+        return text[:60] + ("..." if len(text) > 60 else "")

oracle/services/cross_memory.py

@@ -0,0 +1,154 @@
+"""Cross-project insight store for Oracle."""
+
+import json
+import uuid
+from datetime import datetime, timezone
+
+from oracle.config import ORACLE_DIR
+
+_CROSS_MEMORY_FILE = ORACLE_DIR / "cross_memory.json"
+
+INSIGHT_TYPES = {
+    "pattern", "dependency", "convention", "risk", "opportunity", "drift",
+    "shared_convention", "duplicated_fact", "divergent_decision", "shared_bug_pattern",
+}
+
+
+def _load() -> dict:
+    try:
+        if _CROSS_MEMORY_FILE.is_file():
+            with open(_CROSS_MEMORY_FILE, encoding="utf-8") as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {"version": 1, "insights": [], "project_links": []}
+
+
+def _save(data: dict):
+    ORACLE_DIR.mkdir(parents=True, exist_ok=True)
+    with open(_CROSS_MEMORY_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+class CrossMemory:
+    """Manages cross-project insights and project links."""
+
+    def __init__(self):
+        self.data = _load()
+
+    def reload(self):
+        self.data = _load()
+
+    def get_all_insights(self) -> list[dict]:
+        return [i for i in self.data.get("insights", []) if not i.get("dismissed")]
+
+    def get_for_project(self, project_path: str) -> list[dict]:
+        return [
+            i for i in self.get_all_insights()
+            if project_path in i.get("source_projects", [])
+        ]
+
+    def search(self, query: str, top_k: int = 10) -> list[dict]:
+        """Simple keyword search over insight text."""
+        query_lower = query.lower()
+        terms = query_lower.split()
+        scored = []
+        for insight in self.get_all_insights():
+            text_lower = insight.get("text", "").lower()
+            score = sum(1 for t in terms if t in text_lower)
+            if score > 0:
+                scored.append((score, insight))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [s[1] for s in scored[:top_k]]
+
+    def add_insight(
+        self,
+        text: str,
+        insight_type: str,
+        source_projects: list[str],
+        source_fact_ids: dict[str, list[str]] | None = None,
+        confidence: float = 0.7,
+        tags: list[str] | None = None,
+    ) -> dict:
+        """Add a new cross-project insight, deduplicating by text similarity."""
+        # Simple dedup: skip if very similar insight already exists
+        for existing in self.get_all_insights():
+            if self._jaccard(text, existing.get("text", "")) > 0.6:
+                existing["last_reviewed"] = datetime.now(timezone.utc).isoformat()
+                existing["confidence"] = max(existing.get("confidence", 0), confidence)
+                _save(self.data)
+                return existing
+
+        now = datetime.now(timezone.utc).isoformat()
+        insight = {
+            "id": f"ins_{uuid.uuid4().hex[:12]}",
+            "type": insight_type if insight_type in INSIGHT_TYPES else "pattern",
+            "text": text,
+            "source_projects": source_projects,
+            "source_fact_ids": source_fact_ids or {},
+            "confidence": confidence,
+            "created_at": now,
+            "last_reviewed": now,
+            "dismissed": False,
+            "tags": tags or [],
+        }
+        self.data["insights"].append(insight)
+
+        # Update project links
+        self._update_links(insight)
+        _save(self.data)
+        return insight
+
+    def dismiss(self, insight_id: str) -> dict:
+        for insight in self.data.get("insights", []):
+            if insight["id"] == insight_id:
+                insight["dismissed"] = True
+                _save(self.data)
+                return {"dismissed": True, "id": insight_id}
+        return {"error": "Insight not found"}
+
+    def get_project_links(self) -> list[dict]:
+        return self.data.get("project_links", [])
+
+    def stats(self) -> dict:
+        insights = self.get_all_insights()
+        by_type: dict[str, int] = {}
+        for i in insights:
+            t = i.get("type", "unknown")
+            by_type[t] = by_type.get(t, 0) + 1
+        return {
+            "total_insights": len(insights),
+            "by_type": by_type,
+            "total_links": len(self.data.get("project_links", [])),
+        }
+
+    def _update_links(self, insight: dict):
+        """Create or strengthen project links from an insight."""
+        projects = insight.get("source_projects", [])
+        links = self.data.setdefault("project_links", [])
+        for i, src in enumerate(projects):
+            for dst in projects[i + 1:]:
+                existing = next(
+                    (l for l in links if {l["src"], l["dst"]} == {src, dst}),
+                    None,
+                )
+                if existing:
+                    existing["strength"] = existing.get("strength", 0) + 1
+                    if insight["id"] not in existing.get("insight_ids", []):
+                        existing.setdefault("insight_ids", []).append(insight["id"])
+                else:
+                    links.append({
+                        "src": src,
+                        "dst": dst,
+                        "link_type": insight.get("type", "pattern"),
+                        "strength": 1,
+                        "insight_ids": [insight["id"]],
+                    })
+
+    @staticmethod
+    def _jaccard(a: str, b: str) -> float:
+        words_a = set(a.lower().split())
+        words_b = set(b.lower().split())
+        if not words_a or not words_b:
+            return 0.0
+        return len(words_a & words_b) / len(words_a | words_b)