seedcode-cli 6.1.5__py3-none-any.whl

seedcode/commands/doctor.py

@@ -0,0 +1,152 @@
+"""/doctor — diagnose configuration, network, and provider health.
+
+Every check is best-effort and individually guarded: the doctor itself can
+never crash the app, and it never prints tracebacks — just a table of
+pass/warn/fail rows with actionable hints.
+"""
+
+from __future__ import annotations
+
+import json
+
+from rich.table import Table
+
+from ..core.providers import ProviderError, get_provider
+from ..utils.helpers import app_dir, config_path, history_dir
+from . import CommandContext, CommandResult, command
+
+_OK = "ok"
+_WARN = "warn"
+_FAIL = "fail"
+
+_STYLE = {_OK: "seed.success", _WARN: "seed.warning", _FAIL: "seed.error"}
+_MARK = {_OK: "PASS", _WARN: "WARN", _FAIL: "FAIL"}
+
+
+def _check_config_file() -> tuple[str, str]:
+    path = config_path()
+    if not path.exists():
+        return _WARN, "no config file yet (first run) — it is created on save"
+    try:
+        json.loads(path.read_text(encoding="utf-8"))
+        return _OK, str(path)
+    except (OSError, ValueError) as exc:
+        return _FAIL, f"config.json unreadable ({exc}) — defaults are used"
+
+
+def _check_storage() -> tuple[str, str]:
+    probe = history_dir() / ".doctor-probe"
+    try:
+        probe.write_text("ok", encoding="utf-8")
+        probe.unlink()
+        return _OK, str(app_dir())
+    except OSError as exc:
+        return _FAIL, f"cannot write to {app_dir()} ({exc}) — history/config won't persist"
+
+
+def _check_desktop(config) -> tuple[str, str]:
+    """Computer Engine availability (only a WARN when desktop mode is off)."""
+    from ..computer import is_available
+
+    ok, reason = is_available()
+    if ok:
+        state = "enabled" if config.desktop_mode else "available (off — /desktop on)"
+        return _OK, state
+    return (_FAIL if config.desktop_mode else _WARN), reason
+
+
+def _check_ocr() -> tuple[str, str]:
+    """OCR engine health — a real probe, not just an import check.
+
+    Only ever a WARN: OCR is one tier of the detection ladder (accessibility,
+    DOM inspection, and URL-driven workflows all come first), so a missing
+    engine narrows capability rather than breaking anything.
+    """
+    try:
+        from ..computer import ocr
+
+        ok, detail = ocr.status()
+    except Exception as exc:  # the doctor must never crash the app
+        return _WARN, f"could not probe OCR ({exc})"
+    if not ok:
+        return _WARN, detail
+    return _OK, ocr.version() or detail
+
+
+def _run_checks(config) -> list[tuple[str, str, str]]:
+    """Return (status, check name, detail) rows."""
+    rows: list[tuple[str, str, str]] = []
+
+    status, detail = _check_config_file()
+    rows.append((status, "Config file", detail))
+
+    status, detail = _check_storage()
+    rows.append((status, "Data directory", detail))
+
+    status, detail = _check_desktop(config)
+    rows.append((status, "Desktop control", detail))
+
+    status, detail = _check_ocr()
+    rows.append((status, "OCR engine", detail))
+
+    try:
+        provider = get_provider(config.provider)
+        rows.append((_OK, "Active provider", provider.label))
+    except ProviderError as exc:
+        rows.append((_FAIL, "Active provider", str(exc)))
+        return rows  # nothing else is checkable without a provider
+
+    provider.prepare(config)  # bind checks to the configured sub-backend
+    if provider.requires_key:
+        key = config.get_api_key(provider.id).strip()
+        if not key:
+            rows.append((_FAIL, "API key", "missing — run /apikey"))
+        else:
+            try:
+                result = provider.validate_key(key)
+                rows.append(
+                    (_OK if result.ok else _FAIL, "API key", result.message)
+                )
+            except Exception:  # validation itself must never explode
+                rows.append((_WARN, "API key", "could not be validated right now"))
+    else:
+        rows.append((_OK, "API key", "not required for this provider"))
+
+    if config.model:
+        rows.append((_OK, "Model", config.model))
+    else:
+        rows.append((_FAIL, "Model", "not selected — run /model"))
+
+    # Live connectivity: fetching the model list exercises DNS, TLS, and the
+    # provider endpoint in one real request.
+    try:
+        models = provider.list_models(config)
+        rows.append((_OK, "Provider reachable", f"{len(models)} models available"))
+    except ProviderError as exc:
+        rows.append((_FAIL, "Provider reachable", str(exc)))
+    except Exception as exc:
+        rows.append((_FAIL, "Provider reachable", f"unexpected error: {exc}"))
+
+    return rows
+
+
+@command("doctor", "Diagnose configuration, network, and provider health")
+def _doctor(ctx: CommandContext, arg: str) -> CommandResult:
+    with ctx.ui.thinking("Running diagnostics"):
+        rows = _run_checks(ctx.config)
+
+    table = Table.grid(padding=(0, 2))
+    table.add_column(justify="left", no_wrap=True)
+    table.add_column(style="seed.text", no_wrap=True)
+    table.add_column(style="seed.dim")
+    for status, name, detail in rows:
+        table.add_row(
+            f"[{_STYLE[status]}]{_MARK[status]}[/{_STYLE[status]}]", name, detail
+        )
+    ctx.ui.panel(table, title="Doctor")
+
+    if any(status == _FAIL for status, _, _ in rows):
+        ctx.ui.dim("Fix the FAIL rows above; run /doctor again to re-check.")
+    else:
+        ctx.ui.success("Everything looks healthy.")
+    return CommandResult()

