seedcode-cli 6.1.5__py3-none-any.whl

seedcode/tools/terminal.py

@@ -0,0 +1,200 @@
+"""Terminal execution tool: run a shell command in the workspace, live.
+
+Commands run through ``subprocess.Popen`` with a reader thread so output
+streams line-by-line while the process is still running (Windows pipes have
+no ``select``, hence the thread + queue). The agent layer can attach a
+per-line callback via ``PermissionManager.on_output`` to echo progress to
+the user as it happens.
+
+Shell selection: ``cmd``, ``powershell`` and ``bash`` are supported
+explicitly; the default ("") is the platform shell (cmd on Windows,
+/bin/sh elsewhere) via ``shell=True``.
+
+Cancellation: pressing Ctrl+C while a command is running kills that
+command's whole process tree (``taskkill /T /F`` on Windows, process-group
+SIGKILL elsewhere) and reports the cancellation as a failed tool result —
+the agent turn itself continues, so the model learns the command was
+cancelled instead of the loop dying.
+"""
+
+from __future__ import annotations
+
+import os
+import queue
+import signal
+import subprocess
+import sys
+import threading
+import time
+from typing import IO, TYPE_CHECKING, Any, Callable
+
+from .base import MAX_OUTPUT_CHARS, ToolResult, int_arg, register
+from .permissions import CATEGORY_SHELL
+
+if TYPE_CHECKING:
+    from .permissions import PermissionManager
+
+_DEFAULT_TIMEOUT_S = 60
+_MAX_TIMEOUT_S = 300
+
+# Explicit shell -> argv builder. "" (default) uses shell=True instead.
+_SHELLS: dict[str, Callable[[str], list[str]]] = {
+    "cmd": lambda c: ["cmd", "/d", "/c", c],
+    "powershell": lambda c: [
+        "powershell", "-NoProfile", "-NonInteractive", "-Command", c
+    ],
+    "bash": lambda c: ["bash", "-lc", c],
+}
+
+_EOF = object()  # sentinel the reader thread puts when the pipe closes
+
+
+def _kill_tree(proc: subprocess.Popen) -> None:
+    """Kill a process and all of its children; never raises."""
+    try:
+        if sys.platform == "win32":
+            subprocess.run(
+                ["taskkill", "/PID", str(proc.pid), "/T", "/F"],
+                capture_output=True,
+            )
+        else:
+            os.killpg(proc.pid, signal.SIGKILL)
+    except OSError:
+        pass
+    try:
+        proc.wait(timeout=5)
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+
+def _reader(pipe: IO[str], out: "queue.Queue[object]") -> None:
+    """Pump lines from the child's merged stdout into the queue."""
+    try:
+        for line in pipe:
+            out.put(line)
+    except (OSError, ValueError):
+        pass  # pipe closed mid-read; treat as EOF
+    out.put(_EOF)
+
+
+def run_command(
+    perm: "PermissionManager",
+    command: str,
+    timeout_s: int,
+    *,
+    shell: str = "",
+    on_line: Callable[[str], None] | None = None,
+) -> ToolResult:
+    """Shared runner (the git tool reuses it for real git invocations).
+
+    ``on_line`` receives each output line (rstripped) as it arrives; when
+    None, ``perm.on_output`` is used so the app layer's live echo applies
+    everywhere.
+    """
+    timeout_s = max(1, min(int(timeout_s), _MAX_TIMEOUT_S))
+    on_line = on_line or perm.on_output
+
+    if shell:
+        builder = _SHELLS.get(shell.strip().lower())
+        if builder is None:
+            choices = ", ".join(sorted(_SHELLS))
+            return ToolResult(False, f"Unknown shell '{shell}'. Choose one of: {choices}.")
+        popen_args: str | list[str] = builder(command)
+        use_shell = False
+    else:
+        popen_args = command
+        use_shell = True
+
+    kwargs: dict[str, Any] = {}
+    if sys.platform == "win32":
+        # Own process group so Ctrl+C in our console doesn't ambiguously
+        # signal the child; taskkill /T handles the whole tree regardless.
+        kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        kwargs["start_new_session"] = True  # killpg needs its own group
+
+    try:
+        proc = subprocess.Popen(
+            popen_args,
+            shell=use_shell,
+            cwd=perm.workspace,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,  # merged: live ordering stays sane
+            stdin=subprocess.DEVNULL,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            **kwargs,
+        )
+    except OSError as exc:
+        return ToolResult(False, f"Could not run command: {exc}")
+
+    lines: "queue.Queue[object]" = queue.Queue()
+    thread = threading.Thread(target=_reader, args=(proc.stdout, lines), daemon=True)
+    thread.start()
+
+    chunks: list[str] = []
+    collected = 0
+    deadline = time.monotonic() + timeout_s
+    eof = False
+    try:
+        while not eof:
+            if time.monotonic() > deadline:
+                _kill_tree(proc)
+                partial = "".join(chunks).rstrip()
+                tail = f"\nOutput before timeout:\n{partial}" if partial else ""
+                return ToolResult(
+                    False, f"Command timed out after {timeout_s}s: {command}{tail}"
+                )
+            try:
+                item = lines.get(timeout=0.2)
+            except queue.Empty:
+                continue
+            if item is _EOF:
+                eof = True
+                continue
+            line = str(item)
+            if collected < MAX_OUTPUT_CHARS:
+                chunks.append(line)
+                collected += len(line)
+            if on_line is not None:
+                try:
+                    on_line(line.rstrip("\r\n"))
+                except Exception:
+                    pass  # a UI echo bug must never kill the command
+    except KeyboardInterrupt:
+        # Ctrl+C cancels THIS command, not the agent turn.
+        _kill_tree(proc)
+        partial = "".join(chunks).rstrip()
+        tail = f"\nOutput before cancel:\n{partial}" if partial else ""
+        return ToolResult(False, f"Command cancelled by user (Ctrl+C): {command}{tail}")
+
+    proc.wait()
+    body = "".join(chunks).rstrip() or "(no output)"
+
+    # Make exit code failure explicit
+    success = proc.returncode == 0
+    status = "✓ Success" if success else f"✗ FAILED (exit code {proc.returncode})"
+
+    return ToolResult(success, f"{status}\n{body}")
+
+
+@register(
+    "run_command",
+    "Run a shell command in the workspace; output streams live to the user.",
+    {
+        "command": "the shell command to run",
+        "timeout": "(optional) seconds before the command is killed (default 60)",
+        "shell": "(optional) cmd, powershell, or bash (default: system shell)",
+    },
+    mutates=True,
+    types={"timeout": "integer"},
+)
+def _run_command(perm: "PermissionManager", args: dict[str, Any]) -> ToolResult:
+    command = str(args["command"]).strip()
+    if not command:
+        return ToolResult(False, "Command is empty.")
+    timeout_s = int_arg(args, "timeout", _DEFAULT_TIMEOUT_S, 1, _MAX_TIMEOUT_S)
+    perm.check_execute(command)
+    perm.confirm_action(CATEGORY_SHELL, command)
+    return run_command(perm, command, timeout_s, shell=str(args.get("shell", "")))

