gdmcode 0.1.0__py3-none-any.whl

src/memory/continuous_memory.py

@@ -0,0 +1,234 @@
+"""ContinuousMemory — cross-session developer decision log and hotspot tracking.
+
+Stores file-level decisions in a lightweight SQLite DB (.gdm/memory.db),
+separate from the main GdmDatabase.  Thread-safe via threading.Lock.
+
+Privacy: file paths stored as relative; rows older than 90 days are auto-purged.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import sqlite3
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+__all__ = ["ContinuousMemory"]
+
+log = logging.getLogger(__name__)
+
+_DDL = """
+CREATE TABLE IF NOT EXISTS developer_decisions (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id    TEXT NOT NULL,
+    file_context  TEXT,
+    decision_type TEXT NOT NULL,
+    value         TEXT NOT NULL,
+    turn_index    INTEGER,
+    created_at    TEXT DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_decisions_file ON developer_decisions (file_context);
+
+CREATE TABLE IF NOT EXISTS file_hotspots (
+    file_path         TEXT NOT NULL,
+    project_id        TEXT NOT NULL,
+    edit_session_count INTEGER DEFAULT 1,
+    total_edit_count  INTEGER DEFAULT 1,
+    last_edited_at    TEXT,
+    PRIMARY KEY (file_path, project_id)
+);
+"""
+
+
+class ContinuousMemory:
+    """Cross-session developer decision log with file hotspot detection."""
+
+    def __init__(self, db_path: str = ".gdm/memory.db") -> None:
+        self._db_path = db_path
+        self._lock = threading.Lock()
+        if db_path != ":memory:":
+            Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._conn.execute("PRAGMA journal_mode=WAL")
+        self._conn.executescript(_DDL)
+        self._conn.commit()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def log_decision(
+        self,
+        session_id: str,
+        file_context: str,
+        decision_type: str,
+        value: str,
+        turn_index: int = 0,
+    ) -> None:
+        """Log a developer decision.
+
+        Stores relative file path.  Purges entries >90 days old on each call.
+        """
+        rel_context = self._to_rel(file_context) if file_context else file_context
+        with self._lock:
+            self._conn.execute(
+                "DELETE FROM developer_decisions "
+                "WHERE created_at < datetime('now', '-90 days')"
+            )
+            self._conn.execute(
+                "INSERT INTO developer_decisions "
+                "(session_id, file_context, decision_type, value, turn_index) "
+                "VALUES (?, ?, ?, ?, ?)",
+                (session_id, rel_context, decision_type, value, turn_index),
+            )
+            self._conn.commit()
+
+    def update_hotspot(
+        self, session_id: str, file_path: str, project_id: str  # noqa: ARG002
+    ) -> None:
+        """Upsert into file_hotspots, incrementing counters.
+
+        Hotspot definition: edited in >50% of last 10 sessions (min 3).
+        Callers should invoke once per session per written file.
+        """
+        rel_path = self._to_rel(file_path) if file_path else file_path
+        now = datetime.now(timezone.utc).isoformat()
+        with self._lock:
+            self._conn.execute(
+                """
+                INSERT INTO file_hotspots
+                    (file_path, project_id, edit_session_count, total_edit_count, last_edited_at)
+                VALUES (?, ?, 1, 1, ?)
+                ON CONFLICT(file_path, project_id) DO UPDATE SET
+                    edit_session_count = edit_session_count + 1,
+                    total_edit_count   = total_edit_count + 1,
+                    last_edited_at     = excluded.last_edited_at
+                """,
+                (rel_path, project_id, now),
+            )
+            self._conn.commit()
+
+    def get_session_hints(
+        self, context_files: list[str], project_id: str
+    ) -> list[str]:
+        """Return <=3 hint strings for the current session.
+
+        Returns an empty list on cold start (<3 distinct sessions).
+        Never raises — all DB errors are swallowed.
+        """
+        try:
+            return self._build_hints(context_files, project_id)
+        except Exception as exc:  # noqa: BLE001
+            log.debug("ContinuousMemory.get_session_hints failed: %s", exc)
+            return []
+
+    def clear(self) -> None:
+        """Wipe all rows from developer_decisions and file_hotspots."""
+        with self._lock:
+            self._conn.execute("DELETE FROM developer_decisions")
+            self._conn.execute("DELETE FROM file_hotspots")
+            self._conn.commit()
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _build_hints(
+        self, context_files: list[str], project_id: str
+    ) -> list[str]:
+        session_count = self._count_sessions()
+        if session_count < 3:
+            return []
+
+        hints: list[str] = []
+        window = min(session_count, 10)
+        threshold = window * 0.5
+
+        # Hotspot hints — limit to relevant context files first
+        rel_files = [
+            self._to_rel(f) if f else f
+            for f in (context_files or [])
+        ]
+        if rel_files:
+            placeholders = ",".join("?" * len(rel_files))
+            rows = self._conn.execute(
+                f"SELECT file_path, edit_session_count FROM file_hotspots "
+                f"WHERE project_id = ? AND file_path IN ({placeholders}) "
+                f"ORDER BY edit_session_count DESC",
+                (project_id, *rel_files),
+            ).fetchall()
+            for row in rows:
+                if row["edit_session_count"] >= 3 and row["edit_session_count"] > threshold:
+                    hints.append(
+                        f"{row['file_path']} was edited in "
+                        f"{row['edit_session_count']}/{window} recent sessions "
+                        f"\u2014 likely a hotspot"
+                    )
+                if len(hints) >= 3:
+                    return hints
+
+        # Fallback hotspot hints when no context files provided
+        if not rel_files and len(hints) < 3:
+            rows = self._conn.execute(
+                "SELECT file_path, edit_session_count FROM file_hotspots "
+                "WHERE project_id = ? AND edit_session_count >= 3 "
+                "ORDER BY edit_session_count DESC LIMIT 3",
+                (project_id,),
+            ).fetchall()
+            for row in rows:
+                if row["edit_session_count"] > threshold:
+                    hints.append(
+                        f"{row['file_path']} was edited in "
+                        f"{row['edit_session_count']}/{window} recent sessions "
+                        f"\u2014 likely a hotspot"
+                    )
+                if len(hints) >= 3:
+                    return hints
+
+        # Decision hints for remaining slots
+        if len(hints) < 3:
+            if rel_files:
+                placeholders = ",".join("?" * len(rel_files))
+                dec_rows = self._conn.execute(
+                    f"SELECT decision_type, value FROM developer_decisions "
+                    f"WHERE file_context IN ({placeholders}) "
+                    f"ORDER BY created_at DESC LIMIT 20",
+                    tuple(rel_files),
+                ).fetchall()
+            else:
+                dec_rows = self._conn.execute(
+                    "SELECT decision_type, value FROM developer_decisions "
+                    "ORDER BY created_at DESC LIMIT 20"
+                ).fetchall()
+            seen: set[str] = set()
+            for row in dec_rows:
+                key = f"{row['decision_type']}:{row['value']}"
+                if key not in seen:
+                    seen.add(key)
+                    hints.append(
+                        f"Last session used {row['value']} for {row['decision_type']}"
+                    )
+                if len(hints) >= 3:
+                    break
+
+        return hints[:3]
+
+    def _count_sessions(self) -> int:
+        row = self._conn.execute(
+            "SELECT COUNT(DISTINCT session_id) AS n FROM developer_decisions"
+        ).fetchone()
+        return row["n"] if row else 0
+
+    @staticmethod
+    def _to_rel(path: str) -> str:
+        """Convert an absolute path to relative, with cross-drive fallback on Windows."""
+        if not path or not os.path.isabs(path):
+            return path
+        try:
+            return os.path.relpath(path)
+        except ValueError:
+            # Different drives on Windows — use basename as fallback
+            return os.path.basename(path)