seedcode-cli 6.1.5__py3-none-any.whl

seedcode/ui/dashboard.py

@@ -0,0 +1,197 @@
+"""The Seed Code startup dashboard.
+
+A single branded panel shown exactly once at application startup: the ASCII
+logo, tagline and credits on the left, and a live "Current Session" summary
+(provider, backend, model, status, context, history) on the right. Wide
+terminals get the two-column layout with a vertical divider; narrow terminals
+stack the session block below the logo. Every width decision is derived from
+the live console size and measured content — nothing is padded by hand.
+
+Rendering uses plain Rich primitives (Panel, Columns, Table.grid, Rule) so the
+dashboard displays identically in Windows Terminal, PowerShell, CMD, Linux and
+macOS terminals; legacy Windows consoles get pure-ASCII fallbacks.
+"""
+
+from __future__ import annotations
+
+from rich import box
+from rich.align import Align
+from rich.console import Console, Group, RenderableType
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.table import Table
+from rich.text import Text
+
+from .. import APP_NAME, TAGLINE, __version__
+from ..core.models import AppConfig
+from ..core.providers import PROVIDERS, provider_label
+from ..core.providers.base import STATUS_CONNECTED, STATUS_UNKNOWN
+
+_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"|____/|_____|_____|____/   \____\___/|____/|_____|",
+]
+
+_CREDIT = "Created by Al Shahriar Sowan"
+
+
+# --- session state ----------------------------------------------------------
+def _provider_ready(config: AppConfig) -> bool:
+    """True when the active provider is selected and has what it needs."""
+    provider = PROVIDERS.get(config.provider)
+    if provider is None:
+        return False
+    return not provider.requires_key or bool(config.get_api_key().strip())
+
+
+def _provider_value(config: AppConfig) -> str:
+    """Provider display label."""
+    if not _provider_ready(config):
+        return "Not selected"
+    return provider_label(config.provider)
+
+
+def _backend_value(config: AppConfig) -> str:
+    """The API family the active provider talks to (its own backend_label)."""
+    if not _provider_ready(config):
+        return "--"
+    if config.provider == "ollama":
+        return config.ollama_host
+    provider = PROVIDERS.get(config.provider)
+    if provider is not None and provider.backend_label:
+        return provider.backend_label
+    return f"{provider_label(config.provider)} API"
+
+
+def _model_value(config: AppConfig) -> str:
+    if not config.model:
+        return "Not selected"
+    if config.model == "auto":
+        return "Auto (best free model)"
+    return config.model
+
+
+def _status_value(config: AppConfig, marker: str) -> Text:
+    """Connection status from the provider's session cache (no network I/O)."""
+    if not config.is_configured():
+        return Text("Not configured", style="seed.dim")
+    provider = PROVIDERS.get(config.provider)
+    status = provider.status if provider is not None else STATUS_UNKNOWN
+    if status == STATUS_CONNECTED:
+        return Text(f"{marker} Connected", style="seed.success")
+    if status == STATUS_UNKNOWN:
+        # Configured but not probed yet — ready to chat, not yet verified.
+        return Text(f"{marker} Ready", style="seed.success")
+    return Text(f"{marker} {status}", style="seed.dim")
+
+
+def _context_value(config: AppConfig) -> str:
+    """Model context window — the live catalogue is not cached at startup."""
+    return "--"
+
+
+def _mode_value(config: AppConfig) -> str:
+    """The user-facing mode: Chat or Assist (never Agent/Desktop)."""
+    return "Assist" if config.agent_mode else "Chat"
+
+
+# --- blocks -----------------------------------------------------------------
+def _brand_block(legacy: bool) -> RenderableType:
+    """Left side: the exact ASCII logo with tagline and author centered under it."""
+    lines = _LOGO_LINES_ASCII if legacy else _LOGO_LINES
+    logo = Text("\n".join(lines), style="seed.primary", no_wrap=True, overflow="crop")
+    tagline = Text(TAGLINE, style="seed.accent")
+    credit = Text(_CREDIT, style="seed.dim")
+    return Group(
+        Align.center(logo),
+        Text(),
+        Align.center(tagline),
+        Text(),
+        Align.center(credit),
+    )
+
+
+def _session_block(config: AppConfig, legacy: bool) -> RenderableType:
+    """Right side: the dynamic Current Session summary."""
+    marker = "*" if legacy else "●"
+    grid = Table.grid(padding=(0, 1))
+    grid.add_column(style="seed.accent", no_wrap=True)
+    grid.add_column(style="seed.dim", no_wrap=True)
+    grid.add_column(style="seed.text", overflow="fold")
+    rows: list[tuple[str, RenderableType]] = [
+        ("Provider", Text(_provider_value(config))),
+        ("Backend", Text(_backend_value(config))),
+        ("Model", Text(_model_value(config))),
+        ("Mode", Text(_mode_value(config), style="seed.accent")),
+        ("Status", _status_value(config, marker)),
+        ("Context", Text(_context_value(config))),
+        ("History", Text("Enabled")),
+    ]
+    for label, value in rows:
+        grid.add_row(label, ":", value)
+    return Group(
+        Text("Current Session", style="seed.primary"),
+        Rule(style="seed.dim", characters="-" if legacy else "─"),
+        Text(),
+        grid,
+    )
+
+
+def _logo_width(legacy: bool) -> int:
+    lines = _LOGO_LINES_ASCII if legacy else _LOGO_LINES
+    return max(len(line) for line in lines)
+
+
+# --- dashboard --------------------------------------------------------------
+def render_dashboard(console: Console, config: AppConfig) -> None:
+    """Render the startup dashboard panel, adapting to the terminal width."""
+    legacy = console.legacy_windows
+    brand = _brand_block(legacy)
+    session = _session_block(config, legacy)
+
+    session_width = console.measure(session).maximum
+    # Panel borders/padding (6) + column gutters and divider (5), all fixed
+    # rendering overhead — the terminal width itself is never assumed.
+    needed = _logo_width(legacy) + session_width + 11
+
+    if console.size.width >= needed:
+        # Two columns with a single vertical divider between them: a Table
+        # whose outer edge is hidden renders only the column separator.
+        body: RenderableType = Table(
+            box=box.SQUARE,
+            show_header=False,
+            show_edge=False,
+            border_style="seed.dim",
+            padding=(0, 2),
+            pad_edge=False,
+        )
+        body.add_column()
+        body.add_column()
+        body.add_row(brand, session)
+    else:
+        # Narrow terminals: stack the session block below the logo.
+        body = Group(brand, Text(), Align.center(session))
+
+    console.print(
+        Panel(
+            body,
+            title=f"{APP_NAME} v{__version__}",
+            title_align="left",
+            border_style="seed.primary",
+            padding=(1, 2),
+        )
+    )

