gemcode 0.3.29__tar.gz → 0.3.31__tar.gz

{gemcode-0.3.29/src/gemcode.egg-info → gemcode-0.3.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.29
+Version: 0.3.31
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.29 → gemcode-0.3.31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.3.29"
+version = "0.3.31"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.3.29 → gemcode-0.3.31}/src/gemcode/agent.py

@@ -49,11 +49,77 @@ def _chain_before_model_callbacks(*callbacks):
 
 
 def _load_gemini_md(project_root: Path) -> str:
-  for name in ("GEMINI.md", "gemini.md"):
-    p = project_root / name
-    if p.is_file():
-      return p.read_text(encoding="utf-8", errors="replace")[:50_000]
-  return ""
+  """
+  Load GEMINI.md / .gemcode/NOTES.md from a Claude Code–style hierarchy.
+
+  Priority (later entries override earlier ones, all are concatenated):
+    1. ~/.gemcode/GEMINI.md           — user-global instructions (all projects)
+    2. Walk UP from project_root: each directory's GEMINI.md / .gemcode/GEMINI.md
+       (org-level files at higher dirs, project-level at project_root)
+    3. project_root/GEMINI.md         — the primary project instructions
+    4. project_root/.gemcode/GEMINI.md — alternative location
+    5. project_root/.gemcode/notes.md  — agent auto-generated notes (read-only context)
+
+  Max total: 80,000 chars.  Each file is capped at 30,000 chars.
+  HTML comments (<!-- ... -->) are stripped before injection (saves tokens).
+  """
+  import re
+
+  _NAMES = ("GEMINI.md", "gemini.md", ".gemcode/GEMINI.md")
+  _FILE_CAP = 30_000
+  _TOTAL_CAP = 80_000
+  _COMMENT_RE = re.compile(r"<!--.*?-->", re.DOTALL)
+
+  def _read(p: Path) -> str:
+    if not p.is_file():
+      return ""
+    try:
+      raw = p.read_text(encoding="utf-8", errors="replace")[:_FILE_CAP]
+      # Strip HTML comments (like Claude Code does — saves tokens)
+      return _COMMENT_RE.sub("", raw).strip()
+    except OSError:
+      return ""
+
+  seen: set[Path] = set()
+  sections: list[str] = []
+
+  def _add(p: Path, label: str | None = None) -> None:
+    resolved = p.resolve()
+    if resolved in seen:
+      return
+    seen.add(resolved)
+    text = _read(p)
+    if text:
+      sections.append(f"<!-- {label or str(p)} -->\n{text}" if label else text)
+
+  # 1. User-global: ~/.gemcode/GEMINI.md
+  user_global = Path.home() / ".gemcode" / "GEMINI.md"
+  _add(user_global, "user-global (~/.gemcode/GEMINI.md)")
+
+  # 2. Walk UP from project_root to filesystem root — loads org / monorepo-level instructions
+  walk = project_root.resolve()
+  ancestors = []
+  while walk != walk.parent:
+    walk = walk.parent
+    if walk == Path.home() or walk == Path("/"):
+      break
+    ancestors.append(walk)
+  # Walk outer→inner (org first, closer dirs later — later = higher priority)
+  for ancestor in reversed(ancestors):
+    for name in _NAMES:
+      _add(ancestor / name)
+
+  # 3+4. Project-root level instructions (primary location)
+  for name in ("GEMINI.md", "gemini.md", ".gemcode/GEMINI.md", ".gemcode/gemini.md"):
+    _add(project_root / name)
+
+  # 5. Agent-generated notes (informational context, not instructions)
+  notes = project_root / ".gemcode" / "notes.md"
+  if notes.is_file():
+    _add(notes, "agent notes (.gemcode/notes.md)")
+
+  combined = "\n\n---\n\n".join(s for s in sections if s.strip())
+  return combined[:_TOTAL_CAP]
 
 
 def _build_runtime_facts(cfg: GemCodeConfig) -> str:
@@ -66,6 +132,8 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 
   # ── Active capabilities ──────────────────────────────────────────────────
   caps: list[str] = []
+  if getattr(cfg, "enable_web_search", False) and not getattr(cfg, "enable_deep_research", False):
+    caps.append("web_search ON (tool: google_search — standalone search without full deep_research)")
   if getattr(cfg, "enable_deep_research", False):
     dr_extras = " + google_maps_grounding" if getattr(cfg, "enable_maps_grounding", False) else ""
     caps.append(f"deep_research ON (tools: google_search, url_context{dr_extras})")
