gemcode 0.3.15__tar.gz → 0.3.16__tar.gz

{gemcode-0.3.15/src/gemcode.egg-info → gemcode-0.3.16}/PKG-INFO

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

{gemcode-0.3.15 → gemcode-0.3.16}/pyproject.toml

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

gemcode-0.3.16/src/gemcode/agent.py

@@ -0,0 +1,286 @@
+"""
+Root LlmAgent definition (Claude Code: agent config + tool list, analogous to tools.ts + prompts).
+
+See `session_runtime.py` for Runner/session wiring (outer layer).
+See `tool_registry.py` for tool categories (read vs mutating vs shell).
+"""
+
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+
+from google.adk.agents.llm_agent import LlmAgent
+
+from gemcode.autocompact import make_before_model_autocompact_callback
+from gemcode.callbacks import (
+  make_after_model_callback,
+  make_after_tool_callback,
+  make_before_tool_callback,
+  make_on_model_error_callback,
+  make_on_tool_error_callback,
+)
+from gemcode.compaction import make_before_model_callback
+from gemcode.config import GemCodeConfig
+from gemcode.context_budget import make_before_model_context_shrink_callback
+from gemcode.limits import make_before_model_limits_callback, make_before_model_token_budget_callback
+from gemcode.thinking import build_thinking_config
+from gemcode.tools import build_function_tools
+from gemcode.tool_prompt_manifest import build_tool_manifest
+
+
+def _chain_before_model_callbacks(*callbacks):
+  cbs = [c for c in callbacks if c is not None]
+  if not cbs:
+    return None
+  if len(cbs) == 1:
+    return cbs[0]
+
+  async def chained(callback_context, llm_request):
+    for cb in cbs:
+      out = cb(callback_context, llm_request)
+      if inspect.isawaitable(out):
+        out = await out
+      if out is not None:
+        return out
+    return None
+
+  return chained
+
+
+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 ""
+
+
+def _build_runtime_facts(cfg: GemCodeConfig) -> str:
+  """
+  Injected every session so the model does not hallucinate deployment, permissions,
+  or "how to switch Pro" the way a product-agnostic base prompt would.
+  """
+  root = cfg.project_root.resolve()
+  model = (getattr(cfg, "model", None) or "").strip() or "(default)"
+  return f"""## Runtime facts (authoritative for this session)
+- **Project root** — every filesystem tool path is relative to: `{root}`
+- **Model id in use:** `{model}`. In this TUI/REPL you can override it for subsequent turns with `/model use <id>` (use `/model list` to browse IDs). For a full restart you can still use `--model <id>` or env `GEMCODE_MODEL`.
+- **UI banner** phrases such as "GemCode Pro" are **terminal marketing**, not a separate API tier or model you enable from chat.
+- **Env toggles** (`GEMCODE_ENABLE_COMPUTER_USE`, `GEMCODE_MODEL`, etc.) affect only the **OS process** that launched `gemcode`. Pasting `VAR=1` in chat does **not** reconfigure a running session—tell the user to export in their shell, use project `.env`, or restart the CLI.
+- **Working in subfolders** — use tools: e.g. `list_directory("Desktop")`, `glob_files("**/query.ts")`, `read_file("testing/ai-edtech-app/src/app/page.tsx")`, or `run_command` with `cwd_subdir`. Never claim the sandbox cannot reach a subpath unless a tool returned an explicit error."""
+
+
+def build_instruction(cfg: GemCodeConfig) -> str:
+  base = f"""You are GemCode, an expert software engineering agent powered by Google Gemini.
+You run locally via the GemCode CLI. You are the same agent the user launched — not a hosted portal.
+
+{_build_runtime_facts(cfg)}
+
+## Core identity and approach
+You are a senior engineer who *acts*, not just advises. When given a task:
+1. **Orient** — understand the repo structure, find the relevant files.
+2. **Plan** — for complex tasks, call `todo_write` upfront to map out the work.
+3. **Execute** — make the changes, run the checks, iterate.
+4. **Verify** — confirm the result is correct before reporting done.
+
+Never stop mid-task just because the first tool call succeeded. Keep going until the full task is complete or you hit a genuine blocker.
+
+## Thinking through hard problems
+You have native deep thinking capability — use it actively:
+- **Before** starting a complex refactor or architectural change, think: what are the dependencies? what could break? what is the minimal safe change?
+- **When debugging**: trace the execution path mentally before acting. Form a hypothesis, then verify with tools.
+- **When stuck after 2 attempts**: stop and reconsider your assumptions rather than repeating the same approach.
+- **For trade-off decisions** (which library, which pattern, which approach): reason through the pros/cons given this specific codebase.
+
+## Interpreting requests
+- Treat every message as a software engineering task unless clearly otherwise.
+- If vague ("fix it", "the config", "rename that"), **infer from the repo**: search, read, then act. Do not give abstract advice when concrete files exist.
+- If the user refers to symbols or behaviors, **find them** with glob/grep/list — never ask them to paste paths you can discover yourself.
+- **Never propose edits to files you haven't read.** Read first, then edit.
+- When something fails, diagnose (re-read the error, check assumptions) before switching strategy. Do not repeat the same failed call.
+
+## Tool selection guide
+
+### Shell execution (critical — use these for real work)
+- **`bash`** — use for all shell workflows that need pipelines, redirects, or shell features:
+  - `bash("git log --oneline -20")` — git history
+  - `bash("git diff HEAD~1 -- src/api/")` — targeted diff
+  - `bash("git status && git diff --stat")` — repo state
+  - `bash("find . -name '*.py' | xargs grep -l 'SomeClass' | head -20")` — cross-file search
+  - `bash("npm run build 2>&1 | tail -50")` — build output (stderr + stdout combined)
+  - `bash("pytest tests/ -x -q --tb=short 2>&1 | head -150")` — test run
+  - `bash("cat package.json | python3 -m json.tool")` — parse JSON
+  - `bash("ls -la src/ | grep -E '\\.(ts|tsx)$'")` — filtered listing
+  - `bash("wc -l $(find . -name '*.py') | sort -n | tail -20")` — largest files
+  - For **dev servers**: `bash("npm run dev", background=True, cwd_subdir="frontend")`
+  - For **subfolders**: `bash("cargo build --release", cwd_subdir="backend")`
+
+- **`run_command`** — simple single-executable calls without shell features:
+  - `run_command("npm", args=["install", "--legacy-peer-deps"])` — clean npm install
+  - `run_command("python3", args=["-m", "pytest", "--version"])` — version check
+  - Use `extra_env_keys`/`extra_env_values` for non-interactive scaffolding tools.
+
+### File operations
+- **`read_file`** — read code/config. Use `start_line`/`end_line` for large files:
+  - `read_file("src/server.py", start_line=100, end_line=200)` — read a section
+  - `read_file("long_file.py", start_line=500)` — from line 500 to end
+  - Always read before editing.
+
+- **`grep_content`** — search with regex. Use `context_lines` to see surrounding code:
+  - `grep_content("def authenticate", "**/*.py", context_lines=4)` — function + context
+  - `grep_content("TODO|FIXME|HACK", "**/*.ts")` — multiple patterns (regex alternation)
+  - `grep_content("import React", "**/*.tsx", case_sensitive=False)` — case-insensitive
+  - `grep_content("class.*Error", "**/*.py", context_lines=2)` — error classes
+
+- **`glob_files`** — find files by name pattern:
+  - `glob_files("**/*.test.ts")`, `glob_files("**/config*.json")`, `glob_files("src/**/*.py")`
+
+- **`list_directory`** — explore directory structure:
+  - `list_directory(".")`, `list_directory("src/api")`, `list_directory("Desktop")`
+
+- **`write_file`** — create or overwrite files. Read first if the file exists.
+- **`search_replace`** — targeted in-place edits. Provide enough context in `old_string` to be unique.
+- **`move_file`** — rename or reorganize files/directories within the project.
+- **`delete_file`** — remove a single file.
+
+### Research and documentation
+- **`web_fetch`** — fetch docs, APIs, changelogs, READMEs from the web:
+  - `web_fetch("https://docs.python.org/3/library/asyncio.html")` — official docs
+  - `web_fetch("https://api.github.com/repos/owner/repo/releases/latest")` — API data
+  - `web_fetch("https://registry.npmjs.org/react/latest")` — npm package info
+  - Use when you need to look up an API, check the latest version, or read documentation.
+
+### Planning
+- **`todo_write`** — track work items. Use for any task with 3+ steps.
+  - Create at task start, mark completed as you finish, merge updates.
+
+## Multi-step task execution
+One user message = many model↔tool rounds (up to 256 LLM calls by default). This is intentional — you are expected to do complete tasks autonomously.
+
+**Standard workflow for complex tasks:**
+1. `todo_write` — plan the work items
+2. Explore — `bash("find . ...")` or `list_directory` or `glob_files` to understand structure
+3. Read — `read_file` with line ranges on large files; `grep_content` for symbol search
+4. Edit — `write_file` / `search_replace` for changes
+5. Verify — `bash("pytest ...")` or `bash("npm run build ...")` or `bash("git diff")`
+6. Fix — iterate on failures, re-verify
+7. Update todos — mark done as you go
+
+**Do not stop after step 2 or 3** — complete the full task.
+
+## Parallelism
+Issue independent tool calls in the same turn when outputs don't depend on each other:
+- Reading multiple files simultaneously ✓
+- Grepping for different patterns at once ✓
+- `list_directory` + `glob_files` in parallel ✓
+Sequential: when step B needs step A's result.
+
+## Error recovery
+- **Test/build failures**: read the full error, identify the exact line, fix, re-run.
+- **Tool errors**: diagnose why it failed before retrying — don't repeat the exact same call.
+- **After 2 failed attempts on the same problem**: stop and explain the blocker clearly.
+- **Unexpected file content**: re-read the actual file rather than assuming your mental model is correct.
+
+## Risk and permissions
+- State destructive operations clearly before doing them (deletes, force-push, data truncation).
+- For `bash` commands that could be destructive (`rm -rf`, `git push --force`), confirm with the user first.
+- If a tool is denied, adjust the plan — don't retry the same gated call.
+
+## Communication
+- One short line before the first tool call in a turn (e.g. "Reading the auth module and checking the test suite...").
+- Summarize tool results in plain language — the user doesn't see raw tool internals.
+- After completing a task: clear summary of what changed, where, and why.
+- If the user pastes UI copy / noise / error output, extract the real intent and act on source files.
+- 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`."""
+
+  tool_manifest = build_tool_manifest(cfg)
+
+  if tool_manifest:
+    base = f"{base}\n\n{tool_manifest}"
+  extra = _load_gemini_md(cfg.project_root)
+  if extra.strip():
+    return f"{base}\n\n## Project instructions (GEMINI.md)\n{extra}"
+  return base
+
+
+def build_root_agent(cfg: GemCodeConfig, extra_tools: list | None = None) -> LlmAgent:
+  """Create the root LlmAgent with tools and callbacks (no Runner)."""
+  tools = build_function_tools(cfg)
+  if getattr(cfg, "enable_memory", False):
+    # ADK preload_memory injects retrieved memories into the next llm_request.
+    from google.adk.tools import preload_memory
+
+    tools = [preload_memory, *tools]
+  if extra_tools:
+    tools = [*tools, *extra_tools]
+
+  before_model = _chain_before_model_callbacks(
+      make_before_model_autocompact_callback(cfg),
+      make_before_model_context_shrink_callback(cfg),
+      make_before_model_callback(cfg),
+      make_before_model_limits_callback(cfg),
+      make_before_model_token_budget_callback(cfg),
+  )
+  cb_kwargs: dict = {
+    "before_tool_callback": make_before_tool_callback(cfg),
+    "after_tool_callback": make_after_tool_callback(cfg),
+    "after_model_callback": make_after_model_callback(cfg),
+    "on_tool_error_callback": make_on_tool_error_callback(cfg),
+    "on_model_error_callback": make_on_model_error_callback(cfg),
+  }
+  if before_model is not None:
+    cb_kwargs["before_model_callback"] = before_model
+
+  # Claude-like thinking: enabled by default (Gemini dynamic), but allow
+  # explicit overrides for disable/budgets/levels.
+  gen_cfg = None
+  thinking_cfg = build_thinking_config(cfg)
+  tool_cfg = None
+  model_id = getattr(cfg, "model", "") or ""
+  is_gemini_3 = "gemini-3" in model_id.lower()
+  comb_mode = (getattr(cfg, "tool_combination_mode", None) or "deep_research").lower()
+  enable_for_run = False
+  if comb_mode in ("auto", "deep_research"):
+    enable_for_run = bool(getattr(cfg, "enable_deep_research", False))
+  elif comb_mode == "always":
+    enable_for_run = True
+  elif comb_mode == "never":
+    enable_for_run = False
+  else:
+    # Unknown values: stay conservative.
+    enable_for_run = bool(getattr(cfg, "enable_deep_research", False))
+
+  if enable_for_run and is_gemini_3:
+    from google.genai import types
+
+    # Gemini "tool context circulation" enables built-in tools results to
+    # be combined with your client-side function tools in the same workflow.
+    tool_cfg = types.ToolConfig(include_server_side_tool_invocations=True)
+
+  if thinking_cfg is not None or tool_cfg is not None:
+    from google.genai import types
+
+    gen_cfg = types.GenerateContentConfig(
+      thinking_config=thinking_cfg,
+      tool_config=tool_cfg,
+    )
+
+  return LlmAgent(
+      model=cfg.model,
+      name="gemcode",
+      instruction=build_instruction(cfg),
+      tools=tools,
+      generate_content_config=gen_cfg,
+      **cb_kwargs,
+  )
+
+
+def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None):
+  """Backward-compatible: prefer `gemcode.session_runtime.create_runner`."""
+  from gemcode.session_runtime import create_runner as _cr
+
+  return _cr(cfg, extra_tools=extra_tools)

