gemcode 0.2.2__py3-none-any.whl

gemcode/tools/edit.py

@@ -0,0 +1,53 @@
+"""Write and search_replace tools."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from gemcode.config import GemCodeConfig
+from gemcode.paths import PathEscapeError, resolve_under_root
+
+
+def make_edit_tools(cfg: GemCodeConfig):
+  root = cfg.project_root
+
+  def write_file(path: str, content: str) -> dict:
+    """Create or overwrite a file relative to the project root."""
+    try:
+      p = resolve_under_root(root, path)
+    except PathEscapeError as e:
+      return {"error": str(e)}
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(content, encoding="utf-8")
+    return {"path": path, "bytes_written": len(content.encode("utf-8"))}
+
+  def search_replace(
+    path: str,
+    old_string: str,
+    new_string: str,
+    replace_all: bool = False,
+  ) -> dict:
+    """
+    Replace old_string with new_string in a text file. Fails if old_string
+    is missing or duplicate (unless replace_all=True).
+    """
+    try:
+      p = resolve_under_root(root, path)
+    except PathEscapeError as e:
+      return {"error": str(e)}
+    if not p.is_file():
+      return {"error": f"Not a file: {path}"}
+    text = p.read_text(encoding="utf-8", errors="strict")
+    count = text.count(old_string)
+    if count == 0:
+      return {"error": "old_string not found"}
+    if count > 1 and not replace_all:
+      return {"error": f"old_string appears {count} times; set replace_all=true or narrow snippet"}
+    if replace_all:
+      new_text = text.replace(old_string, new_string)
+    else:
+      new_text = text.replace(old_string, new_string, 1)
+    p.write_text(new_text, encoding="utf-8")
+    return {"path": path, "replacements": count if replace_all else 1}
+
+  return write_file, search_replace

gemcode/tools/filesystem.py

@@ -0,0 +1,73 @@
+"""Read and list files under project root."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from gemcode.config import GemCodeConfig
+from gemcode.paths import PathEscapeError, resolve_under_root
+from gemcode.trust import is_trusted_root
+
+
+def make_filesystem_tools(cfg: GemCodeConfig):
+  root = cfg.project_root
+  trusted = is_trusted_root(root)
+
+  def read_file(path: str, max_bytes: int = 200_000) -> dict:
+    """Read a text file relative to the project root. Large files are truncated."""
+    if not trusted:
+      return {"error": "Project folder is not trusted. Re-run GemCode and approve folder trust."}
+    try:
+      p = resolve_under_root(root, path)
+    except PathEscapeError as e:
+      return {"error": str(e)}
+    if not p.is_file():
+      return {"error": f"Not a file: {path}"}
+    data = p.read_bytes()
+    truncated = len(data) > max_bytes
+    text = data[:max_bytes].decode("utf-8", errors="replace")
+    return {
+      "path": path,
+      "content": text,
+      "truncated": truncated,
+      "total_bytes": len(data),
+    }
+
+  def list_directory(path: str = ".") -> dict:
+    """List files and directories under path (relative to project root)."""
+    if not trusted:
+      return {"error": "Project folder is not trusted. Re-run GemCode and approve folder trust."}
+    try:
+      p = resolve_under_root(root, path)
+    except PathEscapeError as e:
+      return {"error": str(e)}
+    if not p.is_dir():
+      return {"error": f"Not a directory: {path}"}
+    entries: list[dict] = []
+    for child in sorted(p.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower())):
+      entries.append(
+        {
+          "name": child.name,
+          "type": "dir" if child.is_dir() else "file",
+        }
+      )
+    return {"path": path, "entries": entries[:500]}
+
+  def glob_files(pattern: str) -> dict:
+    """Glob file paths relative to project root (e.g. 'src/**/*.py')."""
+    if not trusted:
+      return {"error": "Project folder is not trusted. Re-run GemCode and approve folder trust."}
+    if ".." in pattern or pattern.startswith("/"):
+      return {"error": "Invalid pattern"}
+    matches: list[str] = []
+    for m in root.glob(pattern):
+      try:
+        rel = m.resolve().relative_to(root)
+      except ValueError:
+        continue
+      matches.append(str(rel))
+      if len(matches) >= 200:
+        break
+    return {"pattern": pattern, "matches": matches}
+
+  return read_file, list_directory, glob_files

gemcode/tools/search.py