seedcode/commands/help.py

@@ -0,0 +1,61 @@
+"""Informational commands: /help, /version, /shortcuts."""
+
+from __future__ import annotations
+
+from .. import __version__
+from ..ui.layout import shortcuts_grid
+from ..ui.selector import Option, select
+from . import CommandContext, CommandResult, _REGISTRY, command
+
+SHORTCUTS: tuple[tuple[str, str], ...] = (
+    ("Ctrl+K", "Command Palette"),
+    ("Ctrl+P", "Project File Search"),
+    ("Ctrl+L", "Clear Screen"),
+    ("Ctrl+R", "Search History"),
+    ("Ctrl+/", "Keyboard Shortcuts"),
+    ("Ctrl+,", "Settings"),
+    ("Tab / Shift+Tab", "Next / Previous item"),
+    ("↑ ↓", "Move selection"),
+    ("Home / End", "Jump to first / last"),
+    ("PageUp / PageDown", "Scroll a page"),
+    ("Enter", "Confirm"),
+    ("Esc", "Back / Cancel"),
+    ("Ctrl+C", "Cancel current menu or response"),
+)
+
+
+def show_shortcuts(ui) -> None:
+    """Render the keyboard-shortcut reference panel."""
+    ui.panel(shortcuts_grid(SHORTCUTS), title="Keyboard Shortcuts")
+
+
+@command("help", "Show available commands")
+def _help(ctx: CommandContext, arg: str) -> CommandResult:
+    # The command list itself is a searchable selector: Enter shows the
+    # command's help line, Esc closes.
+    options = [
+        Option(f"/{name}", value=name, detail=help_text)
+        for name, (_, help_text) in sorted(_REGISTRY.items())
+    ]
+    chosen = select(
+        options,
+        title="Commands",
+        hint="type to filter   ↑↓ move   Esc close",
+        max_rows=14,
+    )
+    if chosen is not None:
+        _, help_text = _REGISTRY[str(chosen)]
+        ctx.ui.info(f"/{chosen} — {help_text}")
+    return CommandResult()
+
+
+@command("shortcuts", "Show keyboard shortcuts", aliases=("keys",))
+def _shortcuts(ctx: CommandContext, arg: str) -> CommandResult:
+    show_shortcuts(ctx.ui)
+    return CommandResult()
+
+
+@command("version", "Show the Seed Code version")
+def _version(ctx: CommandContext, arg: str) -> CommandResult:
+    ctx.ui.info(f"Seed Code v{__version__}")
+    return CommandResult()

seedcode/commands/history.py

