gemcode 0.3.30__tar.gz → 0.3.31__tar.gz

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

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

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

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

{gemcode-0.3.30 → 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:
@@ -527,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):
@@ -590,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.30 → 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.31/src/gemcode/mcp_loader.py

@@ -0,0 +1,147 @@
+"""
+Optional MCP toolsets from `.gemcode/mcp.json`.
+
+Now supports all three ADK connection types — like Claude Code's MCP integration:
+
+Schema (example):
+{
+  "servers": [
+    {
+      "name": "filesystem",
+      "stdio": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"] }
+    },
+    {
+      "name": "github",
+      "http": {
+        "url": "https://api.githubcopilot.com/mcp/",
+        "headers": { "Authorization": "Bearer ${GITHUB_TOKEN}" }
+      }
+    },
+    {
+      "name": "notion",
+      "sse": { "url": "https://mcp.notion.com/sse" }
+    }
+  ]
+}
+
+Connection types:
+  stdio  — local subprocess (npx, python, etc.) — legacy, always worked
+  http   — Streamable HTTP (remote servers, Cloud Run, Smithery.ai)
+  sse    — Server-Sent Events (older remote servers; use http when possible)
+
+Header values support ${ENV_VAR} substitution from environment.
+
+Requires: pip install gemcode[mcp]
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from gemcode.config import GemCodeConfig
+
+_ENV_VAR_RE = re.compile(r"\$\{([A-Z_][A-Z0-9_]*)\}")
+
+
+def _expand_env(value: str) -> str:
+  """Expand ${VAR} placeholders from environment variables."""
+  return _ENV_VAR_RE.sub(lambda m: os.environ.get(m.group(1), m.group(0)), value)
+
+
+def _expand_headers(headers: dict) -> dict:
+  return {k: _expand_env(str(v)) for k, v in headers.items()}
+
+
+def load_mcp_toolsets(cfg: GemCodeConfig) -> list:
+  path = cfg.project_root / ".gemcode" / "mcp.json"
+  if not path.is_file():
+    return []
+  try:
+    data = json.loads(path.read_text(encoding="utf-8"))
+  except json.JSONDecodeError as e:
+    raise ValueError(f"Invalid mcp.json: {e}") from e
+
+  try:
+    from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
+    from mcp import StdioServerParameters
+  except ImportError as e:
+    raise ImportError("Install MCP extras: pip install gemcode[mcp]") from e
+
+  servers = data.get("servers") or []
+  toolsets: list[Any] = []
+
+  for s in servers:
+    prefix = s.get("name") or "mcp"
+    tool_filter: list[str] | None = s.get("tools") or None  # optional allowlist
+
+    # ── stdio (local subprocess) ─────────────────────────────────────────
+    if "stdio" in s:
+      stdio = s["stdio"]
+      cmd = stdio.get("command")
+      args = stdio.get("args") or []
+      env_extra = {k: _expand_env(str(v)) for k, v in (stdio.get("env") or {}).items()}
+      if not cmd:
+        continue
+      params = StdioServerParameters(
+          command=cmd,
+          args=args,
+          env={**os.environ, **env_extra} if env_extra else None,
+      )
+      kw: dict[str, Any] = dict(connection_params=params, tool_name_prefix=prefix)
+      if tool_filter:
+        kw["tool_filter"] = tool_filter
+      toolsets.append(McpToolset(**kw))
+      continue
+
+    # ── http (Streamable HTTP — modern, Cloud Run-friendly) ──────────────
+    if "http" in s:
+      http_cfg = s["http"]
+      url = _expand_env(http_cfg.get("url", ""))
+      if not url:
+        continue
+      headers = _expand_headers(http_cfg.get("headers") or {})
+      try:
+        from google.adk.tools.mcp_tool.mcp_session_manager import (
+            StreamableHTTPConnectionParams,
+        )
+        params_http = StreamableHTTPConnectionParams(url=url, headers=headers or None)
+        kw = dict(connection_params=params_http, tool_name_prefix=prefix)
+        if tool_filter:
+          kw["tool_filter"] = tool_filter
+        toolsets.append(McpToolset(**kw))
+      except ImportError:
+        # Fallback: try SseConnectionParams for older ADK builds
+        try:
+          from google.adk.tools.mcp_tool.mcp_session_manager import SseConnectionParams
+          params_sse_fb = SseConnectionParams(url=url, headers=headers or None)
+          kw = dict(connection_params=params_sse_fb, tool_name_prefix=prefix)
+          if tool_filter:
+            kw["tool_filter"] = tool_filter
+          toolsets.append(McpToolset(**kw))
+        except ImportError:
+          pass  # ADK version doesn't support remote MCP — skip silently
+      continue
+
+    # ── sse (Server-Sent Events — older remote servers) ──────────────────
+    if "sse" in s:
+      sse_cfg = s["sse"]
+      url = _expand_env(sse_cfg.get("url", ""))
+      if not url:
+        continue
+      headers = _expand_headers(sse_cfg.get("headers") or {})
+      try:
+        from google.adk.tools.mcp_tool.mcp_session_manager import SseConnectionParams
+        params_sse = SseConnectionParams(url=url, headers=headers or None)
+        kw = dict(connection_params=params_sse, tool_name_prefix=prefix)
+        if tool_filter:
+          kw["tool_filter"] = tool_filter
+        toolsets.append(McpToolset(**kw))
+      except ImportError:
+        pass  # ADK version too old — skip
+      continue
+
+  return toolsets

gemcode-0.3.31/src/gemcode/openapi_loader.py

@@ -0,0 +1,127 @@
+"""
+Auto-loads OpenAPI specs from `.gemcode/openapi/` as ADK OpenAPIToolset instances.
+
+Inspired by the ADK community pattern: drop an OpenAPI spec in a directory and
+the agent automatically gets REST API tools for it — no manual tool wiring needed.
+
+Supported formats: .yaml, .yml, .json
+
+Example:
+  .gemcode/openapi/
+  ├── github.yaml        → tools: mcp__github__list_repos, mcp__github__create_pr, …
+  ├── sentry.json        → tools: mcp__sentry__list_issues, …
+  └── internal_api.yaml  → tools from your company's internal REST API
+
+The filename (without extension) is used as the tool name prefix.
+So `github.yaml` → tools prefixed with `github_`.
+
+Auth:
+  Each spec file can have a matching `.auth` sidecar file with JSON:
+  {
+    "type": "api_key",        // "api_key" | "bearer" | "basic" | "oauth2"
+    "header": "X-API-Key",
+    "value": "${GITHUB_TOKEN}"  // ${ENV_VAR} is expanded from environment
+  }
+  For oauth2: {"type": "oauth2", "token_url": "...", "client_id": "...", "client_secret": "${VAR}"}
+
+Requires: pip install google-adk (OpenAPIToolset is included in the main package)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+_ENV_VAR_RE = re.compile(r"\$\{([A-Z_][A-Z0-9_]*)\}")
+_OPENAPI_DIR = ".gemcode/openapi"
+
+
+def _expand(value: str) -> str:
+  return _ENV_VAR_RE.sub(lambda m: os.environ.get(m.group(1), m.group(0)), value)
+
+
+def _load_auth(spec_path: Path):
+  """Try to load auth config from <spec_stem>.auth next to the spec file."""
+  auth_path = spec_path.with_suffix(".auth")
+  if not auth_path.is_file():
+    auth_path = spec_path.parent / (spec_path.stem + ".auth.json")
+  if not auth_path.is_file():
+    return None, None
+  try:
+    auth_data = json.loads(auth_path.read_text())
+  except Exception:
+    return None, None
+
+  auth_type = auth_data.get("type", "").lower()
+  try:
+    from google.adk.auth import AuthCredential, AuthCredentialTypes
+    if auth_type == "api_key":
+      return None, AuthCredential(
+          auth_type=AuthCredentialTypes.API_KEY,
+          api_key=_expand(auth_data.get("value", "")),
+      )
+    if auth_type in ("bearer", "token"):
+      return None, AuthCredential(
+          auth_type=AuthCredentialTypes.HTTP,
+          http={"scheme": "bearer", "token": _expand(auth_data.get("value", ""))},
+      )
+  except ImportError:
+    pass
+  return None, None
+
+
+def load_openapi_toolsets(project_root: Path) -> list[Any]:
+  """
+  Scan .gemcode/openapi/ for spec files and return OpenAPIToolset instances.
+
+  Returns an empty list if the directory doesn't exist or no valid specs are found.
+  Errors loading individual specs are logged but don't crash GemCode.
+  """
+  openapi_dir = project_root / _OPENAPI_DIR
+  if not openapi_dir.is_dir():
+    return []
+
+  try:
+    from google.adk.tools.openapi_tool.openapi_spec_parser.openapi_toolset import (
+        OpenAPIToolset,
+    )
+  except ImportError:
+    log.debug("[openapi] OpenAPIToolset not available in this ADK version — skipping")
+    return []
+
+  toolsets: list[Any] = []
+
+  for spec_file in sorted(openapi_dir.iterdir()):
+    if spec_file.suffix.lower() not in (".yaml", ".yml", ".json"):
+      continue
+    if spec_file.stem.endswith(".auth"):
+      continue
+
+    prefix = spec_file.stem  # e.g. "github" from "github.yaml"
+    fmt = "json" if spec_file.suffix.lower() == ".json" else "yaml"
+
+    try:
+      spec_str = spec_file.read_text(encoding="utf-8", errors="replace")
+    except OSError as e:
+      log.warning("[openapi] Could not read %s: %s", spec_file.name, e)
+      continue
+
+    _, auth_credential = _load_auth(spec_file)
+
+    try:
+      kwargs: dict[str, Any] = dict(spec_str=spec_str, spec_str_type=fmt)
+      if auth_credential is not None:
+        kwargs["auth_credential"] = auth_credential
+      toolset = OpenAPIToolset(**kwargs)
+      toolsets.append(toolset)
+      log.info("[openapi] Loaded spec '%s' from %s", prefix, spec_file.name)
+    except Exception as exc:
+      log.warning("[openapi] Failed to load %s: %s", spec_file.name, exc)
+
+  return toolsets

