gemcode 0.3.10__tar.gz → 0.3.12__tar.gz

{gemcode-0.3.10/src/gemcode.egg-info → gemcode-0.3.12}/PKG-INFO

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

{gemcode-0.3.10 → gemcode-0.3.12}/pyproject.toml

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

{gemcode-0.3.10 → gemcode-0.3.12}/src/gemcode/cli.py

@@ -183,6 +183,10 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
   _maybe_prompt_google_api_key()
   require_google_api_key()
   _initialize_gemcode_project(cfg)
+  
+  # Show beautiful startup screen before TUI loads
+  from gemcode.tui.startup_screen import print_startup_screen
+  print_startup_screen()
   extra: list = []
   if use_mcp:
     from gemcode.mcp_loader import load_mcp_toolsets
@@ -237,7 +241,9 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
         )
       else:
         try:
-          style = os.environ.get("GEMCODE_TUI_STYLE", "scrollback").strip().lower()
+          # Default to the full-screen TUI (OpenClaude-like). Scrollback is still
+          # available for terminals that can't handle alternate screen UIs.
+          style = os.environ.get("GEMCODE_TUI_STYLE", "full").strip().lower()
           if style in ("scrollback", "claude", "claude-like"):
             from gemcode.tui.scrollback import run_gemcode_scrollback_tui
 

{gemcode-0.3.10 → gemcode-0.3.12}/src/gemcode/tui/app.py