seedcode/tools/textio.py

@@ -0,0 +1,59 @@
+"""Encoding- and newline-preserving text file I/O for edit-path tools.
+
+Editing a latin-1 or CRLF file must not silently convert it to UTF-8/LF —
+that corrupts files the user never asked to touch. Every tool that edits an
+EXISTING file reads it through :func:`read_text_file` (which remembers the
+encoding and dominant newline) and writes it back through
+:func:`write_text_file` (which re-applies both). Matching and editing happen
+on ``\\n``-normalized text, so tools never worry about CRLF.
+
+Decoding order: UTF-8 with BOM ("utf-8-sig"), then strict UTF-8, then
+latin-1 (which cannot fail — every byte is valid — so nothing is ever lossy
+on the read side).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class TextFile:
+    """A decoded text file: normalized text plus how to write it back."""
+
+    text: str       # normalized to \n line endings
+    encoding: str   # "utf-8-sig" | "utf-8" | "latin-1"
+    newline: str    # "\r\n" | "\n"
+
+
+def read_text_file(path: Path) -> TextFile:
+    """Read and decode, remembering encoding and dominant newline.
+
+    Raises OSError on filesystem problems (callers turn that into a
+    friendly ToolResult).
+    """
+    raw = path.read_bytes()
+
+    if raw.startswith(b"\xef\xbb\xbf"):
+        encoding = "utf-8-sig"
+        text = raw.decode("utf-8-sig")
+    else:
+        try:
+            text = raw.decode("utf-8")
+            encoding = "utf-8"
+        except UnicodeDecodeError:
+            text = raw.decode("latin-1")
+            encoding = "latin-1"
+
+    crlf = text.count("\r\n")
+    bare_lf = text.count("\n") - crlf
+    newline = "\r\n" if crlf > bare_lf else "\n"
+
+    return TextFile(text=text.replace("\r\n", "\n"), encoding=encoding, newline=newline)
+
+
+def write_text_file(path: Path, tf: TextFile) -> None:
+    """Write normalized text back with the original newline and encoding."""
+    text = tf.text.replace("\n", tf.newline) if tf.newline != "\n" else tf.text
+    path.write_bytes(text.encode(tf.encoding))

seedcode/ui/__init__.py

@@ -0,0 +1,164 @@
+"""Rich-based presentation layer for Seed Code.
+
+Everything the user sees on screen is produced here so the visual identity —
+the Seed theme system, the startup dashboard, panels, spinners, and the
+interactive component library (selector, menus, dialogs, palette) — stays in
+one place. Business logic lives elsewhere and calls into these helpers.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Iterator
+
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.text import Text
+
+from ..core.models import AppConfig
+from .dashboard import render_dashboard
+from .renderer import StreamRenderer
+from .theme import SEED_THEME, rich_theme, set_active_theme
+
+__all__ = ["UI", "StreamRenderer", "SEED_THEME"]
+
+
+class UI:
+    """Thin wrapper around a Rich console with Seed Code styling helpers."""
+
+    def __init__(self) -> None:
+        self.console = Console(theme=rich_theme(), highlight=False)
+        # The active Live display (spinner/stream), if any — permission
+        # dialogs pause it so interactive input works cleanly.
+        self._live: Live | None = None
+        # Legacy Windows consoles (pre-Windows-Terminal cmd.exe with raster
+        # fonts) can't render ✔/✖ — fall back to pure-ASCII markers there.
+        if self.console.legacy_windows:
+            self._ok_mark, self._err_mark = "[OK]", "[X]"
+        else:
+            self._ok_mark, self._err_mark = "✔", "✖"
+        self._theme_pushed = False
+
+    def apply_theme(self, name: str) -> None:
+        """Switch the active theme everywhere (console + interactive styles).
+
+        Keeps exactly one theme overlay on the console so live-preview
+        arrowing through the picker never stacks themes.
+        """
+        set_active_theme(name)
+        if self._theme_pushed:
+            try:
+                self.console.pop_theme()
+            except Exception:
+                pass
+        self.console.push_theme(rich_theme(name))
+        self._theme_pushed = True
+
+    # --- primitives --------------------------------------------------------
+    def print(self, *args, **kwargs) -> None:
+        self.console.print(*args, **kwargs)
+
+    def blank(self) -> None:
+        self.console.print()
+
+    # --- startup -----------------------------------------------------------
+    def banner(self, config: AppConfig) -> None:
+        """Render the startup dashboard (shown exactly once at launch)."""
+        render_dashboard(self.console, config)
+
+    # --- chat rendering ----------------------------------------------------
+    @contextmanager
+    def thinking(self, label: str = "Thinking") -> Iterator[None]:
+        """Show a spinner while awaiting the first streamed token."""
+        spinner = Spinner("dots", text=Text(f" {label}...", style="seed.accent"))
+        with Live(
+            spinner, console=self.console, refresh_per_second=12, transient=True
+        ) as live:
+            self._live = live
+            try:
+                yield
+            finally:
+                self._live = None
+
+    @contextmanager
+    def streaming(self) -> Iterator["StreamRenderer"]:
+        """Provide a live, incrementally-updating markdown renderer."""
+        renderer = StreamRenderer(self.console)
+        with Live(
+            renderer.renderable(),
+            console=self.console,
+            refresh_per_second=15,
+            transient=False,
+        ) as live:
+            renderer.bind(live)
+            yield renderer
+        self.console.print()
+
+    # --- messaging ---------------------------------------------------------
+    def info(self, message: str) -> None:
+        self.console.print(Text(message, style="seed.text"))
+
+    def dim(self, message: str) -> None:
+        self.console.print(Text(message, style="seed.dim"))
+
+    def success(self, message: str) -> None:
+        self.console.print(Text(f"{self._ok_mark} {message}", style="seed.success"))
+
+    def warning(self, message: str) -> None:
+        self.console.print(Text(f"! {message}", style="seed.warning"))
+
+    def error(self, message: str) -> None:
+        self.console.print(Text(f"{self._err_mark} {message}", style="seed.error"))
+
+    def panel(self, body, title: str | None = None) -> None:
+        self.console.print(
+            Panel(
+                body,
+                title=title,
+                border_style="seed.primary",
+                title_align="left",
+                padding=(1, 2),
+            )
+        )
+
+    # --- action confirmation ------------------------------------------------
+    def _confirm(self, title: str, category_label: str, description: str) -> str:
+        """Ask the user to approve an action; returns 'y', 'a', or 'n'.
+
+        Shows the action details in a warning panel, then an interactive
+        Allow Once / Always Allow / Deny dialog. Pauses any live spinner so
+        the dialog renders cleanly, then resumes it. Cancelling (Esc or
+        Ctrl+C) counts as deny — never approve by accident.
+        """
+        from .dialog import permission_dialog
+
+        live = self._live
+        if live is not None:
+            live.stop()
+        try:
+            body = Text()
+            body.append(f"{category_label}\n", style="seed.warning")
+            body.append(description, style="seed.text")
+            self.console.print(
+                Panel(
+                    body,
+                    title=title,
+                    border_style="seed.warning",
+                    title_align="left",
+                    padding=(1, 2),
+                )
+            )
+            return permission_dialog()
+        finally:
+            if live is not None:
+                live.start()
+
+    def confirm_desktop(self, category_label: str, description: str) -> str:
+        """Approve a desktop action; returns 'y', 'a', or 'n'."""
+        return self._confirm("Desktop Control", category_label, description)
+
+    def confirm_tool_action(self, category_label: str, description: str) -> str:
+        """Approve a dangerous agent tool action; returns 'y', 'a', or 'n'."""
+        return self._confirm("Assist Action", category_label, description)

