acc-context-compaction 0.1.0__tar.gz

acc_context_compaction-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: acc-context-compaction
+Version: 0.1.0
+Summary: Automatically Context Compaction framework
+Requires-Python: >=3.10
+Requires-Dist: mcp
+Requires-Dist: typer
+Requires-Dist: fastapi
+Requires-Dist: sqlmodel
+Requires-Dist: alembic
+Requires-Dist: pydantic-settings
+Requires-Dist: httpx
+Requires-Dist: tiktoken
+Requires-Dist: pyyaml
+Provides-Extra: slicer
+Requires-Dist: tree-sitter==0.21.3; extra == "slicer"
+Requires-Dist: tree-sitter-languages>=1.10; extra == "slicer"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"

acc_context_compaction-0.1.0/README.md

@@ -0,0 +1,17 @@
+# ACC - Automatically Context Compaction
+
+## Project Overview
+ACC is a context compaction framework designed to drastically reduce token consumption and improve context retention for AI IDEs and agents. It contains three main modules:
+
+1. **`acc_cli`**: A Python-based CLI proxy that intelligently filters, deduplicates, and compresses verbose terminal outputs (such as massive git logs or test runner failures) before sending them to the LLM.
+2. **`acc_memory`**: A FastAPI and SQLAlchemy-powered memory backend for durable, cross-session context retention. It extracts semantic facts from conversations and stores them.
+3. **`acc_mcp`**: A standard Model Context Protocol (MCP) server that seamlessly exposes both the CLI proxy and the memory backend tools to modern IDEs like Cursor and Codex.
+
+## Key Features
+- **Token Efficiency:** Drops terminal output token usage by 50-80% using deterministic heuristic filtering without relying on expensive LLM summaries.
+- **Tee Failsafe Strategy:** When logs are aggressively truncated, the full raw output is safely dumped to a local temporary file, and a footnote is provided so the AI can retrieve the rest of the file if needed.
+- **Fact-Based Memory:** Converts passive conversational history into an atomic, queryable knowledge graph to prevent context amnesia across large repositories.
+- **Smart Git Parsers:** Contains built-in interceptors for `git status`, `git diff`, and `git log` to strip out noise and condense the output format specifically for LLM ingestion.
+
+## Architecture & Integration
+ACC is designed as a standalone toolchain. Once the MCP server is mounted in your IDE, the AI is instructed (via system prompts) to execute all shell commands through the `acc.cli_run` tool rather than running raw terminal processes.

acc_context_compaction-0.1.0/acc/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py

acc_context_compaction-0.1.0/acc/api/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py

acc_context_compaction-0.1.0/acc/api/routes.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+from acc.schemas.memory import MemoryCreate, MemorySearch
+from acc.services.memory_service import save_memory, search_memory
+
+app = FastAPI(title="ACC API")
+
+@app.post("/memory/save")
+def api_memory_save(data: MemoryCreate):
+    return save_memory(data)
+
+@app.post("/memory/search")
+def api_memory_search(data: MemorySearch):
+    return search_memory(data)

acc_context_compaction-0.1.0/acc/compaction/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py

acc_context_compaction-0.1.0/acc/compaction/_formatter_deprecated.py

@@ -0,0 +1,43 @@
+from typing import List, Dict
+
+def format_pytest(parsed: Dict, raw_lines: List[str]) -> str:
+    lines = []
+    if parsed.get("summary"):
+        lines.append(f"PYTEST SUMMARY: {parsed['summary']}")
+    if parsed["failures"]:
+        lines.append("FAILING TESTS:")
+        for f in parsed["failures"][:20]:
+            lines.append(f"- {f['file']}:: {f['test']} — {f['reason']}")
+    else:
+        lines.append("No explicit failing tests detected in parsed output.")
+    return "\n".join(lines)
+
+def format_git_status(parsed: Dict, raw_lines: List[str]) -> str:
+    lines = ["GIT STATUS SUMMARY:"]
+    if parsed["modified"]:
+        lines.append("Modified Files:")
+        lines.extend([f"  {f}" for f in parsed["modified"][:20]])
+    if parsed["untracked"]:
+        lines.append("Untracked Files:")
+        lines.extend([f"  {f}" for f in parsed["untracked"][:20]])
+    if not parsed["modified"] and not parsed["untracked"]:
+        lines.append("Working tree clean.")
+    return "\n".join(lines)
+
+def format_git_log(parsed: Dict, raw_lines: List[str]) -> str:
+    lines = ["GIT LOG SUMMARY:"]
+    for c in parsed["commits"][:20]:
+        lines.append(f"- {c['hash']} {c['message']}")
+    return "\n".join(lines)
+
+def format_git_diff(parsed: Dict, raw_lines: List[str]) -> str:
+    lines = ["GIT DIFF SUMMARY:"]
+    if parsed["files_changed"]:
+        lines.append("Files Changed:")
+        for f in parsed["files_changed"][:10]:
+            lines.append(f"  {f.replace('diff --git a/', '').replace(' b/', ' -> ')}")
+    if parsed["hunks"]:
+        lines.append("Hunks modified:")
+        for h in parsed["hunks"][:10]:
+            lines.append(f"  {h}")
+    return "\n".join(lines)