@@ -77,6 +77,12 @@ async def run_gemcode_tui(
 
   interrupted = {"flag": False}
 
+  # Import spinner utilities
+  from gemcode.tui.spinner import SpinnerState, format_spinner_line, format_idle_status
+  
+  # Initialize spinner state
+  spinner_state = SpinnerState()
+  
   def append(text: str) -> None:
     output.buffer.insert_text(text)
     if not text.endswith("\n"):
@@ -124,25 +130,36 @@ async def run_gemcode_tui(
 
   def header_text():
     model = getattr(cfg, "model", "") or ""
+    # Clean up model display
+    if "gemini-" in model:
+      model_display = model.replace("gemini-", "Gemini ").replace("-", " ").title()
+    else:
+      model_display = model or "Gemini 2.0 Flash"
+    
     mode = (
-      "yes"
+      "auto"
       if getattr(cfg, "yes_to_all", False)
       else "ask"
       if getattr(cfg, "interactive_permission_ask", False)
-      else "ro"
+      else "read-only"
     )
     root = str(getattr(cfg, "project_root", "") or "")
+    # Shorten root path if too long
+    if len(root) > 40:
+      root = "..." + root[-37:]
+    
     now = datetime.now().strftime("%a %b %d %H:%M")
     # Shift+Enter isn't reliably distinguishable across terminals, so we
     # provide a portable newline binding (Ctrl+J).
     tips = "Enter=send | Ctrl+J=newline | Esc=interrupt | Ctrl+D=exit"
     return [
-      ("class:brand", " GemCode "),
-      ("", f"  model={model or '<auto>'}  perm={mode}  root={root}  {now}\n"),
+      ("class:brand", " ◆ GemCode "),
+      ("", f"  {model_display}  ·  perm={mode}  ·  {now}\n"),
+      ("class:muted", f" {root}\n"),
       ("class:muted", f" {tips}"),
     ]
 
-  header = Window(height=2, content=FormattedTextControl(header_text), dont_extend_height=True)
+  header = Window(height=3, content=FormattedTextControl(header_text), dont_extend_height=True)
 
   _git_cache = {"t": 0.0, "branch": ""}
 
@@ -180,6 +197,12 @@ async def run_gemcode_tui(
   # Non-modal permission prompt state. Modal dialogs can corrupt a full-screen TUI.
   pending_confirm: dict[str, object] = {"future": None, "tool": "", "hint": ""}
   assistant_busy: dict[str, bool] = {"value": False}
+  # Claude-style: hide thinking by default, reveal via Ctrl+O.
+  show_thinking: dict[str, bool] = {"value": False}
+  thinking_active: dict[str, bool] = {"value": False}
+  thinking_start_ts: dict[str, float] = {"value": 0.0}
+  pending_thinking_text: dict[str, str | None] = {"value": None}
+  pending_thinking_insert_pos: dict[str, int | None] = {"value": None}
   spinner_idx: dict[str, int] = {"value": 0}
 
   def _set_input_prompt() -> None:
@@ -203,7 +226,7 @@ async def run_gemcode_tui(
       ]
     return [
       ("class:muted", " "),
-      ("class:muted", "Type your message below. Enter=send · Ctrl+J=newline · Ctrl+O=home"),
+      ("class:muted", "Type your message below. Enter=send · Ctrl+J=newline · Ctrl+O=show thinking"),
     ]
 
   def _status_text():
@@ -212,44 +235,62 @@ async def run_gemcode_tui(
       tool = str(pending_confirm.get("tool") or "tool")
       return [
         ("class:muted", " "),
-        ("class:pill", f"Permission: {tool}"),
+        ("class:pill", f"⚠ Permission: {tool}"),
         ("class:muted", "  "),
         ("class:accent", "y=approve"),
         ("class:muted", "  "),
         ("class:accent", "n=deny"),
         ("class:muted", "  "),
-        ("class:muted", "(Esc cancels)"),
+        ("class:muted", "(Esc to cancel)"),
       ]
     if assistant_busy.get("value"):
-      frames = ["|", "/", "-", "\\"]
-      fr = frames[spinner_idx.get("value", 0) % len(frames)]
+      # Calculate elapsed time
+      elapsed_s = max(0, int(time.time() - float(thinking_start_ts.get("value", 0.0) or 0.0)))
+      
+      if not show_thinking.get("value") and thinking_active.get("value"):
+        # Thinking but hidden - show duration and hint
+        return [
+          ("class:muted", " "),
+          ("class:pill", f"💭 Thinking for {elapsed_s}s"),
+          ("class:muted", "  "),
+          ("class:accent", "Ctrl+O to show"),
+          ("class:muted", "  ·  "),
+          ("class:muted", "Esc=interrupt"),
+        ]
+      
+      # Active spinner - use OpenClaude-style Braille frames
+      frame = spinner_state.get_frame()
+      verb = spinner_state.verb
       return [
         ("class:muted", " "),
-        ("class:pill", f"thinking {fr}"),
-        ("class:muted", "  "),
-        ("class:muted", "Tip: Esc=interrupt"),
+        ("class:accent", f"{frame}"),
+        ("class:muted", f" {verb}…"),
+        ("class:muted", "  ·  "),
+        ("class:muted", "Esc=interrupt"),
       ]
+    
+    # Idle status - use OpenClaude format
+    git_br = _git_branch()
     return [
       ("class:muted", " "),
-      ("class:pill", f"🌿 {_git_branch()}" if _git_branch() else "📁 no-git"),
-      ("class:muted", "  "),
-      ("class:muted", "Tip: Ctrl+J=newline  Esc=interrupt  Ctrl+D=exit"),
+      ("class:pill", f"🌿 {git_br}" if git_br else "📁 workspace"),
+      ("class:muted", "  ·  "),
+      ("class:muted", "Ready  ·  Ctrl+K=home  ·  Ctrl+O=thinking"),
     ]
 
   status.content = FormattedTextControl(_status_text)
   _set_input_prompt()
 
   async def _spin_status() -> None:
-    frames = ["|", "/", "-", "\\"]
-    i = 0
+    """Animate spinner matching OpenClaude's exact behavior."""
     while assistant_busy.get("value"):
-      spinner_idx["value"] = i % len(frames)
-      i += 1
+      spinner_state.advance()
+      spinner_idx["value"] = spinner_state.frame_index
       try:
         app.invalidate()
       except Exception:
         pass
-      await asyncio.sleep(0.12)
+      await asyncio.sleep(0.12)  # 120ms like OpenClaude
 
   input_help = Window(
     height=1,
@@ -278,8 +319,11 @@ async def run_gemcode_tui(
   def _model_display() -> str:
     m = getattr(cfg, "model", "") or ""
     if not m:
-      return "GemCode"
-    return m.replace("gemini-", "Gemini ").replace("-", ".")
+      return "Gemini 2.0 Flash"
+    # Clean up model name for display
+    if "gemini-" in m:
+      return m.replace("gemini-", "Gemini ").replace("-", " ").title()
+    return m
 
   def _render_home_text():
     # Recompute with current terminal width for a "dashboard" feel.
@@ -311,10 +355,10 @@ async def run_gemcode_tui(
 
     # Tiny "gem" ASCII mark (kept simple for terminal portability).
     art = [
-      "   ▄▄▄▄   ",
-      "  ▐█  █▌  ",
-      "  ▐█  █▌  ",
-      "   ▀▀▀▀   ",
+      "   ▄▄▄▄▄▄▄   ",
+      "  ▐█████████▌ ",
+      "  ▐█████████▌ ",
+      "   ▀▀▀▀▀▀▀   ",
     ]
     art_w = max(len(x) for x in art)
 
@@ -333,8 +377,9 @@ async def run_gemcode_tui(
 
     tips = [
       "Tips for getting started",
-      "First run: trust folder, API key, then .gemcode/",
-      "Note: Use perm=ask to approve tools",
+      "Use /help to see all commands",
+      "Ctrl+O toggles thinking display",
+      "Ctrl+K toggles this home screen",
     ]
     activity = ["Recent activity", "No recent activity"]
 
@@ -358,9 +403,9 @@ async def run_gemcode_tui(
       lines.append("│ " + l + " │ " + r + " │")
     lines.append("│" + (" " * (width - 2)) + "│")
     lines.append("└" + ("─" * (width - 2)) + "┘")
-    lines.append("↑ GemCode Pro now supports larger contexts · faster streaming")
+    lines.append("↑ GemCode now supports larger contexts · faster streaming · better tools")
     lines.append("")
-    lines.append("  ? for shortcuts".ljust(max(0, width - 12)) + "Ctrl+O home")
+    lines.append("  ? for shortcuts".ljust(max(0, width - 12)) + "Ctrl+K home")
 
     # Prevent overflow: clamp to available rows (leave space for header/input/status).
     max_lines = max(6, min(len(lines), max(6, rows - 7)))
@@ -413,8 +458,46 @@ async def run_gemcode_tui(
 
   # Note: do NOT bind y/n globally. Permission answers are typed into the
   # input field (perm>) and submitted with Enter, Claude-style.
+  async def _flush_pending_thinking() -> None:
+    # Insert hidden thinking back into the transcript (before the already-rendered final),
+    # so ctrl+o behaves like Claude's "expand" (best-effort).
+    if not show_thinking.get("value"):
+      return
+    t = pending_thinking_text.get("value")
+    pos = pending_thinking_insert_pos.get("value")
+    if not t or pos is None:
+      return
+    try:
+      output.buffer.cursor_position = int(pos)
+      output.buffer.insert_text(t)
+      output.buffer.insert_text("\n\n")
+      output.buffer.cursor_position = len(output.text)
+      pending_thinking_text["value"] = None
+      pending_thinking_insert_pos["value"] = None
+      try:
+        app.invalidate()
+      except Exception:
+        pass
+    except Exception:
+      return
+
   @kb.add("c-o")
+  def _toggle_thinking(event) -> None:
+    show_thinking["value"] = not show_thinking.get("value")
+    try:
+      event.app.invalidate()
+    except Exception:
+      pass
+    # If we just turned thinking on, flush the most recent pending thinking.
+    if show_thinking.get("value") and pending_thinking_text.get("value"):
+      try:
+        event.app.create_background_task(_flush_pending_thinking())
+      except Exception:
+        pass
+
+  @kb.add("c-k")
   def _toggle_home(event) -> None:
+    # Repurposed Ctrl+O for thinking reveal; Ctrl+K keeps the home dashboard toggle.
     show_home["value"] = not show_home["value"]
     try:
       event.app.invalidate()
@@ -570,6 +653,22 @@ async def run_gemcode_tui(
     cfg.model = pick_effective_model(cfg, prompt)
 
     assistant_busy["value"] = True
+    spinner_idx["value"] = 0
+    try:
+      app.invalidate()
+    except Exception:
+      pass
+    # Make the start of a turn visually obvious in the transcript, like
+    # OpenClaude's "thinking" row next to the spinner. We still keep the
+    # *content* of the thought hidden until Ctrl+O is pressed; this is just
+    # a dim/italic label so the user always sees that the model is busy.
+    append("\033[2m\033[3m⎿ ∴ Thinking…\033[0m")
+    
+    # Mark thinking start for spinner (OpenClaude-style)
+    spinner_state.start_thinking()
+    thinking_active["value"] = True
+    thinking_start_ts["value"] = time.time()
+    
     spinner_task = asyncio.create_task(_spin_status())
 
     try:
@@ -665,11 +764,12 @@ async def run_gemcode_tui(
         # into a separate buffer.
         buffered_thought: list[str] = []
         buffered_final: list[str] = []
-        # Show Claude-like "thinking" section immediately.
-        # We fill the thought content at the end of the pass (and can omit
-        # identical-thought/final cases), but the label itself should appear
-        # right away so there's a visible loading cue.
-        append_inline("⎿ GemCode (thinking): ")
+        # Claude-like thinking header is implicit in the spinner; we only
+        # print the full thinking block when the user asks for it via Ctrl+O.
+        thinking_active["value"] = True
+        thinking_start_ts["value"] = time.time()
+        pending_thinking_text["value"] = None
+        pending_thinking_insert_pos["value"] = None
         kwargs = dict(
             user_id="local",
             session_id=session_state["id"],
@@ -714,22 +814,26 @@ async def run_gemcode_tui(
         confirmation_fcs = _get_confirmation_fcs(events)
         if not confirmation_fcs:
           # Now that we know no confirmation is needed, render buffered
-          # thinking + final response separately.
+          # thinking + final response. By default we keep thinking hidden
+          # (Claude-style); Ctrl+O can later expand it from the buffer.
           thought_text = "".join(buffered_thought)
           final_text = "".join(buffered_final)
           if buffered_thought:
             # If Gemini returns the same content for both "thought" and
             # final text, don't repeat it (Claude typically doesn't).
             if buffered_final and _normalize_ws(thought_text) == _normalize_ws(final_text):
-              await typewrite("(omitted: identical to final response)")
-              append("")
+              pending_thinking_text["value"] = "(omitted: identical to final response)"
             else:
-              await typewrite(thought_text)
-              # Ensure visual separation before the final response section.
-              append("")
-          else:
-            await typewrite("(no thinking output)")
-            append("")
+              pending_thinking_text["value"] = thought_text
+            # If the user already asked to see thinking, insert it now;
+            # otherwise remember the insertion point so Ctrl+O can expand.
+            if show_thinking.get("value"):
+              insert_pos = len(output.text)
+              pending_thinking_insert_pos["value"] = insert_pos
+              await _flush_pending_thinking()
+            else:
+              pending_thinking_insert_pos["value"] = len(output.text)
+          thinking_active["value"] = False
           if buffered_final:
             append_inline("⎿ GemCode: ")
             await typewrite("".join(buffered_final))
@@ -809,6 +913,8 @@ async def run_gemcode_tui(
       append(f"GemCode: error: {e}\n")
     finally:
       assistant_busy["value"] = False
+      thinking_active["value"] = False
+      spinner_state.stop_thinking()  # Mark thinking end (OpenClaude-style)
       try:
         spinner_task.cancel()
       except Exception:
@@ -838,12 +944,12 @@ async def run_gemcode_tui(
 
   style = Style.from_dict(
     {
-      "brand": "bold #60a5fa",
-      "accent": "bold #3b82f6",
-      "muted": "#6b7280",
-      "sep": "#1f2937",
-      "pill": "bold #93c5fd",
-      "inputframe": "bg:#071426 #e5e7eb",
+      "brand": "bold #f0945c",  # Sunset orange
+      "accent": "bold #f09464",  # Warm accent
+      "muted": "#786452",  # Warm gray
+      "sep": "#64503d",  # Dark border
+      "pill": "bold #d97757",  # Warm pill
+      "inputframe": "bg:#1a0f0a #e5d5c5",  # Warm dark bg with cream text
     }
   )
 

{gemcode-0.3.10 → gemcode-0.3.12}/src/gemcode/tui/scrollback.py

@@ -117,25 +117,28 @@ class _Ansi:
 
   @property
   def blue(self) -> str:
-    # ANSI 256-color bright-ish blue.
-    return self.esc("38;5;75")
+    # Sunset orange/warm color instead of blue
+    return self.esc("38;5;215")
 
   @property
   def blue2(self) -> str:
-    # Slightly deeper blue for secondary accents.
-    return self.esc("38;5;33")
+    # Deeper warm color
+    return self.esc("38;5;209")
 
   @property
   def blue_ok(self) -> str:
-    return self.esc("38;5;81")
+    # Warm green for success
+    return self.esc("38;5;150")
 
   @property
   def blue_warn(self) -> str:
-    return self.esc("38;5;39")
+    # Warm amber for warnings
+    return self.esc("38;5;221")
 
   @property
   def blue_tool(self) -> str:
-    return self.esc("38;5;69")
+    # Warm tool color
+    return self.esc("38;5;180")
 
 
 def _term_width(default: int = 100) -> int:
@@ -176,16 +179,18 @@ def _dashboard(cfg) -> str:
     "",
     f"Welcome back {user}!",
     "",
-    "   ▐▛███▜▌",
-    "  ▝▜█████▛▘",
-    "    ▘▘ ▝▝",
+    "   ▄▄▄▄▄▄▄",
+    "  ▐█████████▌",
+    "  ▐█████████▌",
+    "   ▀▀▀▀▀▀▀",
     "",
-    f"{model or 'GemCode'} · Local session",
+    f"{model or 'Gemini 2.0 Flash'} · Local session",
     root,
   ]
   right = [
     "Tips for getting started",
     "First run creates .gemcode/ (trust + API key)",
+    "Use /help to see available commands",
     "",
     "Recent activity",
     "No recent activity",
@@ -202,7 +207,7 @@ def _dashboard(cfg) -> str:
     lines.append("│" + pad(f" {nt}", w - 2) + "│")
   lines.append(box_bot)
   lines.append("")
-  lines.append("  ↑ GemCode Pro now supports larger contexts · faster streaming")
+  lines.append("  ↑ GemCode now supports larger contexts · faster streaming · better tools")
   lines.append("")
   return "\n".join(lines)
 
@@ -247,6 +252,7 @@ async def run_gemcode_scrollback_tui(
     print(dash)
 
   print(f"{ansi.dim}  ? for shortcuts{ansi.reset}")
+  print(f"{ansi.dim}  (Tip: set GEMCODE_TUI_STYLE=full for spinner/status bar){ansi.reset}")
   print("")
 
   char_delay_ms = int(os.environ.get("GEMCODE_TUI_CHAR_DELAY_MS", "0") or "0")
@@ -417,14 +423,27 @@ async def run_gemcode_scrollback_tui(
         final_text = "".join(buffered_final)
         if buffered_thought:
           if buffered_final and _normalize_ws(thought_text) == _normalize_ws(final_text):
-            print(f"  ⎿  {ansi.dim}{ansi.bold}GemCode{ansi.reset} (thinking): {ansi.reset}(omitted: identical to final response)")
+            print(
+              f"  ⎿  {ansi.dim}{ansi.bold}\u2234 Thinking{ansi.reset}: "
+              f"{ansi.reset}(omitted: identical to final response)"
+            )
             print("")
           else:
-            sys.stdout.write(f"  ⎿  {ansi.dim}{ansi.bold}GemCode{ansi.reset} (thinking): ")
+            sys.stdout.write(
+              f"  ⎿  {ansi.dim}{ansi.bold}\u2234 Thinking{ansi.reset}: "
+            )
             sys.stdout.flush()
             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}: ")

gemcode-0.3.12/src/gemcode/tui/spinner.py

@@ -0,0 +1,150 @@
+"""
+Spinner component matching OpenClaude's exact implementation.
+Includes thinking status, tips, and animated spinner.
+"""
+
+from __future__ import annotations
+
+import os
+import random
+import time
+from typing import Optional
+
+# Spinner frames - Braille patterns like OpenClaude
+SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+# Spinner verbs - matching OpenClaude's variety
+SPINNER_VERBS = [
+    "Thinking",
+    "Analyzing",
+    "Planning",
+    "Writing",
+    "Checking",
+    "Reviewing",
+    "Processing",
+    "Evaluating",
+    "Considering",
+    "Examining",
+]
+
+# Tips - matching OpenClaude's helpful hints
+SPINNER_TIPS = [
+    "Use /help to see all available commands",
+    "Press Ctrl+O to toggle thinking display",
+    "Press Ctrl+K to toggle home screen",
+    "Use /clear to start fresh when switching topics",
+    "Type /tools to see available tools",
+    "Use Esc to interrupt the current operation",
+]
+
+
+class SpinnerState:
+    """Manages spinner animation state."""
+    
+    def __init__(self):
+        self.frame_index = 0
+        self.verb = random.choice(SPINNER_VERBS)
+        self.thinking_start: Optional[float] = None
+        self.thinking_duration: Optional[float] = None
+        self.thinking_display_until: Optional[float] = None
+        self.last_update = time.time()
+        
+    def get_frame(self) -> str:
+        """Get current spinner frame."""
+        return SPINNER_FRAMES[self.frame_index % len(SPINNER_FRAMES)]
+    
+    def advance(self) -> None:
+        """Advance to next frame."""
+        now = time.time()
+        # Update every 120ms like OpenClaude
+        if now - self.last_update >= 0.12:
+            self.frame_index += 1
+            self.last_update = now
+    
+    def start_thinking(self) -> None:
+        """Mark start of thinking phase."""
+        if self.thinking_start is None:
+            self.thinking_start = time.time()
+            self.thinking_duration = None
+            self.thinking_display_until = None
+    
+    def stop_thinking(self) -> None:
+        """Mark end of thinking phase."""
+        if self.thinking_start is not None:
+            duration = time.time() - self.thinking_start
+            self.thinking_duration = duration
+            # Display "thought for Xs" for minimum 2 seconds
+            self.thinking_display_until = time.time() + 2.0
+            self.thinking_start = None
+    
+    def get_thinking_status(self) -> Optional[str]:
+        """Get thinking status text."""
+        now = time.time()
+        
+        # Currently thinking
+        if self.thinking_start is not None:
+            elapsed = int(now - self.thinking_start)
+            if elapsed >= 1:
+                return f"💭 Thinking for {elapsed}s"
+            return "💭 Thinking"
+        
+        # Show duration after thinking (for 2s minimum)
+        if self.thinking_duration is not None and self.thinking_display_until is not None:
+            if now < self.thinking_display_until:
+                duration = int(self.thinking_duration)
+                return f"Thought for {duration}s"
+            # Clear after display period
+            self.thinking_duration = None
+            self.thinking_display_until = None
+        
+        return None
+    
+    def should_show_tip(self, elapsed_seconds: float) -> bool:
+        """Determine if we should show a tip based on elapsed time."""
+        # Show tips after 30 seconds like OpenClaude
+        return elapsed_seconds > 30
+    
+    def get_tip(self) -> str:
+        """Get a random tip."""
+        return random.choice(SPINNER_TIPS)
+
+
+def format_spinner_line(
+    spinner_state: SpinnerState,
+    mode: str = "working",
+    elapsed_seconds: float = 0,
+    show_tip: bool = True,
+) -> tuple[str, Optional[str]]:
+    """
+    Format spinner line matching OpenClaude's exact style.
+    
+    Returns:
+        Tuple of (main_line, tip_line)
+    """
+    frame = spinner_state.get_frame()
+    verb = spinner_state.verb
+    
+    # Check for thinking status
+    thinking_status = spinner_state.get_thinking_status()
+    
+    if thinking_status:
+        # Show thinking status instead of regular spinner
+        main_line = f"  {thinking_status}  ·  Esc=interrupt"
+    else:
+        # Regular spinner with verb
+        main_line = f"  {frame} {verb}…  ·  Esc=interrupt"
+    
+    # Tip line (shown after 30s)
+    tip_line = None
+    if show_tip and spinner_state.should_show_tip(elapsed_seconds):
+        tip = spinner_state.get_tip()
+        tip_line = f"  Tip: {tip}"
+    
+    return main_line, tip_line
+
+
+def format_idle_status(git_branch: Optional[str] = None) -> str:
+    """Format idle status line matching OpenClaude."""
+    if git_branch:
+        return f"  🌿 {git_branch}  ·  Ready  ·  Ctrl+K=home  ·  Ctrl+O=thinking"
+    return "  📁 workspace  ·  Ready  ·  Ctrl+K=home  ·  Ctrl+O=thinking"

gemcode-0.3.12/src/gemcode/tui/startup_screen.py

@@ -0,0 +1,196 @@
+"""
+GemCode startup screen with gradient ASCII art logo.
+Inspired by OpenClaude's beautiful startup experience.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import NamedTuple
+
+
+class RGB(NamedTuple):
+    r: int
+    g: int
+    b: int
+
+
+ESC = "\x1b["
+RESET = f"{ESC}0m"
+DIM = f"{ESC}2m"
+
+
+def rgb(r: int, g: int, b: int) -> str:
+    return f"{ESC}38;2;{r};{g};{b}m"
+
+
+def lerp(a: RGB, b: RGB, t: float) -> RGB:
+    return RGB(
+        round(a.r + (b.r - a.r) * t),
+        round(a.g + (b.g - a.g) * t),
+        round(a.b + (b.b - a.b) * t),
+    )
+
+
+def grad_at(stops: list[RGB], t: float) -> RGB:
+    c = max(0.0, min(1.0, t))
+    s = c * (len(stops) - 1)
+    i = int(s)
+    if i >= len(stops) - 1:
+        return stops[-1]
+    return lerp(stops[i], stops[i + 1], s - i)
+
+
+def paint_line(text: str, stops: list[RGB], line_t: float) -> str:
+    out = ""
+    for i, ch in enumerate(text):
+        t = line_t * 0.5 + (i / (len(text) - 1)) * 0.5 if len(text) > 1 else line_t
+        color = grad_at(stops, t)
+        out += f"{rgb(color.r, color.g, color.b)}{ch}"
+    return out + RESET
+
+
+# Color palette - sunset gradient
+SUNSET_GRAD: list[RGB] = [
+    RGB(255, 180, 100),
+    RGB(240, 140, 80),
+    RGB(217, 119, 87),
+    RGB(193, 95, 60),
+    RGB(160, 75, 55),
+    RGB(130, 60, 50),
+]
+
+ACCENT = RGB(240, 148, 100)
+CREAM = RGB(220, 195, 170)
+DIMCOL = RGB(120, 100, 82)
+BORDER = RGB(100, 80, 65)
+
+# Filled block text logo
+LOGO_GEM = [
+    "  ██████╗ ███████╗███╗   ███╗",
+    " ██╔════╝ ██╔════╝████╗ ████║",
+    " ██║  ███╗█████╗  ██╔████╔██║",
+    " ██║   ██║██╔══╝  ██║╚██╔╝██║",
+    " ╚██████╔╝███████╗██║ ╚═╝ ██║",
+    "  ╚═════╝ ╚══════╝╚═╝     ╚═╝",
+]
+
+LOGO_CODE = [
+    "  ██████╗ ██████╗ ██████╗ ███████╗",
+    " ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+    " ██║     ██║   ██║██║  ██║█████╗  ",
+    " ██║     ██║   ██║██║  ██║██╔══╝  ",
+    " ╚██████╗╚██████╔╝██████╔╝███████╗",
+    "  ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+]
+
+
+def detect_provider() -> dict[str, str | bool]:
+    """Detect current provider configuration."""
+    # Check for Gemini (default for GemCode)
+    api_key = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
+    model = os.environ.get("GEMINI_MODEL") or os.environ.get("GEMCODE_MODEL") or "gemini-2.0-flash-exp"
+    base_url = os.environ.get("GEMINI_BASE_URL") or "https://generativelanguage.googleapis.com"
+    
+    return {
+        "name": "Google Gemini",
+        "model": model,
+        "base_url": base_url,
+        "is_local": False,
+        "has_key": bool(api_key),
+    }
+
+
+def box_row(content: str, width: int, raw_len: int) -> str:
+    """Create a box row with proper padding."""
+    pad = max(0, width - 2 - raw_len)
+    return f"{rgb(BORDER.r, BORDER.g, BORDER.b)}│{RESET}{content}{' ' * pad}{rgb(BORDER.r, BORDER.g, BORDER.b)}│{RESET}"
+
+
+def print_startup_screen() -> None:
+    """Print the beautiful gradient startup screen."""
+    # Skip in non-interactive / CI environments
+    if os.environ.get("CI") or not sys.stdout.isatty():
+        return
+    
+    # Skip if explicitly disabled
+    if os.environ.get("GEMCODE_NO_STARTUP_SCREEN", "").lower() in ("1", "true", "yes", "on"):
+        return
+    
+    p = detect_provider()
+    W = 62
+    out: list[str] = []
+    
+    out.append("")
+    
+    # Gradient logo
+    all_logo = LOGO_GEM + [""] + LOGO_CODE
+    total = len(all_logo)
+    for i, line in enumerate(all_logo):
+        t = i / (total - 1) if total > 1 else 0
+        if line == "":
+            out.append("")
+        else:
+            out.append(paint_line(line, SUNSET_GRAD, t))
+    
+    out.append("")
+    
+    # Tagline
+    out.append(
+        f"  {rgb(ACCENT.r, ACCENT.g, ACCENT.b)}✦{RESET} "
+        f"{rgb(CREAM.r, CREAM.g, CREAM.b)}Gemini-powered coding agent. Fast. Capable. Local.{RESET} "
+        f"{rgb(ACCENT.r, ACCENT.g, ACCENT.b)}✦{RESET}"
+    )
+    out.append("")
+    
+    # Provider info box
+    out.append(f"{rgb(BORDER.r, BORDER.g, BORDER.b)}╔{'═' * (W - 2)}╗{RESET}")
+    
+    def lbl(k: str, v: str, c: RGB = CREAM) -> tuple[str, int]:
+        pad_k = k.ljust(9)
+        return (
+            f" {DIM}{rgb(DIMCOL.r, DIMCOL.g, DIMCOL.b)}{pad_k}{RESET} {rgb(c.r, c.g, c.b)}{v}{RESET}",
+            len(f" {pad_k} {v}"),
+        )
+    
+    prov_c = RGB(130, 175, 130) if p["is_local"] else ACCENT
+    r, l = lbl("Provider", str(p["name"]), prov_c)
+    out.append(box_row(r, W, l))
+    
+    r, l = lbl("Model", str(p["model"]))
+    out.append(box_row(r, W, l))
+    
+    ep = str(p["base_url"])
+    if len(ep) > 38:
+        ep = ep[:35] + "..."
+    r, l = lbl("Endpoint", ep)
+    out.append(box_row(r, W, l))
+    
+    out.append(f"{rgb(BORDER.r, BORDER.g, BORDER.b)}╠{'═' * (W - 2)}╣{RESET}")
+    
+    # Status line
+    s_c = RGB(130, 175, 130) if p["is_local"] else ACCENT
+    s_l = "local" if p["is_local"] else "cloud"
+    status_text = (
+        f" {rgb(s_c.r, s_c.g, s_c.b)}●{RESET} "
+        f"{DIM}{rgb(DIMCOL.r, DIMCOL.g, DIMCOL.b)}{s_l}{RESET}    "
+        f"{DIM}{rgb(DIMCOL.r, DIMCOL.g, DIMCOL.b)}Ready — type {RESET}"
+        f"{rgb(ACCENT.r, ACCENT.g, ACCENT.b)}/help{RESET}"
+        f"{DIM}{rgb(DIMCOL.r, DIMCOL.g, DIMCOL.b)} to begin{RESET}"
+    )
+    s_len = len(f" ● {s_l}    Ready — type /help to begin")
+    out.append(box_row(status_text, W, s_len))
+    
+    out.append(f"{rgb(BORDER.r, BORDER.g, BORDER.b)}╚{'═' * (W - 2)}╝{RESET}")
+    
+    # Version
+    from gemcode.version import get_version
+    version = os.environ.get("GEMCODE_VERSION", get_version())
+    out.append(
+        f"  {DIM}{rgb(DIMCOL.r, DIMCOL.g, DIMCOL.b)}gemcode {RESET}"
+        f"{rgb(ACCENT.r, ACCENT.g, ACCENT.b)}v{version}{RESET}"
+    )
+    out.append("")
+    
+    print("\n".join(out), flush=True)

{gemcode-0.3.10 → gemcode-0.3.12/src/gemcode.egg-info}/PKG-INFO

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

{gemcode-0.3.10 → gemcode-0.3.12}/src/gemcode.egg-info/SOURCES.txt

@@ -71,6 +71,8 @@ src/gemcode/tools/shell_gate.py
 src/gemcode/tools/todo.py
 src/gemcode/tui/app.py
 src/gemcode/tui/scrollback.py
+src/gemcode/tui/spinner.py
+src/gemcode/tui/startup_screen.py
 src/gemcode/web/__init__.py
 src/gemcode/web/claude_sse_adapter.py
 src/gemcode/web/terminal_repl.py