seedcode/ui/badges.py

@@ -0,0 +1,64 @@
+"""Status badges — the one consistent indicator vocabulary for Seed Code.
+
+Every screen that shows a status uses these markers so the language stays
+uniform:
+
+    ● Connected    ◐ Connecting    ○ Offline    ⚠ Error
+    ⟳ Loading      ✓ Ready         ✗ Failed
+
+Badges exist in two renderings: prompt_toolkit fragments (interactive
+selectors) and Rich markup (panels, dashboard).
+"""
+
+from __future__ import annotations
+
+from ..core.providers.base import (
+    STATUS_BAD_KEY,
+    STATUS_CONNECTED,
+    STATUS_NO_KEY,
+    STATUS_OFFLINE,
+    STATUS_UNKNOWN,
+)
+
+# badge key -> (marker, label, pt style class, rich style)
+BADGES: dict[str, tuple[str, str, str, str]] = {
+    "connected": ("●", "Connected", "class:sel.ok", "seed.success"),
+    "connecting": ("◐", "Connecting", "class:sel.warn", "seed.warning"),
+    "offline": ("○", "Offline", "class:sel.off", "seed.dim"),
+    "error": ("⚠", "Error", "class:sel.err", "seed.error"),
+    "loading": ("⟳", "Loading", "class:sel.warn", "seed.warning"),
+    "ready": ("✓", "Ready", "class:sel.ok", "seed.success"),
+    "failed": ("✗", "Failed", "class:sel.err", "seed.error"),
+}
+
+# Provider session status -> badge key.
+_STATUS_TO_BADGE = {
+    STATUS_CONNECTED: "connected",
+    STATUS_UNKNOWN: "ready",
+    STATUS_OFFLINE: "offline",
+    STATUS_NO_KEY: "offline",
+    STATUS_BAD_KEY: "error",
+}
+
+
+def badge_for_status(status: str) -> str:
+    """Map a provider connection status string to a badge key."""
+    return _STATUS_TO_BADGE.get(status, "offline")
+
+
+def badge_fragment(key: str) -> tuple[str, str]:
+    """(pt style, text) for one badge, e.g. ('class:sel.ok', '● Connected')."""
+    marker, label, style, _ = BADGES.get(key, BADGES["offline"])
+    return style, f"{marker} {label}"
+
+
+def badge_markup(key: str) -> str:
+    """Rich markup for one badge, e.g. '[seed.success]● Connected[/]'."""
+    marker, label, _, rich_style = BADGES.get(key, BADGES["offline"])
+    return f"[{rich_style}]{marker} {label}[/{rich_style}]"
+
+
+def badge_text(key: str) -> str:
+    """Plain '● Connected' text for one badge."""
+    marker, label, _, _ = BADGES.get(key, BADGES["offline"])
+    return f"{marker} {label}"