@@ -151,6 +219,40 @@ Memory is **ON** ({kind}). Stored at: `{mem_path}`
 """
 
 
+def _build_plan_mode_section() -> str:
+  """Injected when plan_mode=True — instructs agent to write explicit plans first."""
+  return """
+## PLAN MODE IS ACTIVE
+
+You are currently in **Plan Mode**. Before executing ANY tools that modify files or run shell commands, you MUST:
+
+1. **Write a numbered plan** in your response text — list every step you intend to take.
+   Example:
+   ```
+   Plan:
+   1. Read src/auth/login.ts to understand the current flow
+   2. Read src/types/user.ts for the User interface
+   3. Add `lastLogin: Date` field to User interface
+   4. Update login handler to set lastLogin on successful auth
+   5. Run `npm run build` to verify no TypeScript errors
+   ```
+
+2. **Pause after the plan** — do not immediately execute tools. Present the plan and wait for the user to confirm ("go", "proceed", "looks good") before starting.
+
+3. **Stick to the plan** — if you discover the plan needs changing mid-execution, note the update before proceeding.
+
+4. **Report completion** against the plan — when done, confirm each step as completed.
+
+**Why plan mode?**
+- Prevents unintended side effects from premature tool execution
+- Gives you and the user visibility into the full scope before any changes
+- Makes complex multi-file tasks reviewable and reversible
+- Catches scope creep early
+
+**To turn off plan mode**, type `/plan off` at the prompt.
+"""
+
+
 def _build_computer_use_section(cfg: GemCodeConfig) -> str:
   """Rich computer use guidance, only injected when enable_computer_use=True."""
   w = getattr(cfg, "_cfg", None)
@@ -491,7 +593,23 @@ For tasks where quality matters:
 - Prefer small, testable, accurate changes over broad rewrites.
 
 ## Workspace scope
-All file tools use paths **relative to the project root** (where GemCode was started). The root may be the home folder — subfolders like `Desktop`, `Desktop/code`, `Documents` are inside the sandbox. Call `list_directory("Desktop")` or `glob_files("**/*name*.ts")` instead of assuming access is blocked. Only treat access as denied when a tool returns an explicit `error`."""
+All file tools use paths **relative to the project root** (where GemCode was started). The root may be the home folder — subfolders like `Desktop`, `Desktop/code`, `Documents` are inside the sandbox. Call `list_directory("Desktop")` or `glob_files("**/*name*.ts")` instead of assuming access is blocked. Only treat access as denied when a tool returns an explicit `error`.
+
+## Agent notes (.gemcode/notes.md)
+You have two tools to persist project insights across sessions, like Claude Code's auto-memory:
+
+- **`append_project_note(note)`** — write a note to `.gemcode/notes.md`. Use this proactively when you discover something worth remembering:
+  - Build/test/lint commands you discover ("Build: `npm run build` — requires Node 20")
+  - Key file locations ("Auth middleware: `src/middleware/auth.ts`")
+  - Known issues or patterns ("DB migrations: always run `prisma db push` after schema changes")
+  - User workflow preferences ("User prefers running tests before committing")
+  - Architecture decisions or tricky patterns
+  
+  Call this **immediately** when you discover something useful — not just at the end of tasks.
+  Notes are loaded at session start so future sessions inherit this knowledge.
+
+- **`read_project_notes()`** — read current notes before starting a new project task.
+  If notes exist and you haven't read them yet, read them first to avoid re-discovering known information."""
 
   # Inject capability-specific strategy sections only when those caps are on.
   if getattr(cfg, "enable_computer_use", False):