{gemcode-0.3.15 → gemcode-0.3.16}/src/gemcode/config.py

@@ -259,18 +259,94 @@ class GemCodeConfig:
       else:
         self.allow_commands = frozenset(
           (
+            # Python
             "pytest",
             "python3",
             "python",
             "pip",
             "pip3",
-            "npm",
-            "npx",
-            "git",
             "ruff",
             "uv",
+            "mypy",
+            "black",
+            "isort",
+            "flake8",
+            "pylint",
+            # Node / JS
+            "npm",
+            "npx",
+            "node",
+            "pnpm",
+            "yarn",
+            "bun",
+            "bunx",
+            "tsc",
+            "eslint",
+            "prettier",
+            "vite",
+            "next",
+            "turbo",
+            # Systems
             "cargo",
             "go",
+            "rustc",
+            "make",
+            "cmake",
+            "gradle",
+            "mvn",
+            "java",
+            "javac",
+            "dotnet",
+            # Version control
+            "git",
+            "gh",
+            # Shell utilities (safe read/inspect)
+            "cat",
+            "ls",
+            "echo",
+            "find",
+            "head",
+            "tail",
+            "wc",
+            "sort",
+            "uniq",
+            "cut",
+            "awk",
+            "sed",
+            "grep",
+            "rg",
+            "ag",
+            # File management
+            "mkdir",
+            "cp",
+            "mv",
+            "touch",
+            "chmod",
+            "chown",
+            # Networking (read)
+            "curl",
+            "wget",
+            # Containers
+            "docker",
+            "docker-compose",
+            "kubectl",
+            # Database
+            "psql",
+            "mysql",
+            "sqlite3",
+            # Misc
+            "jq",
+            "yq",
+            "which",
+            "env",
+            "printenv",
+            "date",
+            "pwd",
+            "diff",
+            "patch",
+            "zip",
+            "unzip",
+            "tar",
           )
         )
 

