gemcode 0.3.11__tar.gz → 0.3.14__tar.gz

{gemcode-0.3.11/src/gemcode.egg-info → gemcode-0.3.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.11
+Version: 0.3.14
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -178,14 +178,12 @@ License-File: LICENSE
 Requires-Dist: google-adk>=1.0.0
 Requires-Dist: google-genai>=1.0.0
 Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.0.0; extra == "mcp"
-Provides-Extra: tui
-Requires-Dist: prompt_toolkit>=3.0.0; extra == "tui"
-Requires-Dist: rich>=13.0.0; extra == "tui"
 Dynamic: license-file
 
 # GemCode

{gemcode-0.3.11 → gemcode-0.3.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.3.11"
+version = "0.3.14"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -30,6 +30,7 @@ dependencies = [
   "google-adk>=1.0.0",
   "google-genai>=1.0.0",
   "python-dotenv>=1.0.0",
+  "rich>=13.0.0",
 ]
 
 [project.urls]
@@ -40,7 +41,6 @@ Issues = "https://github.com/spiderdev27/GemCode/issues"
 [project.optional-dependencies]
 dev = ["pytest>=8.0.0", "pytest-asyncio>=0.24.0"]
 mcp = ["mcp>=1.0.0"]
-tui = ["prompt_toolkit>=3.0.0", "rich>=13.0.0"]
 
 [project.scripts]
 gemcode = "gemcode.cli:main"

{gemcode-0.3.11 → gemcode-0.3.14}/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
@@ -225,11 +229,10 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       except EOFError:
         pass
 
-    # Optional TUI. Claude-like default is "scrollback" (no internal scrolling).
+    # Optional terminal UI: single scrollback-style REPL (terminal history, no alt-screen app).
     tui_enabled = os.environ.get("GEMCODE_TUI", "1").lower() in ("1", "true", "yes", "on")
     if tui_enabled:
       term = (os.environ.get("TERM") or "").strip().lower()
-      # Guardrails: Prompt Toolkit needs a real interactive terminal.
       if not sys.stdin.isatty() or not sys.stdout.isatty() or term in ("", "dumb", "unknown"):
         print(
           f"[tui] disabled (stdin/stdout isatty={sys.stdin.isatty()}/{sys.stdout.isatty()}, TERM={term or '<unset>'}); using plain REPL",
@@ -237,33 +240,19 @@ 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()
-          if style in ("scrollback", "claude", "claude-like"):
-            from gemcode.tui.scrollback import run_gemcode_scrollback_tui
-
-            await run_gemcode_scrollback_tui(
-                cfg=cfg,
-                runner=runner,
-                session_id=session_id,
-                extra_tools=extra or None,
-            )
-          else:
-            from gemcode.tui.app import run_gemcode_tui
-
-            await run_gemcode_tui(
-                cfg=cfg,
-                runner=runner,
-                session_id=session_id,
-                extra_tools=extra or None,
-            )
+          from gemcode.tui.scrollback import run_gemcode_scrollback_tui
+
+          await run_gemcode_scrollback_tui(
+              cfg=cfg,
+              runner=runner,
+              session_id=session_id,
+              extra_tools=extra or None,
+          )
           return
         except Exception as e:
-          # Dependency missing or terminal doesn't support full-screen.
-          # Print one line so users know how to fix it.
           print(
-            f"[tui] failed to start: {type(e).__name__}: {e} (falling back to plain REPL). "
-            "Install extras with: pip install 'gemcode[tui]'",
-            file=sys.stderr,
+              f"[tui] failed to start: {type(e).__name__}: {e} (falling back to plain REPL).",
+              file=sys.stderr,
           )
 
     print(

{gemcode-0.3.11 → gemcode-0.3.14}/src/gemcode/tui/scrollback.py

@@ -8,13 +8,13 @@ from dataclasses import dataclass
 
 from google.adk.agents.run_config import RunConfig
 from google.genai import types
+from rich.console import Console
 
 from gemcode.capability_routing import apply_capability_routing
 from gemcode.config import load_cli_environment
 from gemcode.model_routing import pick_effective_model
 from gemcode.repl_slash import process_repl_slash
-from gemcode.version import get_version
-from gemcode.workspace_hints import narrow_workspace_tip
+from gemcode.tui.welcome_rich import print_shortcuts_hint, print_welcome_dashboard
 
 _ADK_REQUEST_CONFIRMATION = "adk_request_confirmation"
 
@@ -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:
@@ -151,62 +154,6 @@ def _hr(ch: str = "─") -> str:
   return ch * _term_width()
 
 
-def _dashboard(cfg) -> str:
-  w = _term_width()
-  title = f" GemCode v{os.environ.get('GEMCODE_VERSION', get_version())} "
-  left_w = (w - 4) * 2 // 3
-  right_w = (w - 4) - left_w
-
-  def pad(s: str, ww: int) -> str:
-    s = s.replace("\n", " ")
-    if len(s) > ww:
-      return s[: ww - 1] + "…"
-    return s + (" " * (ww - len(s)))
-
-  user = (os.environ.get("USER") or os.environ.get("LOGNAME") or "there").strip()
-  model = getattr(cfg, "model", "") or ""
-  root = str(getattr(cfg, "project_root", "") or "")
-
-  box_top = "╭" + ("─" * (w - 2)) + "╮"
-  box_bot = "╰" + ("─" * (w - 2)) + "╯"
-  lines: list[str] = [box_top]
-  lines.append("│" + pad(title, w - 2) + "│")
-  lines.append("│" + (" " * (w - 2)) + "│")
-  left = [
-    "",
-    f"Welcome back {user}!",
-    "",
-    "   ▐▛███▜▌",
-    "  ▝▜█████▛▘",
-    "    ▘▘ ▝▝",
-    "",
-    f"{model or 'GemCode'} · Local session",
-    root,
-  ]
-  right = [
-    "Tips for getting started",
-    "First run creates .gemcode/ (trust + API key)",
-    "",
-    "Recent activity",
-    "No recent activity",
-  ]
-  h = max(len(left), len(right))
-  left += [""] * (h - len(left))
-  right += [""] * (h - len(right))
-  for i in range(h):
-    lines.append(
-      "│ " + pad(left[i], left_w) + " │ " + pad(right[i], right_w) + " │"
-    )
-  nt = narrow_workspace_tip(getattr(cfg, "project_root"))
-  if nt:
-    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("")
-  return "\n".join(lines)
-
-
 async def run_gemcode_scrollback_tui(
     *, cfg, runner, session_id: str, extra_tools=None
 ) -> None:
@@ -229,24 +176,15 @@ async def run_gemcode_scrollback_tui(
     )
   )
 
+  console = Console(
+      width=_term_width(),
+      force_terminal=bool(sys.stdout.isatty()),
+      no_color=not ansi.enabled,
+      highlight=False,
+  )
   if os.environ.get("GEMCODE_TUI_SHOW_DASHBOARD", "1").lower() in ("1", "true", "yes", "on"):
-    dash = _dashboard(cfg)
-    if ansi.enabled:
-      # Color title + the ASCII mark.
-      lines = dash.splitlines()
-      if len(lines) >= 2:
-        lines[1] = (
-          lines[1]
-          .replace("GemCode", f"{ansi.blue}{ansi.bold}GemCode{ansi.reset}")
-          .replace("v", f"{ansi.dim}v{ansi.reset}")
-        )
-      for i, ln in enumerate(lines):
-        if "▐▛███▜▌" in ln or "▝▜█████▛▘" in ln or "▘▘ ▝▝" in ln:
-          lines[i] = f"{ansi.blue2}{ln}{ansi.reset}"
-      dash = "\n".join(lines)
-    print(dash)
-
-  print(f"{ansi.dim}  ? for shortcuts{ansi.reset}")
+    print_welcome_dashboard(cfg, console=console)
+  print_shortcuts_hint(console=console)
   print("")
 
   char_delay_ms = int(os.environ.get("GEMCODE_TUI_CHAR_DELAY_MS", "0") or "0")

gemcode-0.3.14/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.14/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)