acc_context_compaction-0.1.0/acc/compaction/_parsers_deprecated.py

@@ -0,0 +1,53 @@
+import re
+from typing import List, Dict
+
+PYTEST_FAIL_RE = re.compile(r"^FAILED\s+(.+?)::(.+?)\s+\[([^\]]+)\]")
+
+def parse_pytest(lines: List[str]) -> Dict:
+    failures = []
+    summary_line = None
+    for line in lines:
+        if " failed," in line and " passed" in line:
+            summary_line = line.strip()
+        m = PYTEST_FAIL_RE.match(line)
+        if m:
+            file_path, test_name, reason = m.groups()
+            failures.append({
+                "file": file_path,
+                "test": test_name,
+                "reason": reason,
+            })
+    return {"summary": summary_line, "failures": failures}
+
+def parse_git_status(lines: List[str]) -> Dict:
+    # A simple parser for git status -s
+    modified = []
+    untracked = []
+    for line in lines:
+        if len(line) < 3: continue
+        status = line[:2]
+        file_path = line[3:].strip()
+        if "??" in status:
+            untracked.append(file_path)
+        else:
+            modified.append(f"{status.strip()} {file_path}")
+    return {"modified": modified, "untracked": untracked}
+
+def parse_git_log(lines: List[str]) -> Dict:
+    commits = []
+    for line in lines:
+        parts = line.split(" ", 1)
+        if len(parts) == 2 and len(parts[0]) >= 7:
+            commits.append({"hash": parts[0], "message": parts[1].strip()})
+    return {"commits": commits}
+
+def parse_git_diff(lines: List[str]) -> Dict:
+    # Extract just the files that changed and the hunk headers
+    files_changed = []
+    hunks = []
+    for line in lines:
+        if line.startswith("diff --git"):
+            files_changed.append(line.strip())
+        elif line.startswith("@@ "):
+            hunks.append(line.strip())
+    return {"files_changed": files_changed, "hunks": hunks}

acc_context_compaction-0.1.0/acc/compaction/dedup_cache.py

