gemcode 0.2.2__tar.gz → 0.3.0__tar.gz

{gemcode-0.2.2/src/gemcode.egg-info → gemcode-0.3.0}/PKG-INFO

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

{gemcode-0.2.2 → gemcode-0.3.0}/pyproject.toml

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

{gemcode-0.2.2 → gemcode-0.3.0}/src/gemcode/agent.py

@@ -12,6 +12,7 @@ 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,
@@ -21,6 +22,7 @@ from gemcode.callbacks import (
 )
 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
@@ -55,9 +57,36 @@ def _load_gemini_md(project_root: Path) -> str:
 
 
 def build_instruction(cfg: GemCodeConfig) -> str:
+  # Layered instructions mirror the *structure* of mature coding agents (scope,
+  # task interpretation, tool choice, parallelism, risk)—not proprietary text.
   base = """You are GemCode, an expert software engineering agent.
-You work only inside the user's project directory. Use tools to read and explore before editing.
-Prefer small, testable edits. Explain assumptions briefly."""
+You operate only inside the user's project directory (current working directory).
+
+## How to interpret requests
+- Treat every message as a **software engineering** task in this repo unless the user clearly wants something else. If the instruction is vague ("fix it", "rename that", "the config", "see codebase"), **infer intent from the repository**: search, read, then act—do not answer with abstract advice when concrete files exist.
+- If the user refers to symbols, filenames, or behaviors, **locate them in the tree** (glob/grep/list) instead of asking them to paste paths. Only ask a clarifying question when multiple plausible targets exist **and** choosing wrongly would be harmful.
+- **Do not propose edits to files you have not read** (or have not inspected via grep/list with enough context). Understand what is there before you change it.
+- When something fails, **diagnose** (read the error, re-check assumptions) before switching strategies; do not repeat the exact same failed tool call.
+
+## Using tools (decisive and efficient)
+- **Multi-step work:** call `todo_write` to track tasks (merge updates by id). Mark items completed as you finish—helps you stay organized like a senior engineer.
+- **Prefer dedicated tools over the shell** for this workspace: `read_file`, `list_directory`, `glob_files`, `grep_content`, `write_file`, `search_replace`, `delete_file`. Use `run_command` for builds, tests, package managers, git, and other true shell workflows.
+- **`run_command` rules (critical):**
+  - `command` must be a **single executable basename** (e.g. `npm`, `npx`, `mkdir`) — **not** `bash`, `sh`, or `cd foo && ...`.
+  - Pass argv as `args` (list). To run a command **inside** a subfolder (e.g. Next app in `testing/`), set **`cwd_subdir`** to that relative path (e.g. `"testing"`) and run `npm run dev` there — **never** simulate `cd` with `bash`.
+  - **Scaffolding** (`create-next-app`, etc.): many CLIs require non-interactive mode — pass **`extra_env`** like `{"CI": "1"}` and/or flags supported by that tool (`--yes` where documented).
+  - **Dev servers** (`npm run dev`, `vite`, etc.) run until stopped: use **`background=True`** so the process detaches; otherwise the tool may time out. You cannot open a *new OS terminal window* from here—background start is the supported way to keep running.
+- **Parallelize:** when you need several **independent** reads or searches (no output from one is required to form the next call), issue them together in one turn so the user gets answers faster. When step B depends on step A's result, run **sequentially**.
+- **Deletion:** use `delete_file` for a single file under the project root; reserve `rm` via `run_command` for unusual cases.
+- **Autonomy:** explore with `list_directory` ("."), `glob_files` (e.g. `**/*.md`, `**/*keyword*`), and `grep_content` before asking "which file?". Prefer widening your search over interrogating the user.
+
+## Risk and permissions
+- Destructive or irreversible actions (deletes, force pushes, anything that wipes data) deserve a clear, honest description; the runtime may require explicit user approval. If the session uses **inline** approval, wait for it—do not instruct the user to "re-run with --yes" unless that is actually required by the environment.
+- If a tool call is denied, **do not** immediately retry the identical call; adjust the plan or explain the blocker.
+
+## Communication
+- Before the first tool call in a turn, give a **short** line on what you are about to do. Assume the user does not see raw tool internals—summarize outcomes in plain language.
+- Prefer small, testable edits and accurate reporting over breadth."""
 
   tool_manifest = build_tool_manifest(cfg)
 
@@ -81,6 +110,8 @@ def build_root_agent(cfg: GemCodeConfig, extra_tools: list | None = None) -> Llm
     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),

gemcode-0.3.0/src/gemcode/autocompact.py

@@ -0,0 +1,210 @@
+"""
+Claude Code–style autocompact for ADK/Gemini.
+
+GemCode already has:
+- bounded tool output (after_tool truncation)
+- soft context shrink (before_model trimming/clearing)
+
+This module adds:
+- threshold-based autocompact: when context is near the ceiling, summarize older
+  conversation into a compact "memory" message and keep only the tail turns.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from google.genai import Client
+from google.genai import types
+
+from gemcode.config import GemCodeConfig
+from gemcode.context_budget import estimate_contents_text_chars
+
+_AC_STATE_KEY = "gemcode:autocompact"
+_AC_FAILURES_KEY = "gemcode:autocompact_failures"
+_AC_LAST_SUMMARY_KEY = "gemcode:autocompact_last_summary"
+
+
+def _truthy_env(name: str, *, default: bool = False) -> bool:
+  v = os.environ.get(name)
+  if v is None:
+    return default
+  return v.lower() in ("1", "true", "yes", "on")
+
+
+def _autocompact_enabled(cfg: GemCodeConfig) -> bool:
+  # Default on to match "it knows what to do and when".
+  if os.environ.get("GEMCODE_AUTOCOMPACT") is not None:
+    return _truthy_env("GEMCODE_AUTOCOMPACT", default=True)
+  return True
+
+
+def _autocompact_threshold_chars(cfg: GemCodeConfig) -> int:
+  # Claude Code uses token windows; we use a character proxy budget since
+  # Gemini tokenizers vary and ADK does not expose a cheap exact counter.
+  max_chars = int(getattr(cfg, "max_context_chars", 0) or 0)
+  if max_chars <= 0:
+    return 0
+  buffer_chars = int(os.environ.get("GEMCODE_AUTOCOMPACT_BUFFER_CHARS", "60000"))
+  return max(50_000, max_chars - max(10_000, buffer_chars))
+
+
+def _max_failures() -> int:
+  return int(os.environ.get("GEMCODE_AUTOCOMPACT_MAX_FAILURES", "3"))
+
+
+def _tail_keep_contents(cfg: GemCodeConfig) -> int:
+  return int(os.environ.get("GEMCODE_AUTOCOMPACT_KEEP_CONTENT_ITEMS", "18"))
+
+
+def _summary_model(cfg: GemCodeConfig) -> str:
+  return os.environ.get("GEMCODE_AUTOCOMPACT_MODEL", getattr(cfg, "model", ""))
+
+
+def _build_summary_prompt(contents: Any) -> str:
+  # Safe, bounded textualization for summarization. We do not try to serialize
+  # structured tool blocks fully; the pre-model context shrink already clears
+  # most large payloads under pressure.
+  lines: list[str] = []
+  for c in contents or []:
+    role = getattr(c, "role", "unknown")
+    parts = getattr(c, "parts", None) or []
+    texts: list[str] = []
+    for p in parts:
+      t = getattr(p, "text", None)
+      if isinstance(t, str) and t.strip():
+        texts.append(t.strip())
+    if not texts:
+      continue
+    joined = "\n".join(texts)
+    # Bound per content item to avoid PTL inside the compact call itself.
+    if len(joined) > 20_000:
+      joined = joined[:20_000] + "\n… [truncated for autocompact]"
+    lines.append(f"{role.upper()}:\n{joined}")
+  transcript = "\n\n".join(lines)
+  if len(transcript) > 180_000:
+    transcript = transcript[:180_000] + "\n… [older transcript truncated for autocompact]"
+
+  return (
+    "You are GemCode. Summarize the conversation so far into a compact, actionable memory.\n"
+    "Requirements:\n"
+    "- Preserve key decisions, constraints, and current plan.\n"
+    "- Preserve important file paths, commands, and errors.\n"
+    "- Keep it concise but information-dense.\n"
+    "- Do NOT include tool call JSON; paraphrase.\n\n"
+    "Conversation:\n"
+    f"{transcript}\n"
+  )
+
+
+def _summarize_via_genai(cfg: GemCodeConfig, prompt: str) -> str:
+  api_key = os.environ.get("GOOGLE_API_KEY")
+  if not api_key:
+    raise RuntimeError("GOOGLE_API_KEY not set (required for autocompact summary call)")
+  client = Client(api_key=api_key)
+  model = _summary_model(cfg) or getattr(cfg, "model", "")
+  resp = client.models.generate_content(
+    model=model,
+    contents=[types.Content(role="user", parts=[types.Part(text=prompt)])],
+    config=types.GenerateContentConfig(temperature=0.2),
+  )
+  out_parts: list[str] = []
+  try:
+    if resp.candidates:
+      c0 = resp.candidates[0]
+      content = getattr(c0, "content", None)
+      for p in getattr(content, "parts", None) or []:
+        t = getattr(p, "text", None)
+        if isinstance(t, str) and t:
+          out_parts.append(t)
+  except Exception:
+    pass
+  text = "".join(out_parts).strip()
+  if not text:
+    raise RuntimeError("autocompact summary call returned empty text")
+  # Hard bound
+  return text[:80_000]
+
+
+def make_before_model_autocompact_callback(cfg: GemCodeConfig):
+  if not _autocompact_enabled(cfg):
+    return None
+
+  async def before_model(callback_context, llm_request):
+    try:
+      contents = getattr(llm_request, "contents", None) or []
+    except Exception:
+      return None
+
+    threshold = _autocompact_threshold_chars(cfg)
+    if threshold <= 0:
+      return None
+
+    used = estimate_contents_text_chars(contents)
+    force = os.environ.get("GEMCODE_AUTOCOMPACT_FORCE", "").lower() in (
+      "1",
+      "true",
+      "yes",
+      "on",
+    )
+    if not force and used < threshold:
+      return None
+
+    st = getattr(callback_context, "state", None) or {}
+    failures = int(st.get(_AC_FAILURES_KEY, 0) or 0)
+    if failures >= _max_failures():
+      return None
+
+    # Build summary from the "older" prefix; keep tail untouched.
+    #
+    # Keep a reasonable tail by default, but allow compaction even in short
+    # conversations that become huge due to tool payloads.
+    requested_keep = max(4, _tail_keep_contents(cfg))
+    # Need at least 2 items in the summarize slice to be worth it:
+    # [first] + [summary] + [tail...]
+    max_keep_for_summarize = max(2, len(contents) - 2)
+    keep_n = min(requested_keep, max_keep_for_summarize)
+    keep_first = 1 if contents else 0
+    tail = contents[-keep_n:] if len(contents) > keep_n else list(contents)
+    prefix = []
+    if keep_first:
+      prefix = contents[:1]
+      summarize_slice = contents[1:-keep_n] if len(contents) > (1 + keep_n) else []
+    else:
+      summarize_slice = contents[:-keep_n] if len(contents) > keep_n else []
+
+    if not summarize_slice:
+      return None
+
+    try:
+      prompt = _build_summary_prompt(summarize_slice)
+      summary_text = _summarize_via_genai(cfg, prompt)
+    except Exception:
+      st[_AC_FAILURES_KEY] = failures + 1
+      return None
+
+    st[_AC_FAILURES_KEY] = 0
+    st[_AC_LAST_SUMMARY_KEY] = summary_text
+    st[_AC_STATE_KEY] = True
+
+    summary_msg = types.Content(
+      role="user",
+      parts=[
+        types.Part(
+          text=(
+            "Conversation summary (autocompacted):\n"
+            f"{summary_text}\n"
+          )
+        )
+      ],
+    )
+
+    llm_request.contents = [*prefix, summary_msg, *tail]
+    # One-shot force flag.
+    if force:
+      os.environ.pop("GEMCODE_AUTOCOMPACT_FORCE", None)
+    return None
+
+  return before_model
+