seedcode/ui/dialog.py

@@ -0,0 +1,62 @@
+"""Interactive dialogs: confirmations and permission prompts.
+
+Replaces every [Y]/[N] text prompt with an arrow-key choice list:
+
+    ❯ Allow Once
+      Always Allow
+      Deny
+
+Esc/Ctrl+C always mean the safe answer (deny/cancel) — an accidental
+cancel can never grant a permission.
+"""
+
+from __future__ import annotations
+
+from .selector import Option, select
+
+# Values returned by permission_dialog, aligned with the existing gates.
+ALLOW_ONCE = "y"
+ALLOW_ALWAYS = "a"
+DENY = "n"
+
+
+def permission_dialog(*, allow_always: bool = True) -> str:
+    """Ask Allow Once / Always Allow / Deny; returns 'y', 'a', or 'n'.
+
+    Cancelling (Esc/Ctrl+C) returns 'n' — never an approval.
+    """
+    options = [Option("Allow Once", ALLOW_ONCE, detail="approve this action only")]
+    if allow_always:
+        options.append(
+            Option("Always Allow", ALLOW_ALWAYS, detail="approve for this session")
+        )
+    options.append(Option("Deny", DENY, detail="block this action"))
+    result = select(
+        options,
+        searchable=False,
+        hint="↑↓ move   Enter confirm   Esc deny",
+    )
+    return result if result in (ALLOW_ONCE, ALLOW_ALWAYS, DENY) else DENY
+
+
+def confirm_dialog(
+    question: str,
+    *,
+    yes_label: str = "Yes",
+    no_label: str = "No",
+    danger: bool = False,
+) -> bool:
+    """A two-option yes/no dialog; Esc/cancel counts as No.
+
+    ``danger=True`` puts No first so Enter-mashing never destroys anything.
+    """
+    yes = Option(yes_label, True)
+    no = Option(no_label, False)
+    options = [no, yes] if danger else [yes, no]
+    result = select(
+        options,
+        title=question,
+        searchable=False,
+        hint="↑↓ move   Enter confirm   Esc cancel",
+    )
+    return bool(result)

