gemcode 0.2.2__py3-none-any.whl

gemcode/tui/scrollback.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from dataclasses import dataclass
+
+from google.adk.agents.run_config import RunConfig
+from google.genai import types
+
+from gemcode.capability_routing import apply_capability_routing
+from gemcode.model_routing import pick_effective_model
+
+
+@dataclass(frozen=True)
+class _Ansi:
+  enabled: bool
+
+  def esc(self, code: str) -> str:
+    if not self.enabled:
+      return ""
+    return f"\x1b[{code}m"
+
+  @property
+  def reset(self) -> str:  # noqa: D401
+    return self.esc("0")
+
+  @property
+  def dim(self) -> str:
+    return self.esc("2")
+
+  @property
+  def bold(self) -> str:
+    return self.esc("1")
+
+  @property
+  def blue(self) -> str:
+    # ANSI 256-color bright-ish blue.
+    return self.esc("38;5;75")
+
+  @property
+  def blue2(self) -> str:
+    # Slightly deeper blue for secondary accents.
+    return self.esc("38;5;33")
+
+  @property
+  def blue_ok(self) -> str:
+    return self.esc("38;5;81")
+
+  @property
+  def blue_warn(self) -> str:
+    return self.esc("38;5;39")
+
+  @property
+  def blue_tool(self) -> str:
+    return self.esc("38;5;69")
+
+
+def _term_width(default: int = 100) -> int:
+  try:
+    import shutil
+
+    return max(60, shutil.get_terminal_size((default, 24)).columns)
+  except Exception:
+    return default
+
+
+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', '0.1.0')} "
+  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",
+    "Run /init to create a .gemcode file",
+    "",
+    "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) + " │"
+    )
+  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) -> None:
+  """
+  Claude-like terminal UI: NO internal scrolling, just terminal scrollback.
+
+  - User prompt line starts with: ❯
+  - Assistant/tool blocks start with: ⎿  (indented)
+  - Tool calls are shown as a short "internal state" block.
+  - Permission prompts are inline: type y/n at the prompt.
+  """
+  os.environ["GEMCODE_TUI_ACTIVE"] = "1"
+
+  ansi = _Ansi(
+    enabled=(
+      sys.stdout.isatty()
+      and os.environ.get("NO_COLOR") is None
+      and os.environ.get("GEMCODE_TUI_NO_COLOR") is None
+    )
+  )
+
+  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("")
+
+  char_delay_ms = int(os.environ.get("GEMCODE_TUI_CHAR_DELAY_MS", "0") or "0")
+
+  async def typewrite(text: str) -> None:
+    if not text:
+      return
+    if char_delay_ms <= 0:
+      sys.stdout.write(text)
+      sys.stdout.flush()
+      await asyncio.sleep(0)
+      return
+    for ch in text:
+      sys.stdout.write(ch)
+      sys.stdout.flush()
+      await asyncio.sleep(char_delay_ms / 1000.0)
+
+  REQUEST_CONFIRMATION_FC = "adk_request_confirmation"
+
+  def _get_confirmation_fcs(events: list) -> list[types.FunctionCall]:
+    out: list[types.FunctionCall] = []
+    for ev in events:
+      try:
+        for fc in ev.get_function_calls() or []:
+          if getattr(fc, "name", None) == REQUEST_CONFIRMATION_FC:
+            out.append(fc)
+      except Exception:
+        continue
+    return out
+
+  def _extract_tool_and_hint(fc: types.FunctionCall) -> tuple[str, str]:
+    tool_name = "unknown_tool"
+    hint = ""
+    try:
+      args = getattr(fc, "args", None) or {}
+      orig = args.get("originalFunctionCall") or {}
+      tool_name = orig.get("name") or tool_name
+      tc = args.get("toolConfirmation") or {}
+      hint = tc.get("hint") or ""
+    except Exception:
+      pass
+    return tool_name, hint
+
+  def _render_tool_calls(ev) -> None:
+    try:
+      fcs = ev.get_function_calls() or []
+    except Exception:
+      fcs = []
+    for fc in fcs:
+      name = getattr(fc, "name", "") or ""
+      if name == REQUEST_CONFIRMATION_FC:
+        continue
+      print(f"  ⎿  {ansi.blue_tool}[tool]{ansi.reset} {ansi.bold}{name}{ansi.reset}")
+
+  run_config = (
+    RunConfig(max_llm_calls=cfg.max_llm_calls)
+    if getattr(cfg, "max_llm_calls", None) is not None
+    else None
+  )
+
+  while True:
+    try:
+      prompt = input(f"{ansi.bold}❯{ansi.reset} ").strip()
+    except EOFError:
+      print("")
+      return
+    if not prompt:
+      continue
+    if prompt in (":q", "quit", "exit", "/exit"):
+      return
+
+    apply_capability_routing(cfg, prompt, context="prompt")
+    cfg.model = pick_effective_model(cfg, prompt)
+
+    # Start streaming assistant output.
+    sys.stdout.write(f"  ⎿  {ansi.bold}GemCode{ansi.reset}: ")
+    sys.stdout.flush()
+
+    current_message = types.Content(role="user", parts=[types.Part(text=prompt)])
+    do_reset = True
+
+    while True:
+      events: list = []
+      kwargs = dict(user_id="local", session_id=session_id, new_message=current_message)
+      if run_config is not None:
+        kwargs["run_config"] = run_config
+      # (We don't handle token budget reset here; full-screen TUI does.)
+
+      async for ev in runner.run_async(**kwargs):
+        events.append(ev)
+        _render_tool_calls(ev)
+        try:
+          if not ev.content or not ev.content.parts:
+            continue
+          if not getattr(ev, "author", None) or ev.author == "user":
+            continue
+          for part in ev.content.parts:
+            delta = getattr(part, "text", None)
+            if delta:
+              await typewrite(delta)
+        except Exception:
+          continue
+
+      confirmation_fcs = _get_confirmation_fcs(events)
+      if not confirmation_fcs:
+        break
+
+      interactive_enabled = bool(getattr(cfg, "interactive_permission_ask", False))
+      parts: list[types.Part] = []
+      for fc in confirmation_fcs:
+        tool_name, hint = _extract_tool_and_hint(fc)
+        if not interactive_enabled:
+          print("")
+          print(
+            f"  ⎿  {ansi.blue_warn}{ansi.bold}Permission needed{ansi.reset} for {ansi.bold}{tool_name}{ansi.reset} "
+            f"but perm mode is not ask. Denying."
+          )
+          ok = False
+        else:
+          print("")
+          if hint:
+            print(
+              f"  ⎿  {ansi.blue}{ansi.bold}Permission needed{ansi.reset} for {ansi.bold}{tool_name}{ansi.reset}: {hint}"
+            )
+          else:
+            print(
+              f"  ⎿  {ansi.blue}{ansi.bold}Permission needed{ansi.reset} for {ansi.bold}{tool_name}{ansi.reset}."
+            )
+          ans = input(
+            f"  ⎿  Allow? ({ansi.blue_ok}y{ansi.reset}/{ansi.dim}N{ansi.reset}) "
+          ).strip().lower()
+          ok = ans in ("y", "yes")
+          # Resume the assistant indent after permission prompt.
+          sys.stdout.write(f"  ⎿  {ansi.bold}GemCode{ansi.reset}: ")
+          sys.stdout.flush()
+
+        parts.append(
+          types.Part(
+            function_response=types.FunctionResponse(
+              name=REQUEST_CONFIRMATION_FC,
+              id=getattr(fc, "id", None),
+              response={"confirmed": bool(ok)},
+            )
+          )
+        )
+      current_message = types.Content(role="user", parts=parts)
+      do_reset = False
+
+    print("")
+    print("")
+

