seedcode-cli 6.2.0__py3-none-any.whl → 6.2.5__py3-none-any.whl

seedcode/__init__.py

@@ -6,7 +6,7 @@ Plant ideas. Grow code.
 # Single source of truth for the application version. Every consumer reads it:
 # the PyPI build (via [tool.hatch.version]), the CLI --version flag, the
 # Windows installer metadata, the GitHub release tag, and the WinGet manifest.
-__version__ = "6.2.0"
+__version__ = "6.2.5"
 __author__ = "Al shahriar sowan"
 __publisher__ = "Eagox Studio"
 

seedcode/_default_key_template.py

@@ -1,10 +1,14 @@
-"""Embedded default OpenRouter credential (v6.2.0 build-time artifact).
+"""Embedded built-in credential for the Default provider (v6.2.5 artifact).
 
 This file is NOT committed to source control. The release build generates
 ``seedcode/_default_key.py`` from the local ``.env`` (see
 ``scripts/windows/embed_default_key.py``). Source checkouts without that
 generated file fall back to the empty default below, so behavior is
 unchanged for developers and CI.
+
+The credential belongs to the built-in ``Default`` provider and is resolved
+per request by :mod:`seedcode.core.providers.default`; it is never copied
+into another provider's stored configuration.
 """
 
 DEFAULT_OPENROUTER_API_KEY = ""

seedcode/app.py

@@ -14,9 +14,12 @@ Ctrl+L clear screen.
 
 from __future__ import annotations
 
+import sys
+
 from prompt_toolkit import PromptSession
 from prompt_toolkit.key_binding import KeyBindings
 
+from . import __version__
 from .commands import CommandContext, dispatch, is_command
 from .commands.about import show_about
 from .commands.help import show_shortcuts
@@ -29,13 +32,14 @@ from .core.agent import AgentEngine, strip_tool_blocks
 from .core.chat import ChatEngine, ChatError
 from .core.lifecycle import lifecycle
 from .core.models import AppConfig
-from .core.providers import PROVIDERS, provider_label
+from .core.providers import PROVIDERS, provider_label, provider_ready
 from .core.providers.freemodel import AUTO_MODEL
 from .memory import HistoryStore
 from .tools import PermissionManager, PermissionMode
 from .ui import UI
 from .ui.badges import badge_for_status
 from .ui.menu import MenuItem, run_menu
+from .ui.reference import CONTROLS_HINT, INPUT_HINT
 from .ui.textbox import prompt_label
 from .ui.theme import pt_style, set_active_theme
 from .utils.logger import get_logger
@@ -102,9 +106,14 @@ def _release_desktop_resources() -> None:
 
 
 def _provider_status(config: AppConfig) -> str:
-    """Menu status line: the active provider, or 'Not Configured'."""
-    ready = config.provider == "ollama" or bool(config.get_api_key().strip())
-    return provider_label(config.provider) if ready else "Not Configured"
+    """Menu status line: the active provider, or 'Not Configured'.
+
+    Uses the shared provider-ready rule, so the menu never disagrees with the
+    dashboard: Default and Ollama need no key, everyone else needs their own.
+    """
+    if provider_ready(config.provider, config):
+        return provider_label(config.provider)
+    return "Not Configured"
 
 
 def _model_status(config: AppConfig) -> str:
@@ -124,27 +133,75 @@ def _key_status(config: AppConfig) -> str:
     return config.masked_key()
 
 
+def _mode_status(config: AppConfig) -> str:
+    """Menu status for the Code Mode item (ON only when really active)."""
+    try:
+        from .codemode_state import codemode_state
+
+        if codemode_state().enabled:
+            return "ON"
+    except Exception:
+        pass
+    return "ON" if config.agent_mode else "OFF"
+
+
 def _main_menu(config: AppConfig):
-    """The interactive main menu; returns an action id or None (exit)."""
+    """The interactive main menu; returns an action id or None (exit).
+
+    v6.2.5 reference layout: the six mode/setup actions carry Ctrl+1..Ctrl+6
+    shortcuts that execute the real handlers (no decorative items), followed
+    by the chat/setup actions kept from earlier releases.
+    """
     provider = PROVIDERS.get(config.provider)
     badge = badge_for_status(provider.status if provider is not None else "")
     return run_menu(
         [
+            MenuItem("Code Mode", "codemode", status=_mode_status(config), shortcut="1"),
+            MenuItem("Agent Mode", "agent", shortcut="2"),
+            MenuItem("Assist Mode", "assist", shortcut="3"),
+            MenuItem("Project Memory", "memory", shortcut="4"),
+            MenuItem("Settings", "settings", shortcut="5"),
+            MenuItem("Exit", "exit", shortcut="6"),
             MenuItem("Start Chat", "chat", status=_model_status(config), badge=badge),
             MenuItem("Provider", "provider", status=_provider_status(config)),
             MenuItem("API Key", "apikey", status=_key_status(config)),
             MenuItem("Model", "model", status=_model_status(config)),
-            MenuItem("Settings", "settings"),
             MenuItem("Theme", "theme", status=config.theme),
             MenuItem("About", "about"),
-            MenuItem("Exit", "exit"),
         ],
-        title="Seed Code",
-        hint="↑↓ move   type to filter   Enter select   Esc exit",
+        title=f"Seed Code v{__version__}",
+        hint=CONTROLS_HINT,
         initial="chat",
     )
 
 
+def _dispatch_command(ui: UI, config: AppConfig, engine, command: str) -> None:
+    """Run a slash command from a menu action through the real router."""
+    dispatch(CommandContext(ui=ui, config=config, engine=engine), command)
+
+
+def _report_command_error(ui: UI, exc: Exception) -> None:
+    """Render a failed command/action without leaking a raw traceback.
+
+    A transport failure becomes one actionable ``[Network Error]`` line, mapped
+    by :mod:`seedcode.core.http` (which never includes request headers, so an
+    API key can never surface here). Anything else keeps its own message; the
+    full traceback is already written to the log file.
+    """
+    try:
+        import httpx
+
+        from .core.http import friendly_error
+
+        if isinstance(exc, httpx.HTTPError):
+            ui.error(f"[Network Error] {friendly_error(exc)}")
+            ui.dim("Action: check your network connection or provider configuration.")
+            return
+    except Exception:
+        pass  # error reporting must never itself raise
+    ui.error(f"[Command Error] {exc}")
+
+
 def _guided_setup(ui: UI, config: AppConfig) -> bool:
     """Provider -> API key -> validate -> fetch models -> select -> save.
 