seedcode/ui/fuzzy.py

@@ -0,0 +1,128 @@
+"""Fuzzy matching for the interactive components.
+
+Subsequence matching with a smallest-window score, tuned for picking model
+ids and command names:
+
+* ``cld`` matches **Cl**au**d**e
+* ``gpt55`` matches **GPT-5.5** (separators are skipped freely)
+* ``opus`` matches Claude **Opus**
+
+Scoring prefers, in order: exact substring at a word start, exact substring
+anywhere, then the tightest subsequence window with bonuses for matches at
+word boundaries and consecutive runs. Pure Python, no dependencies, fast
+enough for thousand-entry model lists (a single linear scan per candidate).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+_WORD_SEPARATORS = set(" -_./:@")
+
+
+@dataclass(slots=True)
+class FuzzyResult:
+    """Outcome of matching one query against one candidate string."""
+
+    matched: bool
+    score: float
+    positions: tuple[int, ...]  # candidate indices to highlight
+
+
+_NO_MATCH = FuzzyResult(False, float("-inf"), ())
+
+
+def _is_boundary(text: str, i: int) -> bool:
+    """True when ``text[i]`` starts a word (position 0, after a separator,
+    a digit after a letter, or an upper-case letter after a lower-case one)."""
+    if i == 0:
+        return True
+    prev, ch = text[i - 1], text[i]
+    if prev in _WORD_SEPARATORS:
+        return True
+    if ch.isdigit() and prev.isalpha():
+        return True
+    if ch.isupper() and prev.islower():
+        return True
+    return False
+
+
+def _subsequence_from(low_text: str, low_query: str, start: int) -> list[int] | None:
+    """Greedy left-to-right subsequence match beginning at/after ``start``."""
+    positions: list[int] = []
+    i = start
+    for qc in low_query:
+        j = low_text.find(qc, i)
+        if j < 0:
+            return None
+        positions.append(j)
+        i = j + 1
+    return positions
+
+
+def fuzzy_match(query: str, text: str) -> FuzzyResult:
+    """Match ``query`` against ``text``; empty queries match everything."""
+    if not query:
+        return FuzzyResult(True, 0.0, ())
+    if not text:
+        return _NO_MATCH
+
+    low_text = text.lower()
+    low_query = "".join(ch for ch in query.lower() if not ch.isspace())
+    if not low_query:
+        return FuzzyResult(True, 0.0, ())
+
+    # Fast paths: exact substring (best at a word boundary).
+    idx = low_text.find(low_query)
+    if idx >= 0:
+        span = tuple(range(idx, idx + len(low_query)))
+        bonus = 200.0 if _is_boundary(text, idx) else 100.0
+        return FuzzyResult(True, 1000.0 + bonus - idx * 0.5 - len(text) * 0.01, span)
+
+    # Subsequence: try anchoring at each occurrence of the first query char
+    # and keep the best-scoring window (bounded to a handful of anchors).
+    first = low_query[0]
+    best: FuzzyResult = _NO_MATCH
+    anchor = low_text.find(first)
+    tries = 0
+    while anchor >= 0 and tries < 8:
+        positions = _subsequence_from(low_text, low_query, anchor)
+        if positions is None:
+            break  # later anchors can only fail too
+        score = _score(text, positions)
+        if score > best.score:
+            best = FuzzyResult(True, score, tuple(positions))
+        anchor = low_text.find(first, anchor + 1)
+        tries += 1
+    return best
+
+
+def _score(text: str, positions: list[int]) -> float:
+    window = positions[-1] - positions[0] + 1
+    score = 500.0 - (window - len(positions)) * 10.0  # tighter window is better
+    for k, pos in enumerate(positions):
+        if _is_boundary(text, pos):
+            score += 15.0
+        if k > 0 and positions[k - 1] == pos - 1:
+            score += 5.0  # consecutive run
+    score -= positions[0] * 0.5  # earlier start is better
+    score -= len(text) * 0.01  # shorter candidates win ties
+    return score
+
+
+def fuzzy_filter(
+    query: str, items: list, key=lambda item: str(item)
+) -> list[tuple[object, FuzzyResult]]:
+    """Return ``(item, result)`` for matching items, best score first.
+
+    Sorting is stable for equal scores, so the caller's original order is
+    preserved within ties (important for grouped model lists).
+    """
+    scored: list[tuple[object, FuzzyResult]] = []
+    for item in items:
+        result = fuzzy_match(query, key(item))
+        if result.matched:
+            scored.append((item, result))
+    if query:
+        scored.sort(key=lambda pair: -pair[1].score)
+    return scored

seedcode/ui/layout.py

@@ -0,0 +1,54 @@
+"""Shared layout conventions: panels, key-value grids, shortcut tables.
+
+Every screen builds its content through these helpers so padding, borders
+and column styles stay identical across the app.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Sequence
+
+from rich.console import RenderableType
+from rich.panel import Panel
+from rich.table import Table
+
+
+def branded_panel(body: RenderableType, title: str | None = None) -> Panel:
+    """The standard Seed Code panel: primary border, left title, padding."""
+    return Panel(
+        body,
+        title=title,
+        border_style="seed.primary",
+        title_align="left",
+        padding=(1, 2),
+    )
+
+
+def kv_grid(rows: Iterable[tuple[str, RenderableType]]) -> Table:
+    """A two-column label/value grid (labels dimmed right, values plain)."""
+    grid = Table.grid(padding=(0, 3))
+    grid.add_column(style="seed.dim", justify="right", no_wrap=True)
+    grid.add_column(style="seed.text")
+    for label, value in rows:
+        grid.add_row(label, value)
+    return grid
+
+
+def columns_grid(rows: Sequence[Sequence[str]], styles: Sequence[str]) -> Table:
+    """An n-column grid with one style per column."""
+    grid = Table.grid(padding=(0, 2))
+    for style in styles:
+        grid.add_column(style=style)
+    for row in rows:
+        grid.add_row(*row)
+    return grid
+
+
+def shortcuts_grid(pairs: Sequence[tuple[str, str]]) -> Table:
+    """Keyboard-shortcut table: accent keys, plain descriptions."""
+    grid = Table.grid(padding=(0, 3))
+    grid.add_column(style="seed.accent", no_wrap=True)
+    grid.add_column(style="seed.text")
+    for key, action in pairs:
+        grid.add_row(key, action)
+    return grid