@@ -0,0 +1,117 @@
+"""
+Session-scoped deduplication cache.
+
+Prevents re-processing identical outputs across multiple MCP tool calls
+within the same server session. Uses O(1) fingerprinting based on
+(byte_length, hash(first_256_chars), hash(last_256_chars)).
+
+Lifetime: process-scoped. Dies with the MCP server process.
+Never persisted to disk — stale cache is worse than cache miss.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class Fingerprint:
+    """Immutable fingerprint for output deduplication."""
+    byte_length: int
+    prefix_hash: int  # hash of first 256 chars
+    suffix_hash: int  # hash of last 256 chars
+
+
+class DedupCache:
+    """
+    Session-scoped dedup cache. Lives for the lifetime of the MCP server process.
+
+    Usage:
+        cache = get_session_cache()
+        cache.next_turn()  # call at start of each tool invocation
+        suppressed = cache.check(raw_output)
+        if suppressed:
+            return suppressed  # identical output seen before
+    """
+
+    def __init__(self):
+        self._cache: dict[Fingerprint, int] = {}  # fingerprint → turn number
+        self._turn: int = 0
+
+    def next_turn(self):
+        """Increment turn counter. Call at the start of each tool invocation."""
+        self._turn += 1
+
+    @property
+    def current_turn(self) -> int:
+        return self._turn
+
+    def check(self, raw: str) -> Optional[str]:
+        """
+        Check if this output was seen before in this session.
+
+        Returns a suppression message if output was seen before, None otherwise.
+        On first seeing an output, it is fingerprinted and cached.
+        """
+        if not raw or not raw.strip():
+            return None
+
+        fp = self._fingerprint(raw)
+        if fp in self._cache:
+            prev_turn = self._cache[fp]
+            return (
+                f"[Output identical to turn #{prev_turn} — "
+                f"suppressed ({fp.byte_length:,} bytes)]"
+            )
+        self._cache[fp] = self._turn
+        return None
+
+    def check_file(self, file_path: str, size: int, mtime_ns: int) -> Optional[str]:
+        """
+        Check if a file has been read before based on stat metadata.
+        O(1) — does not require reading the file contents.
+
+        Returns a suppression message if the file was read with
+        identical size and mtime, None otherwise.
+        """
+        # Use a synthetic fingerprint from file metadata
+        fp = Fingerprint(
+            byte_length=size,
+            prefix_hash=hash(file_path),
+            suffix_hash=hash(mtime_ns),
+        )
+        if fp in self._cache:
+            prev_turn = self._cache[fp]
+            return (
+                f"[File unchanged since turn #{prev_turn} — "
+                f"suppressed ({size:,} bytes)]"
+            )
+        self._cache[fp] = self._turn
+        return None
+
+    def _fingerprint(self, text: str) -> Fingerprint:
+        """Create an O(1) fingerprint from text content."""
+        return Fingerprint(
+            byte_length=len(text),
+            prefix_hash=hash(text[:256]),
+            suffix_hash=hash(text[-256:]) if len(text) > 256 else hash(text),
+        )
+
+    def clear(self):
+        """Reset the cache. Called on session end."""
+        self._cache.clear()
+        self._turn = 0
+
+    @property
+    def size(self) -> int:
+        """Number of entries in the cache."""
+        return len(self._cache)
+
+
+# Module-level singleton — lives for the MCP server process lifetime.
+# All MCP tool calls share this instance.
+_session_cache = DedupCache()
+
+
+def get_session_cache() -> DedupCache:
+    """Get the global session-scoped dedup cache."""
+    return _session_cache

acc_context_compaction-0.1.0/acc/compaction/parsers/__init__.py

@@ -0,0 +1,58 @@
+"""
+Auto-discovery module for parser plugins.
+
+Scans this directory for modules containing BaseParser subclasses,
+instantiates them, and builds a registry keyed by tool name.
+"""
+
+import importlib
+import pkgutil
+from pathlib import Path
+from typing import Optional
+
+from acc.compaction.parsers.base import BaseParser
+
+_registry: list[BaseParser] = []
+_initialized = False
+
+
+def _discover_parsers():
+    """Import all modules in this package and collect BaseParser subclasses."""
+    global _initialized
+    if _initialized:
+        return
+
+    package_dir = Path(__file__).parent
+    for finder, module_name, is_pkg in pkgutil.iter_modules([str(package_dir)]):
+        if module_name in ("base", "__init__"):
+            continue
+        module = importlib.import_module(f"acc.compaction.parsers.{module_name}")
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if (
+                isinstance(attr, type)
+                and issubclass(attr, BaseParser)
+                and attr is not BaseParser
+                and attr.tool_names  # skip abstract or empty
+            ):
+                _registry.append(attr())
+
+    _initialized = True
+
+
+def get_parser(command: str) -> Optional[BaseParser]:
+    """
+    Find a parser that can handle the given command name.
+    Returns None if no parser matches.
+    """
+    _discover_parsers()
+    for parser in _registry:
+        if parser.can_handle(command):
+            return parser
+    return None
+
+
+def get_all_parsers() -> list[BaseParser]:
+    """Return all registered parsers. Useful for testing."""
+    _discover_parsers()
+    return list(_registry)

acc_context_compaction-0.1.0/acc/compaction/parsers/base.py

@@ -0,0 +1,46 @@
+"""Base class for all ACC output parsers."""
+
+from abc import ABC, abstractmethod
+from acc.core.logger import log
+
+
+class BaseParser(ABC):
+    """
+    Base class for tool-specific output parsers.
+    
+    Subclasses declare which commands they handle via `tool_names`,
+    implement `parse()` for structured compression, and inherit
+    automatic fallback-to-raw on any failure.
+    """
+
+    tool_names: list[str] = []
+
+    def can_handle(self, command: str) -> bool:
+        """Check if this parser handles the given command name."""
+        cmd_lower = command.lower()
+        if cmd_lower.endswith(".exe"):
+            cmd_lower = cmd_lower[:-4]
+        # Strip path separators (e.g. /usr/bin/gcc -> gcc)
+        cmd_lower = cmd_lower.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+        return cmd_lower in self.tool_names
+
+    @abstractmethod
+    def parse(self, raw_output: str, **kwargs) -> str:
+        """
+        Parse and compress the raw output.
+
+        Must return a compressed string. On any internal failure,
+        implementations should call self.fallback() rather than raising.
+        """
+
+    def fallback(self, raw_output: str, reason: str = "unknown") -> str:
+        """Return raw output unchanged. Called on parse failure."""
+        log.warning(
+            "Parser fallback triggered",
+            extra={
+                "parser": self.__class__.__name__,
+                "reason": reason,
+                "raw_length": len(raw_output),
+            },
+        )
+        return raw_output

acc_context_compaction-0.1.0/acc/compaction/parsers/build_parser.py

@@ -0,0 +1,122 @@
+"""Parser for build system output: make, cmake, ninja, cargo, gradle, mvn."""
+
+import re
+from acc.compaction.parsers.base import BaseParser
+
+# Lines to drop from build output
+_DROP_PATTERNS = (
+    "Entering directory",
+    "Leaving directory",
+    "make[",
+    "Nothing to be done",
+    "is up to date",
+    "Compiling ",
+    "Linking ",
+    "Building ",
+    "Scanning dependencies",
+    "Built target ",
+    "Installing ",
+    "-- ",  # cmake status messages
+    "[  ",  # progress percentages like [  5%]
+    "[ ",
+    "UP-TO-DATE",
+    "NO-SOURCE",
+    "Downloading ",
+    "Download ",
+    "> Task :",  # gradle task lines
+)
+
+_ERROR_PATTERNS = (
+    "error:",
+    "Error:",
+    "ERROR:",
+    "FAILED",
+    "FAILURE",
+    "BUILD FAILED",
+    "BUILD FAILURE",
+    "fatal:",
+    "undefined reference",
+    "cannot find",
+    "not found",
+    "No rule to make target",
+    "*** ",  # make error marker
+)
+
+
+class BuildParser(BaseParser):
+    tool_names = ["make", "cmake", "ninja", "cargo", "gradle", "mvn", "maven"]
+
+    def parse(self, raw_output: str) -> str:
+        try:
+            return self._parse_impl(raw_output)
+        except Exception as e:
+            return self.fallback(raw_output, reason=str(e))
+
+    def _parse_impl(self, raw_output: str) -> str:
+        lines = raw_output.split("\n")
+
+        # Detect if build succeeded or failed
+        has_failure = any(
+            any(ep in line for ep in _ERROR_PATTERNS)
+            for line in lines[-50:]  # check last 50 lines
+        )
+
+        if not has_failure:
+            # Successful build — super terse
+            total_lines = len([l for l in lines if l.strip()])
+            return f"[BUILD OK] Completed successfully ({total_lines} output lines suppressed)"
+
+        # Build failed — extract error context
+        return self._extract_failure(lines)
+
+    def _extract_failure(self, lines: list[str]) -> str:
+        error_lines = []
+        context_lines = []
+        total_lines = len(lines)
+        dropped = 0
+
+        # First pass: find all error lines and their indices
+        error_indices = []
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            if not stripped:
+                continue
+
+            if any(stripped.startswith(p) or stripped.startswith(p.lstrip()) for p in _DROP_PATTERNS):
+                dropped += 1
+                continue
+
+            if any(ep in stripped for ep in _ERROR_PATTERNS):
+                error_indices.append(i)
+                error_lines.append(stripped)
+
+        # Second pass: grab context around first error (±5 lines)
+        if error_indices:
+            first_error = error_indices[0]
+            start = max(0, first_error - 3)
+            end = min(len(lines), first_error + 8)
+            for i in range(start, end):
+                stripped = lines[i].strip()
+                if stripped and not any(stripped.startswith(p) for p in _DROP_PATTERNS):
+                    context_lines.append(stripped)
+
+        result = []
+        result.append(
+            f"[BUILD FAILED] {len(error_lines)} error(s) in {total_lines} output lines "
+            f"({dropped} noise lines suppressed)"
+        )
+
+        if context_lines:
+            result.append("ERROR CONTEXT:")
+            for c in context_lines[:20]:
+                result.append(f"  {c}")
+
+        # If there are more errors beyond the first, list them
+        if len(error_lines) > 1:
+            result.append(f"ALL ERRORS ({len(error_lines)}):")
+            for e in error_lines[:15]:
+                result.append(f"  {e}")
+            if len(error_lines) > 15:
+                result.append(f"  ... and {len(error_lines) - 15} more")
+
+        return "\n".join(result)

acc_context_compaction-0.1.0/acc/compaction/parsers/compiler_parser.py

@@ -0,0 +1,141 @@
+"""Parser for compiler output: gcc, g++, clang, clang++, cross-compilers."""
+
+import json
+import re
+from acc.compaction.parsers.base import BaseParser
+
+# Matches: file:line:col: severity: message
+_GCC_DIAG_RE = re.compile(
+    r"^(.+?):(\d+):(\d+):\s+(error|warning|fatal error):\s+(.+)$"
+)
+
+# Lines to drop entirely
+_DROP_PREFIXES = (
+    "In file included from",
+    "                 from",
+    "In member function",
+    "In function",
+    "In instantiation of",
+    "   required from",
+    "   required by",
+)
+
+
+class CompilerParser(BaseParser):
+    tool_names = [
+        "gcc", "g++", "cc", "c++",
+        "clang", "clang++",
+        "arm-none-eabi-gcc", "arm-none-eabi-g++",
+        "aarch64-linux-gnu-gcc",
+        "x86_64-linux-gnu-gcc",
+    ]
+
+    def parse(self, raw_output: str) -> str:
+        try:
+            return self._parse_impl(raw_output)
+        except Exception as e:
+            return self.fallback(raw_output, reason=str(e))
+
+    def _parse_impl(self, raw_output: str) -> str:
+        # Try JSON diagnostics (clang --serialize-diagnostics or --json-diagnostics)
+        stripped = raw_output.strip()
+        if stripped.startswith("[") or stripped.startswith("{"):
+            try:
+                return self._parse_json(stripped)
+            except (json.JSONDecodeError, KeyError, TypeError):
+                pass
+
+        return self._parse_text(raw_output)
+
+    def _parse_json(self, raw_output: str) -> str:
+        data = json.loads(raw_output)
+        if isinstance(data, dict):
+            data = data.get("diagnostics", [data])
+        if not isinstance(data, list):
+            data = [data]
+
+        errors = []
+        warnings = []
+        for diag in data:
+            severity = diag.get("severity", "").lower()
+            msg = diag.get("message", "")
+            loc = diag.get("location", {})
+            file_path = loc.get("file", "?")
+            line = loc.get("line", "?")
+            entry = f"{file_path}:{line}: {msg}"
+            if "error" in severity:
+                errors.append(entry)
+            elif "warning" in severity:
+                warnings.append(entry)
+
+        return self._format_output(errors, warnings)
+
+    def _parse_text(self, raw_output: str) -> str:
+        lines = raw_output.split("\n")
+        errors = []
+        warnings = []
+        seen_errors = {}  # message -> count for dedup
+
+        for line in lines:
+            stripped = line.strip()
+
+            # Skip noise lines
+            if any(stripped.startswith(p) for p in _DROP_PREFIXES):
+                continue
+            if stripped.startswith("^") or stripped.startswith("|"):
+                continue
+            if stripped.startswith("note:") or ": note:" in stripped:
+                continue
+
+            m = _GCC_DIAG_RE.match(stripped)
+            if m:
+                file_path, lineno, col, severity, message = m.groups()
+                entry = f"{file_path}:{lineno}:{col}: {message}"
+
+                if severity in ("error", "fatal error"):
+                    # Dedup identical error messages (e.g. undefined reference)
+                    if message in seen_errors:
+                        seen_errors[message] += 1
+                    else:
+                        seen_errors[message] = 1
+                        errors.append(entry)
+                elif severity == "warning":
+                    warnings.append(entry)
+
+        # Append dedup counts
+        final_errors = []
+        for entry in errors:
+            # Extract just the message part after the last ": "
+            msg = entry.rsplit(": ", 1)[-1] if ": " in entry else entry
+            count = seen_errors.get(msg, 1)
+            if count > 1:
+                final_errors.append(f"{entry} (×{count})")
+            else:
+                final_errors.append(entry)
+
+        return self._format_output(final_errors, warnings)
+
+    def _format_output(self, errors: list[str], warnings: list[str]) -> str:
+        result = []
+        result.append(
+            f"[BUILD] {len(errors)} error(s), {len(warnings)} warning(s)"
+        )
+
+        if errors:
+            result.append("ERRORS:")
+            for e in errors[:30]:
+                result.append(f"  {e}")
+
+        if warnings:
+            if len(warnings) > 10:
+                result.append(
+                    f"WARNINGS: {len(warnings)} total (showing first 5)"
+                )
+                for w in warnings[:5]:
+                    result.append(f"  {w}")
+            else:
+                result.append("WARNINGS:")
+                for w in warnings:
+                    result.append(f"  {w}")
+
+        return "\n".join(result)