gemcode 0.3.18__tar.gz → 0.3.20__tar.gz

{gemcode-0.3.18/src/gemcode.egg-info → gemcode-0.3.20}/PKG-INFO

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

{gemcode-0.3.18 → gemcode-0.3.20}/pyproject.toml

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

{gemcode-0.3.18 → gemcode-0.3.20}/src/gemcode/agent.py

@@ -79,13 +79,26 @@ You run locally via the GemCode CLI. You are the same agent the user launched
 
 ## 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.
+1. **Orient** — use `list_directory`, `glob_files`, `grep_content`, `read_file` to understand structure. These tools need **no permission** and are instant. Start here.
 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.
 
+## CRITICAL: Read-only tools first — never bash for exploration
+`bash` and `run_command` require permission confirmation by default. Always start with the **zero-permission** read-only tools:
+
+| Instead of… | Use… |
+|---|---|
+| `bash("ls -la src/")` | `list_directory("src")` |
+| `bash("find . -name '*.py'")` | `glob_files("**/*.py")` |
+| `bash("cat file.py")` | `read_file("file.py")` |
+| `bash("grep -r pattern .")` | `grep_content("pattern", "**/*")` |
+| `bash("find . -type f \| head -50")` | `list_directory(".")` + `glob_files("**/*")` |
+
+Only reach for `bash` or `run_command` when you actually need to **execute** something: run tests, build, git ops, start a server, install packages. **NEVER** use bash to list or read files.
+
 ## 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?
@@ -94,11 +107,12 @@ You have native deep thinking capability — use it actively:
 - **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.
+- Treat every message as a software engineering task — start working immediately. Do NOT respond with just a greeting or introduction.
 - 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.
+- If the user refers to symbols or behaviors, **find them** with `glob_files`/`grep_content`/`list_directory` — 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.
+- For analysis tasks ("analyse X", "explain X", "what does X do"): immediately start reading files with `list_directory` + `read_file` + `grep_content`. Produce concrete findings, not hypotheses.
 
 ## Tool selection guide
 
@@ -174,12 +188,11 @@ One user message = many model↔tool rounds (up to 256 LLM calls by default). Th
 
 **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
+2. **Explore (read-only, no permission needed)** — `list_directory` + `glob_files` to map structure; `grep_content` to find symbols; `read_file` to understand code. Do NOT use `bash` for this step.
+3. **Edit** — `write_file` / `search_replace` for changes
+4. **Verify (shell needed)** — `bash("pytest ...")` or `bash("npm run build ...")` or `bash("git diff")`
+5. Fix — iterate on failures, re-verify
+6. Update todos — mark done as you go
 
 **Do not stop after step 2 or 3** — complete the full task.
 

{gemcode-0.3.18 → gemcode-0.3.20}/src/gemcode/repl_commands.py

@@ -176,6 +176,11 @@ def slash_help_lines() -> list[str]:
       "  /model                Show model routing info",
       "  /model use <id>       Override model for this REPL session",
       "  /model list            List available Gemini model IDs",
+      "  /thinking             Show current thinking config",
+      "  /thinking off         Disable model thinking",
+      "  /thinking on          Re-enable thinking (auto budget/level)",
+      "  /thinking budget <N>  Set thinking token budget (Gemini 2.5, 0=off, -1=dynamic)",
+      "  /thinking level <L>   Set thinking level: minimal|low|medium|high (Gemini 3.x)",
       "  /permissions          Show permission / HITL settings",
       "  /memory               Show persistent memory settings",
       "  /hooks                Show post-turn hook configuration",

{gemcode-0.3.18 → gemcode-0.3.20}/src/gemcode/repl_slash.py

@@ -39,6 +39,7 @@ class ReplSlashResult:
   new_session_id: str | None = None
   skip_model_turn: bool = False
   model_prompt: str | None = None
+  force_rebuild_runner: bool = False  # True when agent config changed (thinking, etc.)
 
 
 def _parse_tail_n(args: str, *, default: int = 40) -> int:
