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

services/protocol.py

@@ -0,0 +1,306 @@
+"""
+Compression Protocol
+
+A custom encoding/decoding scheme for prompts and context that reduces token usage
+by converting natural language into compressed shorthand.
+
+Features:
+- Action shorthand (READ -> R, FIX -> FX, CREATE -> CR, etc.)
+- Path abbreviation
+- Common phrase compression
+- Project-specific dictionary building
+- Reversible encoding
+"""
+import json
+import re
+from pathlib import Path
+
+from core import measure_savings
+
+# Core action dictionary
+ACTION_CODES = {
+    # File operations
+    "read": "R", "write": "W", "create": "CR", "delete": "DEL",
+    "edit": "ED", "modify": "MOD", "update": "UPD", "rename": "RN",
+    "move": "MV", "copy": "CP",
+    # Code operations
+    "fix": "FX", "debug": "DBG", "refactor": "RFT", "optimize": "OPT",
+    "test": "TST", "add": "ADD", "remove": "RM", "implement": "IMP",
+    "extract": "EXT", "inline": "INL", "wrap": "WRP",
+    # Analysis
+    "explain": "EXP", "analyze": "ANL", "review": "REV",
+    "find": "FND", "search": "SRCH", "list": "LST", "show": "SHW",
+    "compare": "CMP", "check": "CHK",
+    # Common qualifiers
+    "the": "", "this": "", "that": "", "a": "", "an": "",
+    "please": "", "can you": "", "could you": "", "would you": "",
+    "i want to": "", "i need to": "", "i'd like to": "",
+    "help me": "", "go ahead and": "",
+}
+
+# Common programming terms
+TERM_CODES = {
+    "function": "fn", "variable": "var", "constant": "const",
+    "class": "cls", "method": "mth", "property": "prop",
+    "interface": "ifc", "type": "typ", "enum": "enm",
+    "component": "cmp", "module": "mod", "package": "pkg",
+    "import": "imp", "export": "exp", "default": "def",
+    "parameter": "param", "argument": "arg", "return": "ret",
+    "async": "asc", "await": "awt", "promise": "prom",
+    "error": "err", "exception": "exc", "warning": "warn",
+    "database": "db", "query": "qry", "schema": "sch",
+    "request": "req", "response": "res", "middleware": "mw",
+    "authentication": "auth", "authorization": "authz",
+    "configuration": "cfg", "environment": "env",
+    "typescript": "TS", "javascript": "JS", "python": "PY",
+    "react": "RCT", "node": "ND",
+    "line": "L", "file": "F", "directory": "D",
+    "string": "str", "number": "num", "boolean": "bool",
+    "array": "arr", "object": "obj", "null": "nil",
+    "undefined": "undef",
+}
+
+# Common phrase patterns
+PHRASE_PATTERNS = [
+    (r"please read the file (.+?) and", r"R:\1"),
+    (r"can you (?:please )?look at (.+)", r"R:\1"),
+    (r"fix the (?:bug|error|issue) (?:in|on|at) (.+?)(?:\s+(?:where|on|at)\s+line\s+(\d+))?", r"FX:\1 L\2"),
+    (r"create a (?:new )?(.+?) (?:file|component|module) (?:called|named) (.+)", r"CR:\2.\1"),
+    (r"add (.+?) to (.+)", r"ADD:\1 IN:\2"),
+    (r"remove (.+?) from (.+)", r"RM:\1 FROM:\2"),
+    (r"refactor (.+?) to (.+)", r"RFT:\1 TO:\2"),
+    (r"move (.+?) to (.+)", r"MV:\1 TO:\2"),
+    (r"rename (.+?) to (.+)", r"RN:\1 TO:\2"),
+    (r"implement (.+?) in (.+)", r"IMP:\1 IN:\2"),
+    (r"there(?:'s| is) (?:a |an )?(?:bug|error|issue|problem) (?:in|with|on) (.+)", r"FX:\1"),
+    (r"on line (\d+)", r"L\1"),
+    (r"the (.+?) (?:is|are) (?:not working|broken|failing)", r"FX:\1"),
+    (r"(?:the |)(.+?) (?:doesn't|does not|isn't|is not) (?:work|working)", r"FX:\1"),
+]
+
+# Reverse lookup for decoding
+REVERSE_ACTIONS = {v: k for k, v in ACTION_CODES.items() if v}
+REVERSE_TERMS = {v: k for k, v in TERM_CODES.items()}
+
+
+class CompressionProtocol:
+    """Encode/decode natural language prompts to compressed shorthand."""
+
+    def __init__(self, project_path: str = "", custom_dict_path: str = ".c3/dictionary.json"):
+        self.project_path = Path(project_path) if project_path else Path(".")
+        self.dict_path = self.project_path / custom_dict_path
+        self.custom_dict = self._load_custom_dict()
+        self.path_aliases = {}
+
+    def encode(self, text: str) -> dict:
+        """Encode natural language to compressed format."""
+        original = text
+        compressed = text.lower().strip()
+
+        # Step 1: Apply phrase patterns
+        for pattern, replacement in PHRASE_PATTERNS:
+            compressed = re.sub(pattern, replacement, compressed, flags=re.IGNORECASE)
+
+        # Step 2: Remove filler words
+        for word in ["please", "can you", "could you", "would you", "i want to",
+                     "i need to", "i'd like to", "help me", "go ahead and",
+                     "the", "this", "that"]:
+            compressed = re.sub(rf'\b{re.escape(word)}\b', '', compressed, flags=re.IGNORECASE)
+
+        # Step 3: Apply action codes
+        for word, code in ACTION_CODES.items():
+            if code:  # Skip empty replacements (already removed filler words)
+                compressed = re.sub(rf'\b{re.escape(word)}\b', code, compressed, flags=re.IGNORECASE)
+
+        # Step 4: Apply term codes
+        for word, code in TERM_CODES.items():
+            compressed = re.sub(rf'\b{re.escape(word)}\b', code, compressed, flags=re.IGNORECASE)
+
+        # Step 5: Apply custom dictionary
+        for word, code in self.custom_dict.items():
+            compressed = re.sub(rf'\b{re.escape(word)}\b', code, compressed, flags=re.IGNORECASE)
+
+        # Step 6: Compress paths
+        compressed = self._compress_paths(compressed)
+
+        # Step 7: Clean up whitespace
+        compressed = re.sub(r'\s+', ' ', compressed).strip()
+
+        savings = measure_savings(original, compressed)
+        savings["original"] = original
+        savings["compressed"] = compressed
+
+        return savings
+
+    def decode(self, compressed: str) -> str:
+        """Decode compressed format back to readable text."""
+        text = compressed
+
+        # Decode action codes (R: -> Read file)
+        action_patterns = {
+            r'\bR:': "Read file ",
+            r'\bW:': "Write to ",
+            r'\bCR:': "Create ",
+            r'\bDEL:': "Delete ",
+            r'\bED:': "Edit ",
+            r'\bFX:': "Fix ",
+            r'\bDBG:': "Debug ",
+            r'\bRFT:': "Refactor ",
+            r'\bOPT:': "Optimize ",
+            r'\bTST:': "Test ",
+            r'\bADD:': "Add ",
+            r'\bRM:': "Remove ",
+            r'\bIMP:': "Implement ",
+            r'\bEXP:': "Explain ",
+            r'\bANL:': "Analyze ",
+            r'\bREV:': "Review ",
+            r'\bFND:': "Find ",
+            r'\bSRCH:': "Search for ",
+            r'\bMV:': "Move ",
+            r'\bRN:': "Rename ",
+            r'\bCMP:': "Compare ",
+            r'\bCHK:': "Check ",
+        }
+
+        for pattern, replacement in action_patterns.items():
+            text = re.sub(pattern, replacement, text)
+
+        # Decode term codes
+        for code, term in REVERSE_TERMS.items():
+            text = re.sub(rf'\b{re.escape(code)}\b', term, text)
+
+        # Decode line references
+        text = re.sub(r'\bL(\d+)', r'on line \1', text)
+
+        # Decode modifiers
+        text = re.sub(r'\bIN:', 'in ', text)
+        text = re.sub(r'\bTO:', 'to ', text)
+        text = re.sub(r'\bFROM:', 'from ', text)
+
+        # Clean up
+        text = re.sub(r'\s+', ' ', text).strip()
+        text = text[0].upper() + text[1:] if text else text
+
+        return text
+
+    def _compress_paths(self, text: str) -> str:
+        """Compress file paths using aliases."""
+        # Auto-detect common path prefixes
+        path_pattern = r'(?:src|lib|app|components|pages|utils|hooks|services|api|config)(?:/\w+)+'
+        paths = re.findall(path_pattern, text)
+
+        for path in paths:
+            parts = path.split('/')
+            if len(parts) > 2:
+                # Keep first and last parts
+                compressed_path = f"{parts[0]}/../{parts[-1]}"
+                text = text.replace(path, compressed_path)
+
+        return text
+
+    def _load_custom_dict(self) -> dict:
+        """Load project-specific custom dictionary."""
+        if self.dict_path.exists():
+            try:
+                with open(self.dict_path, encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception:
+                pass
+        return {}
+
+    def save_custom_dict(self):
+        """Save custom dictionary to disk."""
+        self.dict_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.dict_path, 'w', encoding='utf-8') as f:
+            json.dump(self.custom_dict, f, indent=2)
+
+    def add_custom_term(self, term: str, code: str):
+        """Add a project-specific term to the dictionary."""
+        self.custom_dict[term.lower()] = code
+        self.save_custom_dict()
+
+    def build_project_dictionary(self) -> dict:
+        """Auto-build a project-specific dictionary from codebase analysis."""
+        if not self.project_path.exists():
+            return {}
+
+        # Find commonly used terms in the project
+        term_freq = {}
+        skip_dirs = {'node_modules', '.git', '__pycache__', '.c3', 'venv'}
+        code_exts = {'.py', '.js', '.ts', '.tsx', '.jsx', '.r', '.R'}
+
+        for fpath in self.project_path.rglob('*'):
+            if not fpath.is_file() or fpath.suffix not in code_exts:
+                continue
+            if any(skip in fpath.parts for skip in skip_dirs):
+                continue
+
+            try:
+                content = fpath.read_text(errors='replace')
+            except Exception:
+                continue
+
+            # Extract identifiers
+            identifiers = re.findall(r'\b[a-zA-Z_]\w{5,}\b', content)
+            for ident in identifiers:
+                lower = ident.lower()
+                if lower not in ACTION_CODES and lower not in TERM_CODES:
+                    term_freq[lower] = term_freq.get(lower, 0) + 1
+
+        # Generate codes for frequent terms
+        frequent = sorted(term_freq.items(), key=lambda x: x[1], reverse=True)[:30]
+        new_entries = {}
+
+        for term, freq in frequent:
+            if freq >= 5:  # Only for terms appearing 5+ times
+                # Generate abbreviation
+                if len(term) > 6:
+                    code = term[:3].upper()
+                    # Ensure uniqueness
+                    suffix = 1
+                    while code in TERM_CODES.values() or code in new_entries.values():
+                        code = term[:3].upper() + str(suffix)
+                        suffix += 1
+                    new_entries[term] = code
+
+        # Merge with existing custom dict
+        self.custom_dict.update(new_entries)
+        self.save_custom_dict()
+
+        return new_entries
+
+    def get_protocol_header(self) -> str:
+        """
+        Generate a compression protocol header to include in system prompt.
+        This tells Claude how to interpret compressed messages.
+        """
+        header = """# C3 Compression Protocol
+When you see compressed shorthand, decode using:
+## Actions: R=Read W=Write CR=Create FX=Fix DBG=Debug RFT=Refactor OPT=Optimize TST=Test ADD=Add RM=Remove IMP=Implement
+## Modifiers: L=Line F=File D=Directory IN=in TO=to FROM=from
+## Terms: fn=function cls=class cmp=component mod=module cfg=config auth=authentication db=database
+## Format: ACTION:target [MODIFIER:value] [context]
+## Example: "FX:src/auth.ts L47 TS err missing onClick prop" = "Fix the TypeScript error on line 47 of src/auth.ts where the onClick prop is missing"
+"""
+
+        # Add custom dictionary if exists
+        if self.custom_dict:
+            custom_section = "## Project-specific: " + ' '.join(
+                f"{v}={k}" for k, v in list(self.custom_dict.items())[:20]
+            )
+            header += custom_section + "\n"
+
+        return header
+
+    def batch_encode(self, texts: list) -> list:
+        """Encode multiple texts at once."""
+        return [self.encode(t) for t in texts]
+
+    def get_stats(self) -> dict:
+        """Get compression protocol statistics."""
+        return {
+            "built_in_actions": len(ACTION_CODES),
+            "built_in_terms": len(TERM_CODES),
+            "custom_terms": len(self.custom_dict),
+            "total_codes": len(ACTION_CODES) + len(TERM_CODES) + len(self.custom_dict),
+        }

