gdmcode 0.1.0__py3-none-any.whl

src/tools/result_cache.py

@@ -0,0 +1,157 @@
+"""LRU+TTL cache for tool results — tools-004.
+
+Thread-safe, bounded cache that avoids redundant tool calls.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+import time
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from functools import wraps
+from typing import Any, Callable
+
+
+__all__ = ["CacheEntry", "ToolResultCache", "cached_tool"]
+
+
+@dataclass
+class CacheEntry:
+    result: Any
+    created_at: float = field(default_factory=time.monotonic)
+    hits: int = 0
+
+
+class ToolResultCache:
+    """Bounded LRU cache with TTL for tool call results.
+
+    Args:
+        max_size: Maximum number of entries before LRU eviction.
+        ttl: Time-to-live in seconds (uses ``time.monotonic``).
+    """
+
+    def __init__(self, max_size: int = 256, ttl: float = 300.0) -> None:
+        self._max_size = max_size
+        self._ttl = ttl
+        self._store: OrderedDict[str, CacheEntry] = OrderedDict()
+        self._lock = threading.Lock()
+        self._hits = 0
+        self._misses = 0
+        self._evictions = 0
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def get(self, tool_name: str, args: dict[str, Any]) -> Any | None:
+        """Return cached result or None if missing / expired."""
+        key = self._make_key(tool_name, args)
+        with self._lock:
+            entry = self._store.get(key)
+            if entry is None:
+                self._misses += 1
+                return None
+            if time.monotonic() - entry.created_at > self._ttl:
+                del self._store[key]
+                self._misses += 1
+                return None
+            # Move to end (most-recently-used)
+            self._store.move_to_end(key)
+            entry.hits += 1
+            self._hits += 1
+            return entry.result
+
+    def put(self, tool_name: str, args: dict[str, Any], result: Any) -> None:
+        """Store a result, evicting the LRU entry if at capacity."""
+        key = self._make_key(tool_name, args)
+        with self._lock:
+            if key in self._store:
+                self._store.move_to_end(key)
+                self._store[key] = CacheEntry(result=result)
+                return
+            if len(self._store) >= self._max_size:
+                self._store.popitem(last=False)  # evict LRU (oldest)
+                self._evictions += 1
+            self._store[key] = CacheEntry(result=result)
+
+    def invalidate(self, tool_name: str | None = None) -> int:
+        """Remove entries.
+
+        Args:
+            tool_name: If given, remove only entries for that tool.
+                       If None, clear everything.
+
+        Returns:
+            Number of entries removed.
+        """
+        with self._lock:
+            if tool_name is None:
+                count = len(self._store)
+                self._store.clear()
+                return count
+            prefix = tool_name + ":"
+            keys = [k for k in self._store if k.startswith(prefix)]
+            for k in keys:
+                del self._store[k]
+            return len(keys)
+
+    def stats(self) -> dict[str, int]:
+        """Return cache statistics."""
+        with self._lock:
+            return {
+                "size": len(self._store),
+                "hits": self._hits,
+                "misses": self._misses,
+                "evictions": self._evictions,
+            }
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _make_key(tool_name: str, args: dict[str, Any]) -> str:
+        """Deterministic SHA-256 key; arg order does not affect the result."""
+        canonical = json.dumps(args, sort_keys=True, separators=(",", ":"), default=str)
+        payload = f"{tool_name}:{canonical}"
+        return tool_name + ":" + hashlib.sha256(payload.encode()).hexdigest()
+
+
+# ---------------------------------------------------------------------------
+# Decorator
+# ---------------------------------------------------------------------------
+
+
+def cached_tool(
+    cache: ToolResultCache,
+    tool_name: str | None = None,
+) -> Callable:
+    """Decorator that caches a tool function''s return value.
+
+    Args:
+        cache: ``ToolResultCache`` instance to use.
+        tool_name: Cache key prefix.  Defaults to the wrapped function''s name.
+    """
+
+    def decorator(fn: Callable) -> Callable:
+        name = tool_name or fn.__name__
+
+        @wraps(fn)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Build a stable args dict from positional + keyword arguments
+            call_args: dict[str, Any] = {f"_arg{i}": v for i, v in enumerate(args)}
+            call_args.update(kwargs)
+
+            cached = cache.get(name, call_args)
+            if cached is not None:
+                return cached
+
+            result = fn(*args, **kwargs)
+            cache.put(name, call_args, result)
+            return result
+
+        return wrapper
+
+    return decorator

src/tools/search_tools.py

@@ -0,0 +1,310 @@
+"""GlobTool and GrepTool — fast file pattern and content search.
+
+GlobTool: pathlib-based file pattern matching with .gdmignore support.
+GrepTool: ripgrep-based content search (falls back to Python re if rg not found).
+
+Both tools tag their output as untrusted before returning, since file paths and
+content could contain adversarial data.
+"""
+from __future__ import annotations
+
+import fnmatch
+import logging
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, ClassVar
+
+from src.tools import REGISTRY, ToolBase, ToolResult
+
+__all__ = ["GlobTool", "GrepTool"]
+
+log = logging.getLogger(__name__)
+
+_MAX_RESULTS: int = 500        # max file paths to return
+_MAX_GREP_OUTPUT_BYTES: int = 30_000
+_GDMIGNORE_FILENAME = ".gdmignore"
+
+# Directories always excluded from search.
+_DEFAULT_EXCLUDE_DIRS: frozenset[str] = frozenset({
+    ".git", "__pycache__", ".venv", "venv", "env",
+    "node_modules", ".next", ".nuxt", "dist", "build",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache",
+    ".context-memory",
+})
+
+
+# ---------------------------------------------------------------------------
+# .gdmignore support
+# ---------------------------------------------------------------------------
+
+def _load_ignore_patterns(workspace: Path) -> list[str]:
+    """Read .gdmignore from workspace root; return list of fnmatch patterns."""
+    ignore_file = workspace / _GDMIGNORE_FILENAME
+    if not ignore_file.exists():
+        return []
+    try:
+        lines = ignore_file.read_text(encoding="utf-8").splitlines()
+        return [ln.strip() for ln in lines if ln.strip() and not ln.startswith("#")]
+    except OSError:
+        return []
+
+
+def _is_ignored(path: Path, patterns: list[str]) -> bool:
+    """Return True if any glob pattern matches the path."""
+    name = path.name
+    return any(fnmatch.fnmatch(name, pat) for pat in patterns)
+
+
+# ---------------------------------------------------------------------------
+# GlobTool
+# ---------------------------------------------------------------------------
+
+class GlobTool(ToolBase):
+    """Find files matching a glob pattern within the project."""
+
+    name: ClassVar[str] = "glob"
+    description: ClassVar[str] = (
+        "Find files matching a glob pattern (e.g. '**/*.py', 'src/**/*.ts'). "
+        "Returns up to 500 matching paths relative to the project root. "
+        "Respects .gdmignore and always excludes .git, node_modules, __pycache__."
+    )
+    input_schema: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "required": ["pattern"],
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "description": "Glob pattern, e.g. '**/*.py' or 'src/**/*.ts'.",
+            },
+            "cwd": {
+                "type": "string",
+                "description": "Search root. Defaults to project workspace.",
+            },
+        },
+        "additionalProperties": False,
+    }
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self._workspace = workspace
+
+    def execute(self, params: dict[str, Any]) -> ToolResult:  # noqa: D102
+        pattern: str = params["pattern"]
+        cwd_str: str | None = params.get("cwd")
+
+        root = Path(cwd_str).resolve() if cwd_str else (self._workspace or Path.cwd())
+        if not root.is_dir():
+            return ToolResult(output="", error=f"Directory not found: {root}")
+
+        ignore_patterns = _load_ignore_patterns(root)
+
+        try:
+            matches: list[Path] = []
+            for p in root.glob(pattern):
+                if not p.is_file():
+                    continue
+                # Skip excluded dirs.
+                if any(part in _DEFAULT_EXCLUDE_DIRS for part in p.parts):
+                    continue
+                if _is_ignored(p, ignore_patterns):
+                    continue
+                matches.append(p)
+                if len(matches) >= _MAX_RESULTS:
+                    break
+        except Exception as exc:  # noqa: BLE001
+            return ToolResult(output="", error=f"Glob failed: {exc}")
+
+        if not matches:
+            return ToolResult(output="No files matched.")
+
+        lines = [str(p.relative_to(root)) for p in sorted(matches)]
+        output = "\n".join(lines)
+        truncated = len(matches) >= _MAX_RESULTS
+
+        return ToolResult(
+            output=output,
+            truncated=truncated,
+            metadata={"count": len(matches), "root": str(root)},
+        )
+
+
+# ---------------------------------------------------------------------------
+# GrepTool
+# ---------------------------------------------------------------------------
+
+class GrepTool(ToolBase):
+    """Search file contents using ripgrep (or Python regex fallback)."""
+
+    name: ClassVar[str] = "grep"
+    description: ClassVar[str] = (
+        "Search for a regex pattern in file contents. "
+        "Uses ripgrep if available for speed; otherwise falls back to Python re. "
+        "Returns matching lines with file:line format. Output capped at 30 KB."
+    )
+    input_schema: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "required": ["pattern"],
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "description": "Regular expression to search for.",
+            },
+            "path": {
+                "type": "string",
+                "description": "File or directory to search. Defaults to project root.",
+            },
+            "glob": {
+                "type": "string",
+                "description": "File glob filter, e.g. '*.py'.",
+            },
+            "case_insensitive": {
+                "type": "boolean",
+                "description": "Case-insensitive search.",
+            },
+            "context_lines": {
+                "type": "integer",
+                "description": "Lines of context before and after each match (0–10).",
+            },
+        },
+        "additionalProperties": False,
+    }
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self._workspace = workspace
+
+    def execute(self, params: dict[str, Any]) -> ToolResult:  # noqa: D102
+        pattern: str = params["pattern"]
+        path_str: str | None = params.get("path")
+        glob_filter: str | None = params.get("glob")
+        case_insensitive: bool = bool(params.get("case_insensitive", False))
+        context_lines: int = min(int(params.get("context_lines", 0)), 10)
+
+        search_root = (
+            Path(path_str).resolve()
+            if path_str
+            else (self._workspace or Path.cwd())
+        )
+
+        if _rg_available():
+            output, err = _rg_search(
+                pattern,
+                search_root,
+                glob_filter=glob_filter,
+                case_insensitive=case_insensitive,
+                context_lines=context_lines,
+            )
+        else:
+            output, err = _python_search(
+                pattern,
+                search_root,
+                glob_filter=glob_filter,
+                case_insensitive=case_insensitive,
+                context_lines=context_lines,
+            )
+
+        if err:
+            return ToolResult(output="", error=err)
+        if not output.strip():
+            return ToolResult(output="No matches found.")
+
+        truncated = len(output.encode("utf-8")) >= _MAX_GREP_OUTPUT_BYTES
+        return ToolResult(output=output, truncated=truncated)
+
+
+# ---------------------------------------------------------------------------
+# ripgrep implementation
+# ---------------------------------------------------------------------------
+
+def _rg_available() -> bool:
+    import shutil
+    return shutil.which("rg") is not None
+
+
+def _rg_search(
+    pattern: str,
+    root: Path,
+    *,
+    glob_filter: str | None,
+    case_insensitive: bool,
+    context_lines: int,
+) -> tuple[str, str | None]:
+    """Run ripgrep; return (output, error)."""
+    args = ["rg", "--line-number", "--no-heading", "--color=never"]
+    if case_insensitive:
+        args.append("--ignore-case")
+    if context_lines:
+        args.extend(["-C", str(context_lines)])
+    if glob_filter:
+        args.extend(["--glob", glob_filter])
+    # Exclude default dirs.
+    for d in _DEFAULT_EXCLUDE_DIRS:
+        args.extend(["--glob", f"!{d}/**"])
+    args.extend(["--", pattern, str(root)])
+
+    try:
+        result = subprocess.run(args, capture_output=True, text=True, timeout=30)
+        output = result.stdout
+        if len(output.encode("utf-8")) > _MAX_GREP_OUTPUT_BYTES:
+            output = output.encode("utf-8")[:_MAX_GREP_OUTPUT_BYTES].decode("utf-8", errors="replace")
+        return output, None
+    except subprocess.TimeoutExpired:
+        return "", "Grep timed out after 30s"
+    except Exception as exc:  # noqa: BLE001
+        return "", str(exc)
+
+
+# ---------------------------------------------------------------------------
+# Pure-Python fallback
+# ---------------------------------------------------------------------------
+
+def _python_search(
+    pattern: str,
+    root: Path,
+    *,
+    glob_filter: str | None,
+    case_insensitive: bool,
+    context_lines: int,
+) -> tuple[str, str | None]:
+    """Walk root and search files with re; return (output, error)."""
+    flags = re.IGNORECASE if case_insensitive else 0
+    try:
+        compiled = re.compile(pattern, flags)
+    except re.error as exc:
+        return "", f"Invalid regex: {exc}"
+
+    file_glob = glob_filter or "*"
+    results: list[str] = []
+    total_bytes = 0
+
+    for filepath in root.rglob(file_glob):
+        if not filepath.is_file():
+            continue
+        if any(part in _DEFAULT_EXCLUDE_DIRS for part in filepath.parts):
+            continue
+        try:
+            lines = filepath.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            continue
+
+        for i, line in enumerate(lines):
+            if compiled.search(line):
+                ctx_start = max(0, i - context_lines)
+                ctx_end = min(len(lines), i + context_lines + 1)
+                for j in range(ctx_start, ctx_end):
+                    prefix = ">" if j == i else " "
+                    entry = f"{filepath}:{j + 1}{prefix} {lines[j]}"
+                    results.append(entry)
+                    total_bytes += len(entry.encode("utf-8"))
+                if total_bytes >= _MAX_GREP_OUTPUT_BYTES:
+                    return "\n".join(results), None
+
+    return "\n".join(results), None
+
+
+# ---------------------------------------------------------------------------
+# Auto-register
+# ---------------------------------------------------------------------------
+
+REGISTRY.register(GlobTool())
+REGISTRY.register(GrepTool())