@@ -0,0 +1,85 @@
+"""Grep content with regex (MVP: Python scan, optional rg)."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+from gemcode.config import GemCodeConfig
+
+
+def make_grep_tool(cfg: GemCodeConfig):
+  root = cfg.project_root
+
+  def grep_content(
+    pattern: str,
+    path_glob: str = "**/*",
+    max_matches: int = 80,
+  ) -> dict:
+    """
+    Search file contents with a regex pattern. Scans files under path_glob
+    (glob relative to project root). Binary files skipped.
+    """
+    if max_matches < 1:
+      max_matches = 1
+    if max_matches > 500:
+      max_matches = 500
+    try:
+      re.compile(pattern)
+    except re.error as e:
+      return {"error": f"Invalid regex: {e}"}
+
+    # Prefer ripgrep if available (faster)
+    rg = Path("/usr/bin/rg") if Path("/usr/bin/rg").is_file() else None
+    if rg is None:
+      rg = Path("/opt/homebrew/bin/rg") if Path("/opt/homebrew/bin/rg").is_file() else None
+    if rg and rg.is_file():
+      try:
+        proc = subprocess.run(
+          [
+            str(rg),
+            "-n",
+            "--glob",
+            path_glob,
+            "--glob",
+            "!.git/*",
+            pattern,
+            ".",
+          ],
+          cwd=root,
+          capture_output=True,
+          text=True,
+          timeout=60,
+          check=False,
+        )
+        lines = proc.stdout.splitlines()[:max_matches]
+        return {"pattern": pattern, "matches": lines, "backend": "rg"}
+      except (subprocess.TimeoutExpired, OSError):
+        pass
+
+    rx = re.compile(pattern)
+    matches: list[str] = []
+    for fp in root.glob(path_glob):
+      if not fp.is_file():
+        continue
+      if fp.stat().st_size > 2_000_000:
+        continue
+      try:
+        text = fp.read_text(encoding="utf-8", errors="ignore")
+      except OSError:
+        continue
+      for i, line in enumerate(text.splitlines(), 1):
+        if rx.search(line):
+          rel = fp.resolve().relative_to(root)
+          matches.append(f"{rel}:{i}:{line[:500]}")
+          if len(matches) >= max_matches:
+            return {
+              "pattern": pattern,
+              "matches": matches,
+              "truncated": True,
+              "backend": "python",
+            }
+    return {"pattern": pattern, "matches": matches, "backend": "python"}
+
+  return grep_content

gemcode/tools/shell.py

@@ -0,0 +1,73 @@
+"""Allowlisted subprocess execution."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+from gemcode.config import GemCodeConfig
+from gemcode.trust import is_trusted_root
+
+
+def make_run_command(cfg: GemCodeConfig):
+  root = cfg.project_root
+  trusted = is_trusted_root(root)
+
+  def run_command(
+    command: str,
+    args: list[str] | None = None,
+    timeout_seconds: int = 120,
+  ) -> dict:
+    """
+    Run an allowlisted executable with arguments under the project root cwd.
+
+    The executable must be a basename (no shell metacharacters) and appear in
+    GEMCODE_ALLOW_COMMANDS / default allowlist.
+    """
+    if not trusted:
+      return {"error": "Project folder is not trusted. Re-run GemCode and approve folder trust."}
+    args = args or []
+    if timeout_seconds < 1:
+      timeout_seconds = 1
+    if timeout_seconds > 600:
+      timeout_seconds = 600
+    if any(c in command for c in ";|&$`"):
+      return {"error": "Command must be a single executable name, not a shell snippet"}
+    exe = Path(command).name
+    if exe != command:
+      return {"error": "Use basename only for command (e.g. pytest, not /usr/bin/pytest)"}
+
+    allowed = cfg.allow_commands
+    if exe not in allowed:
+      return {
+        "error": (
+          f"Command {exe!r} not in allowlist. Add it to GEMCODE_ALLOW_COMMANDS "
+          f"(comma-separated)."
+        )
+      }
+
+    resolved = shutil.which(exe)
+    if not resolved:
+      return {"error": f"Executable not found on PATH: {exe}"}
+    try:
+      proc = subprocess.run(
+        [resolved, *args],
+        cwd=root,
+        capture_output=True,
+        text=True,
+        timeout=timeout_seconds,
+        env={**os.environ},
+        check=False,
+      )
+      return {
+        "command": [exe, *args],
+        "exit_code": proc.returncode,
+        "stdout": proc.stdout[:50_000],
+        "stderr": proc.stderr[:50_000],
+      }
+    except subprocess.TimeoutExpired:
+      return {"error": f"Timeout after {timeout_seconds}s"}
+
+  return run_command

gemcode/tools_inspector.py