services/proxy_state.py

@@ -0,0 +1,152 @@
+"""Sliding window state tracker for the MCP proxy.
+
+Maintains rolling conversation context: recent tool calls, files, decisions,
+and detected goal. Generates a compact context line (~50 tokens) that gets
+injected into tool responses so Claude retains state awareness across turns.
+"""
+import re
+from collections import deque
+
+
+class ProxyState:
+    """Rolling conversation state tracker."""
+
+    def __init__(self, window_size: int = 10):
+        self.tool_calls: deque = deque(maxlen=window_size)
+        self.recent_files: deque = deque(maxlen=5)
+        self.recent_decisions: deque = deque(maxlen=3)
+        self.current_goal: str = ""
+
+    # ── Recording ──────────────────────────────────────────
+
+    def record_tool_call(self, tool_name: str, args: dict,
+                         response_text: str = "") -> None:
+        """Record a tool call with a 1-line summary."""
+        summary = self._summarize_call(tool_name, args, response_text)
+        self.tool_calls.append({"name": tool_name, "summary": summary})
+
+        # Extract file paths from args
+        self._extract_files(args)
+
+        # Detect decisions from session_log
+        if tool_name == "c3_session_log" and args.get("event_type") == "decision":
+            decision = args.get("data", "")[:80]
+            if decision:
+                self.recent_decisions.append(decision)
+
+        # Update goal from tool args
+        self._detect_goal(tool_name, args)
+
+    def record_user_text(self, text: str) -> None:
+        """Extract goal hints from user/tool text."""
+        # Look for intent patterns
+        patterns = [
+            (r"(?:fix|debug|resolve)\s+(.{5,40})", "fix"),
+            (r"(?:add|implement|create)\s+(.{5,40})", "add"),
+            (r"(?:refactor|clean|simplify)\s+(.{5,40})", "refactor"),
+            (r"(?:find|search|look\s+for)\s+(.{5,40})", "find"),
+            (r"(?:understand|explain|how\s+does)\s+(.{5,40})", "understand"),
+        ]
+        for pattern, verb in patterns:
+            m = re.search(pattern, text, re.IGNORECASE)
+            if m:
+                self.current_goal = f"{verb} {m.group(1).strip()}"
+                break
+
+    # ── Output ─────────────────────────────────────────────
+
+    def get_context_line(self) -> str:
+        """Generate compact context summary for injection."""
+        parts = []
+
+        # Last tool calls
+        if self.tool_calls:
+            recent = list(self.tool_calls)[-3:]
+            call_strs = [c["summary"] for c in recent]
+            parts.append(f"Last: {', '.join(call_strs)}")
+
+        # Current goal
+        if self.current_goal:
+            parts.append(f"Goal: {self.current_goal}")
+
+        # Recent files
+        if self.recent_files:
+            files = [f.split("/")[-1] for f in self.recent_files]
+            parts.append(f"Files: {', '.join(files)}")
+
+        if not parts:
+            return ""
+        return f"\n[Context: {'. '.join(parts)}]"
+
+    def get_recent_tool_names(self) -> list[str]:
+        """Return names of recent tool calls for classifier input."""
+        return [c["name"] for c in self.tool_calls]
+
+    def get_recent_text(self) -> str:
+        """Return recent context text for classifier keyword matching."""
+        parts = []
+        if self.current_goal:
+            parts.append(self.current_goal)
+        for c in self.tool_calls:
+            parts.append(c["summary"])
+        parts.extend(self.recent_decisions)
+        return " ".join(parts)
+
+    # ── Internal ───────────────────────────────────────────
+
+    def _summarize_call(self, tool_name: str, args: dict,
+                        response_text: str) -> str:
+        """Create a compact 1-line summary of a tool call."""
+        short_name = tool_name.replace("c3_", "")
+
+        # Summarize based on tool type
+        if tool_name == "c3_search":
+            query = args.get("query", "")[:30]
+            # Count results from response
+            count = response_text.count("## ") if response_text else "?"
+            return f"{short_name}({query!r}, {count} results)"
+
+        elif tool_name == "c3_compress":
+            fp = args.get("file_path", "").split("/")[-1]
+            return f"{short_name}({fp})"
+
+        elif tool_name in ("c3_remember", "c3_recall", "c3_memory_query"):
+            text = args.get("fact", args.get("query", ""))[:30]
+            return f"{short_name}({text!r})"
+
+        elif tool_name == "c3_session_log":
+            etype = args.get("event_type", "")
+            data = args.get("data", "")[:20]
+            return f"{short_name}({etype}: {data})"
+
+        elif tool_name in ("c3_extract", "c3_filter"):
+            fp = args.get("file_path", "").split("/")[-1]
+            return f"{short_name}({fp})"
+
+        else:
+            # Generic: show first string arg
+            for v in args.values():
+                if isinstance(v, str) and len(v) > 2:
+                    return f"{short_name}({v[:25]})"
+            return f"{short_name}()"
+
+    def _extract_files(self, args: dict) -> None:
+        """Extract file paths from tool args."""
+        for key in ("file_path", "path"):
+            val = args.get(key)
+            if val and isinstance(val, str):
+                # Normalize and deduplicate
+                if val not in self.recent_files:
+                    self.recent_files.append(val)
+
+    def _detect_goal(self, tool_name: str, args: dict) -> None:
+        """Infer user goal from tool usage patterns."""
+        if tool_name == "c3_search":
+            query = args.get("query", "")
+            if query and not self.current_goal:
+                self.current_goal = f"investigate {query[:40]}"
+        elif tool_name == "c3_session_log":
+            if args.get("event_type") == "decision":
+                data = args.get("data", "")[:40]
+                if data:
+                    self.current_goal = data

