synap-git 0.2.0__py3-none-any.whl

synap_git/retrieval/memory.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from synap_git.config import SynapSettings
+from synap_git.git.state import GitState
+from synap_git.storage.sqlite import SynapStore
+
+
+@dataclass
+class DirtyWarning:
+    files: list[str]
+    commit: str
+    message: str
+
+
+@dataclass
+class InjectionContext:
+    project_overview: str
+    current_branch: str
+    current_commit: str
+    dirty_warning: DirtyWarning | None
+    recent_commits: list[dict[str, Any]]
+    recent_decisions: list[dict[str, Any]]
+    active_checkpoint: dict[str, Any] | None
+    approved_lessons: list[dict[str, Any]]
+    pending_lessons: list[dict[str, Any]]
+    architecture_summary: str
+
+    def format_header(self) -> str:
+        parts = []
+        parts.append("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+        parts.append(
+            f"SYNAPSE CONTEXT — {self.current_branch} ({self.current_commit[:8] if self.current_commit else 'none'})"
+        )
+        parts.append("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+
+        if self.project_overview:
+            parts.append(self.project_overview)
+        else:
+            parts.append("No project overview available.")
+
+        parts.append("")
+
+        if self.active_checkpoint:
+            parts.append("ACTIVE CHECKPOINT:")
+            parts.append(f"  Working on: {self.active_checkpoint.get('doing', '')}")
+
+            try:
+                changed = json.loads(self.active_checkpoint.get("changed_files", "[]"))
+                parts.append(f"  Changed files: {', '.join(changed)}")
+            except json.JSONDecodeError:
+                parts.append(f"  Changed files: {self.active_checkpoint.get('changed_files', '')}")
+
+            parts.append(f"  Next step: {self.active_checkpoint.get('next_step', '')}")
+            parts.append("")
+
+        if self.approved_lessons:
+            parts.append("APPROVED LESSONS (apply always):")
+            for i, lesson in enumerate(self.approved_lessons, 1):
+                parts.append(
+                    f"  [{i}] {lesson.get('what_failed', '')} -> {lesson.get('why_failed', '')}"
+                )
+            parts.append("")
+
+        if self.pending_lessons:
+            parts.append("PENDING LESSONS (unverified — use with caution):")
+            for i, lesson in enumerate(self.pending_lessons, 1):
+                parts.append(f"  [{i}] ⚠ {lesson.get('what_failed', '')} — awaiting user review")
+            parts.append("")
+
+        if self.recent_decisions:
+            parts.append("RECENT DECISIONS:")
+            for dec in self.recent_decisions:
+                parts.append(f"  [{dec.get('created_at', '')}] {dec.get('content', '')}")
+            parts.append("")
+
+        if self.dirty_warning:
+            parts.append(
+                f"⚠ DIRTY TREE: {len(self.dirty_warning.files)} files modified since {self.dirty_warning.commit}"
+            )
+
+        parts.append("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+        return "\n".join(parts)
+
+
+def check_dirty_tree(git_state: GitState) -> DirtyWarning | None:
+    if git_state.is_dirty:
+        # We'd get actual files from GitState ideally. Let's return empty for now.
+        return DirtyWarning(
+            files=[],
+            commit=git_state.head_commit[:8] if git_state.head_commit else "unknown",
+            message="⚠ Modified files not yet committed. Agent context may not match reported commit.",
+        )
+    return None
+
+
+def read_wiki(settings: SynapSettings, filename: str) -> str:
+    path = settings.state_path / "wiki" / filename
+    if path.exists():
+        return path.read_text(encoding="utf-8")
+    return ""
+
+
+def build_injection_context(
+    settings: SynapSettings, store: SynapStore, git_state: GitState
+) -> InjectionContext:
+    branch = git_state.effective_branch
+
+    return InjectionContext(
+        project_overview=read_wiki(settings, "overview.md"),
+        current_branch=branch,
+        current_commit=git_state.head_commit or "unknown",
+        dirty_warning=check_dirty_tree(git_state),
+        recent_commits=[],
+        recent_decisions=store.get_decisions(branch, limit=10),
+        active_checkpoint=store.get_latest_checkpoint(branch),
+        approved_lessons=store.get_lessons(status="approved"),
+        pending_lessons=store.get_lessons(status="pending"),
+        architecture_summary=read_wiki(settings, "architecture.md"),
+    )

synap_git/storage/__init__.py

@@ -0,0 +1,3 @@
+from synap_git.storage.sqlite import SynapStore
+
+__all__ = ["SynapStore"]

synap_git/storage/sqlite.py

@@ -0,0 +1,575 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from collections.abc import Iterator
+from contextlib import contextmanager
+from datetime import UTC, datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from synap_git.utils.serialization import stable_hash
+
+
+class LessonStatus(str, Enum):
+    PENDING = "pending"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+    EXPIRED = "expired"
+    SUPERSEDED = "superseded"
+    FAILED = "failed"
+
+
+class SynapStore:
+    """Deterministic SQLite store for repository symbols and structural relationships."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+
+    def initialize(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.connect() as conn:
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA synchronous=NORMAL")
+            conn.execute("PRAGMA foreign_keys=ON")
+
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS files (
+                    file_id TEXT PRIMARY KEY,
+                    path TEXT UNIQUE,
+                    git_oid TEXT,
+                    content_hash TEXT,
+                    language TEXT,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS symbols (
+                    symbol_id TEXT PRIMARY KEY,
+                    file_id TEXT,
+                    name TEXT,
+                    kind TEXT,
+                    start_line INTEGER,
+                    end_line INTEGER,
+                    ast_hash TEXT,
+                    metadata_json TEXT,
+                    FOREIGN KEY(file_id) REFERENCES files(file_id) ON DELETE CASCADE
+                );
+
+                CREATE TABLE IF NOT EXISTS edges (
+                    edge_id TEXT PRIMARY KEY,
+                    source_symbol TEXT,
+                    target_symbol TEXT,
+                    edge_type TEXT,
+                    FOREIGN KEY(source_symbol) REFERENCES symbols(symbol_id) ON DELETE CASCADE,
+                    FOREIGN KEY(target_symbol) REFERENCES symbols(symbol_id) ON DELETE CASCADE
+                );
+
+                CREATE TABLE IF NOT EXISTS embeddings (
+                    embedding_id TEXT PRIMARY KEY,
+                    symbol_id TEXT,
+                    model_name TEXT,
+                    model_version TEXT,
+                    prompt_version TEXT,
+                    vector BLOB,
+                    content_hash TEXT,
+                    FOREIGN KEY(symbol_id) REFERENCES symbols(symbol_id) ON DELETE CASCADE
+                );
+
+                CREATE TABLE IF NOT EXISTS active_state (
+                    branch TEXT PRIMARY KEY,
+                    git_commit_hash TEXT,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS decisions (
+                    decision_id TEXT PRIMARY KEY,
+                    branch TEXT NOT NULL,
+                    commit_hash TEXT NOT NULL,
+                    content TEXT NOT NULL,
+                    context TEXT,
+                    agent_id TEXT,
+                    created_at INTEGER NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS checkpoints (
+                    checkpoint_id TEXT PRIMARY KEY,
+                    branch TEXT NOT NULL,
+                    commit_hash TEXT NOT NULL,
+                    doing TEXT NOT NULL,
+                    changed_files TEXT NOT NULL,
+                    next_step TEXT,
+                    decisions TEXT,
+                    blockers TEXT,
+                    token_count INTEGER,
+                    created_at INTEGER NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS lessons (
+                    lesson_id TEXT PRIMARY KEY,
+                    branch TEXT NOT NULL,
+                    revert_commit TEXT NOT NULL,
+                    reverted_from TEXT NOT NULL,
+                    what_failed TEXT NOT NULL,
+                    why_failed TEXT NOT NULL,
+                    files_affected TEXT NOT NULL,
+                    status TEXT NOT NULL DEFAULT 'pending',
+                    created_at INTEGER NOT NULL,
+                    approved_at INTEGER,
+                    expires_at INTEGER NOT NULL,
+                    approval_actor TEXT
+                );
+
+                CREATE TABLE IF NOT EXISTS activity (
+                    activity_id TEXT PRIMARY KEY,
+                    branch TEXT NOT NULL,
+                    commit_hash TEXT NOT NULL,
+                    action TEXT NOT NULL,
+                    files TEXT,
+                    created_at INTEGER NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS llm_calls (
+                    call_id TEXT PRIMARY KEY,
+                    provider TEXT NOT NULL,
+                    model TEXT NOT NULL,
+                    input_tokens INTEGER NOT NULL,
+                    output_tokens INTEGER NOT NULL,
+                    cost_usd REAL NOT NULL,
+                    purpose TEXT NOT NULL,
+                    file_path TEXT,
+                    created_at INTEGER NOT NULL
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_id);
+                CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+                CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_symbol);
+                CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_symbol);
+                CREATE INDEX IF NOT EXISTS idx_embeddings_symbol ON embeddings(symbol_id);
+                CREATE INDEX IF NOT EXISTS idx_lessons_status ON lessons(status);
+                CREATE INDEX IF NOT EXISTS idx_checkpoints_branch ON checkpoints(branch);
+                CREATE INDEX IF NOT EXISTS idx_activity_branch ON activity(branch);
+            """)
+
+    @contextmanager
+    def connect(self) -> Iterator[sqlite3.Connection]:
+        conn = sqlite3.connect(self.path, timeout=30.0)
+        conn.row_factory = sqlite3.Row
+        try:
+            conn.execute("PRAGMA foreign_keys=ON")
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
+
+    def upsert_file_and_symbols(
+        self,
+        file_id: str,
+        path: str,
+        git_oid: str,
+        content_hash: str,
+        language: str,
+        symbols: list[dict[str, Any]],
+    ) -> str:
+        now = datetime.now(UTC).isoformat()
+        with self.connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO files (file_id, path, git_oid, content_hash, language, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(path) DO UPDATE SET
+                    file_id = excluded.file_id,
+                    git_oid = excluded.git_oid,
+                    content_hash = excluded.content_hash,
+                    language = excluded.language,
+                    updated_at = excluded.updated_at
+                """,
+                (file_id, path, git_oid, content_hash, language, now),
+            )
+            conn.execute("DELETE FROM symbols WHERE file_id = ?", (file_id,))
+            for sym in symbols:
+                conn.execute(
+                    """
+                    INSERT INTO symbols (symbol_id, file_id, name, kind, start_line, end_line, ast_hash, metadata_json)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        sym["symbol_id"],
+                        file_id,
+                        sym["name"],
+                        sym["kind"],
+                        sym["start_line"],
+                        sym["end_line"],
+                        sym["ast_hash"],
+                        json.dumps(sym.get("metadata") or {}),
+                    ),
+                )
+        return file_id
+
+    def get_file_by_path(self, path: str) -> dict[str, Any] | None:
+        with self.connect() as conn:
+            row = conn.execute("SELECT * FROM files WHERE path = ?", (path,)).fetchone()
+        return dict(row) if row else None
+
+    def set_active_commit(self, branch: str, commit_hash: str) -> None:
+        now = datetime.now(UTC).isoformat()
+        with self.connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO active_state (branch, git_commit_hash, updated_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(branch) DO UPDATE SET
+                    git_commit_hash = excluded.git_commit_hash,
+                    updated_at = excluded.updated_at
+            """,
+                (branch, commit_hash, now),
+            )
+
+    def get_active_commit(self, branch: str) -> str | None:
+        with self.connect() as conn:
+            row = conn.execute(
+                "SELECT git_commit_hash FROM active_state WHERE branch = ?", (branch,)
+            ).fetchone()
+        return row["git_commit_hash"] if row else None
+
+    def get_symbols_by_file(self, file_id: str) -> list[dict[str, Any]]:
+        with self.connect() as conn:
+            rows = conn.execute(
+                """
+                SELECT s.*, f.path as source_path
+                FROM symbols s
+                JOIN files f ON s.file_id = f.file_id
+                WHERE s.file_id = ?
+                """,
+                (file_id,),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_symbols_by_name(self, name: str) -> list[dict[str, Any]]:
+        with self.connect() as conn:
+            rows = conn.execute(
+                """
+                SELECT s.*, f.path as source_path
+                FROM symbols s
+                JOIN files f ON s.file_id = f.file_id
+                WHERE s.name LIKE ?
+                """,
+                (f"%{name}%",),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_neighborhood(self, symbol_id: str, depth: int = 2) -> list[dict[str, Any]]:
+        """Use Recursive CTE for SQL-side graph traversal."""
+        with self.connect() as conn:
+            rows = conn.execute(
+                """
+                WITH RECURSIVE neighborhood(id, d) AS (
+                    SELECT ? as id, 0 as d
+                    UNION
+                    SELECT target_symbol, d + 1
+                    FROM edges JOIN neighborhood ON source_symbol = id
+                    WHERE d < ?
+                    UNION
+                    SELECT source_symbol, d + 1
+                    FROM edges JOIN neighborhood ON target_symbol = id
+                    WHERE d < ?
+                )
+                SELECT s.*, f.path as source_path, n.d as distance
+                FROM symbols s
+                JOIN files f ON s.file_id = f.file_id
+                JOIN neighborhood n ON s.symbol_id = n.id
+                ORDER BY n.d ASC
+            """,
+                (symbol_id, depth, depth),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def put_embedding(
+        self,
+        symbol_id: str,
+        model_name: str,
+        model_version: str,
+        prompt_version: str,
+        vector: list[float],
+        content_hash: str,
+    ) -> None:
+        embedding_id = stable_hash(
+            {
+                "symbol_id": symbol_id,
+                "model": model_name,
+                "version": model_version,
+                "prompt": prompt_version,
+            }
+        )
+        with self.connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO embeddings (embedding_id, symbol_id, model_name, model_version, prompt_version, vector, content_hash)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(embedding_id) DO UPDATE SET
+                    vector = excluded.vector,
+                    content_hash = excluded.content_hash
+            """,
+                (
+                    embedding_id,
+                    symbol_id,
+                    model_name,
+                    model_version,
+                    prompt_version,
+                    json.dumps(vector),
+                    content_hash,
+                ),
+            )
+
+    def get_embedding(self, symbol_id: str, model_name: str) -> dict[str, Any] | None:
+        with self.connect() as conn:
+            row = conn.execute(
+                """
+                SELECT * FROM embeddings
+                WHERE symbol_id = ? AND model_name = ?
+            """,
+                (symbol_id, model_name),
+            ).fetchone()
+        return dict(row) if row else None
+
+    def put_decision(
+        self, decision_id: str, branch: str, commit_hash: str, content: str, context_info: str
+    ) -> None:
+        now = int(datetime.now(UTC).timestamp())
+        with self.connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO decisions (decision_id, branch, commit_hash, content, context, agent_id, created_at)
+                VALUES (?, ?, ?, ?, ?, 'agent', ?)
+                """,
+                (decision_id, branch, commit_hash, content, context_info, now),
+            )
+
+    def put_checkpoint(
+        self,
+        checkpoint_id: str,
+        branch: str,
+        commit_hash: str,
+        doing: str,
+        changed_files: str,
+        next_step: str,
+        blockers: str,
+    ) -> None:
+        now = int(datetime.now(UTC).timestamp())
+        with self.connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO checkpoints (checkpoint_id, branch, commit_hash, doing, changed_files, next_step, blockers, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    checkpoint_id,
+                    branch,
+                    commit_hash,
+                    doing,
+                    changed_files,
+                    next_step,
+                    blockers,
+                    now,
+                ),
+            )
+
+    def update_lesson(
+        self, lesson_id: str, why_failed: str, status: str, actor: str = "system"
+    ) -> None:
+        try:
+            LessonStatus(status)
+        except ValueError:
+            raise ValueError(f"Invalid lesson status: {status}")
+
+        now = int(datetime.now(UTC).timestamp())
+        with self.connect() as conn:
+            conn.execute(
+                """
+                UPDATE lessons SET why_failed = ?, status = ?, approved_at = ?, approval_actor = ?
+                WHERE lesson_id = ?
+                """,
+                (why_failed, status, now, actor, lesson_id),
+            )
+
+    def prune_expired_lessons(self) -> int:
+        now = int(datetime.now(UTC).timestamp())
+        with self.connect() as conn:
+            cursor = conn.execute(
+                """
+                UPDATE lessons
+                SET status = ?
+                WHERE status IN (?, ?) AND expires_at < ?
+                """,
+                (
+                    LessonStatus.EXPIRED.value,
+                    LessonStatus.PENDING.value,
+                    LessonStatus.APPROVED.value,
+                    now,
+                ),
+            )
+            return cursor.rowcount
+
+    def get_decisions(self, branch: str, limit: int = 10) -> list[dict[str, Any]]:
+        with self.connect() as conn:
+            rows = conn.execute(
+                "SELECT * FROM decisions WHERE branch = ? ORDER BY created_at DESC LIMIT ?",
+                (branch, limit),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_latest_checkpoint(self, branch: str) -> dict[str, Any] | None:
+        with self.connect() as conn:
+            row = conn.execute(
+                "SELECT * FROM checkpoints WHERE branch = ? ORDER BY created_at DESC LIMIT 1",
+                (branch,),
+            ).fetchone()
+        return dict(row) if row else None
+
+    def get_checkpoints(self, branch: str) -> list[dict[str, Any]]:
+        with self.connect() as conn:
+            rows = conn.execute(
+                "SELECT * FROM checkpoints WHERE branch = ? ORDER BY created_at DESC",
+                (branch,),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_checkpoint(self, checkpoint_id: str) -> dict[str, Any] | None:
+        with self.connect() as conn:
+            row = conn.execute(
+                "SELECT * FROM checkpoints WHERE checkpoint_id = ?",
+                (checkpoint_id,),
+            ).fetchone()
+        return dict(row) if row else None
+
+    def delete_checkpoint(self, checkpoint_id: str) -> None:
+        with self.connect() as conn:
+            conn.execute(
+                "DELETE FROM checkpoints WHERE checkpoint_id = ?",
+                (checkpoint_id,),
+            )
+
+    def get_lessons(self, status: str) -> list[dict[str, Any]]:
+        now = int(datetime.now(UTC).timestamp())
+        with self.connect() as conn:
+            rows = conn.execute(
+                "SELECT * FROM lessons WHERE status = ? AND expires_at >= ? ORDER BY created_at DESC",
+                (status, now),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_activity(self, branch: str, limit: int = 50) -> list[dict[str, Any]]:
+        with self.connect() as conn:
+            rows = conn.execute(
+                "SELECT * FROM activity WHERE branch = ? ORDER BY created_at DESC LIMIT ?",
+                (branch, limit),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def integrity_check(self) -> str:
+        with self.connect() as conn:
+            return str(conn.execute("PRAGMA quick_check").fetchone()[0])
+
+    def recover_if_corrupted(self) -> bool:
+        """Checks DB integrity. If corrupted, deletes SQLite files to force a clean rebuild from Git."""
+        try:
+            if not self.path.exists():
+                return False
+            with self.connect() as conn:
+                res = conn.execute("PRAGMA quick_check").fetchone()[0]
+                if res == "ok":
+                    return False
+        except Exception:
+            pass
+
+        # If we got here, it's corrupted or unreachable. Wipe it securely.
+        for ext in ["", "-wal", "-shm"]:
+            f = Path(f"{self.path}{ext}")
+            if f.exists():
+                try:
+                    f.unlink()
+                except OSError:
+                    pass
+        return True
+
+    def put_llm_call(
+        self,
+        provider: str,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        purpose: str,
+        file_path: str | None = None,
+    ) -> None:
+        import uuid
+        from datetime import UTC
+
+        cost = 0.0
+        p_lower = provider.lower() if provider else ""
+        m_lower = model.lower() if model else ""
+
+        if "openai" in p_lower:
+            if "mini" in m_lower:
+                cost = (input_tokens * 0.150 + output_tokens * 0.600) / 1_000_000
+            else:
+                cost = (input_tokens * 5.00 + output_tokens * 15.00) / 1_000_000
+        elif "gemini" in p_lower:
+            if "pro" in m_lower:
+                cost = (input_tokens * 3.50 + output_tokens * 10.50) / 1_000_000
+            else:
+                cost = (input_tokens * 0.075 + output_tokens * 0.300) / 1_000_000
+        elif "anthropic" in p_lower:
+            if "sonnet" in m_lower:
+                cost = (input_tokens * 3.00 + output_tokens * 15.00) / 1_000_000
+            elif "haiku" in m_lower:
+                cost = (input_tokens * 0.25 + output_tokens * 1.25) / 1_000_000
+            else:
+                cost = (input_tokens * 3.00 + output_tokens * 15.00) / 1_000_000
+
+        call_id = str(uuid.uuid4())
+        now = int(datetime.now(UTC).timestamp())
+        with self.connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO llm_calls (call_id, provider, model, input_tokens, output_tokens, cost_usd, purpose, file_path, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    call_id,
+                    provider or "unknown",
+                    model or "unknown",
+                    input_tokens,
+                    output_tokens,
+                    cost,
+                    purpose,
+                    file_path,
+                    now,
+                ),
+            )
+
+    def get_llm_calls(self) -> list[dict[str, Any]]:
+        with self.connect() as conn:
+            rows = conn.execute("SELECT * FROM llm_calls ORDER BY created_at DESC").fetchall()
+        return [dict(row) for row in rows]
+
+    def clear_llm_calls(self) -> None:
+        with self.connect() as conn:
+            conn.execute("DELETE FROM llm_calls")
+
+    def clear_all(self) -> None:
+        with self.connect() as conn:
+            conn.execute("DELETE FROM edges")
+            conn.execute("DELETE FROM symbols")
+            conn.execute("DELETE FROM files")
+            conn.execute("DELETE FROM embeddings")
+            conn.execute("DELETE FROM active_state")
+            conn.execute("DELETE FROM decisions")
+            conn.execute("DELETE FROM checkpoints")
+            conn.execute("DELETE FROM lessons")
+            conn.execute("DELETE FROM activity")
+            conn.execute("DELETE FROM llm_calls")
+
+            conn.execute("VACUUM")