seedcode-cli 6.1.5__py3-none-any.whl

seedcode/cli.py

@@ -0,0 +1,95 @@
+"""Seed Code command-line entry point (``seedcode``).
+
+Thin wrapper: prepares the Windows console, builds the UI, hands off to the
+application controller (:mod:`seedcode.app`), and provides the final safety
+net so a stray exception is shown as a friendly message rather than a
+traceback. Heavy imports are deferred into :func:`main` so ``--version``
+(used by installers to verify the install) answers instantly.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def _prepare_console() -> None:
+    """Make stdout/stderr UTF-8-safe, primarily for Windows.
+
+    Interactive Windows consoles accept Unicode natively (PEP 528), but a
+    redirected stream falls back to the legacy ANSI code page (e.g. cp1252),
+    where the banner's box-drawing characters would raise UnicodeEncodeError.
+    Reconfiguring to UTF-8 with ``errors="replace"`` makes output safe in
+    Windows Terminal, PowerShell, CMD, and when piped to files.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
+        except (AttributeError, OSError, ValueError):
+            pass  # exotic streams (tests, embedders) — never fatal
+
+
+_HELP = """\
+Seed Code - a terminal-based AI coding assistant. Plant ideas. Grow code.
+
+Usage:
+  seedcode              Start the interactive app (chat + menu)
+  seedcode --version    Print the version and exit
+  seedcode --help       Show this help and exit
+
+Inside the app, type /help for commands: /provider, /model, /agent,
+/permission, /settings, /doctor, and more.
+
+Docs: https://github.com/Alshahriar-07/seedcode-cli
+"""
+
+
+def main() -> None:
+    """Console-script entry point (``seedcode``)."""
+    # --version/--help must work non-interactively and fast (installers and
+    # scripts verify with them), so handle both before any UI, config, or
+    # logging work happens.
+    if len(sys.argv) > 1 and sys.argv[1] in ("--version", "-V"):
+        from . import __version__
+
+        print(f"Seed Code v{__version__}")
+        return
+    if len(sys.argv) > 1 and sys.argv[1] in ("--help", "-h"):
+        print(_HELP)
+        return
+
+    _prepare_console()
+
+    from .utils.logger import get_logger, setup_logging
+
+    setup_logging()
+    log = get_logger("cli")
+
+    from . import __version__
+
+    log.info(
+        "Seed Code v%s starting (python %s on %s)",
+        __version__,
+        sys.version.split()[0],
+        sys.platform,
+    )
+
+    from .app import run
+    from .ui import UI
+
+    ui = UI()
+    try:
+        run(ui)
+        log.info("Clean exit.")
+    except KeyboardInterrupt:
+        ui.blank()
+        ui.dim("Interrupted.")
+        log.info("Exited via Ctrl+C.")
+    except Exception as exc:  # final safety net — never show a traceback
+        log.exception("Fatal error")
+        ui.error(f"Fatal error: {exc}")
+        ui.dim("Details were logged to ~/.seedcode/logs/seedcode.log")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

seedcode/commands/__init__.py