services/retrieval_broker.py

@@ -0,0 +1,129 @@
+"""Unified retrieval broker across facts, conversations, files, sessions, and snapshots."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from services.text_index import TextIndex
+
+
+class MemoryRetrievalBroker:
+    """Normalizes retrieval across the project's memory sources."""
+
+    def __init__(self, project_path: str, memory_store, conversation_store=None, file_memory=None, snapshots=None):
+        self.project_path = Path(project_path)
+        self.memory_store = memory_store
+        self.conversation_store = conversation_store
+        self.file_memory = file_memory
+        self.snapshots = snapshots
+        self._session_index = TextIndex()
+        self._session_meta = {}
+        self._session_dirty = True
+
+    def mark_sessions_dirty(self):
+        self._session_dirty = True
+
+    def search(self, query: str, top_k: int = 5) -> dict:
+        self._session_dirty = True
+        self._ensure_session_index()
+
+        fact_results = self.memory_store.recall(query, top_k=top_k)
+        conversation_results = self.conversation_store.search(query, limit=top_k) if self.conversation_store else []
+        file_results = self.file_memory.search(query, top_k=top_k) if self.file_memory else []
+        snapshot_results = self.snapshots.search(query, top_k=top_k) if self.snapshots else []
+
+        session_hits = []
+        for session_id, score in self._session_index.search(query, top_k=top_k):
+            meta = self._session_meta.get(session_id)
+            if not meta:
+                continue
+            session_hits.append({**meta, "score": round(score, 4)})
+
+        merged = []
+        for fact in fact_results:
+            merged.append({
+                "kind": "fact",
+                "id": fact["id"],
+                "title": fact.get("category", "fact"),
+                "text": fact.get("fact", ""),
+                "score": float(fact.get("score", 0.0)),
+                "payload": fact,
+            })
+        for convo in conversation_results:
+            merged.append({
+                "kind": "conversation",
+                "id": convo["turn_key"],
+                "title": convo.get("session_title", convo.get("session_id", "")),
+                "text": convo.get("snippet") or convo.get("text", ""),
+                "score": float(convo.get("score", 0.0)),
+                "payload": convo,
+            })
+        for session in session_hits:
+            merged.append({
+                "kind": "session",
+                "id": session["session_id"],
+                "title": session.get("summary") or session.get("session_id", ""),
+                "text": session.get("summary", ""),
+                "score": float(session.get("score", 0.0)),
+                "payload": session,
+            })
+        for file_hit in file_results:
+            merged.append({
+                "kind": "file",
+                "id": file_hit["path"],
+                "title": file_hit["path"],
+                "text": file_hit.get("summary") or "",
+                "score": float(file_hit.get("score", 0.0)),
+                "payload": file_hit,
+            })
+        for snap in snapshot_results:
+            merged.append({
+                "kind": "snapshot",
+                "id": snap["snapshot_id"],
+                "title": snap.get("task_description", ""),
+                "text": snap.get("task_description", ""),
+                "score": float(snap.get("score", 0.0)),
+                "payload": snap,
+            })
+
+        merged.sort(key=lambda item: item["score"], reverse=True)
+        return {
+            "facts": fact_results,
+            "conversations": conversation_results[:top_k],
+            "sessions": session_hits[:top_k],
+            "files": file_results[:top_k],
+            "snapshots": snapshot_results[:top_k],
+            "results": merged[:top_k * 3],
+        }
+
+    def _ensure_session_index(self):
+        if not self._session_dirty:
+            return
+        session_dir = self.project_path / ".c3" / "sessions"
+        docs = {}
+        meta = {}
+        if session_dir.exists():
+            for path in sorted(session_dir.glob("session_*.json"), reverse=True):
+                try:
+                    with open(path, encoding="utf-8") as handle:
+                        session = json.load(handle)
+                except Exception:
+                    continue
+                session_id = session.get("id") or session.get("session_id")
+                if not session_id:
+                    continue
+                text_parts = [session.get("description", ""), session.get("summary", "")]
+                for decision in session.get("decisions", []):
+                    text_parts.append(decision.get("decision", ""))
+                    text_parts.append(decision.get("reasoning", ""))
+                text_parts.extend(session.get("context_notes", []))
+                docs[session_id] = " ".join(part for part in text_parts if part)
+                meta[session_id] = {
+                    "session_id": session_id,
+                    "started": session.get("started", ""),
+                    "summary": session.get("summary", ""),
+                }
+        self._session_index.rebuild(docs)
+        self._session_meta = meta
+        self._session_dirty = False