{gemcode-0.2.2 → gemcode-0.3.0}/src/gemcode/callbacks.py

@@ -11,15 +11,21 @@ from __future__ import annotations
 
 import os
 import sys
+from pathlib import Path
 from typing import Any
 
 from google.adk.tools.base_tool import BaseTool
 
 from gemcode.audit import append_audit
 from gemcode.config import GemCodeConfig
+from gemcode.context_budget import truncate_tool_result_dict
+from gemcode.context_warning import calculate_context_warning_state, worst_alert_level
 from gemcode.limits import SESSION_TOTAL_TOKENS_KEY
 from gemcode.query.token_budget import BudgetTracker, check_token_budget, create_budget_tracker
+from gemcode.hitl_session import HITL_STICKY_SESSION_KEY
+from gemcode.model_errors import format_model_error_for_user
 from gemcode.tool_registry import MUTATING_TOOLS, SHELL_TOOLS
+from gemcode.tools.shell_gate import arm_confirmed_shell_basename
 
 _STATE_FAILURE_KEY = "gemcode:consecutive_tool_failures"
 TERMINAL_REASON_KEY = "gemcode:terminal_reason"
@@ -33,6 +39,10 @@ _BT_CC = "gemcode:bt_cc"
 _BT_LD = "gemcode:bt_ld"
 _BT_LG = "gemcode:bt_lg"
 _BT_T0 = "gemcode:bt_t0"