@@ -270,6 +271,95 @@ async def process_repl_slash(
   if name in ("exit", "quit"):
     return ReplSlashResult(exit_repl=True)
 
+  if name == "thinking":
+    model_id = getattr(cfg, "model", "") or ""
+    is_25 = "2.5" in model_id
+    args = (sc.args or "").strip()
+
+    if not args:
+      # Show current thinking config.
+      disable = bool(getattr(cfg, "disable_thinking", False))
+      level   = getattr(cfg, "thinking_level", None)
+      budget  = getattr(cfg, "thinking_budget", None)
+      out("Thinking config:")
+      out(f"  model:            {model_id or '(default)'}")
+      out(f"  disable_thinking: {disable}")
+      if is_25:
+        out(f"  thinking_budget:  {budget if budget is not None else '(auto / dynamic)'}")
+        out()
+        out("Gemini 2.5 commands:")
+        out("  /thinking off              — disable thinking")
+        out("  /thinking on               — re-enable with auto budget")
+        out("  /thinking budget <0-24576> — set exact token budget (0 = off)")
+      else:
+        out(f"  thinking_level:   {level if level is not None else '(auto)'}")
+        out()
+        out("Gemini 3.x commands:")
+        out("  /thinking off                         — use minimal thinking")
+        out("  /thinking on                          — re-enable auto level")
+        out("  /thinking level <minimal|low|medium|high>")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    parts = args.split()
+    sub = parts[0].lower()
+
+    if sub == "off":
+      setattr(cfg, "disable_thinking", True)
+      out("thinking: disabled (runner will rebuild on next turn)")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    if sub in ("on", "auto"):
+      setattr(cfg, "disable_thinking", False)
+      setattr(cfg, "thinking_level", None)
+      setattr(cfg, "thinking_budget", None)
+      out("thinking: auto (runner will rebuild on next turn)")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    if sub == "budget":
+      if len(parts) < 2:
+        out("Usage: /thinking budget <N>  e.g. /thinking budget 8192")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      try:
+        budget = int(parts[1])
+      except ValueError:
+        out(f"Invalid budget '{parts[1]}' — must be an integer (0–24576, or -1 for dynamic)")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      setattr(cfg, "thinking_budget", budget)
+      setattr(cfg, "disable_thinking", False)
+      out(f"thinking: budget={budget} tokens (runner will rebuild on next turn)")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    if sub == "level":
+      if len(parts) < 2:
+        out("Usage: /thinking level <minimal|low|medium|high>")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      level = parts[1].lower()
+      valid = ("minimal", "low", "medium", "high")
+      if level not in valid:
+        out(f"Unknown level '{level}'. Choose from: {', '.join(valid)}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      setattr(cfg, "thinking_level", level)
+      setattr(cfg, "disable_thinking", False)
+      out(f"thinking: level={level} (runner will rebuild on next turn)")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    out(f"Unknown /thinking subcommand: {sub}")
+    if is_25:
+      out("Usage: /thinking [off | on | budget <N>]")
+    else:
+      out("Usage: /thinking [off | on | level <minimal|low|medium|high>]")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   out(f"Unknown command: /{sc.command_name}")
   out("Try /help")
   out()

{gemcode-0.3.18 → gemcode-0.3.20}/src/gemcode/thinking.py

@@ -25,6 +25,13 @@ def _is_gemini_3_pro(model_id: str) -> bool:
   return "3.1-pro" in (model_id or "") or "3-pro" in (model_id or "")
 
 
+def _supports_thinking(model_id: str) -> bool:
+  """True for Gemini 2.5+ and Gemini 3.x which return thought tokens."""
+  m = model_id or ""
+  return "2.5" in m or "2.0-flash-thinking" in m or "gemini-3" in m or \
+         "-3." in m or "-3-" in m
+
+
 def build_thinking_config(cfg: GemCodeConfig) -> Optional[types.ThinkingConfig]:
   """
   Returns a `types.ThinkingConfig` to pass to ADK's LlmAgent.generate_content_config.
@@ -96,7 +103,11 @@ def build_thinking_config(cfg: GemCodeConfig) -> Optional[types.ThinkingConfig]:
   # Otherwise: Claude-like auto mapping based on model_mode.
   mode = (getattr(cfg, "model_mode", "auto") or "auto").lower()
   if mode == "auto":
-    # Let Gemini choose its dynamic/adaptive thinking.
+    # Use Gemini's adaptive thinking budget but request thought tokens in the
+    # response so the TUI can display them.  Models that don't support thinking
+    # ignore include_thoughts gracefully; for others we fall back to None.
+    if _supports_thinking(model_id):
+      return types.ThinkingConfig(include_thoughts=True)
     return None
 
   if not is_25:
@@ -104,33 +115,32 @@ def build_thinking_config(cfg: GemCodeConfig) -> Optional[types.ThinkingConfig]:
     if mode == "fast":
       return types.ThinkingConfig(
         thinking_level="low" if _is_gemini_3_pro(model_id) else "minimal",
-        include_thoughts=None,
+        include_thoughts=True,
       )
     if mode == "balanced":
       return types.ThinkingConfig(
         thinking_level="medium",
-        include_thoughts=None,
+        include_thoughts=True,
       )
     # quality
     return types.ThinkingConfig(
       thinking_level="high",
-      include_thoughts=None,
+      include_thoughts=True,
     )
 
   # Gemini 2.5 thinkingBudget mapping.
   if mode == "fast":
     if "2.5-pro" in model_id:
-      return types.ThinkingConfig(thinking_budget=512, include_thoughts=None)
+      return types.ThinkingConfig(thinking_budget=512, include_thoughts=True)
     # flash/flash-preview/flash-lite
     return types.ThinkingConfig(
-      thinking_budget=0 if "flash-lite" in model_id else 0, include_thoughts=None
+      thinking_budget=0 if "flash-lite" in model_id else 1024, include_thoughts=True
     )
   if mode == "balanced":
     if "2.5-pro" in model_id:
-      return types.ThinkingConfig(thinking_budget=4096, include_thoughts=None)
-    return types.ThinkingConfig(thinking_budget=1024, include_thoughts=None)
+      return types.ThinkingConfig(thinking_budget=4096, include_thoughts=True)
+    return types.ThinkingConfig(thinking_budget=2048, include_thoughts=True)
 
-  # quality
-  # For 2.5 Pro this remains dynamic because disable isn't supported.
-  return types.ThinkingConfig(thinking_budget=-1, include_thoughts=None)
+  # quality — dynamic budget (model decides how much to think)
+  return types.ThinkingConfig(thinking_budget=-1, include_thoughts=True)
 

{gemcode-0.3.18 → gemcode-0.3.20}/src/gemcode/tui/input_handler.py

@@ -49,6 +49,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("compact",     "Summarise conversation history to reclaim context space"),
     ("config",      "Show active configuration and environment variables"),
     ("permissions", "Show current permission mode (default / strict / yes)"),
+    ("thinking",    "View or change thinking config  ·  /thinking level <low|medium|high>  ·  /thinking budget <N>"),
     ("audit",       "Show recent audit log  ·  /audit [N lines]"),
     ("memory",      "Show memory / storage settings"),
     ("doctor",      "Run diagnostics and validate the environment"),

{gemcode-0.3.18 → gemcode-0.3.20}/src/gemcode/tui/scrollback.py

@@ -236,15 +236,134 @@ async def run_gemcode_scrollback_tui(
       pass
     return tool_name, hint
 
+  # ── Live animated status indicator ───────────────────────────────────────
+  # An asyncio.Task drives a braille spinner that rewrites the current line
+  # every 150 ms with the elapsed time.  Because the spinner runs concurrently
+  # with `async for ev in runner.run_async(...)`, it updates while we await
+  # the next event — giving the user live timing feedback at every phase:
+  #   "Thinking…"  → model generating first response
+  #   "Running…"   → tool executing (can be 30–120 s for npx / cargo / pytest)
+  #   "Querying…"  → model re-querying after tool results
+  _anim_task:   list = [None]   # asyncio.Task | None
+  _anim_active: list = [False]  # True while spinner text is on stdout
+
+  async def _spinner_loop(msg: str) -> None:
+    frames = "⣾⣽⣻⢿⡿⣟⣯⣷"
+    t0 = asyncio.get_running_loop().time()
+    i = 0
+    try:
+      while True:
+        elapsed = asyncio.get_running_loop().time() - t0
+        frame = frames[i % len(frames)]
+        sys.stdout.write(
+            f"\r  {ansi.dim}{frame}  {msg}  ({elapsed:.0f}s){ansi.reset}  "
+        )
+        sys.stdout.flush()
+        i += 1
+        await asyncio.sleep(0.15)
+    except asyncio.CancelledError:
+      pass  # _stop_anim() handles clearing the line
+
+  def _start_anim(msg: str) -> None:
+    """Start (or restart) the spinner with a new status message."""
+    _stop_anim()
+    if not ansi.enabled:
+      return
+    try:
+      loop = asyncio.get_event_loop()
+      if loop.is_running():
+        _anim_task[0] = loop.create_task(_spinner_loop(msg))
+        _anim_active[0] = True
+    except Exception:
+      pass
+
+  def _stop_anim() -> None:
+    """Cancel the spinner task and erase its line from stdout."""
+    task = _anim_task[0]
+    if task is not None:
+      task.cancel()
+      _anim_task[0] = None
+    if _anim_active[0]:
+      sys.stdout.write("\r\033[K")
+      sys.stdout.flush()
+      _anim_active[0] = False
+
+  def _fmt_tool_result(resp: object) -> str:
+    """One-line summary of a tool execution result."""
+    try:
+      d = resp if isinstance(resp, dict) else {}
+      inner = d.get("result", d)
+      if not isinstance(inner, dict):
+        inner = d
+      err = inner.get("error") or d.get("error")
+      if err:
+        return f"\u2717 {str(err)[:80]}"
+      exit_code = inner.get("exit_code")
+      if exit_code is not None:
+        icon = "\u2713" if exit_code == 0 else f"\u2717 exit {exit_code}"
+        out = str(inner.get("stdout", "") or "").strip()
+        first = out.split("\n")[0][:80] if out else ""
+        if not first:
+          first = str(inner.get("stderr", "") or "").strip().split("\n")[0][:80]
+        return f"{icon}  {first}" if first else icon
+      if inner.get("content") is not None:
+        lines = str(inner["content"]).count("\n") + 1
+        return f"\u2713 {lines} lines"
+      if inner.get("files") is not None:
+        return f"\u2713 {len(inner['files'])} files"
+      if inner.get("matches") is not None:
+        return f"\u2713 {len(inner['matches'])} matches"
+      if inner.get("ok") or d.get("ok"):
+        return "\u2713"
+      return ""
+    except Exception:
+      return ""
+
+  def _render_tool_results(ev) -> None:
+    """Show a one-line result summary; transition spinner to 'Querying…'."""
+    try:
+      frs: list = []
+      try:
+        frs = ev.get_function_responses() or []
+      except Exception:
+        pass
+      if not frs and ev.content and ev.content.parts:
+        for part in ev.content.parts:
+          fr = getattr(part, "function_response", None)
+          if fr is not None:
+            frs.append(fr)
+      real_frs = [
+          fr for fr in frs
+          if getattr(fr, "name", "") not in ("", _ADK_REQUEST_CONFIRMATION)
+      ]
+      if not real_frs:
+        return  # nothing to show; keep spinner running
+      _stop_anim()  # clear "Running…" before printing results
+      for fr in real_frs:
+        resp = getattr(fr, "response", {}) or {}
+        summary = _fmt_tool_result(resp)
+        if summary:
+          print(f"  ⎿    {ansi.dim}\u21b3 {summary}{ansi.reset}")
+      # Restart spinner while model re-queries with the tool outputs.
+      _start_anim("Querying\u2026")
+    except Exception:
+      pass
+
   def _render_tool_calls(ev) -> None:
+    """Print tool-call lines; transition spinner to 'Running…'."""
     try:
       fcs = ev.get_function_calls() or []
     except Exception:
       fcs = []
-    for fc in fcs:
+    real_fcs = [
+        fc for fc in fcs
+        if getattr(fc, "name", "") not in ("", _ADK_REQUEST_CONFIRMATION)
+    ]
+    if not real_fcs:
+      return  # no visible tool calls; leave spinner as-is
+    _stop_anim()  # clear "Thinking…" or "Querying…"
+    for fc in real_fcs:
       name = getattr(fc, "name", "") or ""
-      if name == _ADK_REQUEST_CONFIRMATION:
-        continue
       extra = format_tool_call_extras(fc)
       if extra:
         print(
@@ -253,6 +372,7 @@ async def run_gemcode_scrollback_tui(
         )
       else:
         print(f"  ⎿  {ansi.blue_tool}[tool]{ansi.reset} {ansi.bold}{name}{ansi.reset}")
+    _start_anim("Running\u2026")  # spinner while tool actually executes
 
   run_config = (
     RunConfig(max_llm_calls=cfg.max_llm_calls)
@@ -290,11 +410,16 @@ async def run_gemcode_scrollback_tui(
         current_session_id = slash.new_session_id
         _current_session_id_holder[0] = current_session_id
       if slash.skip_model_turn:
-        # Runner binds the model at creation time (LlmAgent(model=...)),
-        # so rebuild it when the user overrides the model mid-session.
+        # Runner holds the LlmAgent which bakes in model + thinking config at
+        # construction time.  Rebuild whenever the model or thinking changes.
         new_model = getattr(cfg, "model", "")
         new_model_overridden = bool(getattr(cfg, "model_overridden", False))
-        if new_model != old_model or new_model_overridden != old_model_overridden:
+        needs_rebuild = (
+            new_model != old_model
+            or new_model_overridden != old_model_overridden
+            or slash.force_rebuild_runner
+        )
+        if needs_rebuild:
           try:
             close_fn = getattr(runner, "close", None)
             if close_fn:
@@ -331,9 +456,15 @@ async def run_gemcode_scrollback_tui(
         kwargs["run_config"] = run_config
       # (We don't handle token budget reset here; full-screen TUI does.)
 
+      # Animated spinner starts immediately so the user always knows the
+      # agent is active.  It transitions: Thinking… → Running… → Querying…
+      # as different phases of the turn complete.
+      _start_anim("Thinking\u2026")
+
       async for ev in runner.run_async(**kwargs):
         events.append(ev)
         _render_tool_calls(ev)
+        _render_tool_results(ev)
         try:
           if not ev.content or not ev.content.parts:
             continue
@@ -351,6 +482,8 @@ async def run_gemcode_scrollback_tui(
         except Exception:
           continue
 
+      _stop_anim()  # ensure spinner is gone before printing the response
+
       if not assistant_wrote_text and _events_had_non_confirmation_tools(events):
         await typewrite(
             f"{ansi.dim}(Tools ran without a text reply in this step; "
@@ -377,15 +510,6 @@ async def run_gemcode_scrollback_tui(
             await typewrite(thought_text)
             sys.stdout.write("\n")
             sys.stdout.flush()
-        else:
-          # Keep thinking visible even if the model produced no separate
-          # "thought" channel output.
-          print(
-            f"  ⎿  {ansi.dim}{ansi.bold}\u2234 Thinking{ansi.reset}: "
-            "(no thinking output)"
-          )
-          print("")
-
         if buffered_final:
           sys.stdout.write(f"  ⎿  {ansi.bold}GemCode{ansi.reset}: ")
           sys.stdout.flush()

{gemcode-0.3.18 → gemcode-0.3.20/src/gemcode.egg-info}/PKG-INFO

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