@@ -343,14 +400,11 @@ def _chat_loop(
     config: AppConfig,
     engine: ChatEngine,
     history: HistoryStore,
-    session: PromptSession,
+    session: PromptSession | _PlainSession,
 ) -> None:
     """Interactive chat until /exit (returns to the main menu)."""
     ctx = CommandContext(ui=ui, config=config, engine=engine)
-    ui.dim(
-        "Type /help for commands, /exit for the menu — "
-        "Ctrl+K palette, Ctrl+P files, Ctrl+/ shortcuts."
-    )
+    ui.dim(INPUT_HINT)
 
     # The Assist engine is built lazily on the first assist-mode turn and
     # rebuilt when the permission or desktop mode changes (its system
@@ -398,7 +452,7 @@ def _chat_loop(
                 continue
             except Exception as exc:  # a broken command must not kill the REPL
                 _log.exception("command failed: %s", text.split()[0])
-                ui.error(f"Command failed: {exc}")
+                _report_command_error(ui, exc)
                 continue
             if result.should_exit:
                 return
@@ -435,6 +489,56 @@ def _chat_loop(
                 _handle_chat(ui, engine, history, text)
 
 
+def _interactive() -> bool:
+    """True when a real console is attached (mirrors ``ui.selector._interactive``).
+
+    prompt_toolkit needs a console/PTY it can drive. Piped, redirected, or
+    console-less hosts (CI, ``seedcode < file``, some Git Bash/MSYS sessions)
+    cannot provide one, and constructing a prompt there raises instead of
+    degrading — so every interactive entry point checks this first.
+    """
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except (AttributeError, ValueError):
+        return False
+
+
+class _PlainSession:
+    """Line-based stand-in for :class:`PromptSession` on non-console hosts.
+
+    The chat loop only needs ``prompt()``, so this shim keeps Seed Code usable
+    where prompt_toolkit cannot start. Reading raises ``EOFError`` /
+    ``KeyboardInterrupt`` exactly like the real session, so the loop's existing
+    Ctrl+C / Ctrl+D handling is unchanged.
+    """
+
+    def prompt(self, message=None, **_kwargs) -> str:
+        return input(_plain_text(message) or "> ")
+
+
+def _plain_text(message) -> str:
+    """Literal text of a prompt message (a prompt_toolkit ``FormattedText``)."""
+    if isinstance(message, str):
+        return message
+    try:
+        return "".join(fragment[1] for fragment in message)
+    except Exception:
+        return ""
+
+
+def _make_chat_session(ui: UI):
+    """A prompt_toolkit session when a console exists, else the plain shim."""
+    if not _interactive():
+        return _PlainSession()
+    try:
+        return _build_chat_session(ui)
+    except Exception:
+        # A console that exists but still cannot be driven (e.g. a MSYS/mintty
+        # TERM against a non-Windows console). Never fatal — degrade instead.
+        _log.warning("prompt_toolkit unavailable; using line-based input")
+        return _PlainSession()
+
+
 def _build_chat_session(ui: UI) -> PromptSession:
     """The chat PromptSession with the global shortcut bindings attached."""
     kb = KeyBindings()
@@ -480,7 +584,7 @@ def run(ui: UI) -> None:
     active_backend = config.provider
     engine = ChatEngine(config)
     history = HistoryStore(provider_id=active_backend)
-    chat_session = _build_chat_session(ui)
+    chat_session = _make_chat_session(ui)
 
     # Best-effort teardown for the one legitimate shutdown path.
     lifecycle().on_shutdown(_release_desktop_resources)
@@ -530,6 +634,14 @@ def run(ui: UI) -> None:
                 apikey_menu(ui, config)
             elif choice == "model":
                 select_model(ui, config)
+            elif choice == "codemode":
+                _dispatch_command(ui, config, engine, "/codemode on")
+            elif choice == "agent":
+                _dispatch_command(ui, config, engine, "/agent on")
+            elif choice == "assist":
+                _dispatch_command(ui, config, engine, "/assist on")
+            elif choice == "memory":
+                _dispatch_command(ui, config, engine, "/codemode status")
             elif choice == "settings":
                 settings_menu(ui, config)
             elif choice == "theme":
@@ -543,4 +655,4 @@ def run(ui: UI) -> None:
             ui.dim("Cancelled.")
         except Exception as exc:  # menu actions must never crash the app
             _log.exception("menu action failed: %s", choice)
-            ui.error(f"Something went wrong: {exc}")
+            _report_command_error(ui, exc)

seedcode/branding.py

@@ -4,9 +4,14 @@ The official Seed Code mark is the 16x16 pixel-art "sprouting seed" on a
 dark rounded tile (the Seed Green identity). This module owns the grid and
 the exact palette so every surface renders identical art:
 
-* ``seedcode/ui/logo.py``             — terminal rendering (half-block pixels)
 * ``scripts/windows/build_assets.py`` — ``seedcode.ico``, the Inno wizard
   bitmaps, the canonical ``assets/logo.png`` and the preview render
+* the installer wizard and the Windows taskbar/Explorer surfaces
+
+v6.2.5 note: the interactive CLI no longer renders any ASCII art. The mark
+is a packaging/desktop asset only (:mod:`seedcode.ui.dashboard` renders a
+borderless text header with no logo), so this module is not imported by the
+terminal UI at all.
 
 Stdlib only (struct/zlib): safe to import from anywhere in the package,
 costs nothing at startup, and keeps the brand byte-reproducible.

seedcode/cli.py

@@ -51,7 +51,8 @@ def main() -> None:
     if len(sys.argv) > 1 and sys.argv[1] in ("--version", "-V"):
         from . import __version__
 
-        print(f"Seed Code v{__version__}")
+        # Installers verify the install by parsing this exact line.
+        print(f"Seed Code CLI {__version__}")
         return
     if len(sys.argv) > 1 and sys.argv[1] in ("--help", "-h"):
         print(_HELP)
@@ -65,18 +66,25 @@ def main() -> None:
     log = get_logger("cli")
 
     from . import __version__
+    from .utils.terminal_env import detect_terminal, workspace_root
 
+    # Detect the terminal host/shell once (VS Code, Windows Terminal, Git Bash
+    # or unknown) so a support log says exactly where this session ran. The
+    # workspace root is the launch directory and is never changed below.
+    terminal = detect_terminal()
     log.info(
-        "Seed Code v%s starting (python %s on %s)",
+        "Seed Code v%s starting (python %s on %s); terminal %s; cwd=%s",
         __version__,
         sys.version.split()[0],
         sys.platform,
+        terminal.describe(),
+        workspace_root(),
     )
 
     from .app import run
     from .ui import UI
 
-    ui = UI()
+    ui = UI(plain=terminal.plain)
     try:
         run(ui)
         log.info("Clean exit.")

seedcode/commands/__init__.py

@@ -62,14 +62,16 @@ def dispatch(ctx: CommandContext, text: str) -> CommandResult:
 
     entry = _REGISTRY.get(name)
     if entry is None:
-        ctx.ui.warning(f"Unknown command: /{name}. Type /help for the list.")
+        # Never silently ignore a command: name it, then point at /help.
+        ctx.ui.warning(f"[Command Error] Unknown command: /{name}")
+        ctx.ui.dim("Run /help for available commands.")
         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, codemode, desktop, doctor, help, history, palette, provider, theme  # noqa: E402,F401
+from . import about, agent, assist, chat, clear, codemode, desktop, doctor, help, history, mode, palette, provider, status, theme  # noqa: E402,F401
 
 __all__ = [
     "CommandContext",

seedcode/commands/agent.py

@@ -23,7 +23,8 @@ def _agent(ctx: CommandContext, arg: str) -> CommandResult:
     elif not raw:
         enable = not ctx.config.agent_mode  # bare /agent toggles
     else:
-        ctx.ui.warning("Usage: /agent [on|off]")
+        ctx.ui.warning("[Command Error] Invalid syntax.")
+        ctx.ui.dim("Expected: /agent on|off")
         return CommandResult()
 
     # Agent Mode was merged into Assist Mode — route there transparently.
@@ -35,7 +36,11 @@ def _agent(ctx: CommandContext, arg: str) -> CommandResult:
     return CommandResult()
 
 
-@command("permission", "Show or set the Assist permission mode", aliases=("perm",))
+@command(
+    "permission",
+    "Show or set the Assist permission mode",
+    aliases=("perm", "permissions"),
+)
 def _permission(ctx: CommandContext, arg: str) -> CommandResult:
     raw = arg.strip()
     detail = {

seedcode/commands/assist.py

@@ -45,7 +45,8 @@ def _assist(ctx: CommandContext, arg: str) -> CommandResult:
         _show_status(ctx)
         return CommandResult()
     else:
-        ctx.ui.warning("Usage: /assist [on|off]")
+        ctx.ui.warning("[Command Error] Invalid syntax.")
+        ctx.ui.dim("Expected: /assist on|off")
         return CommandResult()
 
     if enable:

seedcode/commands/chat.py

@@ -0,0 +1,46 @@
+"""/chat — explicit Chat Mode (plain conversation, no tools).
+
+/chat      — show the current mode.
+/chat on   — leave Assist/Code Mode and return to plain Chat: the AI answers
+             with text only and never touches the filesystem or terminal.
+
+Chat Mode is the default runtime mode; this command exists so a user can
+always get back to it directly, without hunting through menus.
+"""
+
+from __future__ import annotations
+
+from . import CommandContext, CommandResult, command
+from .status import mode_label
+
+
+@command("chat", "Switch to plain Chat Mode. Usage: /chat [on]")
+def _chat(ctx: CommandContext, arg: str) -> CommandResult:
+    raw = arg.strip().lower()
+    if raw in ("", "status"):
+        ctx.ui.info(f"Mode: {mode_label(ctx.config)}")
+        ctx.ui.dim("Switch with: /chat on · /assist on · /codemode on (or /mode chat|assist|code)")
+        return CommandResult()
+
+    if raw != "on":
+        ctx.ui.warning("[Command Error] Invalid syntax.")
+        ctx.ui.dim("Expected: /chat [on]")
+        return CommandResult()
+
+    _enter_chat(ctx)
+    return CommandResult()
+
+
+def _enter_chat(ctx: CommandContext) -> None:
+    """Return the session to plain Chat Mode (idempotent)."""
+    from .. import codemode_state as cms
+    from .assist import disable_assist
+
+    if cms.codemode_state().enabled:
+        cms.disable()
+        ctx.ui.dim("Code Mode OFF — .seedcode memory kept for next session")
+
+    was_assist = ctx.config.agent_mode
+    if was_assist:
+        disable_assist(ctx.ui, ctx.config)
+    ctx.ui.success("Chat Mode ON — plain conversation, no tools")

seedcode/commands/codemode.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 from rich.table import Table
 
-from .. import codemode_state
+from ..codemode_state import codemode_state
 from ..config import save_config
 from ..tools import PermissionMode
 from . import CommandContext, CommandResult, command
@@ -45,7 +45,8 @@ def _codemode(ctx: CommandContext, arg: str) -> CommandResult:
         _disable_codemode(ctx)
         return CommandResult()
 
-    ctx.ui.warning("Usage: /codemode [on|off|status]")
+    ctx.ui.warning("[Command Error] Invalid syntax.")
+    ctx.ui.dim("Expected: /codemode on|off|status")
     return CommandResult()
 
 

seedcode/commands/mode.py

@@ -0,0 +1,50 @@
+"""/mode — one generic switcher for the runtime modes.
+
+/mode           — show the current mode.
+/mode chat      — plain conversation (no tools).
+/mode assist    — the unified AI + tools mode (filesystem, terminal, git, ...).
+/mode code      — Assist sharpened for the current workspace (Code Mode).
+/mode agent     — legacy alias of assist.
+
+The individual commands (/chat, /assist, /codemode) remain the direct routes;
+this command is the single entry point that understands all of them.
+"""
+
+from __future__ import annotations
+
+from . import CommandContext, CommandResult, command
+from .status import mode_label
+
+
+@command("mode", "Show or switch the runtime mode. Usage: /mode [chat|assist|code|agent]")
+def _mode(ctx: CommandContext, arg: str) -> CommandResult:
+    raw = arg.strip().lower()
+
+    if not raw:
+        ctx.ui.info(f"Mode: {mode_label(ctx.config)}")
+        ctx.ui.dim("Switch with: /mode chat|assist|code|agent")
+        return CommandResult()
+
+    if raw == "chat":
+        from .chat import _enter_chat
+
+        _enter_chat(ctx)
+    elif raw == "assist":
+        from .assist import enable_assist
+
+        enable_assist(ctx.ui, ctx.config)
+    elif raw == "code":
+        from .codemode import _enable_codemode
+
+        _enable_codemode(ctx)
+    elif raw == "agent":
+        # Agent Mode merged into Assist Mode; keep the name working.
+        from .assist import enable_assist
+
+        enable_assist(ctx.ui, ctx.config)
+        ctx.ui.dim("(Agent Mode is Assist Mode now — same engine, same tools)")
+    else:
+        ctx.ui.warning("[Command Error] Invalid syntax.")
+        ctx.ui.dim("Expected: /mode chat|assist|code|agent")
+
+    return CommandResult()

seedcode/commands/provider.py

@@ -46,14 +46,45 @@ def _resolve_provider(text: str) -> Provider | None:
     return matches[0] if len(matches) == 1 else None
 
 
+# Selector groups, in display order. Providers are grouped by what they need
+# from the user, so "Default" is never mistaken for "OpenRouter" (they can
+# share an underlying service but are separate choices with separate config).
+_GROUP_BUILTIN = "Built-in  ·  no API key needed"
+_GROUP_BYOK = "Your own API key"
+_GROUP_LOCAL = "Local  ·  runs on this machine"
+
+
+def _provider_group(provider: Provider) -> str:
+    if provider.local:
+        return _GROUP_LOCAL
+    if provider.id == "default":
+        return _GROUP_BUILTIN
+    return _GROUP_BYOK
+
+
 def _provider_backend(provider: Provider, config) -> str:
-    if provider.id == "ollama":
+    """Human connection type: 'Local' for on-machine backends, else the API family."""
+    if provider.local:
         return "Local"
     return provider.backend_label or f"{provider.label} API"
 
 
+def _provider_key_column(provider: Provider, config) -> str:
+    """What this provider needs from the user: no key, a masked key, or a prompt.
+
+    This is the column that makes the API-key rules visible before switching:
+    Default and Ollama read "no API key", configured providers show their
+    masked key, and the rest ask for one. A key is never shown in full.
+    """
+    if not provider.requires_key:
+        return "no API key"
+    if config.get_api_key(provider.id).strip():
+        return config.masked_key(provider.id)
+    return "API key needed"
+
+
 def _provider_menu(ui, config) -> Provider | None:
-    """Interactive provider selector: badge, backend, and current model."""
+    """Interactive provider selector: badge, backend, model, and key state."""
     options = []
     for p in PROVIDERS.values():
         entry = config.providers.get(p.id)
@@ -65,7 +96,12 @@ def _provider_menu(ui, config) -> Provider | None:
                 p.label,
                 value=p.id,
                 badge=badge_for_status(p.status),
-                columns=(_provider_backend(p, config), model),
+                columns=(
+                    _provider_backend(p, config),
+                    model,
+                    _provider_key_column(p, config),
+                ),
+                group=_provider_group(p),
             )
         )
     chosen = select(
@@ -113,22 +149,22 @@ def _collect_key(ui, config, provider: Provider, *, replacing: bool = False) ->
 
 
 def _ensure_ready(ui, config, provider: Provider) -> bool:
-    """Make ``provider`` usable: collect+validate a key, or detect Ollama.
+    """Make ``provider`` usable: collect+validate a key, or probe a key-less one.
 
-    Returns False only when the user cancels key entry; a stopped Ollama
-    server is reported but not fatal (the user may start it later).
+    Returns False only when the user cancels key entry. An unreachable
+    key-less backend (local Ollama, or the built-in Default connection in a
+    build that carries no credential) is reported with its own actionable
+    message but is never fatal — the user may start Ollama or pick another
+    provider later.
     """
     if not provider.requires_key:
-        with ui.thinking("Checking Ollama"):
-            running = provider.detect(config)
-        provider.status = STATUS_CONNECTED if running else STATUS_OFFLINE
-        if running:
-            ui.success("Ollama server detected.")
+        with ui.thinking(f"Checking {provider.label}"):
+            reachable = provider.detect(config)
+        provider.status = STATUS_CONNECTED if reachable else STATUS_OFFLINE
+        if reachable:
+            ui.success(f"{provider.label} is ready.")
         else:
-            ui.warning(
-                f"Ollama is not reachable at {config.ollama_host}. "
-                "Start it with 'ollama serve' — chatting will fail until it runs."
-            )
+            ui.warning(provider.unavailable_hint(config))
         return True
 
     if config.get_api_key(provider.id).strip():
@@ -352,7 +388,7 @@ def select_model(ui, config, target: str = "") -> None:
 @command(
     "provider",
     "Select the active provider "
-    "(OpenRouter, FreeModel Claude, FreeModel Codex, AeroLink, Ollama)",
+    "(Default, OpenRouter, FreeModel Claude, FreeModel Codex, AeroLink, Ollama)",
 )
 def _provider_cmd(ctx: CommandContext, arg: str) -> CommandResult:
     select_provider(ctx.ui, ctx.config, arg.strip())