{gemcode-0.3.15 → gemcode-0.3.16}/src/gemcode/tool_registry.py

@@ -18,6 +18,7 @@ READ_ONLY_TOOLS: frozenset[str] = frozenset(
     "list_directory",
     "glob_files",
     "grep_content",
+    "web_fetch",
   }
 )
 
@@ -27,11 +28,12 @@ MUTATING_TOOLS: frozenset[str] = frozenset(
     "write_file",
     "search_replace",
     "delete_file",
+    "move_file",
   }
 )
 
-# Subprocess (allowlist enforced inside tool)
-SHELL_TOOLS: frozenset[str] = frozenset({"run_command"})
+# Subprocess (allowlist or bash -c; require --yes / not strict)
+SHELL_TOOLS: frozenset[str] = frozenset({"run_command", "bash"})
 
 # Session planning only (no disk / shell; no extra permission)
 PLANNING_TOOLS: frozenset[str] = frozenset({"todo_write"})

{gemcode-0.3.15 → gemcode-0.3.16}/src/gemcode/tools/__init__.py

@@ -3,27 +3,34 @@
 from __future__ import annotations
 
 from gemcode.config import GemCodeConfig
+from gemcode.tools.bash import make_bash_tool
 from gemcode.tools.edit import make_edit_tools
 from gemcode.tools.filesystem import make_filesystem_tools
 from gemcode.tools.search import make_grep_tool
 from gemcode.tools.shell import make_run_command
 from gemcode.tools.todo import make_todo_tool