seedcode/ui/menu.py

@@ -0,0 +1,61 @@
+"""Action menus built on the interactive Selector.
+
+A menu is a selector over labelled actions: the main menu, the API-key
+menu, and every "pick one of these things to do" screen use this instead
+of numbered rows. Items may show a live status column and a badge.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Sequence
+
+from .selector import Option, select
+
+
+@dataclass(slots=True)
+class MenuItem:
+    """One menu action: a label, the value returned when chosen, and an
+    optional status column shown dimmed to the right."""
+
+    label: str
+    value: Any = None
+    status: str = ""
+    badge: str = ""
+    group: str = ""
+    disabled: bool = False
+
+    def __post_init__(self) -> None:
+        if self.value is None:
+            self.value = self.label
+
+
+def run_menu(
+    items: Sequence[MenuItem],
+    *,
+    title: str = "",
+    breadcrumbs: Sequence[str] = (),
+    hint: str = "",
+    initial: Any = None,
+    searchable: bool = True,
+) -> Any | None:
+    """Show an interactive menu; returns the chosen item's value or None."""
+    options = [
+        Option(
+            label=item.label,
+            value=item.value,
+            columns=(item.status,) if item.status else (),
+            badge=item.badge,
+            group=item.group,
+            disabled=item.disabled,
+        )
+        for item in items
+    ]
+    return select(
+        options,
+        title=title,
+        breadcrumbs=breadcrumbs,
+        hint=hint,
+        initial=initial,
+        searchable=searchable,
+    )