@@ -500,6 +618,9 @@ All file tools use paths **relative to the project root** (where GemCode was sta
   if getattr(cfg, "enable_memory", False):
     base = f"{base}\n\n{_build_memory_section(cfg)}"
 
+  if getattr(cfg, "plan_mode", False):
+    base = f"{base}\n\n{_build_plan_mode_section()}"
+
   tool_manifest = build_tool_manifest(cfg)
   if tool_manifest:
     base = f"{base}\n\n{tool_manifest}"
@@ -551,6 +672,14 @@ def build_root_agent(
   except Exception:
     pass
 
+  # Agent auto-notes: write project insights to .gemcode/notes.md (Claude Code MEMORY.md equivalent)
+  try:
+    from gemcode.tools.notes import build_notes_tools
+    notes_tools = build_notes_tools(cfg.project_root)
+    tools = [*tools, *notes_tools]
+  except Exception:
+    pass
+
   if extra_tools:
     tools = [*tools, *extra_tools]
 

{gemcode-0.3.29 → gemcode-0.3.31}/src/gemcode/callbacks.py

@@ -141,6 +141,22 @@ def make_before_tool_callback(cfg: GemCodeConfig):
     record = {"tool": name, "args": _redact_args(name, args)}
     append_audit(cfg.project_root, record)
 
+    # ── Shell hooks: pre_tool_use ─────────────────────────────────────────
+    # If the project has a .gemcode/hooks/pre_tool_use.sh, run it now.
+    # Non-zero exit or {"decision":"deny"} stdout will block the tool call.
+    try:
+      from gemcode.hooks import run_pre_tool_use_hook
+      hook_result = run_pre_tool_use_hook(
+          cfg.project_root,
+          model=getattr(cfg, "model", "") or "",
+          tool_name=name,
+          args=args or {},
+      )
+      if hook_result is not None:
+        return hook_result
+    except Exception:
+      pass
+
     streak = 0
     if tool_context is not None:
       try:
@@ -316,6 +332,19 @@ def make_after_tool_callback(cfg: GemCodeConfig):
         st[_STATE_FAILURE_KEY] = 0
     else:
       st[_STATE_FAILURE_KEY] = 0
+    # ── Shell hooks: post_tool_use ────────────────────────────────────────
+    try:
+      from gemcode.hooks import run_post_tool_use_hook
+      run_post_tool_use_hook(
+          cfg.project_root,
+          model=getattr(cfg, "model", "") or "",
+          tool_name=name,
+          args=args or {},
+          result=tool_response if isinstance(tool_response, dict) else {},
+      )
+    except Exception:
+      pass
+
     if _maybe_tool_summary_enabled():
       summary: dict[str, Any] = {
         "phase": "tool_result",
@@ -399,6 +428,7 @@ def make_after_model_callback(cfg: GemCodeConfig):
           "candidates_token_count",
           "cached_content_token_count",
           "total_token_count",
+          "thoughts_token_count",
       ):
         if hasattr(um, attr):
           v = getattr(um, attr)
@@ -407,6 +437,44 @@ def make_after_model_callback(cfg: GemCodeConfig):
     if d:
       append_audit(cfg.project_root, {"phase": "model_usage", **d})
 
+    # ── Expose live token stats to the TUI ───────────────────────────────────
+    # The TUI reads cfg._last_turn_stats after each turn to display token counts
+    # and estimated cost in the footer (like OpenClaude's spinner token display).
+    try:
+      in_tok  = d.get("prompt_token_count", 0) or 0
+      out_tok = d.get("candidates_token_count", 0) or 0
+      think_tok = d.get("thoughts_token_count", 0) or 0
+      cache_tok = d.get("cached_content_token_count", 0) or 0
+      total_tok = d.get("total_token_count", 0) or 0
+
+      prev_session_tokens = int(st.get(SESSION_TOTAL_TOKENS_KEY, 0) or 0)
+      session_total = prev_session_tokens + total_tok
+
+      from gemcode.pricing import estimate_cost
+      turn_cost = estimate_cost(
+          getattr(cfg, "model", "") or "",
+          input_tokens=in_tok,
+          output_tokens=out_tok,
+      )
+      # Accumulate session cost
+      prev_cost = getattr(cfg, "_session_cost_usd", 0.0) or 0.0
+      session_cost = prev_cost + (turn_cost or 0.0)
+      object.__setattr__(cfg, "_session_cost_usd", session_cost)
+
+      stats: dict[str, Any] = {
+          "in": in_tok,
+          "out": out_tok,
+          "think": think_tok,
+          "cache": cache_tok,
+          "total": total_tok,
+          "session_total": session_total,
+          "turn_cost": turn_cost,
+          "session_cost": session_cost,
+      }
+      object.__setattr__(cfg, "_last_turn_stats", stats)
+    except Exception:
+      pass
+
     pt = d.get("prompt_token_count")
     if isinstance(pt, int) and pt >= 0:
       try:

{gemcode-0.3.29 → gemcode-0.3.31}/src/gemcode/cli.py

@@ -151,13 +151,8 @@ async def _run_prompt(
   _maybe_prompt_google_api_key()
   require_google_api_key()
   _initialize_gemcode_project(cfg)
-  extra: list = []
-  if use_mcp:
-    from gemcode.mcp_loader import load_mcp_toolsets
-
-    extra = load_mcp_toolsets(cfg)
-
-  runner = create_runner(cfg, extra_tools=extra or None)
+  # MCP and OpenAPI toolsets are now loaded inside create_runner() directly.
+  runner = create_runner(cfg, extra_tools=None)
   try:
     collected = await run_turn(
         runner,
@@ -184,13 +179,8 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
   require_google_api_key()
   _initialize_gemcode_project(cfg)
 
-  extra: list = []
-  if use_mcp:
-    from gemcode.mcp_loader import load_mcp_toolsets
-
-    extra = load_mcp_toolsets(cfg)
-
-  runner = create_runner(cfg, extra_tools=extra or None)
+  # MCP and OpenAPI toolsets are now loaded inside create_runner() directly.
+  runner = create_runner(cfg, extra_tools=None)
   try:
     # For CLI UX, show concise tool summaries (helps users see what ran).
     if os.environ.get("GEMCODE_EMIT_TOOL_USE_SUMMARIES") is None:

{gemcode-0.3.29 → gemcode-0.3.31}/src/gemcode/config.py

@@ -267,6 +267,21 @@ class GemCodeConfig:
     default_factory=lambda: _truthy_env("GEMCODE_ENABLE_ARTIFACTS", default=True)
   )
 
+  # Plan mode: when ON, the agent explicitly writes out a numbered plan
+  # BEFORE executing any tools, then checks the plan before reporting done.
+  # Like OpenClaude's EnterPlanMode — great for complex, multi-file tasks.
+  # Toggle at runtime with /plan on|off.
+  plan_mode: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_PLAN_MODE", default=False)
+  )
+
+  # Always-on web search (independent of deep_research / research mode).
+  # When True, google_search is available as a basic tool without enabling
+  # the full deep_research capability suite (url_context, maps, etc.).
+  enable_web_search: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_ENABLE_WEB_SEARCH", default=False)
+  )
+
   def __post_init__(self) -> None:
     self.project_root = self.project_root.resolve()
     # Default agentic depth when env omits GEMCODE_MAX_LLM_CALLS (was: None → SDK default).

gemcode-0.3.31/src/gemcode/hooks.py

@@ -0,0 +1,194 @@
+"""
+GemCode shell hooks — scriptable lifecycle events inspired by OpenClaude.
+
+Hooks are shell scripts stored under ``<project_root>/.gemcode/hooks/``.
+They receive a JSON payload on stdin and can:
+  - pre_tool_use.sh:  return non-zero exit to DENY the tool call, or
+                      print JSON {"decision":"deny","reason":"..."} to stderr.
+  - post_tool_use.sh: informational; return value ignored.
+  - session_start.sh: runs when a new GemCode session starts.
+  - session_stop.sh:  runs when the session ends.
+
+HOOK ENVIRONMENT
+  All hooks receive these env vars:
+    GEMCODE_HOOK_TYPE       — "pre_tool_use" | "post_tool_use" | "session_start" | "session_stop"
+    GEMCODE_PROJECT_ROOT    — absolute path to the project root
+    GEMCODE_MODEL           — active model id
+
+HOOK STDIN (pre_tool_use, post_tool_use)
+  JSON object with:
+    { "tool": "<tool_name>",
+      "args": { ...tool_args... },
+      "type": "pre_tool_use" | "post_tool_use",
+      "result": { ...tool_result... }   // post only
+    }
+
+PRE_TOOL_USE DECISION
+  If exit code is non-zero → the tool is DENIED.
+  If exit code is 0 → the tool proceeds normally.
+  If stdout starts with '{' and contains "decision": "deny" → the tool is denied.
+
+EXAMPLE HOOKS
+  # .gemcode/hooks/pre_tool_use.sh
+  #!/bin/bash
+  # Deny all delete_file calls
+  HOOK=$(cat)
+  TOOL=$(echo "$HOOK" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['tool'])")
+  if [ "$TOOL" = "delete_file" ]; then
+    echo "delete_file blocked by hook" >&2
+    exit 1
+  fi
+
+  # .gemcode/hooks/session_start.sh
+  #!/bin/bash
+  echo "[gemcode hook] session started in $GEMCODE_PROJECT_ROOT" >> /tmp/gemcode-audit.log
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+_HOOKS_DIR = ".gemcode/hooks"
+_TIMEOUT_PRE = 5.0   # seconds — pre_tool_use must respond quickly
+_TIMEOUT_POST = 10.0  # seconds — post_tool_use has more budget
+
+
+def _find_hook(project_root: Path, name: str) -> Path | None:
+    """Return the hook file path if it exists and is executable, else None."""
+    hooks_dir = project_root / _HOOKS_DIR
+    for ext in ("", ".sh", ".py", ".bash"):
+        candidate = hooks_dir / f"{name}{ext}"
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return candidate
+    return None
+
+
+def _run_hook(
+    hook_path: Path,
+    project_root: Path,
+    model: str,
+    hook_type: str,
+    stdin_data: dict | None = None,
+    timeout: float = 5.0,
+) -> tuple[int, str, str]:
+    """
+    Run a hook script.
+
+    Returns (exit_code, stdout, stderr).
+    Never raises — all exceptions are caught and logged.
+    """
+    try:
+        env = {
+            **os.environ,
+            "GEMCODE_HOOK_TYPE": hook_type,
+            "GEMCODE_PROJECT_ROOT": str(project_root),
+            "GEMCODE_MODEL": model or "",
+        }
+        stdin_bytes = (
+            json.dumps(stdin_data, ensure_ascii=False).encode() if stdin_data else b""
+        )
+        result = subprocess.run(
+            [str(hook_path)],
+            input=stdin_bytes,
+            capture_output=True,
+            timeout=timeout,
+            env=env,
+            cwd=str(project_root),
+        )
+        return result.returncode, result.stdout.decode(errors="replace"), result.stderr.decode(errors="replace")
+    except subprocess.TimeoutExpired:
+        log.warning("[hooks] %s timed out after %.1fs", hook_path.name, timeout)
+        return 1, "", f"hook timed out after {timeout}s"
+    except Exception as exc:
+        log.debug("[hooks] failed to run %s: %s", hook_path.name, exc)
+        return 1, "", str(exc)
+
+
+def run_pre_tool_use_hook(
+    project_root: Path,
+    model: str,
+    tool_name: str,
+    args: dict[str, Any],
+) -> dict | None:
+    """
+    Run the pre_tool_use hook (if it exists).
+
+    Returns:
+        None  → tool is allowed (default)
+        dict  → {"error": "...", "error_kind": "hook_denied"} to deny the tool
+    """
+    hook = _find_hook(project_root, "pre_tool_use")
+    if hook is None:
+        return None
+
+    payload = {"tool": tool_name, "args": args, "type": "pre_tool_use"}
+    rc, stdout, stderr = _run_hook(
+        hook, project_root, model, "pre_tool_use", payload, timeout=_TIMEOUT_PRE
+    )
+
+    if rc != 0:
+        reason = stderr.strip() or stdout.strip() or f"hook exited {rc}"
+        log.info("[hooks] pre_tool_use denied %s: %s", tool_name, reason[:200])
+        return {
+            "error": f"Tool denied by pre_tool_use hook: {reason[:400]}",
+            "error_kind": "hook_denied",
+        }
+
+    # Check if stdout contains an explicit deny decision.
+    if stdout.strip().startswith("{"):
+        try:
+            decision = json.loads(stdout.strip())
+            if str(decision.get("decision", "")).lower() == "deny":
+                reason = decision.get("reason", "hook denied")
+                log.info("[hooks] pre_tool_use JSON-denied %s: %s", tool_name, reason)
+                return {
+                    "error": f"Tool denied by hook: {reason}",
+                    "error_kind": "hook_denied",
+                }
+        except Exception:
+            pass
+
+    return None  # allowed
+
+
+def run_post_tool_use_hook(
+    project_root: Path,
+    model: str,
+    tool_name: str,
+    args: dict[str, Any],
+    result: dict[str, Any],
+) -> None:
+    """Run the post_tool_use hook if it exists. Return value is ignored."""
+    hook = _find_hook(project_root, "post_tool_use")
+    if hook is None:
+        return
+    payload = {
+        "tool": tool_name,
+        "args": args,
+        "result": result,
+        "type": "post_tool_use",
+    }
+    _run_hook(hook, project_root, model, "post_tool_use", payload, timeout=_TIMEOUT_POST)
+
+
+def run_session_start_hook(project_root: Path, model: str) -> None:
+    """Run the session_start hook if it exists."""
+    hook = _find_hook(project_root, "session_start")
+    if hook is None:
+        return
+    _run_hook(hook, project_root, model, "session_start", timeout=10.0)
+
+
+def run_session_stop_hook(project_root: Path, model: str) -> None:
+    """Run the session_stop hook if it exists."""
+    hook = _find_hook(project_root, "session_stop")
+    if hook is None:
+        return
+    _run_hook(hook, project_root, model, "session_stop", timeout=10.0)