gemcode/vertex.py

@@ -0,0 +1,22 @@
+"""
+Vertex AI (optional production path).
+
+Set for Google GenAI client routing (see google-genai docs):
+- GOOGLE_GENAI_USE_VERTEXAI=true
+- GOOGLE_CLOUD_PROJECT=your-project-id
+- GOOGLE_CLOUD_LOCATION=us-central1
+
+Application Default Credentials (gcloud auth application-default login) or
+service account for CI.
+
+GemCode currently uses the default google-genai behavior from the environment;
+no extra code is required for basic Vertex text generation once env is set.
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def vertex_env_active() -> bool:
+  return os.environ.get("GOOGLE_GENAI_USE_VERTEXAI", "").lower() in ("1", "true", "yes")

gemcode/web/__init__.py

@@ -0,0 +1,2 @@
+"""Web adapter modules for GemCode."""
+

gemcode/web/claude_sse_adapter.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+import uuid
+from dataclasses import dataclass
+from typing import Any, Iterable
+from pathlib import Path
+
+from gemcode.config import GemCodeConfig
+from gemcode.session_runtime import create_runner
+
+
+def _extract_text_from_event(event: Any) -> str:
+  """
+  Best-effort extraction of assistant-visible text from ADK events.
+
+  GemCode's CLI uses `event.content.parts` and skips events whose author is
+  "user". We reuse the same heuristic so the web UI can render incremental
+  text deltas.
+  """
+  try:
+    content = getattr(event, "content", None)
+    author = getattr(event, "author", None)
+    if author == "user":
+      return ""
+    if not content or not getattr(content, "parts", None):
+      return ""
+    parts = content.parts
+    out: list[str] = []
+    for p in parts:
+      t = getattr(p, "text", None)
+      if isinstance(t, str) and t:
+        out.append(t)
+    return "".join(out)
+  except Exception:
+    return ""
+
+
+def _extract_text_from_message_content(content: Any) -> str:
+  if isinstance(content, str):
+    return content
+  try:
+    return json.dumps(content, ensure_ascii=False)
+  except Exception:
+    return str(content)
+
+
+def _build_prompt(messages: list[dict[str, Any]]) -> str:
+  """
+  Claude's web UI sends the full conversation history in `messages`.
+
+  GemCode's current invocation is "single user message" only, so we embed the
+  conversation into the prompt text.
+  """
+  lines: list[str] = []
+  for m in messages:
+    role = m.get("role")
+    content = _extract_text_from_message_content(m.get("content"))
+    if role == "user":
+      lines.append(f"User: {content}")
+    elif role == "assistant":
+      lines.append(f"Assistant: {content}")
+  if not lines:
+    return ""
+  return "Conversation so far:\n" + "\n".join(lines) + "\n\nNow respond as the assistant."
+
+
+def _sse_emit(obj: dict[str, Any]) -> None:
+  sys.stdout.write(f"data: {json.dumps(obj)}\n\n")
+  sys.stdout.flush()
+
+
+def _iter_chunks(text: str, chunk_size: int) -> Iterable[str]:
+  if chunk_size <= 0:
+    yield text
+    return
+  for i in range(0, len(text), chunk_size):
+    yield text[i : i + chunk_size]
+
+
+async def _emit_text_delta(index: int, delta: str) -> None:
+  """
+  Emit a text delta in smaller chunks to create smoother streaming in the UI.
+
+  The upstream ADK events can arrive in sentence-sized deltas; splitting reduces
+  "chunky" updates without requiring true token events.
+  """
+  if not delta:
+    return
+
+  # Default small chunk for smoother streaming; override via env.
+  chunk_size = int(os.environ.get("GEMCODE_WEB_STREAM_CHUNK", "8"))
+  for piece in _iter_chunks(delta, max(1, chunk_size)):
+    _sse_emit(
+      {
+        "type": "content_block_delta",
+        "index": index,
+        "delta": {"type": "text_delta", "text": piece},
+      }
+    )
+    _sse_emit({"type": "text", "content": piece})
+    # Yield to the event loop so chunks flush promptly under load.
+    await asyncio.sleep(0)
+
+
+async def run_adapter(req: dict[str, Any]) -> None:
+  # ---- Request parsing ----
+  messages = req.get("messages")
+  requested_model = req.get("model")
+  model = requested_model or os.environ.get("GEMCODE_MODEL") or "gemini-2.5-flash"
+
+  if not isinstance(messages, list):
+    raise ValueError("messages must be a list")
+
+  prompt = _build_prompt(messages)
+
+  # ---- Config ----
+  project_root = os.environ.get("GEMCODE_WEB_PROJECT_ROOT") or os.getcwd()
+  cfg = GemCodeConfig(project_root=Path(project_root))
+
+  # Permission mapping: for the web MVP we gate all mutations behind `--yes`
+  # style confirmation using an env flag.
+  cfg.permission_mode = os.environ.get("GEMCODE_PERMISSION_MODE", cfg.permission_mode)
+  cfg.yes_to_all = os.environ.get("GEMCODE_WEB_YES_TO_ALL", "false").lower() in (
+    "1",
+    "true",
+    "yes",
+    "on",
+  )
+
+  # Model mapping/validation:
+  # The ported Claude UI sends Claude model ids (e.g. "claude-sonnet-4-6"),
+  # but GemCode uses Google GenAI model ids. Ignore unknown model ids and
+  # fall back to cfg defaults so web chat doesn't hard-fail.
+  MODEL_MAP: dict[str, str] = {
+    # GemCode UI model ids
+    "gemcode-pro": "gemini-2.5-pro",
+    "gemcode-balanced": "gemini-2.5-flash",
+    "gemcode-fast": "gemini-2.5-flash",
+    # Backward compatibility with older Claude-branded ids
+    "claude-opus-4-6": "gemini-2.5-pro",
+    "claude-sonnet-4-6": "gemini-2.5-flash",
+    "claude-haiku-4-5-20251001": "gemini-2.5-flash",
+  }
+
+  resolved_model: str | None = None
+  if isinstance(requested_model, str) and requested_model.strip():
+    rm = requested_model.strip()
+    if rm in MODEL_MAP:
+      resolved_model = MODEL_MAP[rm]
+    elif rm.startswith("gemini") or rm.startswith("models/"):
+      resolved_model = rm
+
+  if resolved_model:
+    cfg.model = resolved_model
+    cfg.model_overridden = True
+    model = resolved_model
+
+  # ---- Session + runner ----
+  session_id = req.get("session_id") or str(uuid.uuid4())
+
+  # ---- Claude-like stream event mapping (text-only MVP) ----
+  # We emit the full StreamEvent shape for useChat, and a simplified StreamChunk
+  # shape for ChatInput. Tools are not mapped yet (text-only).
+  message_id = f"msg_{uuid.uuid4().hex[:12]}"
+  assistant_block_index = 0
+
+  # message_start + content_block_start before the first token
+  _sse_emit(
+    {
+      "type": "message_start",
+      "message": {
+        "id": message_id,
+        "role": "assistant",
+        "model": model,
+        "usage": {"input_tokens": 0, "output_tokens": 0},
+      },
+    }
+  )
+  _sse_emit(
+    {
+      "type": "content_block_start",
+      "index": assistant_block_index,
+      "content_block": {"type": "text", "text": ""},
+    }
+  )
+
+  emitted_text = ""
+  runner = None
+  try:
+    # ---- Mock mode (for web smoke tests / local dev without API keys) ----
+    mock_response = os.environ.get("GEMCODE_WEB_MOCK_RESPONSE")
+    if isinstance(mock_response, str) and mock_response.strip():
+      full = mock_response
+      # Emit small deltas so the frontend can exercise its streaming UI.
+      chunk_size = int(os.environ.get("GEMCODE_WEB_MOCK_CHUNK", "6"))
+      for i in range(0, len(full), max(1, chunk_size)):
+        delta = full[i : i + chunk_size]
+        emitted_text += delta
+        _sse_emit(
+          {
+            "type": "content_block_delta",
+            "index": assistant_block_index,
+            "delta": {"type": "text_delta", "text": delta},
+          }
+        )
+        _sse_emit({"type": "text", "content": delta})
+        await asyncio.sleep(0.01)
+      return
+
+    else:
+      # Real ADK streaming mode
+      runner = create_runner(cfg, extra_tools=None)
+
+      # Import here to avoid unused dependency import at module init.
+      from google.adk.agents.run_config import RunConfig
+      from google.genai import types
+
+      new_message = types.Content(role="user", parts=[types.Part(text=prompt)])
+      run_config = (
+        RunConfig(max_llm_calls=cfg.max_llm_calls)
+        if cfg.max_llm_calls is not None
+        else None
+      )
+
+      async for event in runner.run_async(
+        user_id=req.get("user_id") or "web",
+        session_id=session_id,
+        new_message=new_message,
+        **({"run_config": run_config} if run_config is not None else {}),
+      ):
+        text = _extract_text_from_event(event)
+        if not text:
+          continue
+
+        # Ensure we emit only forward deltas.
+        if text.startswith(emitted_text):
+          delta = text[len(emitted_text) :]
+        else:
+          # Fallback: compute a conservative common prefix.
+          common = 0
+          max_common = min(len(text), len(emitted_text))
+          while common < max_common and text[common] == emitted_text[common]:
+            common += 1
+          delta = text[common:]
+
+        if delta:
+          emitted_text += delta
+          await _emit_text_delta(assistant_block_index, delta)
+
+  except Exception as e:
+    _sse_emit({"type": "error", "error": {"type": "server", "message": str(e)}})
+    _sse_emit({"type": "error", "error": str(e)})
+  finally:
+    # Close the StreamEvent content block even if we produced no tokens.
+    _sse_emit({"type": "content_block_stop", "index": assistant_block_index})
+    _sse_emit({"type": "message_stop"})
+    _sse_emit({"type": "done"})
+
+    if runner is not None:
+      try:
+        await runner.close()
+      except Exception:
+        pass
+
+
+def main() -> None:
+  # ---- Read JSON request from stdin ----
+  raw = sys.stdin.read()
+  if not raw.strip():
+    raise RuntimeError("Empty request")
+  req = json.loads(raw)
+
+  asyncio.run(run_adapter(req))
+
+
+if __name__ == "__main__":
+  main()
+