{gemcode-0.3.30 → gemcode-0.3.31}/src/gemcode/repl_commands.py

@@ -189,6 +189,14 @@ def slash_help_lines() -> list[str]:
       "  (CLI) gemcode -C DIR  Use a project folder as root (recommended vs. ~ )",
       "  (CLI) gemcode login   Save or change API key (~/.gemcode/credentials.json)",
       "",
+      "  Project setup:",
+      "  /init                 Analyze project structure and generate GEMINI.md",
+      "  /init force           Regenerate GEMINI.md even if it already exists",
+      "  /cost                 Show token usage and estimated cost for this session",
+      "  /notes                Show agent auto-notes (.gemcode/notes.md)",
+      "  /notes clear          Delete all notes",
+      "  /notes edit           Open notes in $EDITOR",
+      "",
       "  Session:",
       "  /help                 Show this help",
       "  /status               Full status: model, capabilities, thinking, limits",

{gemcode-0.3.30 → gemcode-0.3.31}/src/gemcode/repl_slash.py

@@ -154,6 +154,117 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /init ─────────────────────────────────────────────────────────────────
+  # ── /notes ────────────────────────────────────────────────────────────────
+  if name == "notes":
+    sub = (sc.args or "").strip().lower()
+    notes_path = cfg.project_root / ".gemcode" / "notes.md"
+    if sub == "clear":
+      if notes_path.exists():
+        notes_path.unlink()
+        out("Notes cleared.")
+      else:
+        out("No notes file found.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+    if sub == "edit":
+      import subprocess
+      editor = os.environ.get("EDITOR", "nano")
+      notes_path.parent.mkdir(parents=True, exist_ok=True)
+      if not notes_path.exists():
+        notes_path.write_text("# GemCode Agent Notes\n*Auto-generated project notes.*\n\n", encoding="utf-8")
+      subprocess.run([editor, str(notes_path)])
+      return ReplSlashResult(skip_model_turn=True)
+    # Default: show notes
+    if notes_path.exists():
+      content = notes_path.read_text(encoding="utf-8", errors="replace")
+      out(f"Agent notes ({notes_path}):")
+      out("─" * 60)
+      out(content)
+      out("─" * 60)
+      out("  /notes clear   Delete all notes")
+      out("  /notes edit    Open in $EDITOR")
+    else:
+      out(f"No agent notes yet ({notes_path}).")
+      out("The agent will auto-create notes as it discovers project insights.")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
+  # ── /cost ─────────────────────────────────────────────────────────────────
+  if name == "cost":
+    from gemcode.pricing import format_cost, format_tokens
+    stats = getattr(cfg, "_last_turn_stats", None)
+    out("Session cost summary")
+    out("─" * 40)
+    if stats:
+      out(f"  Last turn input tokens : {format_tokens(stats.get('in', 0) or 0)}")
+      out(f"  Last turn output tokens: {format_tokens(stats.get('out', 0) or 0)}")
+      think = stats.get("think", 0) or 0
+      if think:
+        out(f"  Last turn thinking     : {format_tokens(think)}")
+      cache = stats.get("cache", 0) or 0
+      if cache:
+        out(f"  Last turn cache read   : {format_tokens(cache)}")
+      lc = stats.get("turn_cost")
+      out(f"  Last turn cost         : {format_cost(lc) if lc is not None else '(unknown model pricing)'}")
+      out()
+      out(f"  Session total tokens   : {format_tokens(stats.get('session_total', 0) or 0)}")
+      sc = stats.get("session_cost")
+      if sc and sc > 0:
+        out(f"  Session total cost     : {format_cost(sc)}")
+      else:
+        out("  Session total cost     : (accumulating — will show after first turn)")
+    else:
+      out("  No turn completed yet. Send a message to see token/cost stats.")
+    out()
+    out(f"  Model: {getattr(cfg, 'model', 'unknown')}")
+    out()
+    out("  Note: costs are estimates based on published Gemini pricing.")
+    out("  Thinking tokens billed at same rate as output tokens.")
+    return ReplSlashResult(skip_model_turn=True)
+
+  if name == "init":
+    gemini_md = cfg.project_root / "GEMINI.md"
+    if gemini_md.exists() and (sc.args or "").strip().lower() not in ("force", "overwrite", "-f"):
+      out(f"GEMINI.md already exists at {gemini_md}.")
+      out("Use /init force to regenerate it, or edit it manually.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+    # Dispatch to the model to analyze the project and write GEMINI.md.
+    init_prompt = (
+      "Analyze this codebase and generate a GEMINI.md file for me.\n\n"
+      "To do this:\n"
+      "1. Run `list_directory('.')` to understand the project structure\n"
+      "2. Read `package.json`, `pyproject.toml`, `go.mod`, `Cargo.toml`, `README.md` "
+      "or equivalent to understand the project type and dependencies\n"
+      "3. Look at the source directory structure (src/, lib/, app/, etc.)\n"
+      "4. Check for test directories and test runner config\n"
+      "5. Look for linting/formatting config files (.eslintrc, .prettierrc, ruff.toml, etc.)\n\n"
+      "Then write a GEMINI.md file at the project root containing:\n"
+      "# Project Name\n"
+      "One-sentence description.\n\n"
+      "## Build & Test\n"
+      "- How to install dependencies\n"
+      "- How to build\n"
+      "- How to run tests\n"
+      "- How to lint/format\n\n"
+      "## Architecture\n"
+      "- Key directories and what they contain\n"
+      "- Important entry points\n"
+      "- Key abstractions or patterns used\n\n"
+      "## Coding standards\n"
+      "- Language/framework conventions\n"
+      "- Any style requirements found in config files\n\n"
+      "## Workflow\n"
+      "- Any git branching rules from README or CONTRIBUTING\n"
+      "- PR/commit conventions\n\n"
+      "Keep it under 200 lines. Write the file to GEMINI.md now."
+    )
+    out("Analyzing project to generate GEMINI.md…")
+    out("(GemCode will read the project structure and write a starting GEMINI.md)")
+    out()
+    return ReplSlashResult(model_prompt=init_prompt)
+
   if name == "hooks":
     out("\n".join(format_hooks_lines(cfg)))
     out()

{gemcode-0.3.30 → gemcode-0.3.31}/src/gemcode/session_runtime.py

@@ -56,6 +56,27 @@ def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner
   else:
     merged_extra_tools = modality_tools or None
 
+  # ── MCP toolsets from .gemcode/mcp.json ─────────────────────────────────
+  # Supports stdio, http (Streamable HTTP), and sse connection types.
+  try:
+    from gemcode.mcp_loader import load_mcp_toolsets
+    mcp_tools = load_mcp_toolsets(cfg)
+    if mcp_tools:
+      merged_extra_tools = list(merged_extra_tools or []) + mcp_tools
+  except Exception:
+    pass  # MCP not installed or mcp.json invalid — continue without
+
+  # ── OpenAPI toolsets from .gemcode/openapi/ ──────────────────────────────
+  # Drop any *.yaml / *.json OpenAPI spec in .gemcode/openapi/ to auto-generate
+  # REST API tools for that service (GitHub, Sentry, internal APIs, etc.)
+  try:
+    from gemcode.openapi_loader import load_openapi_toolsets
+    oa_tools = load_openapi_toolsets(cfg.project_root)
+    if oa_tools:
+      merged_extra_tools = list(merged_extra_tools or []) + oa_tools
+  except Exception:
+    pass  # OpenAPIToolset not in this ADK version — continue without
+
   # Computer-use: ADK ComputerUseToolset backed by our Playwright BrowserComputer.
   # Also inject standalone browser inspection tools (screenshot, get_text, etc.)
   # so the agent can read page state without performing side-effecting actions.

gemcode-0.3.31/src/gemcode/tools/notes.py

@@ -0,0 +1,106 @@
+"""
+Agent auto-notes tool — inspired by Claude Code's MEMORY.md auto-writing.
+
+Claude Code lets Claude write its own notes to ~/.claude/projects/<proj>/MEMORY.md.
+GemCode provides an equivalent: the agent can write structured notes to
+.gemcode/notes.md which are loaded back at the start of each session
+(via the GEMINI.md hierarchy in agent.py).
+
+This is different from the persistent memory system (memories.jsonl):
+  - memories.jsonl: semantic search-backed cross-session knowledge (requires /memory on)
+  - notes.md: a free-form markdown notes file the agent curates manually
+    — always loaded, zero-config, like a sticky notepad for project insights
+
+The tool exposes two operations:
+  - append_project_note(note): add a bullet point or section to notes.md
+  - read_project_notes(): read current notes.md content
+
+Usage by agent:
+  When the agent discovers something worth remembering (build command, a tricky
+  pattern, architecture insight, gotcha), it should call append_project_note to
+  persist it for future sessions. The agent instruction tells it when to do this.
+"""
+
+from __future__ import annotations
+
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+def _notes_path(project_root_str: str | None = None) -> Path:
+  root = Path(project_root_str) if project_root_str else Path.cwd()
+  return root / ".gemcode" / "notes.md"
+
+
+def build_notes_tools(project_root: Path) -> list:
+  """Return [append_project_note, read_project_notes] bound to this project."""
+
+  notes_file = project_root / ".gemcode" / "notes.md"
+
+  def append_project_note(note: str) -> dict[str, Any]:
+    """
+    Append a note to the project notes file (.gemcode/notes.md).
+
+    Use this to record important insights, patterns, commands, or gotchas that
+    will be useful in future sessions — like a persistent sticky notepad.
+
+    Best for:
+    - Build/test commands you discovered
+    - Architecture patterns or important abstractions
+    - Known issues or tricky edge cases
+    - User preferences or workflow conventions
+    - Important file locations or entry points
+
+    Not for:
+    - Every single thing the user says (be selective — only durable insights)
+    - Sensitive data or credentials
+
+    Args:
+        note: The note to append. Use markdown. Start with a heading or bullet.
+              Example: "- **Build**: `npm run build` (requires Node 20+)"
+              Example: "## Architecture\\nAuth is handled by src/auth/middleware.ts"
+    """
+    if not note or not note.strip():
+      return {"error": "note cannot be empty"}
+    try:
+      notes_file.parent.mkdir(parents=True, exist_ok=True)
+      timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+      # If file doesn't exist, create with header
+      if not notes_file.exists():
+        header = f"# GemCode Agent Notes\n*Auto-generated project notes. Edit freely.*\n\n"
+        notes_file.write_text(header, encoding="utf-8")
+      current = notes_file.read_text(encoding="utf-8", errors="replace")
+      # Avoid duplicating identical notes
+      stripped = note.strip()
+      if stripped in current:
+        return {"status": "already_exists", "note": stripped}
+      entry = f"\n<!-- {timestamp} -->\n{stripped}\n"
+      notes_file.write_text(current + entry, encoding="utf-8")
+      return {"status": "appended", "notes_path": str(notes_file)}
+    except OSError as e:
+      return {"error": f"Could not write notes: {e}"}
+
+  def read_project_notes() -> dict[str, Any]:
+    """
+    Read the current contents of .gemcode/notes.md.
+
+    Use this to check what has been previously noted about this project before
+    starting a task — avoids re-discovering things already documented.
+
+    Returns the full notes content as a string, or an empty string if no notes exist.
+    """
+    if not notes_file.exists():
+      return {"content": "", "exists": False, "path": str(notes_file)}
+    try:
+      content = notes_file.read_text(encoding="utf-8", errors="replace")
+      return {"content": content, "exists": True, "path": str(notes_file), "chars": len(content)}
+    except OSError as e:
+      return {"error": f"Could not read notes: {e}"}
+
+  # Bind the project root to the function names so they show correctly in tool manifests
+  append_project_note.__name__ = "append_project_note"
+  read_project_notes.__name__ = "read_project_notes"
+
+  return [append_project_note, read_project_notes]

{gemcode-0.3.30 → gemcode-0.3.31}/src/gemcode/tui/input_handler.py

@@ -41,6 +41,9 @@ except ImportError:
 # ---------------------------------------------------------------------------
 SLASH_COMMANDS: list[tuple[str, str]] = [
     ("help",        "List all available commands"),
+    ("init",        "Analyze project and generate GEMINI.md project instructions"),
+    ("cost",        "Show session token usage and estimated USD cost breakdown"),
+    ("notes",       "View agent auto-generated project notes (.gemcode/notes.md)"),
     ("clear",       "Start a fresh session (clears history)  ·  alias: /session new"),
     ("model",       "View or switch model  ·  /model use <id>  ·  /model list"),
     ("mode",        "Set model mode  ·  /mode fast|balanced|quality|auto"),

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

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

{gemcode-0.3.30 → gemcode-0.3.31}/src/gemcode.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/gemcode/mcp_loader.py
 src/gemcode/modality_tools.py
 src/gemcode/model_errors.py
 src/gemcode/model_routing.py
+src/gemcode/openapi_loader.py
 src/gemcode/paths.py
 src/gemcode/permissions.py
 src/gemcode/pricing.py
@@ -70,6 +71,7 @@ src/gemcode/tools/bash.py
 src/gemcode/tools/browser.py
 src/gemcode/tools/edit.py
 src/gemcode/tools/filesystem.py
+src/gemcode/tools/notes.py
 src/gemcode/tools/search.py
 src/gemcode/tools/shell.py
 src/gemcode/tools/shell_gate.py

gemcode-0.3.30/src/gemcode/mcp_loader.py

@@ -1,57 +0,0 @@
-"""
-Optional MCP toolsets from `.gemcode/mcp.json`.
-
-Schema (example):
-{
-  "servers": [
-    {
-      "name": "docs",
-      "stdio": { "command": "npx", "args": ["-y", "@some/mcp-server"] }
-    }
-  ]
-}
-
-Requires: pip install gemcode[mcp]
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-from gemcode.config import GemCodeConfig
-
-
-def load_mcp_toolsets(cfg: GemCodeConfig) -> list:
-  path = cfg.project_root / ".gemcode" / "mcp.json"
-  if not path.is_file():
-    return []
-  try:
-    data = json.loads(path.read_text(encoding="utf-8"))
-  except json.JSONDecodeError as e:
-    raise ValueError(f"Invalid mcp.json: {e}") from e
-
-  try:
-    from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
-    from mcp import StdioServerParameters
-  except ImportError as e:
-    raise ImportError("Install MCP extras: pip install gemcode[mcp]") from e
-
-  servers = data.get("servers") or []
-  toolsets: list[Any] = []
-  for s in servers:
-    stdio = s.get("stdio") or {}
-    cmd = stdio.get("command")
-    args = stdio.get("args") or []
-    if not cmd:
-      continue
-    params = StdioServerParameters(command=cmd, args=args)
-    prefix = s.get("name") or "mcp"
-    toolsets.append(
-      McpToolset(
-        connection_params=params,
-        tool_name_prefix=prefix,
-      )
-    )
-  return toolsets