seedcode-cli 7.1.0__py3-none-any.whl → 7.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__ = "7.1.0"
+__version__ = "7.2.5"
 __author__ = "Al Shahriar Sowan"
 __publisher__ = "Eagox Studio"
 # Current author/company links, surfaced by /about and the README credits.

seedcode/app.py

@@ -32,7 +32,12 @@ from .core.agent import AgentEngine, strip_tool_blocks
 from .core.chat import ChatEngine, ChatError
 from .core.lifecycle import LifecycleError, lifecycle
 from .core.models import AppConfig
-from .core.providers import PROVIDERS, provider_label, provider_ready
+from .core.providers import (
+    PROVIDERS,
+    provider_label,
+    provider_ready,
+    sync_custom_providers,
+)
 from .core.providers.freemodel import AUTO_MODEL
 from .memory import HistoryStore
 from .tools import PermissionManager, PermissionMode
@@ -310,6 +315,14 @@ class _TaskPresenter:
             return
         if kind == "error":
             self.ui.dim(f"  ✖ {detail.splitlines()[0][:120]}")
+        elif kind == "switching_provider":
+            # A provider request failed and a healthy fallback took over; the
+            # task continues rather than restarting (v7.2.5).
+            self.ui.warning(f"  Switching provider: {detail}")
+            if flow is not None:
+                flow.set_activity("Switching provider")
+        elif kind == "retry":
+            self.ui.dim(f"  {detail}")
         elif kind == "limit":
             self.ui.warning(f"Assist stopped: {detail}")
         elif kind == "call" and flow is None:
@@ -384,10 +397,23 @@ class _TaskPresenter:
             self.ui.warning(detail)
         elif kind == "task_failed":
             self.ui.error(detail)
+        elif kind == "task_skipped":
+            # A skipped task is resolved, never verified work (v7.2.5).
+            self.ui.dim(f"  – {detail}")
         elif kind == "final_verify":
             self.ui.dim("  final verification…")
             if flow is not None:
                 flow.set_activity("Verifying the project (tests / build)")
+        elif kind == "reconnect":
+            # The connection dropped; the session is reconnecting and the task
+            # is preserved rather than failed (v7.2.5).
+            self.ui.warning(f"  {detail}")
+            if flow is not None:
+                flow.set_activity("Reconnecting to the provider")
+        elif kind == "reconnected":
+            self.ui.dim(f"  {detail}")
+        elif kind == "network_lost":
+            self.ui.warning(f"Network: {detail}")
         elif kind in ("retry", "continue"):
             self.ui.dim(f"  {detail}")
         if flow is not None and session is not None:
@@ -586,7 +612,13 @@ def _handle_codemode(
         if flow is not None:
             flow.set_state("paused")
             flow.stop()
-        ui.warning("Session paused — state saved. Send /resume to continue.")
+        # Surface the real reason (a network pause says so) but keep the
+        # actionable instruction identical for every pause.
+        reason = (session.reason or "").strip()
+        if reason and "connection" in reason.lower():
+            ui.warning(f"{reason}")
+        else:
+            ui.warning("Session paused — state saved. Send /resume to continue.")
         session_mod.set_current_session(session)
         return
 
@@ -620,6 +652,10 @@ def _report_session_summary(ui: UI, session) -> None:
     graph = session.graph
     done, total = graph.progress()
     ui.success(f"Project completed — {done}/{total} tasks verified")
+    skipped = graph.skipped_count()
+    if skipped:
+        # A skipped task is resolved, never counted as verified work.
+        ui.dim(f"  • Skipped: {skipped} task(s) not needed")
     evidence = session.session_evidence
     if evidence.tests:
         # What matters is the final state: the last test run passed.
@@ -1007,6 +1043,9 @@ def run(ui: UI) -> None:
     interactive menu remains available via /exit for provider/model/settings.
     """
     config = load_config()
+    # Register the saved custom providers before anything resolves a provider
+    # id (v7.2.5): the registry must reflect config.json from the first turn.
+    sync_custom_providers(config)
     set_active_theme(config.theme)
     ui.apply_theme(config.theme)
     ui.banner(config)
@@ -1017,8 +1056,15 @@ def run(ui: UI) -> None:
         config.is_configured(),
     )
 
+    def presenter_on_event(kind: str, detail: str) -> None:
+        """Surface provider retry/failover on the plain chat prompt (v7.2.5)."""
+        if kind == "switching_provider":
+            ui.warning(f"Switching provider: {detail}")
+        elif kind == "retry":
+            ui.dim(f"  {detail}")
+
     active_backend = config.provider
-    engine = ChatEngine(config)
+    engine = ChatEngine(config, on_event=presenter_on_event)
     history = HistoryStore(provider_id=active_backend)
     chat_session = _make_chat_session(ui)
 
@@ -1031,7 +1077,7 @@ def run(ui: UI) -> None:
             if config.provider != active_backend:
                 # Guided setup switched providers: rebuild the backend state.
                 active_backend = config.provider
-                engine = ChatEngine(config)
+                engine = ChatEngine(config, on_event=presenter_on_event)
                 history = HistoryStore(provider_id=active_backend)
             _chat_loop(ui, config, engine, history, chat_session)
         else:
@@ -1048,7 +1094,7 @@ def run(ui: UI) -> None:
             # backend/context and the new provider's own history store.
             _log.info("backend switched: %s -> %s", active_backend, config.provider)
             active_backend = config.provider
-            engine = ChatEngine(config)
+            engine = ChatEngine(config, on_event=presenter_on_event)
             history = HistoryStore(provider_id=active_backend)
 
         try:

seedcode/branding.py

@@ -8,10 +8,11 @@ the exact palette so every surface renders identical art:
   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.
+v7.2.5 note: this module stays a packaging/desktop asset. The terminal UI
+renders its own branding from :data:`seedcode.ui.dashboard.LOGO_LINES` (the
+exact ANSI wordmark, with a text fallback on narrow or non-Unicode consoles),
+so no terminal surface imports this module and the pixel-art mark never costs
+anything at startup.
 
 Stdlib only (struct/zlib): safe to import from anywhere in the package,
 costs nothing at startup, and keeps the brand byte-reproducible.

seedcode/commands/provider.py

@@ -11,12 +11,16 @@ switching behave identically.
 from __future__ import annotations
 
 from ..config import save_config
+from ..core.models import CustomProviderConfig, valid_base_url
 from ..core.providers import (
     PROVIDERS,
     ModelInfo,
     Provider,
     ProviderError,
     get_provider,
+    is_custom_provider_id,
+    sync_custom_providers,
+    visible_provider_ids,
 )
 from ..core.providers.base import STATUS_CONNECTED, STATUS_OFFLINE
 from ..core.providers.freemodel import AUTO_MODEL
@@ -26,6 +30,9 @@ from ..ui.selector import Option, select
 from ..ui.textbox import read_text
 from . import CommandContext, CommandResult, command
 
+#: Sentinel returned by the provider picker for "add a custom provider".
+_ADD_CUSTOM = "__add_custom__"
+
 
 # --- provider selection ------------------------------------------------------
 
@@ -52,9 +59,12 @@ def _resolve_provider(text: str) -> Provider | None:
 _GROUP_BUILTIN = "Built-in  ·  no API key needed"
 _GROUP_BYOK = "Your own API key"
 _GROUP_LOCAL = "Local  ·  runs on this machine"
+_GROUP_CUSTOM = "Custom  ·  your own endpoint"
 
 
 def _provider_group(provider: Provider) -> str:
+    if is_custom_provider_id(provider.id):
+        return _GROUP_CUSTOM
     if provider.local:
         return _GROUP_LOCAL
     if provider.id == "default":
@@ -83,14 +93,31 @@ def _provider_key_column(provider: Provider, config) -> str:
     return "API key needed"
 
 
-def _provider_menu(ui, config) -> Provider | None:
-    """Interactive provider selector: badge, backend, model, and key state."""
+def _provider_model_column(config, provider_id: str) -> str:
+    """The provider's currently selected model, or an em dash."""
+    custom = config.custom_provider(provider_id)
+    if custom is not None:
+        model = custom.model
+    else:
+        entry = config.providers.get(provider_id)
+        model = entry.model if entry else ""
+    if model == AUTO_MODEL:
+        return "Auto"
+    return model or "—"
+
+
+def _provider_menu(ui, config) -> str | None:
+    """Interactive provider selector: badge, backend, model, and key state.
+
+    Offers the v7.2.5 list — OpenRouter, Ollama and every saved custom
+    provider — plus an entry to add a new custom endpoint. A legacy built-in
+    appears only while the user is on it (backward compatibility).
+    """
     options = []
-    for p in PROVIDERS.values():
-        entry = config.providers.get(p.id)
-        model = entry.model if entry and entry.model else "—"
-        if model == AUTO_MODEL:
-            model = "Auto"
+    for pid in visible_provider_ids(config):
+        p = PROVIDERS.get(pid)
+        if p is None:
+            continue
         options.append(
             Option(
                 p.label,
@@ -98,12 +125,20 @@ def _provider_menu(ui, config) -> Provider | None:
                 badge=badge_for_status(p.status),
                 columns=(
                     _provider_backend(p, config),
-                    model,
+                    _provider_model_column(config, p.id),
                     _provider_key_column(p, config),
                 ),
                 group=_provider_group(p),
             )
         )
+    options.append(
+        Option(
+            "Add a custom provider…",
+            value=_ADD_CUSTOM,
+            detail="any OpenAI-compatible API: name, base URL, key",
+            group=_GROUP_CUSTOM,
+        )
+    )
     chosen = select(
         options,
         title="Provider",
@@ -113,7 +148,7 @@ def _provider_menu(ui, config) -> Provider | None:
     if chosen is None:
         ui.dim("Cancelled.")
         return None
-    return PROVIDERS[str(chosen)]
+    return str(chosen)
 
 
 def _collect_key(ui, config, provider: Provider, *, replacing: bool = False) -> bool:
@@ -154,14 +189,18 @@ def _ensure_ready(ui, config, provider: Provider) -> bool:
     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.
+    message but is never fatal — Ollama is auto-started (v7.2.5), and the
+    built-in Default connection can be replaced by another provider later.
     """
     if not provider.requires_key:
+        if provider.id == "ollama":
+            return _ensure_ollama(ui, config, provider)
+        # Use the provider's own status refresh so a build with no built-in
+        # credential reports "No API Key" (a setup state) instead of a false
+        # "Offline" (v7.2.5 pip-install fix).
         with ui.thinking(f"Checking {provider.label}"):
-            reachable = provider.detect(config)
-        provider.status = STATUS_CONNECTED if reachable else STATUS_OFFLINE
-        if reachable:
+            status = provider.refresh_status(config)
+        if status == STATUS_CONNECTED:
             ui.success(f"{provider.label} is ready.")
         else:
             ui.warning(provider.unavailable_hint(config))
@@ -180,15 +219,30 @@ def select_provider(ui, config, target: str = "") -> bool:
     """Switch the active provider; returns True when the switch completed.
 
     Only ``active_provider`` changes — every provider keeps its own saved
-    API key and model, so switching back restores them untouched.
+    API key and model, so switching back restores them untouched. Custom
+    providers are synchronised into the registry first so they resolve.
     """
+    sync_custom_providers(config)
     chosen: Provider | None = None
     if target:
         chosen = _resolve_provider(target)
+        if chosen is None:
+            entry = config.custom_provider(target)
+            if entry is not None:
+                chosen = get_provider(entry.id)
         if chosen is None:
             ui.warning(f"Unknown provider '{target}'.")
     if chosen is None:
-        chosen = _provider_menu(ui, config)
+        picked = _provider_menu(ui, config)
+        if picked is None:
+            return False
+        if picked == _ADD_CUSTOM:
+            entry = _add_custom_flow(ui, config)
+            if entry is None:
+                return False
+            chosen = get_provider(entry.id)
+        else:
+            chosen = PROVIDERS.get(picked)
     if chosen is None:
         return False
 
@@ -198,6 +252,11 @@ def select_provider(ui, config, target: str = "") -> bool:
         config.provider = previous  # cancelled key entry: keep the old backend
         return False
 
+    # An explicit selection clears any prior failure state, so a provider the
+    # user deliberately chose is tried again even if it had cooled down.
+    from ..core.providers import health as health_mod
+
+    health_mod.tracker().reset(chosen.id)
     save_config(config)
     ui.success(f"Provider set to {chosen.label}.")
     # The provider's own saved model is active again automatically.
@@ -208,6 +267,201 @@ def select_provider(ui, config, target: str = "") -> bool:
     return True
 
 
+# --- Ollama auto-start -------------------------------------------------------
+
+
+def _ensure_ollama(ui, config, provider: Provider) -> bool:
+    """Ensure the local Ollama server is running, starting it if needed.
+
+    Starting the server never fails the selection: if it cannot be started,
+    the user is told exactly what to do and may pick another provider.
+    """
+    from ..core.providers.ollama_start import ensure_running
+
+    if provider.detect(config):
+        provider.status = STATUS_CONNECTED
+        ui.success(f"{provider.label} is ready.")
+        return True
+
+    ui.info("Ollama server not detected — starting it…")
+    ok, message = ensure_running(config, on_status=lambda line: ui.dim(f"  {line}"))
+    if ok:
+        provider.status = STATUS_CONNECTED
+        ui.success(message)
+    else:
+        provider.status = STATUS_OFFLINE
+        ui.warning(message)
+    return True
+
+
+# --- custom providers --------------------------------------------------------
+
+
+def custom_providers_menu(ui, config) -> None:
+    """Manage the saved custom providers: add, use, edit, test, reorder, delete."""
+    sync_custom_providers(config)
+    while True:
+        entries = config.ordered_custom_providers()
+        items = [MenuItem("Add a custom provider…", "add", badge="new")]
+        for entry in entries:
+            state = "enabled" if entry.enabled else "disabled"
+            items.append(
+                MenuItem(
+                    entry.name,
+                    f"pick:{entry.id}",
+                    status=f"{entry.base_url} · {state} · {config.masked_key(entry.id)}",
+                )
+            )
+        items.append(MenuItem("Back", "back"))
+        choice = run_menu(
+            items,
+            title=f"Custom providers ({len(entries)})",
+            hint="↑↓ move   Enter select   Esc back",
+        )
+        if choice is None or choice == "back":
+            return
+        if choice == "add":
+            _add_custom_flow(ui, config)
+            continue
+        _custom_actions(ui, config, str(choice).split(":", 1)[1])
+
+
+def _add_custom_flow(ui, config) -> CustomProviderConfig | None:
+    """Prompt for Name, Base URL, API Key (and optional model); save + test."""
+    ui.info("Add a custom provider — any OpenAI-compatible API.")
+    while True:
+        name = read_text("Name > ")
+        if name is None or not name.strip():
+            ui.dim("Cancelled — no provider added.")
+            return None
+        base_url = read_text("Base URL > ")
+        if base_url is None or not base_url.strip():
+            ui.dim("Cancelled — no provider added.")
+            return None
+        if not valid_base_url(base_url):
+            ui.error("Base URL must start with http:// or https://")
+            continue
+        key = read_text("API Key > ", password=True)
+        if key is None:
+            ui.dim("Cancelled — no provider added.")
+            return None
+        model = read_text("Model (optional) > ") or ""
+        try:
+            entry = config.add_custom_provider(name, base_url, key, model)
+        except ValueError as exc:
+            ui.error(str(exc))
+            continue
+        sync_custom_providers(config)
+        save_config(config)
+        ui.success(f"Saved custom provider '{entry.name}'.")
+        _test_connection(ui, config, entry.id)
+        return entry
+
+
+def _edit_custom_flow(ui, config, provider_id: str) -> None:
+    """Edit a saved custom provider; an empty answer keeps the current value."""
+    entry = config.custom_provider(provider_id)
+    if entry is None:
+        return
+    ui.info(f"Editing '{entry.name}' — press Enter to keep the current value.")
+    name = read_text(f"Name [{entry.name}] > ")
+    base_url = read_text(f"Base URL [{entry.base_url}] > ")
+    key = read_text("API Key (keep current) > ", password=True)
+    model = read_text(f"Model [{entry.model or 'none'}] > ")
+    try:
+        config.update_custom_provider(
+            provider_id,
+            name=(name.strip() if name and name.strip() else None),
+            base_url=(base_url.strip() if base_url and base_url.strip() else None),
+            api_key=(key.strip() if key and key.strip() else None),
+            model=(model.strip() if model and model.strip() else None),
+        )
+    except ValueError as exc:
+        ui.error(str(exc))
+        return
+    save_config(config)
+    sync_custom_providers(config)
+    ui.success("Saved.")
+
+
+def _test_connection(ui, config, provider_id: str) -> bool:
+    """Validate a provider's own credential with a real request."""
+    from ..core.providers import health as health_mod
+
+    try:
+        provider = get_provider(provider_id)
+    except ProviderError as exc:
+        ui.error(str(exc))
+        return False
+    with ui.thinking(f"Testing {provider.label}"):
+        result = provider.validate_key(config.get_api_key(provider_id))
+    if result.ok:
+        provider.status = STATUS_CONNECTED
+        health_mod.tracker().record_success(provider_id)
+        ui.success(result.message)
+    else:
+        provider.status = STATUS_OFFLINE
+        health_mod.tracker().record_failure(provider_id, reason=result.message)
+        ui.warning(result.message)
+    return result.ok
+
+
+def _custom_actions(ui, config, provider_id: str) -> None:
+    """Per-provider actions: use, edit, test, enable/disable, reorder, delete."""
+    while True:
+        entry = config.custom_provider(provider_id)
+        if entry is None:
+            return
+        state = "enabled" if entry.enabled else "disabled"
+        choice = run_menu(
+            [
+                MenuItem("Use this provider", "use"),
+                MenuItem("Edit", "edit"),
+                MenuItem("Test connection", "test"),
+                MenuItem("Disable" if entry.enabled else "Enable", "toggle"),
+                MenuItem("Move up", "up"),
+                MenuItem("Move down", "down"),
+                MenuItem("Delete", "delete"),
+                MenuItem("Back", "back"),
+            ],
+            title=f"{entry.name} — {state}",
+            hint="↑↓ move   Enter select   Esc back",
+        )
+        if choice is None or choice == "back":
+            return
+        if choice == "use":
+            select_provider(ui, config, entry.id)
+            return
+        if choice == "edit":
+            _edit_custom_flow(ui, config, provider_id)
+        elif choice == "test":
+            _test_connection(ui, config, provider_id)
+        elif choice == "toggle":
+            config.set_custom_enabled(provider_id, not entry.enabled)
+            save_config(config)
+            sync_custom_providers(config)
+            ui.success(f"'{entry.name}' {'disabled' if entry.enabled else 'enabled'}.")
+        elif choice in ("up", "down"):
+            moved = config.move_custom_provider(
+                provider_id, -1 if choice == "up" else 1
+            )
+            save_config(config)
+            sync_custom_providers(config)
+            ui.dim("Reordered." if moved else "Already at the edge.")
+        elif choice == "delete":
+            from ..ui.dialog import confirm_dialog
+
+            name = entry.name
+            if confirm_dialog(
+                f"Delete '{name}'?", yes_label="Delete", no_label="Keep", danger=True
+            ):
+                config.remove_custom_provider(provider_id)
+                save_config(config)
+                sync_custom_providers(config)
+                ui.success(f"Deleted '{name}'.")
+                return
+
+
 # --- model selection ---------------------------------------------------------
 
 
@@ -387,14 +641,23 @@ def select_model(ui, config, target: str = "") -> None:
 
 @command(
     "provider",
-    "Select the active provider "
-    "(Default, OpenRouter, FreeModel Claude, FreeModel Codex, AeroLink, Ollama)",
+    "Select the active provider (OpenRouter, Ollama, or a saved custom provider)",
 )
 def _provider_cmd(ctx: CommandContext, arg: str) -> CommandResult:
     select_provider(ctx.ui, ctx.config, arg.strip())
     return CommandResult()
 
 
+@command(
+    "custom",
+    "Manage custom providers (add, edit, test, reorder, enable, delete)",
+    aliases=("custom-providers", "providers"),
+)
+def _custom_cmd(ctx: CommandContext, arg: str) -> CommandResult:
+    custom_providers_menu(ctx.ui, ctx.config)
+    return CommandResult()
+
+
 @command("model", "Browse and select a model for the active provider", aliases=("show",))
 def _model_cmd(ctx: CommandContext, arg: str) -> CommandResult:
     target = arg.strip()