code-muse 0.0.1__py3-none-any.whl

code_muse/plugins/filter_engine/registry.py

@@ -0,0 +1,279 @@
+"""Strategy registry for the filter engine.
+
+Maps command categories to compression strategy functions.  Handles
+registration, duplicate detection, and priority-based overrides.
+"""
+
+import json
+import logging
+import re
+from collections.abc import Callable
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class StrategyRegistry:
+    """Registry mapping category names to compression strategy functions."""
+
+    def __init__(self) -> None:
+        """Initialize the registry with the built-in ``unknown`` passthrough."""
+        self._strategies: dict[str, tuple[Callable, int]] = {}
+        self._register_passthrough()
+
+    def _register_passthrough(self) -> None:
+        """Register the built-in passthrough strategy for ``unknown``."""
+
+        def _passthrough(
+            command: str,
+            stdout: str,
+            stderr: str,
+            exit_code: int,
+            verbosity: Any,  # noqa: ANN401
+        ) -> Any:  # noqa: ANN401
+            """Return None to signal that normal execution should proceed."""
+            return None
+
+        self._strategies["unknown"] = (_passthrough, -1)
+
+    def register(
+        self,
+        category: str,
+        strategy_fn: Callable,
+        priority: int = 0,
+    ) -> None:
+        """Register a strategy function for a category.
+
+        If a strategy is already registered for the category, the new one
+        wins only when *priority* is greater than the existing priority.
+        A warning is logged on collision regardless.
+
+        Args:
+            category: The command category (e.g. ``"git"``).
+            strategy_fn: Callable that accepts
+                ``(command, stdout, stderr, exit_code, verbosity)`` and returns
+                a ``ShellCommandOutput`` or ``None``.
+            priority: Higher values win on collision.  Defaults to ``0``.
+        """
+        existing = self._strategies.get(category)
+        if existing is not None:
+            _, existing_priority = existing
+            if priority > existing_priority:
+                logger.warning(
+                    "StrategyRegistry: overriding '%s' strategy (priority %d > %d)",
+                    category,
+                    priority,
+                    existing_priority,
+                )
+                self._strategies[category] = (strategy_fn, priority)
+            else:
+                logger.warning(
+                    "StrategyRegistry: ignoring '%s' strategy registration "
+                    "(priority %d <= %d)",
+                    category,
+                    priority,
+                    existing_priority,
+                )
+        else:
+            self._strategies[category] = (strategy_fn, priority)
+
+    def get_strategy(self, category: str) -> Callable | None:
+        """Return the strategy function for *category*, or ``None``.
+
+        The built-in ``unknown`` passthrough always returns a callable that
+        itself returns ``None``.
+        """
+        entry = self._strategies.get(category)
+        if entry is None:
+            return None
+        return entry[0]
+
+    def list_categories(self) -> list[str]:
+        """Return a sorted list of all registered category names."""
+        return sorted(self._strategies.keys())
+
+
+# Module-level singleton instance
+_registry_instance: StrategyRegistry | None = None
+
+
+def get_registry() -> StrategyRegistry:
+    """Return the module-level singleton registry."""
+    global _registry_instance
+    if _registry_instance is None:
+        _registry_instance = StrategyRegistry()
+    return _registry_instance
+
+
+# ---------------------------------------------------------------------------
+# Content-type stub strategies (filled by Epics 020–021)
+# ---------------------------------------------------------------------------
+
+
+def _register_content_stubs() -> None:
+    """Register passthrough stubs for content-type strategies."""
+    registry = get_registry()
+
+    def _json_smartcrusher(
+        command: str,
+        stdout: str,
+        stderr: str,
+        exit_code: int,
+        verbosity: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        """SmartCrusher JSON compression strategy."""
+        if not stdout or not stdout.strip():
+            return None
+        try:
+            data = json.loads(stdout)
+        except ValueError:
+            # Not valid JSON — let passthrough handle it
+            return None
+
+        from code_muse.plugins.filter_engine.strategies.json_compressor import (
+            compress_json,
+        )
+
+        compressed = compress_json(data, verbosity)
+
+        from code_muse.tools.command_runner import ShellCommandOutput
+
+        return ShellCommandOutput(
+            success=True,
+            command=command,
+            stdout=compressed,
+            stderr=stderr,
+            exit_code=exit_code,
+            execution_time=0.0,
+        )
+
+    def _diff_stub(
+        command: str,
+        stdout: str,
+        stderr: str,
+        exit_code: int,
+        verbosity: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        """Stub — basic diff compaction, keeps headers only."""
+        lines = stdout.splitlines()
+        header_lines = [
+            line
+            for line in lines
+            if line.startswith("@@")
+            or line.startswith("diff ")
+            or line.startswith("---")
+            or line.startswith("+++")
+        ]
+        if not header_lines:
+            return None
+        from code_muse.tools.command_runner import ShellCommandOutput
+
+        return ShellCommandOutput(
+            success=True,
+            command=command,
+            stdout="\n".join(header_lines) + f"\n[{len(lines)} lines in full diff]",
+            stderr=stderr,
+            exit_code=exit_code,
+            execution_time=0.0,
+        )
+
+    def _log_stub(
+        command: str,
+        stdout: str,
+        stderr: str,
+        exit_code: int,
+        verbosity: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        """Stub — basic log dedup, groups repeated lines."""
+        lines = stdout.splitlines()
+        if len(lines) < 10:
+            return None
+        # Simple: just count unique patterns
+        from collections import Counter
+
+        # Keep first 3 and last 3 lines, dedup middle
+        if len(lines) <= 6:
+            return None
+        head = lines[:3]
+        tail = lines[-3:]
+        middle_patterns = Counter(re.sub(r"\d+", "<N>", line) for line in lines[3:-3])
+        compact = (
+            head
+            + [f"[{len(lines) - 6} lines, {len(middle_patterns)} unique patterns]"]
+            + tail
+        )
+        from code_muse.tools.command_runner import ShellCommandOutput
+
+        return ShellCommandOutput(
+            success=True,
+            command=command,
+            stdout="\n".join(compact),
+            stderr=stderr,
+            exit_code=exit_code,
+            execution_time=0.0,
+        )
+
+    def _html_stub(
+        command: str,
+        stdout: str,
+        stderr: str,
+        exit_code: int,
+        verbosity: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        """Stub — basic HTML tag strip."""
+        # Strip all tags, keep text content
+        text = re.sub(r"<[^>]+>", " ", stdout)
+        text = re.sub(r"\s+", " ", text).strip()
+        if not text or len(text) < 10:
+            return None
+        from code_muse.tools.command_runner import ShellCommandOutput
+
+        return ShellCommandOutput(
+            success=True,
+            command=command,
+            stdout=text[:2000] + ("..." if len(text) > 2000 else ""),
+            stderr=stderr,
+            exit_code=exit_code,
+            execution_time=0.0,
+        )
+
+    def _search_stub(
+        command: str,
+        stdout: str,
+        stderr: str,
+        exit_code: int,
+        verbosity: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        """Stub — basic search result compaction."""
+        # Keep only filename:line:match lines, drop context
+        lines = stdout.splitlines()
+        match_lines = [
+            line
+            for line in lines
+            if re.match(r"^\S+\.\w+:\d+:", line) or line.startswith("Found ")
+        ]
+        if not match_lines and lines:
+            match_lines = lines[:10]  # keep first 10 if no matches identified
+        from code_muse.tools.command_runner import ShellCommandOutput
+
+        return ShellCommandOutput(
+            success=True,
+            command=command,
+            stdout="\n".join(match_lines)
+            + (
+                f"\n[{len(lines)} total lines]" if len(lines) > len(match_lines) else ""
+            ),
+            stderr=stderr,
+            exit_code=exit_code,
+            execution_time=0.0,
+        )
+
+    registry.register("json", _json_smartcrusher, priority=10)
+    registry.register("diff", _diff_stub, priority=10)
+    registry.register("log", _log_stub, priority=10)
+    registry.register("html", _html_stub, priority=10)
+    registry.register("search", _search_stub, priority=10)
+
+
+# Call at module load time
+_register_content_stubs()

code_muse/plugins/filter_engine/strategies/__init__.py

@@ -0,0 +1,8 @@
+"""Compression strategies for the filter engine."""
+
+try:
+    import pyximport
+
+    pyximport.install(language_level=3, build_in_temp=True, inplace=True)
+except Exception:
+    pass  # Cython not installed or pyximport unavailable — pure Python fallback

code_muse/plugins/filter_engine/strategies/ast_compressor.pyx

@@ -0,0 +1,348 @@
+"""AST-aware code compressors for Python, JavaScript, and Go.
+
+Keeps semantic essentials (signatures, imports, error paths), drops
+bodies, docstrings, and whitespace.
+"""
+
+import bisect
+import logging
+from typing import Any
+
+from code_muse.plugins.filter_engine.strategies.ast_parser import (
+    ASTNode,
+    CodeLanguage,
+    LanguageParser,
+)
+from code_muse.plugins.filter_engine.verbosity import VerbosityLevel
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Node importance classification
+# ---------------------------------------------------------------------------
+
+# Python node types to KEEP (structural/signature)
+PYTHON_KEEP_TYPES: set[str] = {
+    "function_definition",
+    "class_definition",
+    "import_statement",
+    "import_from_statement",
+    "try_statement",
+    "except_clause",
+    "raise_statement",
+    "return_statement",
+    "decorated_definition",
+    "parameters",
+    "lambda",
+}
+
+# JavaScript/TypeScript node types to KEEP
+JS_KEEP_TYPES: set[str] = {
+    "function_declaration",
+    "method_definition",
+    "class_declaration",
+    "export_statement",
+    "import_statement",
+    "try_statement",
+    "catch_clause",
+    "throw_statement",
+    "return_statement",
+    "arrow_function",
+    "variable_declarator",
+    "lexical_declaration",
+    "interface_declaration",
+    "type_alias_declaration",
+}
+
+# Go node types to KEEP
+GO_KEEP_TYPES: set[str] = {
+    "function_declaration",
+    "method_declaration",
+    "type_declaration",
+    "import_declaration",
+    "return_statement",
+    "if_statement",
+    "for_statement",
+    "call_expression",
+}
+
+
+# ---------------------------------------------------------------------------
+# Line-collection helpers
+# ---------------------------------------------------------------------------
+
+
+def _build_line_map(source: str) -> list[int]:
+    """Return a list of byte offsets for the start of every line."""
+    offsets = [0]
+    for i, ch in enumerate(source):
+        if ch == "\n":
+            offsets.append(i + 1)
+    return offsets
+
+
+def _byte_to_line(byte_offset: int, line_map: list[int]) -> int:
+    """Return the 0-based line number for a given byte offset."""
+    return bisect.bisect_right(line_map, byte_offset) - 1
+
+
+cdef int _byte_to_line_c(int byte_offset, list line_map):
+    """Cython-typed binary search — logic identical to _byte_to_line."""
+    cdef int lo = 0
+    cdef int hi = len(line_map)
+    cdef int mid
+    while lo < hi:
+        mid = (lo + hi) // 2
+        if line_map[mid] <= byte_offset:
+            lo = mid + 1
+        else:
+            hi = mid
+    return lo - 1
+
+
+def _walk_cython(
+    object node,
+    int depth,
+    object keep_types,
+    int level,
+    list lines,
+    set kept_lines,
+    list line_map,
+    object extra_handler,
+):
+    """Cython-typed AST walker — logic identical to the pure-Python _walk."""
+    cdef str node_type
+    cdef int start_line
+    cdef int end_line
+    cdef int i
+    cdef int j
+    cdef int n_lines = len(lines)
+
+    node_type = node.type
+    start_line = _byte_to_line_c(node.start_byte, line_map)
+    end_line = _byte_to_line_c(node.end_byte, line_map)
+
+    if node_type in keep_types:
+        for i in range(start_line, min(end_line + 1, n_lines)):
+            if node_type == "function_definition" and i == start_line:
+                kept_lines.add(i)
+                if level >= 3:
+                    for j in range(start_line + 1, min(start_line + 4, n_lines)):
+                        kept_lines.add(j)
+                elif level >= 1:
+                    kept_lines.add(start_line + 1)
+                break
+            elif node_type in ("class_definition", "decorated_definition"):
+                kept_lines.add(i)
+                if level >= 2:
+                    for j in range(start_line + 1, min(start_line + 3, n_lines)):
+                        kept_lines.add(j)
+                break
+            elif (
+                node_type in ("import_statement", "import_from_statement")
+                or node_type == "try_statement"
+                or node_type == "except_clause"
+                or node_type == "raise_statement"
+                or node_type == "return_statement"
+            ):
+                kept_lines.add(i)
+            else:
+                kept_lines.add(i)
+
+    if extra_handler is not None:
+        extra_handler(node, start_line, end_line, kept_lines, lines, level)
+
+    for child in node.children:
+        _walk_cython(child, depth + 1, keep_types, level, lines, kept_lines, line_map, extra_handler)
+
+
+def _collect_lines(
+    source: str,
+    ast: ASTNode,
+    keep_types: set[str],
+    level: int,
+    extra_handler: Any | None = None,
+) -> set[int]:
+    """Walk an AST and collect line numbers to keep."""
+    lines = source.split("\n")
+    kept_lines: set[int] = set()
+    line_map = _build_line_map(source)
+
+    _walk_cython(ast, 0, keep_types, level, lines, kept_lines, line_map, extra_handler)
+    return kept_lines
+
+
+def _build_output(source: str, kept_lines: set[int], comment_prefix: str = "#") -> str:
+    """Build compressed output from kept line numbers."""
+    lines = source.split("\n")
+    if not kept_lines:
+        return source[:200] + "..." if len(source) > 200 else source
+
+    result_lines: list[str] = []
+    last_kept = -1
+    for i in sorted(kept_lines):
+        if i >= len(lines):
+            continue
+        if last_kept >= 0 and i > last_kept + 1:
+            gap = i - last_kept - 1
+            result_lines.append(f"{comment_prefix} ... {gap} lines omitted ...")
+        result_lines.append(lines[i])
+        last_kept = i
+
+    if last_kept < len(lines) - 1:
+        remaining = len(lines) - 1 - last_kept
+        if remaining > 1:
+            result_lines.append(f"{comment_prefix} ... {remaining} lines omitted ...")
+        elif remaining == 1:
+            result_lines.append(lines[-1])
+
+    return "\n".join(result_lines)
+
+
+# ---------------------------------------------------------------------------
+# Compressors
+# ---------------------------------------------------------------------------
+
+
+def compress_python(
+    source: str, verbosity: VerbosityLevel | int = VerbosityLevel.COMPACT
+) -> str:
+    """Compress Python source code — keep signatures, drop bodies.
+
+    Args:
+        source: Python source code string.
+        verbosity: 0 = signatures only, 4 = keep brief bodies.
+
+    Returns:
+        Compressed Python code.
+    """
+    level = verbosity.value if isinstance(verbosity, VerbosityLevel) else verbosity
+
+    ast = LanguageParser.parse(source, CodeLanguage.PYTHON)
+    if ast is None:
+        return _fallback_compress(source)
+
+    kept_lines = _collect_lines(source, ast, PYTHON_KEEP_TYPES, level)
+    return _build_output(source, kept_lines, comment_prefix="#")
+
+
+def compress_javascript(
+    source: str, verbosity: VerbosityLevel | int = VerbosityLevel.COMPACT
+) -> str:
+    """Compress JavaScript/TypeScript — keep signatures, drop bodies."""
+    level = verbosity.value if isinstance(verbosity, VerbosityLevel) else verbosity
+
+    lang = LanguageParser.detect_language(source)
+    ast = LanguageParser.parse(source, lang)
+    if ast is None:
+        return _fallback_compress(source)
+
+    lines = source.split("\n")
+    kept_lines: set[int] = set()
+    line_map = _build_line_map(source)
+
+    def _walk(node: ASTNode, depth: int = 0) -> None:
+        start_line = _byte_to_line(node.start_byte, line_map)
+
+        if node.type in JS_KEEP_TYPES:
+            for i in range(start_line, min(start_line + 1, len(lines))):
+                kept_lines.add(i)
+            if level >= 3:
+                for j in range(start_line + 1, min(start_line + 3, len(lines))):
+                    kept_lines.add(j)
+
+        for child in node.children:
+            _walk(child, depth + 1)
+
+    _walk(ast)
+    return _build_output(source, kept_lines, comment_prefix="//")
+
+
+def compress_go(
+    source: str, verbosity: VerbosityLevel | int = VerbosityLevel.COMPACT
+) -> str:
+    """Compress Go source — keep func/method/type signatures, drop bodies."""
+    level = verbosity.value if isinstance(verbosity, VerbosityLevel) else verbosity
+
+    ast = LanguageParser.parse(source, CodeLanguage.GO)
+    if ast is None:
+        return _fallback_compress(source)
+
+    kept_lines: set[int] = set()
+
+    def _extra_handler(
+        node: ASTNode,
+        start_line: int,
+        end_line: int,
+        kept: set[int],
+        lines: list[str],
+        level: int,
+    ) -> None:
+        if node.type in ("function_declaration", "method_declaration"):
+            for i in range(start_line, min(start_line + 2, len(lines))):
+                kept.add(i)
+            for i in range(start_line, min(end_line + 1, len(lines))):
+                if "{" in lines[i]:
+                    kept.add(i)
+                    break
+        if level >= 3:
+            for j in range(start_line + 1, min(start_line + 4, len(lines))):
+                kept.add(j)
+
+    kept_lines = _collect_lines(
+        source, ast, GO_KEEP_TYPES, level, extra_handler=_extra_handler
+    )
+    return _build_output(source, kept_lines, comment_prefix="//")
+
+
+def _fallback_compress(source: str) -> str:
+    """Fallback: strip comments when AST parsing fails."""
+    lines = source.split("\n")
+    result: list[str] = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("#") or stripped.startswith("//"):
+            continue
+        if "#" in line and not line.startswith("#"):
+            line = line[: line.index("#")].rstrip()
+        if "//" in line and not line.startswith("//"):
+            line = line[: line.index("//")].rstrip()
+        result.append(line)
+    return "\n".join(result)
+
+
+def compress_ast_code(
+    source: str,
+    language: CodeLanguage | None = None,
+    verbosity: VerbosityLevel | int = VerbosityLevel.COMPACT,
+    filename: str | None = None,
+) -> str:
+    """Compress source code using the appropriate language compressor.
+
+    Args:
+        source: Source code string.
+        language: Optional pre-detected language.
+        verbosity: Compression level.
+        filename: Optional filename for language detection.
+
+    Returns:
+        Compressed source code.
+    """
+    if language is None and filename:
+        language = LanguageParser.detect_language(source, filename)
+    elif language is None:
+        language = LanguageParser.detect_language(source)
+
+    compressors = {
+        CodeLanguage.PYTHON: compress_python,
+        CodeLanguage.JAVASCRIPT: compress_javascript,
+        CodeLanguage.TYPESCRIPT: compress_javascript,
+        CodeLanguage.GO: compress_go,
+    }
+
+    compressor = compressors.get(language)
+    if compressor:
+        return compressor(source, verbosity)
+
+    return _fallback_compress(source)