@@ -0,0 +1,365 @@
+"""Data-inspection and settings commands: /history, /config, /settings.
+
+The settings screen is a nested interactive tree with breadcrumbs
+(Settings › Providers › FreeModel Claude); the history browser is a
+searchable selector where Enter opens a transcript and Delete removes it.
+"""
+
+from __future__ import annotations
+
+from pydantic import ValidationError
+from rich.table import Table
+from rich.text import Text
+
+from ..config import save_config
+from ..core.providers import PROVIDERS, ProviderError, get_provider, provider_label
+from ..memory import delete_session, list_sessions, load_session
+from ..tools import PermissionMode
+from ..ui.selector import Option, select
+from ..ui.textbox import read_text
+from ..ui.tree import TreeNode, navigate
+from . import CommandContext, CommandResult, command
+
+# Settings editable via /settings, with a tiny parser per value type.
+# (provider/model have their own dedicated commands with live validation.)
+_SETTINGS = {
+    "username": str,
+    "stream": bool,
+    "ollama_host": str,
+    "max_tokens": int,
+}
+
+
+# --- history browser ---------------------------------------------------------
+
+
+def _show_transcript(ui, provider_id: str, sid: str) -> None:
+    """Render one saved session's messages."""
+    messages = load_session(provider_id, sid)
+    if not messages:
+        ui.dim("This session is empty or could not be read.")
+        return
+    body = Text()
+    for msg in messages[:60]:
+        role = str(msg.get("role", "?"))
+        content = str(msg.get("content", "")).strip()
+        if not content:
+            continue
+        style = "seed.primary" if role == "user" else "seed.accent"
+        body.append(f"{role}: ", style=style)
+        snippet = content if len(content) <= 500 else content[:500] + " …"
+        body.append(snippet + "\n\n", style="seed.text")
+    if len(messages) > 60:
+        body.append(f"({len(messages) - 60} more messages)", style="seed.dim")
+    ui.panel(body, title=f"Session {sid}")
+
+
+def browse_history(ui, config) -> None:
+    """Interactive history: search, Enter opens, Delete removes."""
+    provider_id = config.provider
+    while True:
+        sessions = list_sessions(provider_id)
+        if not sessions:
+            ui.dim(f"No saved sessions for {provider_label(provider_id)} yet.")
+            return
+
+        def remove(option: Option) -> bool:
+            return delete_session(provider_id, str(option.value))
+
+        chosen = select(
+            [
+                Option(sid, value=sid, detail=f"{count} messages")
+                for sid, count in sessions
+            ],
+            title=f"History — {provider_label(provider_id)}",
+            hint="↑↓ move   Enter open   Delete remove   Esc back",
+            on_delete=remove,
+            max_rows=14,
+        )
+        if chosen is None:
+            return
+        _show_transcript(ui, provider_id, str(chosen))
+
+
+@command("history", "Browse the active provider's saved sessions")
+def _history(ctx: CommandContext, arg: str) -> CommandResult:
+    # History is per provider: only the active backend's sessions are shown.
+    browse_history(ctx.ui, ctx.config)
+    return CommandResult()
+
+
+# --- configuration display ---------------------------------------------------
+
+
+@command("config", "Show current configuration")
+def _config(ctx: CommandContext, arg: str) -> CommandResult:
+    table = Table.grid(padding=(0, 3))
+    table.add_column(style="seed.dim", justify="right")
+    table.add_column(style="seed.text")
+    table.add_row("Active provider", provider_label(ctx.config.provider))
+    table.add_row("Model", ctx.config.model or "(none — run /model)")
+    table.add_row("", "")
+    # Every provider keeps its own key + model; switching never loses them.
+    for provider in PROVIDERS.values():
+        entry = ctx.config.providers.get(provider.id)
+        saved_model = entry.model if entry else ""
+        if provider.requires_key:
+            table.add_row(f"{provider.label} key", ctx.config.masked_key(provider.id))
+        table.add_row(f"{provider.label} model", saved_model or "(none)")
+    table.add_row("", "")
+    table.add_row("Ollama host", ctx.config.ollama_host)
+    table.add_row("Theme", ctx.config.theme)
+    table.add_row("Username", ctx.config.username)
+    table.add_row("Streaming", "on" if ctx.config.stream else "off")
+    table.add_row("Max tokens", str(ctx.config.max_tokens))
+    ctx.ui.panel(table, title="Configuration")
+    return CommandResult()
+
+
+# --- setting application -----------------------------------------------------
+
+
+def apply_setting(ui, config, name: str, raw: str) -> None:
+    """Parse, validate, apply, and persist one setting change.
+
+    Global settings first; anything else routes to the ACTIVE provider's own
+    settings (e.g. OpenRouter 'mode', Ollama 'host').
+    """
+    kind = _SETTINGS.get(name)
+    if kind is None:
+        try:
+            provider = get_provider(config.provider)
+        except ProviderError:
+            provider = None
+        if provider is not None and name in provider.extra_settings(config):
+            ok, message = provider.set_extra_setting(config, name, raw)
+            if ok:
+                save_config(config)
+                ui.success(message)
+            else:
+                ui.warning(message)
+            return
+        known = sorted(_SETTINGS)
+        if provider is not None:
+            known += sorted(provider.extra_settings(config))
+        ui.warning(f"Unknown setting: {name}. Available: {', '.join(known)}")
+        return
+
+    value: object = raw
+    if kind is bool:
+        lowered = raw.lower()
+        if lowered not in ("on", "off", "true", "false"):
+            ui.warning(f"'{name}' expects on/off.")
+            return
+        value = lowered in ("on", "true")
+    elif kind is int:
+        try:
+            value = int(raw)
+        except ValueError:
+            ui.warning(f"'{name}' expects a number.")
+            return
+        if value < 1:
+            ui.warning(f"'{name}' must be at least 1.")
+            return
+
+    try:
+        setattr(config, name, value)
+    except ValidationError:
+        ui.warning(f"Invalid value for '{name}': {raw}")
+        return
+    save_config(config)
+    ui.success(f"{name} set to {value}")
+
+
+# --- interactive settings tree ----------------------------------------------
+
+
+def _edit_text_setting(ui, config, name: str, current: str) -> bool:
+    value = read_text(f"{name} > ", default=current)
+    if value is None or value == current:
+        return True
+    apply_setting(ui, config, name, value)
+    return True
+
+
+def _toggle_setting(ui, config, name: str, current: bool) -> bool:
+    apply_setting(ui, config, name, "off" if current else "on")
+    return True
+
+
+def _choose_permission(ui, config) -> bool:
+    detail = {
+        PermissionMode.READ_ONLY: "inspect only — no writes, no commands",
+        PermissionMode.WORKSPACE: "edit and run inside this directory only",
+        PermissionMode.DESKTOP: "control this computer (mouse, keyboard, apps)",
+        PermissionMode.FULL_SYSTEM: "no path restriction + sensitive actions (use with care)",
+    }
+    chosen = select(
+        [Option(mode.label, mode.value_str, detail=detail[mode]) for mode in PermissionMode],
+        title="Permission Level",
+        initial=config.permission_mode,
+        searchable=False,
+        hint="↑↓ move   Enter select   Esc back",
+    )
+    if chosen is not None:
+        config.permission_mode = str(chosen)
+        save_config(config)
+        ui.success(f"Permission mode set to {PermissionMode.parse(str(chosen)).label}.")
+    return True
+
+
+def _provider_settings_nodes(ui, config, provider) -> list[TreeNode]:
+    """One editable node per provider-specific extra setting."""
+    nodes: list[TreeNode] = []
+    for name in provider.extra_settings(config):
+        def edit(n=name, p=provider) -> bool:
+            current = p.extra_settings(config).get(n, "")
+            value = read_text(f"{n} > ", default=current)
+            if value is None or value == current:
+                return True
+            ok, message = p.set_extra_setting(config, n, value)
+            if ok:
+                save_config(config)
+                ui.success(message)
+            else:
+                ui.warning(message)
+            return True
+
+        nodes.append(
+            TreeNode(
+                name,
+                action=edit,
+                status_fn=lambda n=name, p=provider: p.extra_settings(config).get(n, ""),
+            )
+        )
+    if not nodes:
+        nodes.append(TreeNode(f"{provider.label} has no extra settings", action=lambda: True))
+    return nodes
+
+
+def settings_menu(ui, config) -> None:
+    """Interactive nested settings with breadcrumbs.
+
+    Settings › Providers › <provider> reaches each backend's own options;
+    Appearance holds the theme picker; History, Models, Keyboard and
+    Advanced hold the rest.
+    """
+    from .theme import pick_theme
+
+    def providers_nodes() -> list[TreeNode]:
+        nodes = []
+        for provider in PROVIDERS.values():
+            entry = config.providers.get(provider.id)
+            model = entry.model if entry and entry.model else "no model"
+            nodes.append(
+                TreeNode(
+                    provider.label,
+                    build=lambda p=provider: _provider_settings_nodes(ui, config, p),
+                    status=model,
+                )
+            )
+        return nodes
+
+    def clear_history() -> bool:
+        from ..ui.dialog import confirm_dialog
+
+        sessions = list_sessions(config.provider)
+        if not sessions:
+            ui.dim("No saved sessions to clear.")
+            return True
+        if confirm_dialog(
+            f"Delete all {len(sessions)} saved sessions for "
+            f"{provider_label(config.provider)}?",
+            yes_label="Delete All",
+            no_label="Keep",
+            danger=True,
+        ):
+            removed = sum(
+                1 for sid, _ in sessions if delete_session(config.provider, sid)
+            )
+            ui.success(f"Removed {removed} sessions.")
+        else:
+            ui.dim("History kept.")
+        return True
+
+    def show_shortcuts() -> bool:
+        from .help import show_shortcuts as render
+
+        render(ui)
+        return True
+
+    root = TreeNode(
+        "Settings",
+        build=lambda: [
+            TreeNode("Providers", build=providers_nodes,
+                     status_fn=lambda: provider_label(config.provider)),
+            TreeNode(
+                "Appearance",
+                build=lambda: [
+                    TreeNode("Theme", action=lambda: (pick_theme(ui, config), True)[1],
+                             status_fn=lambda: config.theme),
+                    TreeNode(
+                        "Streaming",
+                        action=lambda: _toggle_setting(ui, config, "stream", config.stream),
+                        status_fn=lambda: "on" if config.stream else "off",
+                    ),
+                ],
+            ),
+            TreeNode(
+                "History",
+                build=lambda: [
+                    TreeNode("Browse Sessions",
+                             action=lambda: (browse_history(ui, config), True)[1]),
+                    TreeNode("Clear History", action=clear_history),
+                ],
+            ),
+            TreeNode(
+                "Models",
+                build=lambda: [
+                    TreeNode(
+                        "Max Tokens",
+                        action=lambda: _edit_text_setting(
+                            ui, config, "max_tokens", str(config.max_tokens)
+                        ),
+                        status_fn=lambda: str(config.max_tokens),
+                    ),
+                ],
+            ),
+            TreeNode("Keyboard", build=lambda: [
+                TreeNode("Show Shortcuts", action=show_shortcuts),
+            ]),
+            TreeNode(
+                "Advanced",
+                build=lambda: [
+                    TreeNode(
+                        "Username",
+                        action=lambda: _edit_text_setting(
+                            ui, config, "username", config.username
+                        ),
+                        status_fn=lambda: config.username,
+                    ),
+                    TreeNode(
+                        "Ollama Host",
+                        action=lambda: _edit_text_setting(
+                            ui, config, "ollama_host", config.ollama_host
+                        ),
+                        status_fn=lambda: config.ollama_host,
+                    ),
+                    TreeNode("Permission Mode",
+                             action=lambda: _choose_permission(ui, config),
+                             status_fn=lambda: config.permission_mode),
+                ],
+            ),
+        ],
+    )
+    navigate(root)
+
+
+@command("settings", "Open interactive settings (or /settings <name> <value>)")
+def _settings(ctx: CommandContext, arg: str) -> CommandResult:
+    parts = arg.split(maxsplit=1)
+    if len(parts) >= 2:
+        apply_setting(ctx.ui, ctx.config, parts[0].lower(), parts[1].strip())
+        return CommandResult()
+    settings_menu(ctx.ui, ctx.config)
+    return CommandResult()