+_CTX_WARN_LEVEL_NOTIFIED = "gemcode:ctx_warn_level_notified"
+_LAST_PROMPT_TOKENS = "gemcode:last_prompt_tokens"
+_LAST_CONTEXT_PCT = "gemcode:last_context_percent_left"
+_LAST_CONTEXT_LEVEL = "gemcode:last_context_alert_level"
 
 def _truthy_env(name: str, *, default: bool = False) -> bool:
   v = os.environ.get(name)
@@ -57,6 +67,12 @@ def _max_consecutive_failures() -> int:
   return int(os.environ.get("GEMCODE_MAX_CONSECUTIVE_TOOL_FAILURES", "8"))
 
 
+def _arm_shell_from_args(args: dict[str, Any]) -> None:
+  cmd = args.get("command")
+  if isinstance(cmd, str) and cmd.strip():
+    arm_confirmed_shell_basename(Path(cmd.strip()).name)
+
+
 def _is_computer_use_tool(tool: BaseTool) -> bool:
   """
   Detect ADK ComputerUseTool instances without enumerating every method name.
@@ -76,6 +92,25 @@ def _is_computer_use_tool(tool: BaseTool) -> bool:
 def make_before_tool_callback(cfg: GemCodeConfig):
   """Permission gate + circuit breaker (open after too many tool errors in a row)."""
 
+  def _hitl_sticky_enabled(tool_context) -> bool:
+    try:
+      return bool(
+          getattr(cfg, "interactive_hitl_sticky_session", False)
+          and tool_context is not None
+          and tool_context.state.get(HITL_STICKY_SESSION_KEY)
+      )
+    except Exception:
+      return False
+
+  def _hitl_mark_session_approved(tool_context) -> None:
+    if not getattr(cfg, "interactive_hitl_sticky_session", False):
+      return
+    try:
+      if tool_context is not None:
+        tool_context.state[HITL_STICKY_SESSION_KEY] = True
+    except Exception:
+      pass
+
   def _tool_confirmation_state(tool_context) -> bool | None:
     """
     Returns:
@@ -145,13 +180,17 @@ def make_before_tool_callback(cfg: GemCodeConfig):
         # In-run HITL: request ADK tool confirmation and pause execution until
         # the user approves in the current terminal session.
         if getattr(cfg, "interactive_permission_ask", False):
+          # After one approval this ADK session, optional skip (see GEMCODE_HITL_STICKY_SESSION).
+          if _hitl_sticky_enabled(tool_context):
+            return None
           tc_state = _tool_confirmation_state(tool_context)
           if tc_state is True:
+            _hitl_mark_session_approved(tool_context)
             return None
           if tc_state is False:
             return {
-              "error": "This tool call was rejected.",
-              "error_kind": _ERROR_KIND_PERMISSION_DENIED,
+                "error": "This tool call was rejected.",
+                "error_kind": _ERROR_KIND_PERMISSION_DENIED,
             }
           if tool_context is not None and hasattr(
               tool_context, "request_confirmation"
@@ -162,7 +201,7 @@ def make_before_tool_callback(cfg: GemCodeConfig):
               )
             else:
               tool_context.request_confirmation(
-                  hint="Approve to apply the requested file mutation (write_file/search_replace)."
+                  hint=f"Approve to apply the requested mutation ({name})."
               )
             return {
               "error": "This tool call requires confirmation.",
@@ -192,8 +231,12 @@ def make_before_tool_callback(cfg: GemCodeConfig):
         }
       if not cfg.yes_to_all:
         if getattr(cfg, "interactive_permission_ask", False):
+          if _hitl_sticky_enabled(tool_context):
+            return None
           tc_state = _tool_confirmation_state(tool_context)
           if tc_state is True:
+            _hitl_mark_session_approved(tool_context)
+            _arm_shell_from_args(args)
             return None
           if tc_state is False:
             return {
@@ -229,13 +272,21 @@ def make_after_tool_callback(cfg: GemCodeConfig):
     tool_context,
     tool_response: dict,
   ) -> dict | None:
+    truncated = False
+    if isinstance(tool_response, dict) and getattr(cfg, "tool_result_max_chars", 0) > 0:
+      new_d, did = truncate_tool_result_dict(
+          tool_response, int(cfg.tool_result_max_chars)
+      )
+      if did:
+        tool_response = new_d
+        truncated = True
     name = getattr(tool, "name", None) or ""
     if tool_context is None:
-      return None
+      return tool_response if truncated else None
     try:
       st = tool_context.state
     except Exception:
-      return None
+      return tool_response if truncated else None
     err = isinstance(tool_response, dict) and tool_response.get("error")
     err_kind = (
       isinstance(tool_response, dict) and tool_response.get("error_kind")
@@ -292,7 +343,7 @@ def make_after_tool_callback(cfg: GemCodeConfig):
       try:
         # Full-screen TUIs get corrupted by stray stderr prints.
         if _truthy_env("GEMCODE_TUI_ACTIVE", default=False):
-          return None
+          return tool_response if truncated else None
         ok = bool(summary.get("ok"))
         prefix = "[tool ok]" if ok else "[tool err]"
         details = ""
@@ -305,6 +356,8 @@ def make_after_tool_callback(cfg: GemCodeConfig):
         print(f"{prefix} {name}{details}", file=sys.stderr)
       except Exception:
         pass
+    if truncated:
+      return tool_response
     return None
 
   return after_tool
@@ -354,6 +407,54 @@ def make_after_model_callback(cfg: GemCodeConfig):
     if d:
       append_audit(cfg.project_root, {"phase": "model_usage", **d})
 
+    pt = d.get("prompt_token_count")
+    if isinstance(pt, int) and pt >= 0:
+      try:
+        model_id = getattr(cfg, "model", "") or ""
+        cw = calculate_context_warning_state(
+            prompt_token_count=pt, model=model_id, cfg=cfg
+        )
+        level = worst_alert_level(cw)
+        st[_LAST_PROMPT_TOKENS] = pt
+        st[_LAST_CONTEXT_PCT] = cw.get("percent_left")
+        st[_LAST_CONTEXT_LEVEL] = level
+        append_audit(
+            cfg.project_root,
+            {
+                "phase": "context_warning",
+                "prompt_token_count": pt,
+                "percent_left": cw.get("percent_left"),
+                "level": level,
+                "is_above_warning_threshold": cw.get("is_above_warning_threshold"),
+                "is_above_error_threshold": cw.get("is_above_error_threshold"),
+                "is_above_auto_compact_threshold": cw.get(
+                    "is_above_auto_compact_threshold"
+                ),
+                "is_at_blocking_limit": cw.get("is_at_blocking_limit"),
+            },
+        )
+        prev = int(st.get(_CTX_WARN_LEVEL_NOTIFIED, 0) or 0)
+        if level < prev:
+          st[_CTX_WARN_LEVEL_NOTIFIED] = level
+          prev = level
+        if (
+            level > prev
+            and not _truthy_env("GEMCODE_TUI_ACTIVE", default=False)
+            and os.environ.get("GEMCODE_CONTEXT_WARNINGS", "1").lower()
+            not in ("0", "false", "no", "off")
+        ):
+          labels = ("ok", "warning", "error", "blocking")
+          label = labels[min(level, 3)]
+          msg = (
+              f"[gemcode context] ~{cw.get('percent_left')}% context left "
+              f"(prompt_tokens≈{pt}; {label}). "
+              "Use /compact or start a new session if you hit limits."
+          )
+          print(msg, file=sys.stderr)
+          st[_CTX_WARN_LEVEL_NOTIFIED] = level
+      except Exception:
+        pass
+
     total_this = d.get("total_token_count")
     if isinstance(total_this, int) and total_this >= 0:
       prev_total = int(st.get(SESSION_TOTAL_TOKENS_KEY, 0) or 0)
@@ -447,11 +548,17 @@ def make_on_model_error_callback(cfg: GemCodeConfig):
     append_audit(
         cfg.project_root,
         {
-          "phase": "model_exception",
-          "error": f"{type(error).__name__}: {error}",
+            "phase": "model_exception",
+            "error": f"{type(error).__name__}: {error}",
         },
     )
-    # Best-effort fallback content; do not attempt full Claude recovery loop.
+    if _truthy_env("GEMCODE_VERBOSE_MODEL_ERRORS", default=False):
+      import traceback
+
+      traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)
+
+    user_text = format_model_error_for_user(error)
+    # Scrollback/TUI already prints "GemCode:" before assistant text — avoid "GemCode: GemCode:".
     from google.adk.models.llm_response import LlmResponse
     from google.genai import types
 
@@ -461,8 +568,8 @@ def make_on_model_error_callback(cfg: GemCodeConfig):
             parts=[
               types.Part(
                   text=(
-                      "GemCode: model call failed. "
-                      "Re-run the request or reduce prompt size."
+                      f"{user_text} "
+                      "You can re-run, shorten the message, or start a fresh session."
                   )
               )
             ],