gdmcode 0.1.0__py3-none-any.whl

src/memory/compressor.py

@@ -0,0 +1,378 @@
+"""Session compressor — summarises old conversation turns via the Scout model.
+
+Called by ``loop._maybe_compress()`` when the context budget exceeds the
+compression trigger threshold.  The resulting digest is injected into the
+transcript as a ``system`` message that replaces the compressed turns.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from src.agent.context_budget import count_tokens
+from src.config import GdmConfig
+from src.models.definitions import PROVIDER_BASE_URLS, ModelTier, Provider, get_model
+
+__all__ = ["CompressResult", "SessionCompressor"]
+
+log = logging.getLogger(__name__)
+
+# ── Constants ────────────────────────────────────────────────────────────────
+
+_MAX_OUTPUT_TOKENS: int = 300
+_FALLBACK_CHAR_LIMIT: int = 200
+
+_COMPRESSION_PROMPT_TEMPLATE: str = """\
+Summarize this conversation segment into ≤300 tokens, preserving:
+- Key decisions made
+- Files modified (with line numbers if mentioned)
+- Errors encountered and how they were resolved
+- User preferences expressed
+- Current task state
+
+Format as plain prose. Be maximally dense.
+Task context: {task_description}
+
+Conversation to summarize:
+{formatted_turns}"""
+
+
+# ── Data model ───────────────────────────────────────────────────────────────
+
+
+@dataclass
+class CompressResult:
+    """Result of a single compression operation."""
+
+    digest: str           # Summary text prefixed with [DIGEST: turns X-Y compressed]
+    tokens_freed: int     # Approximate tokens freed by removing the compressed turns
+    turns_compressed: int  # Number of turns that were summarised
+
+
+# ── Main class ───────────────────────────────────────────────────────────────
+
+
+class SessionCompressor:
+    """Compresses old conversation turns into a digest using the Scout model.
+
+    Uses grok-4-1-fast-non-reasoning (Scout) to generate a dense summary
+    of old turns.  The digest replaces the compressed turns in context.
+
+    Cost: ~500 input tokens → ~$0.0001 per compression (effectively free).
+
+    Usage::
+
+        compressor = SessionCompressor(cfg)
+        result = compressor.compress(turns_to_compress, task_description)
+        # Inject result.digest into transcript as a system message
+    """
+
+    def __init__(self, cfg: GdmConfig) -> None:
+        # Prefer Grok for compression — Scout is a Grok-native model.
+        # Fall back to the configured provider if Grok credentials are absent.
+        if cfg.xai_api_key:
+            self._api_key: str = cfg.xai_api_key
+            self._base_url: str = PROVIDER_BASE_URLS[Provider.GROK]
+            self._model_id: str = get_model(ModelTier.SCOUT, Provider.GROK).id
+        else:
+            self._api_key = cfg.api_key
+            self._base_url = PROVIDER_BASE_URLS.get(
+                cfg.provider, PROVIDER_BASE_URLS[Provider.GROK]
+            )
+            try:
+                self._model_id = get_model(ModelTier.SCOUT, cfg.provider).id
+            except KeyError:
+                self._model_id = get_model(ModelTier.SCOUT, Provider.GROK).id
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def compress(
+        self,
+        turns: list[dict[str, Any]],
+        task_description: str = "",
+    ) -> CompressResult:
+        """Summarize old turns into a compact digest using 3-tier strategy.
+
+        Tier 1 (free): replace raw tool result payloads with 1-line summaries.
+        Tier 2 (~$0.001): summarize old assistant turns via API (1 paragraph each).
+        Tier 3 (~$0.003): full Scout digest of all droppable turns (last resort).
+
+        Non-droppable turns (``non_droppable=True``) are preserved verbatim at
+        every tier — their content is never truncated or summarised.
+
+        Falls back to :meth:`_fallback_compress` if the API is unavailable.
+
+        Args:
+            turns: raw turn dicts, typically from ``turn.to_compress_dict()``.
+            task_description: short description of the current task for context.
+
+        Returns:
+            A :class:`CompressResult` with the digest and token savings.
+        """
+        if not turns:
+            return CompressResult(digest="", tokens_freed=0, turns_compressed=0)
+
+        full_text = self._format_turns(turns)
+        original_tokens = count_tokens(full_text)
+        prefix = f"[DIGEST: turns 1-{len(turns)} compressed]\n"
+
+        # Separate non-droppable turns (preserved verbatim) from droppable ones
+        non_droppable = [t for t in turns if t.get("non_droppable")]
+        droppable = [t for t in turns if not t.get("non_droppable")]
+
+        # ── Tier 1: Drop raw tool result payloads (free, no API call) ─────────
+        tier1_turns = self._tier1_compress(droppable)
+        tier1_tokens = count_tokens(self._format_turns(tier1_turns)) if tier1_turns else 0
+
+        if tier1_tokens <= original_tokens * 0.70:
+            log.debug("Tier 1 sufficient: freed ~%d tokens", original_tokens - tier1_tokens)
+            digest = self._build_tiered_digest(prefix, tier1_turns, non_droppable, len(turns))
+            tokens_freed = max(0, original_tokens - count_tokens(digest))
+            return CompressResult(
+                digest=digest,
+                tokens_freed=tokens_freed,
+                turns_compressed=len(turns),
+            )
+
+        # ── Tier 2: Summarize old assistant turns via API ──────────────────────
+        try:
+            tier2_turns = self._tier2_compress(tier1_turns, task_description)
+            tier2_tokens = count_tokens(self._format_turns(tier2_turns)) if tier2_turns else 0
+        except Exception as exc:
+            log.debug("Tier 2 compression failed: %s", exc)
+            tier2_turns = tier1_turns
+            tier2_tokens = tier1_tokens
+
+        if tier2_tokens <= original_tokens * 0.70:
+            log.debug("Tier 2 sufficient: freed ~%d tokens", original_tokens - tier2_tokens)
+            digest = self._build_tiered_digest(prefix, tier2_turns, non_droppable, len(turns))
+            tokens_freed = max(0, original_tokens - count_tokens(digest))
+            return CompressResult(
+                digest=digest,
+                tokens_freed=tokens_freed,
+                turns_compressed=len(turns),
+            )
+
+        # ── Tier 3: Full Scout digest (last resort) ────────────────────────────
+        try:
+            import openai as _openai  # lazy import — avoids crash if not installed
+            prompt = self.build_compression_prompt(
+                tier2_turns if tier2_turns else turns, task_description
+            )
+            client = _openai.OpenAI(api_key=self._api_key, base_url=self._base_url)
+            response = client.chat.completions.create(
+                model=self._model_id,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=_MAX_OUTPUT_TOKENS,
+            )
+            summary = (response.choices[0].message.content or "").strip()
+            digest = prefix + summary
+            # Preserve non-droppable turns verbatim in the digest
+            if non_droppable:
+                digest += "\n[PRESERVED NON-DROPPABLE TURNS]:\n" + self._format_turns(
+                    non_droppable
+                )
+            tokens_freed = max(0, original_tokens - count_tokens(digest))
+            log.debug(
+                "Tier 3 (Scout): compressed %d turns, freed ~%d tokens",
+                len(turns),
+                tokens_freed,
+            )
+            return CompressResult(
+                digest=digest,
+                tokens_freed=tokens_freed,
+                turns_compressed=len(turns),
+            )
+        except ImportError:
+            return self._fallback_compress(turns)
+        except Exception as exc:
+            log.warning("Tier 3 Scout failed, using fallback: %s", exc)
+            return self._fallback_compress(turns)
+
+    def build_compression_prompt(
+        self, turns: list[dict[str, Any]], task: str
+    ) -> str:
+        """Build the prompt asking Scout to summarize the turns.
+
+        Args:
+            turns: raw turn dicts.
+            task: short description of the current task.
+
+        Returns:
+            A formatted prompt string ready to send to the model.
+        """
+        return _COMPRESSION_PROMPT_TEMPLATE.format(
+            task_description=task or "(not specified)",
+            formatted_turns=self._format_turns(turns),
+        )
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _fallback_compress(
+        self, turns: list[dict[str, Any]]
+    ) -> CompressResult:
+        """Simple non-API fallback: truncate droppable turns to first 200 chars.
+
+        Non-droppable turns (``non_droppable=True``) are preserved verbatim —
+        their content is never truncated regardless of length.
+
+        Called when the Scout API is unavailable or returns an error.
+        Self-contained so it can also be invoked independently.
+        """
+        lines: list[str] = []
+        for turn in turns:
+            role = turn.get("role", "unknown")
+            text = self._extract_content_text(turn.get("content", ""))
+            if turn.get("non_droppable"):
+                # Preserve verbatim — do NOT truncate
+                lines.append(f"{role}: {text}")
+            else:
+                lines.append(f"{role}: {text[:_FALLBACK_CHAR_LIMIT]}")
+
+        prefix = f"[DIGEST: turns 1-{len(turns)} compressed]\n"
+        digest = prefix + "\n".join(lines)
+        full_text = self._format_turns(turns)
+        tokens_freed = max(0, count_tokens(full_text) - count_tokens(digest))
+        return CompressResult(
+            digest=digest,
+            tokens_freed=tokens_freed,
+            turns_compressed=len(turns),
+        )
+
+    def _tier1_compress(
+        self, turns: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        """Tier 1: Replace raw tool result payloads with 1-line summaries.
+
+        Free — no API call required.  Typically achieves 40–60% context
+        reduction when there are many large tool results.
+
+        Non-droppable turns are never modified.
+        """
+        result: list[dict[str, Any]] = []
+        for turn in turns:
+            if turn.get("non_droppable"):
+                result.append(turn)
+                continue
+            if turn.get("role") == "tool":
+                orig = self._extract_content_text(turn.get("content", ""))
+                tool_name = turn.get("name", "tool")
+                short = f"[tool: {tool_name} → {len(orig)} chars truncated]"
+                result.append({**turn, "content": short})
+            else:
+                result.append(turn)
+        return result
+
+    def _tier2_compress(
+        self, turns: list[dict[str, Any]], task_description: str = ""
+    ) -> list[dict[str, Any]]:
+        """Tier 2: Summarize old assistant turns (>3 turns back) via API.
+
+        Each qualifying assistant turn is replaced with a 1-paragraph summary.
+        Short turns (< 50 tokens) and non-droppable turns are skipped.
+
+        Raises:
+            ImportError: if the ``openai`` package is not installed.
+            Exception: on API call failure (caller should fall through to Tier 3).
+        """
+        import openai as _openai  # lazy import — avoids crash if not installed
+
+        result = list(turns)
+        cutoff = max(0, len(turns) - 3)  # only process turns >3 from the end
+
+        try:
+            client = _openai.OpenAI(api_key=self._api_key, base_url=self._base_url)
+        except Exception as exc:
+            log.debug("Tier 2: failed to create OpenAI client: %s", exc)
+            return result
+
+        for i, turn in enumerate(turns[:cutoff]):
+            if turn.get("non_droppable"):
+                continue  # preserve verbatim
+            if turn.get("role") != "assistant":
+                continue
+            orig_content = self._extract_content_text(turn.get("content", ""))
+            if not orig_content or count_tokens(orig_content) < 50:
+                continue  # already short — not worth an API call
+            try:
+                prompt = (
+                    f"Summarize in 1 paragraph "
+                    f"(task: {task_description or '(not specified)'}):\n"
+                    f"{orig_content[:2000]}"
+                )
+                resp = client.chat.completions.create(
+                    model=self._model_id,
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=100,
+                )
+                summary = (resp.choices[0].message.content or "").strip()
+                if summary:
+                    result[i] = {**turn, "content": summary}
+            except Exception as exc:  # noqa: BLE001
+                log.debug("Tier 2: failed to summarize turn %d: %s", i, exc)
+        return result
+
+    def _build_tiered_digest(
+        self,
+        prefix: str,
+        compressed_turns: list[dict[str, Any]],
+        non_droppable_turns: list[dict[str, Any]],
+        original_count: int,
+    ) -> str:
+        """Build a digest string from Tier 1/2 compressed turns.
+
+        Non-droppable turns are appended verbatim in a clearly-labelled section.
+        """
+        digest = prefix + self._format_turns(compressed_turns)
+        if non_droppable_turns:
+            digest += "\n[PRESERVED NON-DROPPABLE TURNS]:\n" + self._format_turns(
+                non_droppable_turns
+            )
+        return digest
+
+    @staticmethod
+    def _extract_content_text(content: Any) -> str:
+        """Coerce a message ``content`` value to plain text.
+
+        Handles both raw strings and the OpenAI list-of-parts format.
+        """
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts: list[str] = []
+            for part in content:
+                if isinstance(part, dict):
+                    parts.append(part.get("text", ""))
+                else:
+                    parts.append(str(part))
+            return " ".join(parts)
+        return str(content)
+
+    def _format_turns(self, turns: list[dict[str, Any]]) -> str:
+        """Format a list of turns as a numbered transcript string.
+
+        Serialises text content and any tool call names so the compressor
+        receives a faithful record of what happened in each turn.
+        """
+        lines: list[str] = []
+        for i, turn in enumerate(turns, 1):
+            role = turn.get("role", "unknown")
+            text = self._extract_content_text(turn.get("content", ""))
+            tool_calls: list[Any] = turn.get("tool_calls") or []
+            if tool_calls:
+                names = [
+                    (tc.get("function", {}).get("name", "?") if isinstance(tc, dict) else str(tc))
+                    for tc in tool_calls
+                ]
+                text = f"{text} [tool_calls: {', '.join(names)}]".strip()
+            if role == "tool":
+                tool_name = turn.get("name", "tool")
+                lines.append(f"[Turn {i}] tool_result({tool_name}): {text}")
+            else:
+                lines.append(f"[Turn {i}] {role}: {text}")
+        return "\n".join(lines)

src/memory/context_memory.py

@@ -0,0 +1,135 @@
+""".context-memory/ directory manager — handles FAISS index paths and daemon IPC."""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from src._internal.constants import _CONTEXT_MEMORY_DIR
+
+__all__ = ["ContextMemoryManager"]
+
+log = logging.getLogger(__name__)
+
+_FAISS_FILENAME: str = "code_index.faiss"
+_INBOX_DIR: str = "inbox"
+_OUTBOX_DIR: str = "outbox"
+_JOB_FILENAME_PATTERN: str = "job-{job_id}.json"
+_SAFE_JOB_ID_RE: re.Pattern[str] = re.compile(r"^[a-zA-Z0-9_-]{1,64}$")
+
+_GITIGNORE_CONTENT: str = (
+    "# gdm code \u2014 managed state, do not commit\n"
+    "gdm.db\n"
+    "code_index.faiss\n"
+    "inbox/\n"
+    "outbox/\n"
+)
+
+
+class ContextMemoryManager:
+    """Manages the .context-memory/ directory structure.
+
+    Responsibilities:
+    - Ensure required subdirectories exist
+    - Manage .gitignore for .context-memory/
+    - Provide typed paths for FAISS index, daemon IPC (inbox/outbox)
+    - Never touches gdm.db (that's GdmDatabase's job)
+
+    Directory layout::
+
+        .context-memory/
+        \u251c\u2500\u2500 gdm.db            (managed by GdmDatabase, not here)
+        \u251c\u2500\u2500 code_index.faiss  (managed by code_index.py)
+        \u251c\u2500\u2500 inbox/            (daemon job queue)
+        \u2514\u2500\u2500 outbox/           (daemon results)
+    """
+
+    def __init__(self, project_root: Path) -> None:
+        self._project_root = project_root
+        self._root = project_root / _CONTEXT_MEMORY_DIR
+
+    def ensure_structure(self) -> None:
+        """Create directories and .gitignore if missing. Idempotent."""
+        self._root.mkdir(parents=True, exist_ok=True)
+        self.inbox_dir.mkdir(exist_ok=True)
+        self.outbox_dir.mkdir(exist_ok=True)
+        self._ensure_gitignore()
+
+    @property
+    def root(self) -> Path:
+        """Path to .context-memory/ directory."""
+        return self._root
+
+    @property
+    def faiss_index_path(self) -> Path:
+        """Path to code_index.faiss file."""
+        return self._root / _FAISS_FILENAME
+
+    @property
+    def inbox_dir(self) -> Path:
+        """Path to daemon job inbox directory."""
+        return self._root / _INBOX_DIR
+
+    @property
+    def outbox_dir(self) -> Path:
+        """Path to daemon results outbox directory."""
+        return self._root / _OUTBOX_DIR
+
+    def get_inbox_path(self, job_id: str) -> Path:
+        """Path for a specific job's inbox file: inbox/job-{job_id}.json"""
+        self._validate_job_id(job_id)
+        return self.inbox_dir / _JOB_FILENAME_PATTERN.format(job_id=job_id)
+
+    def get_outbox_path(self, job_id: str) -> Path:
+        """Path for a specific job's outbox file: outbox/job-{job_id}.json"""
+        self._validate_job_id(job_id)
+        return self.outbox_dir / _JOB_FILENAME_PATTERN.format(job_id=job_id)
+
+    def write_job(self, job_id: str, payload: dict[str, Any]) -> None:
+        """Write a job to the inbox as JSON. Uses atomic write via temp file."""
+        dest = self.get_inbox_path(job_id)
+        tmp = dest.with_suffix(".tmp")
+        tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+        os.replace(tmp, dest)
+        log.debug("Job %s written to inbox", job_id)
+
+    def read_result(self, job_id: str) -> dict[str, Any] | None:
+        """Read a completed job result from outbox. Returns None if not ready."""
+        outbox_path = self.get_outbox_path(job_id)
+        if not outbox_path.exists():
+            return None
+        try:
+            return json.loads(outbox_path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            log.warning("Corrupt result for job %s — treating as not ready", job_id)
+            return None
+
+    def list_pending_jobs(self) -> list[str]:
+        """Return job IDs that are in inbox but not yet in outbox."""
+        if not self.inbox_dir.exists():
+            return []
+        pending: list[str] = []
+        for f in self.inbox_dir.glob("job-*.json"):
+            job_id = f.stem.removeprefix("job-")
+            if not _SAFE_JOB_ID_RE.match(job_id):
+                continue  # skip malformed filenames
+            outbox_file = self.outbox_dir / _JOB_FILENAME_PATTERN.format(job_id=job_id)
+            if not outbox_file.exists():
+                pending.append(job_id)
+        return pending
+
+    def _ensure_gitignore(self) -> None:
+        """Write .gitignore into .context-memory/ if not already present."""
+        gitignore = self._root / ".gitignore"
+        if not gitignore.exists():
+            gitignore.write_text(_GITIGNORE_CONTENT, encoding="utf-8")
+
+    def _validate_job_id(self, job_id: str) -> None:
+        """Raise ValueError if job_id contains unsafe characters (path traversal guard)."""
+        if not _SAFE_JOB_ID_RE.match(job_id):
+            raise ValueError(
+                f"Invalid job_id {job_id!r}: must match [a-zA-Z0-9_-]{{1,64}}"
+            )