@@ -0,0 +1,132 @@
+"""
+GemCode tool inventory + declaration smoke testing.
+
+Claude Code's tool-system prompt emphasizes:
+- inventory of available tools (feature-gated vs always-on)
+- schema/declaration compilation smoke tests per tool
+- permission/category metadata
+
+In GemCode (ADK-based), tool declarations are produced by ADK via:
+- wrapping callables in `google.adk.tools.function_tool.FunctionTool`
+- calling `_get_declaration()` on BaseTool implementations
+
+This module provides a deterministic way to:
+- enumerate tools for a given `GemCodeConfig`
+- validate each tool can build its declaration (when supported)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from google.adk.tools.base_tool import BaseTool
+from google.adk.tools.function_tool import FunctionTool
+
+from gemcode.config import GemCodeConfig
+from gemcode.modality_tools import build_extra_tools as build_modality_tools
+from gemcode.tools import build_function_tools
+
+
+@dataclass(frozen=True)
+class ToolInspection:
+  name: str
+  category: str
+  declaration_present: bool
+  declaration_error: str | None = None
+  tool_type: str = "callable"  # "callable" | "builtin"
+
+
+def _tool_name(tool_union: Any) -> str:
+  if isinstance(tool_union, BaseTool):
+    return getattr(tool_union, "name", "") or ""
+  if callable(tool_union):
+    return getattr(tool_union, "__name__", "") or ""
+  return ""
+
+
+def _classify_tool(name: str) -> str:
+  # Keep this consistent with gemcode/src/gemcode/tool_registry.py
+  from gemcode.tool_registry import READ_ONLY_TOOLS, MUTATING_TOOLS, SHELL_TOOLS
+
+  if name in READ_ONLY_TOOLS:
+    return "read_only"
+  if name in MUTATING_TOOLS:
+    return "mutating"
+  if name in SHELL_TOOLS:
+    return "shell"
+  return "other"
+
+
+def _iter_tool_unions(cfg: GemCodeConfig, *, extra_tools: Iterable[Any] | None = None):
+  # Core function tools (always available for the agent).
+  tools: list[Any] = list(build_function_tools(cfg))
+
+  # Deep research built-in tools (Search/URL/Maps).
+  tools.extend(build_modality_tools(cfg))
+
+  # Optional MCP toolsets are provided as `extra_tools` by the caller (CLI).
+  if extra_tools:
+    tools.extend(list(extra_tools))
+
+  # Note: ComputerUseToolset requires launching Playwright via BrowserComputer.
+  # Tool declaration smoke tests can be slow and brittle, so we intentionally
+  # omit it from inventory unless the caller constructs it already.
+  #
+  # If you want it included, pass it via `extra_tools` explicitly.
+  return tools
+
+
+def inspect_tools(
+  cfg: GemCodeConfig,
+  *,
+  extra_tools: Iterable[Any] | None = None,
+) -> list[ToolInspection]:
+  """
+  Enumerate tools for this config and attempt to compile each tool's
+  declaration (schema) without executing tool logic.
+  """
+  out: list[ToolInspection] = []
+
+  for tool_union in _iter_tool_unions(cfg, extra_tools=extra_tools):
+    name = _tool_name(tool_union) or "<unknown>"
+    category = _classify_tool(name)
+    tool_type = "builtin" if isinstance(tool_union, BaseTool) else "callable"
+
+    declaration_present = False
+    declaration_error: str | None = None
+
+    try:
+      if isinstance(tool_union, BaseTool):
+        decl = tool_union._get_declaration()
+      else:
+        # For pure callables, ADK uses FunctionTool to build FunctionDeclaration.
+        decl_tool = FunctionTool(func=tool_union)  # type: ignore[arg-type]
+        decl = decl_tool._get_declaration()
+
+      declaration_present = decl is not None
+    except Exception as e:
+      declaration_present = False
+      declaration_error = f"{type(e).__name__}: {e}"
+
+    out.append(
+      ToolInspection(
+        name=name,
+        category=category,
+        declaration_present=declaration_present,
+        declaration_error=declaration_error,
+        tool_type=tool_type,
+      )
+    )
+
+  # Stable output ordering.
+  out.sort(key=lambda x: (x.category, x.name.lower()))
+  return out
+
+
+def smoke_tools(
+  inspections: list[ToolInspection],
+) -> list[ToolInspection]:
+  """Return only the tools that failed declaration compilation."""
+  return [i for i in inspections if i.declaration_error is not None]
+

gemcode/trust.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+def _trust_file_path() -> Path:
+  base = Path(os.environ.get("GEMCODE_HOME") or (Path.home() / ".gemcode"))
+  return base / "trust.json"
+
+
+def load_trusted_roots() -> set[str]:
+  """
+  Returns a set of resolved absolute paths (as strings) that are trusted.
+  """
+  p = _trust_file_path()
+  try:
+    data = json.loads(p.read_text("utf-8"))
+  except FileNotFoundError:
+    return set()
+  except Exception:
+    return set()
+  roots = data.get("trusted_roots") if isinstance(data, dict) else None
+  if not isinstance(roots, list):
+    return set()
+  out: set[str] = set()
+  for r in roots:
+    if isinstance(r, str) and r:
+      out.add(str(Path(r).resolve()))
+  return out
+
+
+def save_trusted_roots(roots: set[str]) -> None:
+  p = _trust_file_path()
+  p.parent.mkdir(parents=True, exist_ok=True)
+  payload = {"trusted_roots": sorted(set(str(Path(r).resolve()) for r in roots))}
+  p.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+def is_trusted_root(root: Path) -> bool:
+  r = str(root.resolve())
+  return r in load_trusted_roots()
+
+
+def trust_root(root: Path, *, trusted: bool) -> None:
+  roots = load_trusted_roots()
+  r = str(root.resolve())
+  if trusted:
+    roots.add(r)
+  else:
+    roots.discard(r)
+  save_trusted_roots(roots)
+