seedcode/commands/palette.py

@@ -0,0 +1,100 @@
+"""/palette and /files — the command palette (Ctrl+K) and project search (Ctrl+P).
+
+The palette lists every high-level action (Change Provider, Change Model,
+Settings, History, Doctor, Clear History, About, Theme, Assist Mode, Search
+Projects) as a fuzzy-searchable selector, VS Code style. The chat REPL
+binds Ctrl+K / Ctrl+P to these commands so they open mid-conversation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..ui.palette import PaletteAction, command_palette
+from ..ui.searchbox import search_files
+from . import CommandContext, CommandResult, command, dispatch
+
+
+def _actions(ctx: CommandContext) -> list[PaletteAction]:
+    assist_on = ctx.config.agent_mode
+    return [
+        PaletteAction("Change Provider", "/provider", detail="switch AI backend"),
+        PaletteAction("Change Model", "/model", detail="browse the live catalogue"),
+        PaletteAction("Settings", "/settings", detail="interactive settings"),
+        PaletteAction("History", "/history", detail="browse saved sessions"),
+        PaletteAction("Doctor", "/doctor", detail="diagnose configuration and network"),
+        PaletteAction("Clear History", "__clear_history__",
+                      detail="delete this provider's saved sessions"),
+        PaletteAction("About", "/about", detail="version and credits"),
+        PaletteAction("Theme", "/theme", detail="pick a colour theme (live preview)"),
+        PaletteAction(
+            "Assist Mode",
+            f"/assist {'off' if assist_on else 'on'}",
+            detail=f"currently {'on' if assist_on else 'off'}",
+        ),
+        PaletteAction("Search Projects", "__files__", detail="fuzzy project file search"),
+        PaletteAction("Keyboard Shortcuts", "/shortcuts", detail="key reference"),
+        PaletteAction("Clear Screen", "/clear", detail="wipe the terminal"),
+    ]
+
+
+def open_palette(ctx: CommandContext) -> CommandResult:
+    """Open the command palette and run the chosen action."""
+    chosen = command_palette(_actions(ctx))
+    if chosen is None:
+        return CommandResult()
+    if chosen == "__files__":
+        return open_file_search(ctx)
+    if chosen == "__clear_history__":
+        from ..memory import delete_session, list_sessions
+        from ..ui.dialog import confirm_dialog
+
+        sessions = list_sessions(ctx.config.provider)
+        if not sessions:
+            ctx.ui.dim("No saved sessions to clear.")
+            return CommandResult()
+        if confirm_dialog(
+            f"Delete all {len(sessions)} saved sessions?",
+            yes_label="Delete All",
+            no_label="Keep",
+            danger=True,
+        ):
+            removed = sum(
+                1 for sid, _ in sessions if delete_session(ctx.config.provider, sid)
+            )
+            ctx.ui.success(f"Removed {removed} sessions.")
+        return CommandResult()
+    return dispatch(ctx, str(chosen))
+
+
+def open_file_search(ctx: CommandContext) -> CommandResult:
+    """Open the Ctrl+P project file search; show the chosen file."""
+    chosen = search_files(Path.cwd())
+    if chosen is None:
+        return CommandResult()
+    path = Path.cwd() / chosen
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        ctx.ui.error(f"Cannot open {chosen}: {exc}")
+        return CommandResult()
+    lines = text.splitlines()
+    from rich.syntax import Syntax
+
+    snippet = "\n".join(lines[:80])
+    body = Syntax(snippet, Syntax.guess_lexer(str(path), snippet),
+                  theme="ansi_dark", line_numbers=True)
+    ctx.ui.panel(body, title=str(chosen))
+    if len(lines) > 80:
+        ctx.ui.dim(f"({len(lines) - 80} more lines — showing the first 80)")
+    return CommandResult()
+
+
+@command("palette", "Open the command palette (Ctrl+K)", aliases=("commands",))
+def _palette(ctx: CommandContext, arg: str) -> CommandResult:
+    return open_palette(ctx)
+
+
+@command("files", "Search project files (Ctrl+P)", aliases=("search",))
+def _files(ctx: CommandContext, arg: str) -> CommandResult:
+    return open_file_search(ctx)