@@ -0,0 +1,81 @@
+"""Slash-command system for the Seed Code REPL.
+
+Commands are registered in a table and dispatched by name. Each handler receives
+the live :class:`CommandContext` and returns a :class:`CommandResult` telling the
+REPL whether to keep looping or exit. Handlers live in the sibling modules
+(:mod:`help`, :mod:`clear`, :mod:`history`, :mod:`about`) and are imported at the
+bottom of this file so their ``@command`` decorators populate the registry.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+
+@dataclass
+class CommandContext:
+    """Everything a command handler might need to act on."""
+
+    ui: "object"  # UI; typed loosely to avoid an import cycle.
+    config: "object"  # AppConfig
+    engine: "object"  # ChatEngine
+
+
+@dataclass
+class CommandResult:
+    """Signals control flow back to the REPL."""
+
+    should_exit: bool = False
+    handled: bool = True
+
+
+Handler = Callable[[CommandContext, str], CommandResult]
+
+# name -> (handler, help text). Populated via the @command decorator below.
+_REGISTRY: dict[str, tuple[Handler, str]] = {}
+_ALIASES: dict[str, str] = {}
+
+
+def command(
+    name: str, help_text: str, aliases: tuple[str, ...] = ()
+) -> Callable[[Handler], Handler]:
+    def wrap(func: Handler) -> Handler:
+        _REGISTRY[name] = (func, help_text)
+        for alias in aliases:
+            _ALIASES[alias] = name
+        return func
+
+    return wrap
+
+
+def is_command(text: str) -> bool:
+    return text.strip().startswith("/")
+
+
+def dispatch(ctx: CommandContext, text: str) -> CommandResult:
+    """Route ``text`` (a '/...' string) to its handler."""
+    parts = text.strip().split(maxsplit=1)
+    name = parts[0].lstrip("/").lower()
+    arg = parts[1] if len(parts) > 1 else ""
+    name = _ALIASES.get(name, name)
+
+    entry = _REGISTRY.get(name)
+    if entry is None:
+        ctx.ui.warning(f"Unknown command: /{name}. Type /help for the list.")
+        return CommandResult(handled=True)
+    return entry[0](ctx, arg)
+
+
+# Import handler modules for their registration side effects. Deferred to the
+# bottom so ``command`` / ``_REGISTRY`` already exist when the handlers load.
+from . import about, agent, assist, clear, desktop, doctor, help, history, palette, provider, theme  # noqa: E402,F401
+
+__all__ = [
+    "CommandContext",
+    "CommandResult",
+    "command",
+    "dispatch",
+    "is_command",
+    "_REGISTRY",
+]

seedcode/commands/about.py

@@ -0,0 +1,34 @@
+"""Meta commands: /about, /exit."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from .. import TAGLINE, __author__, __version__
+from ..core.providers import provider_label
+from . import CommandContext, CommandResult, command
+
+
+def show_about(ui, config) -> None:
+    """Render the About panel (shared by /about and the main menu)."""
+    body = Text()
+    body.append("Seed Code\n", style="seed.primary")
+    body.append(f"{TAGLINE}\n\n", style="seed.accent")
+    body.append(f"Version   {__version__}\n", style="seed.text")
+    body.append(f"Author    {__author__}\n", style="seed.text")
+    body.append(f"Provider  {provider_label(config.provider)}\n", style="seed.text")
+    body.append(f"Model     {config.model or '(none)'}\n\n", style="seed.text")
+    body.append("A premium terminal-based AI coding assistant.", style="seed.dim")
+    ui.panel(body, title="About")
+
+
+@command("about", "About Seed Code")
+def _about(ctx: CommandContext, arg: str) -> CommandResult:
+    show_about(ctx.ui, ctx.config)
+    return CommandResult()
+
+
+@command("exit", "Leave the chat (back to the main menu)", aliases=("quit", "q", "menu"))
+def _exit(ctx: CommandContext, arg: str) -> CommandResult:
+    ctx.ui.dim("Back to the menu.")
+    return CommandResult(should_exit=True)

seedcode/commands/agent.py