seedcode/ui/banner.py

@@ -0,0 +1,78 @@
+"""The Seed Code startup banner.
+
+A single branded screen: centered ASCII logo, wordmark, tagline and credits,
+followed by a divider. Every line is centered dynamically against the live
+terminal width (no hardcoded padding), rendered once at startup with plain
+Text — no panels, boxes or animation — so it displays identically in Windows
+Terminal, PowerShell, CMD and the VS Code terminal.
+"""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.text import Text
+
+from ..core.models import AppConfig
+
+_LOGO_LINES = [
+    r" ███████╗███████╗███████╗██████╗      ██████╗ ██████╗ ██████╗ ███████╗",
+    r" ██╔════╝██╔════╝██╔════╝██╔══██╗    ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+    r" ███████╗█████╗  █████╗  ██║  ██║    ██║     ██║   ██║██║  ██║█████╗ ",
+    r" ╚════██║██╔══╝  ██╔══╝  ██║  ██║    ██║     ██║   ██║██║  ██║██╔══╝ ",
+    r" ███████║███████╗███████╗██████╔╝    ╚██████╗╚██████╔╝██████╔╝███████╗",
+    r" ╚══════╝╚══════╝╚══════╝╚═════╝      ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+]
+
+# Pure-ASCII fallback for legacy Windows consoles (raster-font cmd.exe)
+# where the block/box-drawing glyphs above render as garbage.
+_LOGO_LINES_ASCII = [
+    r"  ____  _____ _____ ____     ____ ___  ____  _____ ",
+    r" / ___|| ____| ____|  _ \   / ___/ _ \|  _ \| ____|",
+    r" \___ \|  _| |  _| | | | | | |  | | | | | | |  _|  ",
+    r"  ___) | |___| |___| |_| | | |__| |_| | |_| | |___ ",
+    r" |____/|_____|_____|____/   \____\___/|____/|_____|",
+]
+
+# Monochrome green identity: bright bold logo, dimmer green for everything else.
+_LOGO_STYLE = "bold #2ecc71"
+_SOFT_STYLE = "#1cbf63"
+_DIM_STYLE = "#159a4f"
+
+_WORDMARK = "S E E D   C O D E"
+_TAGLINE = "Plant ideas. Grow code."
+_CREDIT_HEADING = "Created by"
+_CREDIT_NAME = "Al Shahriar Sowan"
+_CREDIT_TOOLS = "Vibe coded with GPT-5.5 + Claude Opus 4.8"
+
+
+def _centered(console: Console, text: str, style: str) -> None:
+    """Print one line centered against the current terminal width."""
+    pad = max((console.size.width - len(text)) // 2, 0)
+    line = Text(" " * pad + text, style=style)
+    line.no_wrap = True
+    console.print(line, overflow="crop")
+
+
+def render_banner(console: Console, config: AppConfig) -> None:
+    """Render the branded startup banner to ``console``."""
+    logo = _LOGO_LINES_ASCII if console.legacy_windows else _LOGO_LINES
+    console.print()
+    for line in logo:
+        _centered(console, line, _LOGO_STYLE)
+
+    console.print()
+    _centered(console, _WORDMARK, _LOGO_STYLE)
+    console.print()
+    _centered(console, _TAGLINE, _SOFT_STYLE)
+    console.print()
+    _centered(console, _CREDIT_HEADING, _DIM_STYLE)
+    _centered(console, _CREDIT_NAME, _SOFT_STYLE)
+    console.print()
+    _centered(console, _CREDIT_TOOLS, _DIM_STYLE)
+
+    console.print()
+    divider_char = "-" if console.legacy_windows else "─"
+    divider = Text(divider_char * console.size.width, style=_DIM_STYLE)
+    divider.no_wrap = True
+    console.print(divider, overflow="crop")
+    console.print()