seedcode/ui/palette.py

@@ -0,0 +1,40 @@
+"""Command palette (Ctrl+K) — searchable actions, VS Code style.
+
+The palette is a fuzzy selector over registered actions, opened from the
+chat prompt with Ctrl+K. Actions are plain (label, value) pairs supplied
+by the app layer, so this module stays free of business logic.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Sequence
+
+from .selector import Option, select
+
+
+@dataclass(slots=True)
+class PaletteAction:
+    """One palette entry: display label, returned value, optional detail."""
+
+    label: str
+    value: Any
+    detail: str = ""
+    group: str = ""
+
+
+def command_palette(
+    actions: Sequence[PaletteAction],
+    *,
+    title: str = "Command Palette",
+) -> Any | None:
+    """Open the palette; returns the chosen action's value or None."""
+    return select(
+        [
+            Option(a.label, a.value, detail=a.detail, group=a.group)
+            for a in actions
+        ],
+        title=title,
+        hint="type to search   ↑↓ move   Enter run   Esc close",
+        max_rows=12,
+    )

seedcode/ui/progress.py

@@ -0,0 +1,41 @@
+"""Progress primitives: themed spinners and step indicators.
+
+Kept deliberately small — the heavy lifting is Rich's Live display, which
+already does minimal-redraw updates. This module provides the branded
+wrappers so every wait state looks the same.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Iterator
+
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.text import Text
+
+
+@contextmanager
+def spinner(console: Console, label: str = "Working") -> Iterator[None]:
+    """A transient themed spinner around a blocking operation."""
+    view = Spinner("dots", text=Text(f" {label}...", style="seed.accent"))
+    with Live(view, console=console, refresh_per_second=12, transient=True):
+        yield
+
+
+class StepProgress:
+    """Sequential step reporting: ⟳ while running, ✓/✗ when finished."""
+
+    def __init__(self, console: Console) -> None:
+        self._console = console
+
+    def start(self, label: str) -> None:
+        self._console.print(Text(f"⟳ {label}...", style="seed.warning"))
+
+    def done(self, label: str) -> None:
+        self._console.print(Text(f"✓ {label}", style="seed.success"))
+
+    def fail(self, label: str, reason: str = "") -> None:
+        suffix = f" — {reason}" if reason else ""
+        self._console.print(Text(f"✗ {label}{suffix}", style="seed.error"))

seedcode/ui/prompts.py

@@ -0,0 +1,16 @@
+"""Compatibility shim — the input component moved to :mod:`seedcode.ui.textbox`.
+
+Kept so existing imports (``from ..ui.prompts import read_line``) continue
+to work; new code should import from ``textbox`` directly.
+"""
+
+from __future__ import annotations
+
+from .textbox import prompt_label, read_line, read_text
+from .theme import pt_style
+
+# Legacy name: a static style object matching the current theme at import
+# time. Prefer pt_style() for live-theme correctness.
+PT_STYLE = pt_style()
+
+__all__ = ["PT_STYLE", "prompt_label", "read_line", "read_text", "pt_style"]

seedcode/ui/renderer.py

@@ -0,0 +1,36 @@
+"""Live streaming markdown renderer.
+
+Accumulates streamed tokens and re-renders them as live markdown so code blocks
+and formatting appear as the assistant types.
+"""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+
+
+class StreamRenderer:
+    """Accumulates streamed tokens and re-renders them as live markdown."""
+
+    def __init__(self, console: Console) -> None:
+        self._console = console
+        self._buffer = ""
+        self._live: Live | None = None
+
+    def bind(self, live: Live) -> None:
+        self._live = live
+
+    def renderable(self):
+        # Assistant output rendered as markdown for code blocks and formatting.
+        return Markdown(self._buffer or "", code_theme="ansi_dark")
+
+    def feed(self, chunk: str) -> None:
+        self._buffer += chunk
+        if self._live is not None:
+            self._live.update(self.renderable())
+
+    @property
+    def text(self) -> str:
+        return self._buffer