@@ -0,0 +1,94 @@
+"""Legacy commands: /agent and /permission.
+
+The old Agent Mode was merged into Assist Mode — /agent now routes there.
+/permission keeps its dedicated interactive picker; /index and /tools stay
+as inspection commands.
+"""
+
+from __future__ import annotations
+
+from ..config import save_config
+from ..tools import TOOL_REGISTRY, PermissionManager, PermissionMode
+from ..tools.filesystem import build_index
+from ..ui.selector import Option, select
+from . import CommandContext, CommandResult, command
+from .assist import disable_assist, enable_assist
+
+
+@command("agent", "Legacy alias for Assist Mode. Usage: /agent [on|off]")
+def _agent(ctx: CommandContext, arg: str) -> CommandResult:
+    raw = arg.strip().lower()
+    if raw in ("on", "off"):
+        enable = raw == "on"
+    elif not raw:
+        enable = not ctx.config.agent_mode  # bare /agent toggles
+    else:
+        ctx.ui.warning("Usage: /agent [on|off]")
+        return CommandResult()
+
+    # Agent Mode was merged into Assist Mode — route there transparently.
+    ctx.ui.dim("(/agent is now Assist Mode)")
+    if enable:
+        enable_assist(ctx.ui, ctx.config)
+    else:
+        disable_assist(ctx.ui, ctx.config)
+    return CommandResult()
+
+
+@command("permission", "Show or set the Assist permission mode", aliases=("perm",))
+def _permission(ctx: CommandContext, arg: str) -> CommandResult:
+    raw = arg.strip()
+    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)",
+    }
+    if not raw:
+        current = PermissionMode.parse(ctx.config.permission_mode)
+        chosen = select(
+            [
+                Option(mode.label, mode.value_str, detail=detail[mode])
+                for mode in PermissionMode
+            ],
+            title="Permission Level",
+            initial=current.value_str,
+            searchable=False,
+            hint="↑↓ move   Enter select   Esc keep current",
+        )
+        if chosen is None:
+            ctx.ui.dim(f"Permission unchanged ({current.label}).")
+            return CommandResult()
+        raw = str(chosen)
+
+    try:
+        mode = PermissionMode.parse(raw)
+    except ValueError as exc:
+        ctx.ui.warning(str(exc))
+        return CommandResult()
+    ctx.config.permission_mode = mode.value_str
+    save_config(ctx.config)
+    ctx.ui.success(f"Permission mode set to {mode.label}.")
+    return CommandResult()
+
+
+@command("index", "Show a compact tree of the current project")
+def _index(ctx: CommandContext, arg: str) -> CommandResult:
+    perm = PermissionManager(mode=PermissionMode.READ_ONLY)
+    ctx.ui.panel(build_index(perm), title="Project Index")
+    return CommandResult()
+
+
+@command("tools", "List the tools available in Assist Mode")
+def _tools(ctx: CommandContext, arg: str) -> CommandResult:
+    from ..ui.layout import columns_grid
+
+    rows = []
+    for name in sorted(TOOL_REGISTRY):
+        tool = TOOL_REGISTRY[name]
+        kind = "changes files/system" if tool.mutates else "read-only"
+        rows.append((name, f"{tool.description}  ({kind})"))
+    ctx.ui.panel(
+        columns_grid(rows, ("seed.primary", "seed.text")), title="Assist Tools"
+    )
+    return CommandResult()

seedcode/commands/assist.py

