seedcode-cli 6.1.5__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.1.5"
+__version__ = "6.2.5"
 __author__ = "Al shahriar sowan"
 __publisher__ = "Eagox Studio"
 

seedcode/_default_key_template.py

@@ -0,0 +1,16 @@
+"""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 = ""
+DEFAULT_API_ENABLED = False
+DEFAULT_API_NOTE = "embedded default key unavailable (development checkout)"

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
@@ -52,13 +56,17 @@ _KEY_ACTIONS = {
 }
 
 
-def _exit_application(reason: str) -> None:
+def _exit_application(ui: "UI", reason: str) -> None:
     """The single, explicit application-exit decision.
 
     Called only from unambiguous user actions (the menu's Exit item, leaving
     the menu with Esc/Ctrl+C/Ctrl+D). Marks the lifecycle, enters SHUTDOWN
     (running teardown hooks), and returns; :func:`run` then unwinds and
     ``main`` finishes normally. Task completion and errors never reach here.
+
+    ``ui`` is passed in explicitly by :func:`run` — this module has no global
+    UI instance, and referencing one from here was the root cause of the
+    ``NameError: name 'ui' is not defined`` users saw on Exit.
     """
     lc = lifecycle()
     lc.request_exit(reason)
@@ -98,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:
@@ -120,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.
 
@@ -227,6 +288,21 @@ def _handle_agent(ui: UI, agent: AgentEngine, history: HistoryStore, text: str)
     else:
         ui.dim("(no response)")
     history.save(agent.transcript)
+    # v6.2.0: Code Mode sessions leave a compact summary in .seedcode/sessions.
+    try:
+        from . import codemode_state as _cms
+
+        state = _cms.codemode_state()
+        if state.enabled and state.store is not None:
+            state.store.save_session_summary({
+                "goal": text[:200],
+                "outcome": (final.strip() or "(no response)")[:400],
+                "tool_calls": sum(
+                    1 for m in agent.messages if m.role == "tool"
+                ),
+            })
+    except Exception:
+        pass
 
 
 def _make_agent(ui: UI, config: AppConfig) -> AgentEngine:
@@ -324,20 +400,25 @@ 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
     # prompt and permission gates reflect both).
     agent: AgentEngine | None = None
     agent_perm = config.permission_mode
+    # v6.2.0: track Code Mode so a /codemode toggle rebuilds the agent with
+    # workspace context (the engine is constructed lazily per turn).
+    try:
+        from . import codemode_state as _cms
+
+        agent_codemode = _cms.enabled
+    except Exception:
+        agent_codemode = False
 
     while True:
         try:
@@ -371,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
@@ -389,14 +470,75 @@ def _chat_loop(
         # prompts again. A task can never end the app.
         with lifecycle().task_span():
             if config.agent_mode:
-                if agent is None or agent_perm != config.permission_mode:
+                try:
+                    from . import codemode_state as _cms
+
+                    codemode_now = _cms.enabled
+                except Exception:
+                    codemode_now = False
+                if (
+                    agent is None
+                    or agent_perm != config.permission_mode
+                    or agent_codemode != codemode_now
+                ):
                     agent = _make_agent(ui, config)
                     agent_perm = config.permission_mode
+                    agent_codemode = codemode_now
                 _handle_agent(ui, agent, history, text)
             else:
                 _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()
@@ -442,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)
@@ -477,7 +619,7 @@ def run(ui: UI) -> None:
             choice = _main_menu(config)
         except (KeyboardInterrupt, EOFError):
             # The user explicitly left the menu — the app-exit decision.
-            _exit_application("menu interrupt")
+            _exit_application(ui, "menu interrupt")
             return
 
         try:
@@ -492,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":
@@ -499,10 +649,10 @@ def run(ui: UI) -> None:
             elif choice == "about":
                 show_about(ui, config)
             elif choice in ("exit", None):
-                _exit_application("menu exit")
+                _exit_application(ui, "menu exit")
                 return
         except (KeyboardInterrupt, EOFError):
             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/apps/discovery.py

@@ -19,7 +19,8 @@ from __future__ import annotations
 
 import os
 import shutil
-from dataclasses import dataclass, field
+import time
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
 
@@ -50,7 +51,32 @@ _START_MENU_DIRS = (
 )
 
 
+# --- v6.2.0 discovery caches ----------------------------------------------------
+# Start Menu scans (rglob over two trees) and the registry walks (App Paths +
+# uninstall keys) are the slow part of discovery; installed software changes
+# on the scale of minutes, not milliseconds, so caching them briefly is safe.
+# Entries are copied on return so callers (find_app resolves the exe on an
+# uninstall entry) can never mutate the cached record.
+_START_MENU_TTL_S = 5.0
+_REGISTRY_TTL_S = 30.0
+_start_menu_cache: tuple[float, list[Path]] | None = None
+_app_paths_cache: tuple[float, dict[str, AppInfo]] | None = None
+_uninstall_cache: tuple[float, dict[str, AppInfo]] | None = None
+
+
+def _reset_discovery_cache() -> None:
+    """Drop all discovery caches (tests, session teardown)."""
+    global _start_menu_cache, _app_paths_cache, _uninstall_cache
+    _start_menu_cache = None
+    _app_paths_cache = None
+    _uninstall_cache = None
+
+
 def _iter_start_menu() -> list[Path]:
+    global _start_menu_cache
+    now = time.monotonic()
+    if _start_menu_cache is not None and now - _start_menu_cache[0] < _START_MENU_TTL_S:
+        return list(_start_menu_cache[1])
     shortcuts: list[Path] = []
     for base in _START_MENU_DIRS:
         try:
@@ -58,7 +84,8 @@ def _iter_start_menu() -> list[Path]:
                 shortcuts.extend(base.rglob("*.lnk"))
         except OSError:
             continue
-    return shortcuts
+    _start_menu_cache = (now, shortcuts)
+    return list(shortcuts)
 
 
 def _shortcut_display_name(path: Path) -> str:
@@ -76,6 +103,9 @@ def _match_name(haystack: str, needle: str) -> bool:
 # --- source 2: App Paths -----------------------------------------------------------
 def _app_paths() -> dict[str, AppInfo]:
     """``App Paths`` registrations: exe name -> full path (best-effort)."""
+    global _app_paths_cache
+    if _app_paths_cache is not None and time.monotonic() - _app_paths_cache[0] < _REGISTRY_TTL_S:
+        return {k: replace(v) for k, v in _app_paths_cache[1].items()}
     found: dict[str, AppInfo] = {}
     if os.name != "nt":
         return found
@@ -108,12 +138,16 @@ def _app_paths() -> dict[str, AppInfo]:
                     )
     except ImportError:
         pass
+    _app_paths_cache = (time.monotonic(), found)
     return found
 
 
 # --- source 3: uninstall registrations ----------------------------------------------
 def _uninstall_apps() -> dict[str, AppInfo]:
     """Display-name/install-location entries from the uninstall keys."""
+    global _uninstall_cache
+    if _uninstall_cache is not None and time.monotonic() - _uninstall_cache[0] < _REGISTRY_TTL_S:
+        return {k: replace(v) for k, v in _uninstall_cache[1].items()}
     found: dict[str, AppInfo] = {}
     if os.name != "nt":
         return found
@@ -158,6 +192,7 @@ def _uninstall_apps() -> dict[str, AppInfo]:
                         found.setdefault(name.lower(), entry)
     except ImportError:
         pass
+    _uninstall_cache = (time.monotonic(), found)
     return found
 
 

seedcode/branding.py

@@ -0,0 +1,95 @@
+"""Canonical Seed Code brand artwork — single source of truth.
+
+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:
+
+* ``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.
+"""
+
+from __future__ import annotations
+
+import struct
+import zlib
+
+GRID = 16  # the mark is authored on a 16x16 grid
+
+# --- palette (mirrors seedcode/ui/theme.py) ---------------------------------
+ACCENT = (123, 237, 159, 255)  # Soft Green — leaf highlight
+PRIMARY = (46, 204, 113, 255)  # Seed Green — leaf body
+DARK = (27, 122, 67, 255)      # seed body
+TILE_BG = (13, 17, 23, 255)    # dark rounded tile behind the mark
+CLEAR = (0, 0, 0, 0)           # outside the rounded tile (transparent)
+
+# --- the mark: a sprouting seed, 16x16 --------------------------------------
+ART: list[str] = [
+    "................",
+    "................",
+    "...LL.....GG....",
+    "..LLLL...GGGG...",
+    ".LLLLLL.GGGGG...",
+    ".LLLLLL.GGGGGG..",
+    "..LLLLL.GGGGG...",
+    "...LLLL.GGGG....",
+    ".....LL.GG......",
+    "......LGG.......",
+    ".......G........",
+    ".......G........",
+    "......DDD.......",
+    ".....DDDDD......",
+    ".....DDDDD......",
+    "......DDD.......",
+]
+INK = {"L": ACCENT, "G": PRIMARY, "D": DARK}
+
+Pixel = tuple[int, int, int, int]
+
+
+def logo_pixels(size: int = GRID) -> list[list[Pixel]]:
+    """Render the mark at ``size`` px: rounded dark tile + scaled pixel art."""
+    radius = size * 3 // 16
+    grid = [[CLEAR] * size for _ in range(size)]
+    for y in range(size):
+        for x in range(size):
+            # Rounded-rect clip: inside unless outside a corner circle.
+            cx = radius if x < radius else (size - 1 - radius if x >= size - radius else x)
+            cy = radius if y < radius else (size - 1 - radius if y >= size - radius else y)
+            if (x - cx) ** 2 + (y - cy) ** 2 > radius * radius and (
+                (x < radius or x >= size - radius) and (y < radius or y >= size - radius)
+            ):
+                continue
+            cell = ART[y * GRID // size][x * GRID // size]
+            grid[y][x] = INK.get(cell, TILE_BG)
+    return grid
+
+
+def render_logo_png(size: int = 256) -> bytes:
+    """Encode the mark at ``size`` px as an RGBA PNG (the canonical asset)."""
+    grid = logo_pixels(size)
+    h = w = size
+
+    def chunk(tag: bytes, data: bytes) -> bytes:
+        return (
+            struct.pack(">I", len(data)) + tag + data
+            + struct.pack(">I", zlib.crc32(tag + data))
+        )
+
+    raw = b"".join(
+        b"\x00" + b"".join(bytes(px) for px in row) for row in grid
+    )
+    return (
+        b"\x89PNG\r\n\x1a\n"
+        + chunk(b"IHDR", struct.pack(">IIBBBBB", w, h, 8, 6, 0, 0, 0))
+        + chunk(b"IDAT", zlib.compress(raw, 9))
+        + chunk(b"IEND", b"")
+    )

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.")