+from gemcode.tools.web import make_web_fetch_tool
 
 
 def build_function_tools(cfg: GemCodeConfig) -> list:
-  read_file, list_directory, glob_files, delete_file = make_filesystem_tools(cfg)
+  read_file, list_directory, glob_files, delete_file, move_file = make_filesystem_tools(cfg)
   grep_content = make_grep_tool(cfg)
   run_command = make_run_command(cfg)
+  bash = make_bash_tool(cfg)
   write_file, search_replace = make_edit_tools(cfg)
   todo_write = make_todo_tool(cfg)
+  web_fetch = make_web_fetch_tool()
   return [
     todo_write,
     read_file,
     list_directory,
     glob_files,
-    delete_file,
     grep_content,
+    bash,
     run_command,
     write_file,
     search_replace,
+    move_file,
+    delete_file,
+    web_fetch,
   ]

gemcode-0.3.16/src/gemcode/tools/bash.py

@@ -0,0 +1,127 @@
+"""
+Arbitrary shell execution via bash -c.
+
+Analogous to OpenClaude's BashTool — allows pipelines, redirects, multi-step
+shell workflows that run_command (basename-only) cannot express.
+
+Security model: same gating as run_command (SHELL_TOOLS category), requires
+--yes / interactive approval. Timeout-bounded; no TTY for child processes.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+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_bash_tool(cfg: GemCodeConfig):
+    root = cfg.project_root
+    trusted = is_trusted_root(root)
+
+    def bash(
+        command: str,
+        timeout_seconds: int = 120,
+        cwd_subdir: str = ".",
+        background: bool = False,
+    ) -> dict:
+        """
+        Run an arbitrary shell command via bash. Supports pipelines, redirects,
+        subshells, and multi-step workflows that run_command cannot express.
+
+        Use this for:
+        - Git operations: bash("git log --oneline -20")
+        - Pipelines: bash("cat package.json | python3 -m json.tool")
+        - Finding files: bash("find . -name '*.py' -newer setup.py | head -20")
+        - Complex builds: bash("cd frontend && npm ci && npm run build")
+        - Inspecting output: bash("ls -la | grep '.py'")
+        - Running tests with flags: bash("pytest -x -q --tb=short 2>&1 | head -100")
+
+        For long-running servers use background=True. cwd_subdir sets working
+        directory relative to the project root.
+
+        IMPORTANT: This runs real shell commands. Be precise and avoid destructive
+        operations (rm -rf, force-push, etc.) without explicit user approval.
+        """
+        if not trusted:
+            return {"error": "Project folder is not trusted. Re-run GemCode and approve folder trust."}
+
+        if not command or not command.strip():
+            return {"error": "command must not be empty"}
+
+        if timeout_seconds < 1:
+            timeout_seconds = 1
+        if timeout_seconds > 600:
+            timeout_seconds = 600
+
+        bash_exe = shutil.which("bash")
+        if not bash_exe:
+            return {"error": "bash not found on PATH"}
+
+        if not (cwd_subdir or "").strip():
+            cwd_subdir = "."
+        try:
+            exec_cwd = resolve_under_root(root, cwd_subdir)
+        except PathEscapeError as e:
+            return {"error": str(e)}
+        if not exec_cwd.is_dir():
+            return {
+                "error": (
+                    f"cwd_subdir={cwd_subdir!r} is not an existing directory under the project. "
+                    "Create it first or fix the path."
+                )
+            }
+
+        env = {**os.environ}
+
+        if background:
+            try:
+                proc = subprocess.Popen(
+                    [bash_exe, "-c", command],
+                    cwd=str(exec_cwd),
+                    env=env,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    start_new_session=True,
+                )
+            except OSError as e:
+                return {"error": f"Failed to start background process: {e}"}
+            return {
+                "command": command,
+                "cwd": str(exec_cwd.relative_to(root)) if exec_cwd != root else ".",
+                "background": True,
+                "pid": proc.pid,
+                "note": "Process started in the background. Stop it with kill from the OS when done.",
+            }
+
+        try:
+            proc = subprocess.run(
+                [bash_exe, "-c", command],
+                cwd=str(exec_cwd),
+                capture_output=True,
+                text=True,
+                timeout=timeout_seconds,
+                env=env,
+                check=False,
+            )
+            stdout = proc.stdout[:80_000]
+            stderr = proc.stderr[:20_000]
+            result: dict = {
+                "command": command,
+                "cwd": str(exec_cwd.relative_to(root)) if exec_cwd != root else ".",
+                "exit_code": proc.returncode,
+                "stdout": stdout,
+                "stderr": stderr,
+            }
+            if proc.returncode != 0 and not stdout and not stderr:
+                result["note"] = f"Command exited {proc.returncode} with no output."
+            return result
+        except subprocess.TimeoutExpired:
+            return {"error": f"Timeout after {timeout_seconds}s", "command": command}
+
+    return bash