@@ -0,0 +1,201 @@
+"""Assist Mode: unified AI + computer control.
+
+/assist on  — enables the full capability set (AI, filesystem, terminal,
+              git, browser, keyboard, mouse, windows, vision, OCR, desktop
+              automation).
+/assist off — back to plain chat.
+
+Assist Mode is the ONLY automation mode Seed Code exposes. The old Agent
+and Desktop modes were merged into it; their commands now route here.
+"""
+
+from __future__ import annotations
+
+from rich.table import Table
+
+from ..computer import is_available
+from ..config import save_config
+from ..tools import TOOL_REGISTRY, PermissionMode
+from . import CommandContext, CommandResult, command
+
+# The Assist capability set, in display order. Desktop-engine rows are
+# marked so they can be dimmed when the Computer Engine is unavailable.
+_CAPABILITIES: tuple[tuple[str, str, bool], ...] = (
+    ("AI", "Chat, reasoning, and code generation", False),
+    ("Filesystem", "Read, write, edit, search, and organise files", False),
+    ("Terminal", "Run shell commands with live output", False),
+    ("Git", "Status, diff, log, commit, push, pull", False),
+    ("Browser", "Navigate, click, type, search", True),
+    ("Keyboard", "Type, hotkeys, shortcuts", True),
+    ("Mouse", "Move, click, drag, scroll", True),
+    ("Windows", "List, focus, open, close", True),
+    ("Vision", "See and understand the screen", True),
+    ("OCR", "Read text from the screen", True),
+    ("Desktop Automation", "Multi-step computer control", True),
+)
+
+
+@command("assist", "Enable/disable Assist Mode (unified AI + computer control)")
+def _assist(ctx: CommandContext, arg: str) -> CommandResult:
+    raw = arg.strip().lower()
+    if raw in ("on", "off"):
+        enable = raw == "on"
+    elif not raw:
+        # Bare /assist: show status
+        _show_status(ctx)
+        return CommandResult()
+    else:
+        ctx.ui.warning("Usage: /assist [on|off]")
+        return CommandResult()
+
+    if enable:
+        enable_assist(ctx.ui, ctx.config)
+    else:
+        disable_assist(ctx.ui, ctx.config)
+    return CommandResult()
+
+
+def capability_table(desktop_ok: bool) -> Table:
+    """The Assist capability list (✓ rows; unavailable rows dim).
+
+    OCR is probed independently of the rest of the desktop stack: it needs a
+    native engine the Python packages do not supply, so marking it available
+    purely because the Computer Engine imports would tell the user something
+    untrue.
+    """
+    table = Table.grid(padding=(0, 2))
+    table.add_column(justify="right", no_wrap=True)
+    table.add_column()
+    ocr_ok = _ocr_available() if desktop_ok else False
+    for name, detail, needs_desktop in _CAPABILITIES:
+        available = desktop_ok if needs_desktop else True
+        if name == "OCR":
+            available = ocr_ok
+        if available:
+            table.add_row(f"[seed.success]✓ {name}[/seed.success]", f"[seed.text]{detail}[/seed.text]")
+        else:
+            table.add_row(f"[seed.dim]○ {name}[/seed.dim]", f"[seed.dim]{detail}[/seed.dim]")
+    return table
+
+
+def _ocr_available() -> bool:
+    """Whether the OCR tier can genuinely run (best-effort)."""
+    try:
+        from ..computer import ocr
+
+        return ocr.available()
+    except Exception:
+        return False
+
+
+def enable_assist(ui, config) -> None:
+    """Enable Assist Mode: the full capability set in one switch."""
+    config.agent_mode = True
+
+    # Desktop capabilities require the Computer Engine. When available, Assist
+    # runs at the ``desktop`` level so the AI can drive the computer; otherwise
+    # it stays at ``workspace`` (AI + filesystem + terminal + git still work).
+    desktop_ok, desktop_reason = is_available()
+    config.permission_mode = (
+        PermissionMode.DESKTOP.value_str if desktop_ok
+        else PermissionMode.WORKSPACE.value_str
+    )
+    save_config(config)
+
+    ui.success("Assist Mode ON")
+    ui.blank()
+    ui.panel(capability_table(desktop_ok), title="Assist Mode")
+    if not desktop_ok:
+        ui.dim(f"Desktop capabilities unavailable: {desktop_reason}")
+    ui.blank()
+
+    level_label = "desktop" if desktop_ok else "workspace"
+    ui.dim(f"Permission level: {level_label} — change in Settings › Advanced or /permission.")
+
+    # Ask for routine desktop control ONCE, here, instead of interrupting every
+    # action later. Sensitive actions still confirm individually.
+    if desktop_ok:
+        request_session_permissions(ui)
+    ui.dim("The AI picks the right tools for each task automatically.")
+
+
+def request_session_permissions(ui) -> bool:
+    """Request every routine desktop permission for the session, in one prompt.
+
+    Returns whether the session-wide grant was given. Declining is safe: the
+    engine simply falls back to confirming each action as it comes, which is
+    the old behaviour. Sensitive actions (registry writes, secrets, system
+    power, deletions, purchases) are never granted here — they always ask.
+    """
+    from ..computer.permissions import (
+        CATEGORY_LABELS,
+        SESSION_GRANT_CATEGORIES,
+        session_permissions,
+    )
+
+    session = session_permissions()
+    if session.requested:
+        return bool(session.granted)
+
+    wanted = "\n".join(
+        f"  • {CATEGORY_LABELS.get(c, c)}" for c in SESSION_GRANT_CATEGORIES
+    )
+    description = (
+        "Grant these for this session so Assist doesn't interrupt every step:\n"
+        f"{wanted}\n"
+        "Sensitive actions (registry writes, passwords, system power, deletions, "
+        "purchases) will still ask each time."
+    )
+
+    try:
+        answer = ui.confirm_desktop("Assist Mode session permissions", description)
+    except Exception:
+        # No interactive prompt available (headless/non-TTY): leave the
+        # per-action flow in place rather than silently granting anything.
+        return False
+
+    allowed = answer in ("y", "a")
+    if allowed:
+        session.request(SESSION_GRANT_CATEGORIES, allow=True)
+        ui.dim("Desktop control granted for this session — you won't be asked again.")
+    else:
+        ui.dim("Declined: Assist will ask before each desktop action.")
+    return allowed
+
+
+def disable_assist(ui, config) -> None:
+    """Disable Assist Mode: back to plain chat."""
+    from ..computer.permissions import session_permissions
+
+    config.agent_mode = False
+    # Drop back to the safe editing level (removes desktop capability).
+    config.permission_mode = PermissionMode.WORKSPACE.value_str
+    save_config(config)
+    # Forget the session-wide desktop grant: turning Assist back on asks again.
+    session_permissions().reset()
+    ui.success("Assist Mode OFF — back to plain chat")
+
+
+def _show_status(ctx: CommandContext) -> None:
+    """Show current Assist Mode status."""
+    on = ctx.config.agent_mode
+    desktop_ok, desktop_reason = is_available()
+
+    table = Table.grid(padding=(0, 3))
+    table.add_column(style="seed.dim", justify="right", no_wrap=True)
+    table.add_column()
+
+    state = "[seed.accent]ON[/seed.accent]" if on else "[seed.dim]OFF[/seed.dim]"
+    table.add_row("Assist Mode", state)
+    table.add_row("Mode", "Assist" if on else "Chat")
+    if not desktop_ok:
+        table.add_row("Desktop", f"Unavailable: {desktop_reason}")
+    table.add_row("Permission", ctx.config.permission_mode.replace("_", " ").title())
+
+    core_tools = [n for n, t in TOOL_REGISTRY.items() if t.group == "core"]
+    desktop_tools = [n for n, t in TOOL_REGISTRY.items() if t.group == "desktop"]
+    table.add_row("Available tools", f"{len(core_tools)} core, {len(desktop_tools)} desktop")
+
+    ctx.ui.panel(table, title="Assist Mode")
+    ctx.ui.blank()
+    ctx.ui.dim("Toggle with: /assist on | /assist off")

seedcode/commands/clear.py

@@ -0,0 +1,20 @@
+"""Screen and context commands: /clear, /reset."""
+
+from __future__ import annotations
+
+from . import CommandContext, CommandResult, command
+
+
+@command("clear", "Clear the screen")
+def _clear(ctx: CommandContext, arg: str) -> CommandResult:
+    # The branded banner renders exactly once at startup, so /clear only
+    # wipes the screen.
+    ctx.ui.console.clear()
+    return CommandResult()
+
+
+@command("reset", "Forget the current conversation context")
+def _reset(ctx: CommandContext, arg: str) -> CommandResult:
+    ctx.engine.reset()  # type: ignore[attr-defined]
+    ctx.ui.success("Conversation context cleared.")
+    return CommandResult()

seedcode/commands/desktop.py

@@ -0,0 +1,104 @@
+"""Desktop-related commands: /desktop (legacy → Assist), /computer,
+/screenshot, /windows.
+
+The old Desktop Mode was merged into Assist Mode — /desktop now routes
+there. /computer shows engine status; /screenshot and /windows work
+immediately (no Assist turn needed) so the user can sanity-check the
+engine by hand.
+"""
+
+from __future__ import annotations
+
+from rich.table import Table
+
+from ..computer import INSTALL_HINT, is_available, missing_packages
+from . import CommandContext, CommandResult, command
+from .assist import disable_assist, enable_assist
+
+
+@command("desktop", "Legacy alias for Assist Mode. Usage: /desktop [on|off]")
+def _desktop(ctx: CommandContext, arg: str) -> CommandResult:
+    raw = arg.strip().lower()
+    if raw in ("on", "off"):
+        enable = raw == "on"
+    elif not raw:
+        enable = not ctx.config.agent_mode  # bare /desktop toggles Assist
+    else:
+        ctx.ui.warning("Usage: /desktop [on|off]")
+        return CommandResult()
+
+    # Desktop Mode was merged into Assist Mode — route there transparently.
+    ctx.ui.dim("(/desktop is now Assist Mode)")
+    if enable:
+        enable_assist(ctx.ui, ctx.config)
+    else:
+        disable_assist(ctx.ui, ctx.config)
+    return CommandResult()
+
+
+@command("computer", "Show Computer Engine status and desktop permissions")
+def _computer(ctx: CommandContext, arg: str) -> CommandResult:
+    ok, reason = is_available()
+
+    table = Table.grid(padding=(0, 3))
+    table.add_column(style="seed.dim", justify="right", no_wrap=True)
+    table.add_column(style="seed.text")
+    table.add_row("Mode", "Assist" if ctx.config.agent_mode else "Chat  (/assist on)")
+    table.add_row("Engine", reason if not ok else "Available")
+    missing = missing_packages()
+    if missing:
+        table.add_row("Missing", f"{', '.join(missing)}  →  {INSTALL_HINT}")
+
+    if ok:
+        try:
+            from ..tools.desktop import get_controller
+
+            table.add_row("Screen", get_controller().screen_info().split("\n")[0])
+        except Exception:
+            pass
+        from ..tools import TOOL_REGISTRY
+
+        names = sorted(n for n, t in TOOL_REGISTRY.items() if t.group == "desktop")
+        table.add_row("Tools", ", ".join(names))
+
+    ctx.ui.panel(table, title="Computer Engine")
+    return CommandResult()
+
+
+@command("screenshot", "Capture a screenshot now. Usage: /screenshot [path]")
+def _screenshot(ctx: CommandContext, arg: str) -> CommandResult:
+    ok, reason = is_available()
+    if not ok:
+        ctx.ui.error(reason)
+        return CommandResult()
+    from pathlib import Path
+
+    from ..tools.desktop import get_controller
+    from ..computer.controller import ComputerError
+
+    save_to = Path(arg.strip()).expanduser() if arg.strip() else None
+    try:
+        path = get_controller().screenshot(save_to=save_to)
+    except ComputerError as exc:
+        ctx.ui.error(str(exc))
+        return CommandResult()
+    ctx.ui.success(f"Screenshot saved: {path}")
+    return CommandResult()
+
+
+@command("windows", "List all open windows")
+def _windows(ctx: CommandContext, arg: str) -> CommandResult:
+    ok, reason = is_available()
+    if not ok:
+        ctx.ui.error(reason)
+        return CommandResult()
+    from ..tools.desktop import get_controller
+    from ..computer.controller import ComputerError
+
+    try:
+        listing = get_controller().list_windows()
+    except ComputerError as exc:
+        ctx.ui.error(str(exc))
+        return CommandResult()
+    ctx.ui.panel(listing, title="Open Windows")
+    return CommandResult()