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

seedcode/__init__.py

@@ -6,9 +6,12 @@ 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.5"
-__author__ = "Al shahriar sowan"
+__version__ = "7.1.0"
+__author__ = "Al Shahriar Sowan"
 __publisher__ = "Eagox Studio"
+# Current author/company links, surfaced by /about and the README credits.
+__portfolio_url__ = "https://alshahriarsayon.vercel.app/"
+__studio_url__ = "https://eagoxstudio.vercel.app/"
 
 APP_NAME = "Seed Code"
 TAGLINE = "Plant ideas. Grow code."

seedcode/_default_key_template.py

@@ -1,4 +1,4 @@
-"""Embedded built-in credential for the Default provider (v6.2.5 artifact).
+"""Embedded built-in credential for the Default provider (v7.1.0 artifact).
 
 This file is NOT committed to source control. The release build generates
 ``seedcode/_default_key.py`` from the local ``.env`` (see

seedcode/app.py

@@ -30,7 +30,7 @@ from .commands.theme import pick_theme
 from .config import load_config
 from .core.agent import AgentEngine, strip_tool_blocks
 from .core.chat import ChatEngine, ChatError
-from .core.lifecycle import lifecycle
+from .core.lifecycle import LifecycleError, lifecycle
 from .core.models import AppConfig
 from .core.providers import PROVIDERS, provider_label, provider_ready
 from .core.providers.freemodel import AUTO_MODEL
@@ -40,6 +40,7 @@ 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.tasks import TaskFlow, TaskState
 from .ui.textbox import prompt_label
 from .ui.theme import pt_style, set_active_theme
 from .utils.logger import get_logger
@@ -84,7 +85,17 @@ def _release_desktop_resources() -> None:
     Cleanup clears caches and closes driver connections only. It must never
     terminate SeedCode — historically a finally-block that "cleaned up" by
     exiting was one of the auto-exit paths.
+
+    v7.1.0 additionally guarantees the other direction: cleanup never closes a
+    user-facing application. Applications Seed Code opened stay open, which is
+    why this hook releases only internal resources (sockets, drivers, caches).
     """
+    try:
+        from .computer import lifecycle_guard
+
+        lifecycle_guard.release_internal()  # logs what is deliberately left open
+    except Exception:
+        pass
     try:
         from .computer.browser_cdp import reset as _cdp_reset
 
@@ -256,56 +267,469 @@ def _handle_chat(ui: UI, engine: ChatEngine, history: HistoryStore, text: str) -
             ui.dim("(no response)")
 
 
-def _handle_agent(ui: UI, agent: AgentEngine, history: HistoryStore, text: str) -> None:
-    """Run one full Assist turn (tool loop) and render the final answer.
+class _TaskPresenter:
+    """Bridges engine activity to the live step view (and plain narration).
 
-    Lifecycle note: every outcome — success, tool failure, provider error,
-    Ctrl+C — ends with a rendered message and a return. Nothing here may
-    terminate the process; the surrounding ``task_span`` guarantees the
-    lifecycle returns to IDLE and the REPL keeps prompting.
+    One presenter per chat session; ``flow`` is set for the duration of a turn
+    so the engine's callbacks land in that turn's task view. Everything here is
+    best-effort: the presenter can never fail a task.
+    """
+
+    # Live command output is echoed compactly; the full output still goes to
+    # the model and the log file, and errors are never hidden.
+    MAX_ECHO_LINES = 8
+
+    def __init__(self, ui: UI) -> None:
+        self.ui = ui
+        self.flow: TaskFlow | None = None
+        self._echo_lines = 0
+        self._echo_elided = False
+
+    # --- one command's live output ------------------------------------------
+    def reset_echo(self) -> None:
+        self._echo_lines = 0
+        self._echo_elided = False
+
+    def on_output(self, line: str) -> None:
+        """Compact live echo: the first few lines, then a single elision note."""
+        if self._echo_lines < self.MAX_ECHO_LINES:
+            self.ui.dim(f"  │ {line[:200]}")
+        elif not self._echo_elided:
+            self._echo_elided = True
+            self.ui.dim(
+                f"  │ … output continues (first {self.MAX_ECHO_LINES} lines shown; "
+                "the agent and the log file get it all)"
+            )
+        self._echo_lines += 1
+
+    # --- narration (human-readable) -----------------------------------------
+    def on_event(self, kind: str, detail: str) -> None:
+        flow = self.flow
+        if kind == "say" and flow is not None:
+            flow.observe_text(detail)
+            return
+        if kind == "error":
+            self.ui.dim(f"  ✖ {detail.splitlines()[0][:120]}")
+        elif kind == "limit":
+            self.ui.warning(f"Assist stopped: {detail}")
+        elif kind == "call" and flow is None:
+            # With a task view on screen the step list already shows the tool
+            # work; without one, narrate it (the plain/legacy experience).
+            self.ui.dim(f"  ⚒ {detail}")
+
+    # --- structured activity -> step states ---------------------------------
+    def on_step(self, payload: dict) -> None:
+        flow = self.flow
+        if flow is None:
+            return
+        phase = str(payload.get("phase") or "")
+        name = str(payload.get("name") or "")
+        args = payload.get("args") or {}
+        if phase == "tool_start":
+            self.reset_echo()
+            flow.observe_tool_start(name, args)
+        elif phase == "tool_done":
+            flow.observe_tool_done(
+                name,
+                bool(payload.get("ok")),
+                str(payload.get("output") or ""),
+                args,
+            )
+        elif phase == "say":
+            flow.observe_text(str(payload.get("text") or ""))
+
+
+    # --- persistent session events (Code Mode) ------------------------------
+    def on_session_event(self, kind: str, detail: str) -> None:
+        """Render compact progress for the persistent session (v7.1.0).
+
+        Only what the user needs: the plan, the task that just finished, the
+        live action, a repair in progress, and the outcome. Raw model output is
+        never dumped here.
+        """
+        from .core import session as session_mod
+
+        flow = self.flow
+        session = session_mod.current_session()
+        if kind == "plan":
+            self.ui.dim("  planning the work…")
+            return
+        if kind == "plan_ready":
+            self.ui.dim(f"  plan: {detail}")
+        elif kind == "task_start":
+            active = None
+            if flow is not None and session is not None:
+                flow.attach_plan(session.graph)
+                active = session.graph.active() or session.graph.next_task()
+                if active is not None:
+                    flow.set_progress(active.id, session.graph.total, active.title)
+                    # The live action line reports the real phase (v7.1.0).
+                    flow.set_activity(f"Working on: {active.title}")
+            self.ui.dim(f"  → {detail}")
+        elif kind == "verify":
+            # A real phase, not decoration: the session is checking acceptance
+            # criteria against observed evidence right now.
+            if flow is not None:
+                flow.set_activity("Verifying acceptance criteria")
+        elif kind == "task_done":
+            if flow is not None and session is not None:
+                # Refresh the checklist so the finished task shows as done.
+                flow.attach_plan(session.graph)
+            self.ui.success(detail)
+        elif kind == "recovery":
+            if flow is not None:
+                flow.set_activity("Diagnosing the failure and repairing")
+            self.ui.warning(detail)
+        elif kind == "task_blocked":
+            self.ui.warning(detail)
+        elif kind == "task_failed":
+            self.ui.error(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 in ("retry", "continue"):
+            self.ui.dim(f"  {detail}")
+        if flow is not None and session is not None:
+            flow.note_call(session.model_calls)
+        state = {
+            "session_paused": "paused",
+            "session_cancelled": "cancelled",
+            "session_failed": "failed",
+            "session_completed": "completed",
+        }.get(kind)
+        if flow is not None and state is not None:
+            if session is not None:
+                flow.attach_plan(session.graph)  # final, real plan state
+            flow.set_state(state)
+
+
+def _advance(lc, method: str) -> None:
+    """Best-effort lifecycle transition around one turn.
+
+    The REPL owns the turn span (``PLANNING`` → … → ``IDLE``); this lets the
+    turn *narrate* where it is without ever turning a phase mismatch into a
+    task failure — a lifecycle bookkeeping problem must not stop the work.
+    """
+    try:
+        getattr(lc, method)()
+    except LifecycleError:
+        _log.debug("lifecycle transition %s skipped", method)
+
+
+def _codemode_enabled() -> bool:
+    """Whether Code Mode is active (the persistent-session path)."""
+    try:
+        from . import codemode_state as _cms
+
+        state = _cms.codemode_state()
+        return bool(state.enabled and state.workspace is not None)
+    except Exception:
+        return False
+
+
+def resume_codemode_session(ui: UI, config: AppConfig, history=None) -> bool:
+    """Continue a paused/checkpointed Code Mode session (used by /resume).
+
+    Returns whether a session was actually resumed. The agent is rebuilt for
+    the current config (exactly as a fresh turn would), so a resume after a
+    provider or permission change still runs with the live settings.
     """
+    from .core import session as session_mod
+    from .core.session import CodeSession
+
+    workspace, store = _codemode_workspace()
+    if store is None:
+        return False
+    agent = _make_agent(ui, config, _TaskPresenter(ui))
+    presenter = agent_presenter(agent)
+    session = CodeSession.resume(
+        agent,
+        store=store,
+        workspace=workspace,
+        on_event=presenter.on_session_event if presenter is not None else None,
+    )
+    if session is None:
+        return False
+    session.control.clear()
+    _handle_codemode(
+        ui,
+        agent,
+        history if history is not None else HistoryStore(provider_id=config.provider),
+        session.request,
+        presenter,
+        session=session,
+    )
+    session_mod.set_current_session(None)
+    return True
+
+
+def agent_presenter(agent: AgentEngine) -> _TaskPresenter | None:
+    """The presenter an engine was built with (used by /resume)."""
+    presenter = getattr(agent, "presenter", None)
+    return presenter if isinstance(presenter, _TaskPresenter) else None
+
+
+def _task_mode_label(config: AppConfig) -> str:
+    """The mode named in a task header (Code Mode sharpens Assist Mode)."""
+    try:
+        from .codemode_state import codemode_state
+
+        if codemode_state().enabled:
+            return "Code Mode"
+    except Exception:
+        pass
+    return "Assist Mode"
+
+
+def _save_codemode_summary(agent: AgentEngine, text: str, outcome: str) -> None:
+    """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": (outcome or "(no response)")[:400],
+                "tool_calls": sum(1 for m in agent.messages if m.role == "tool"),
+            })
+    except Exception:
+        pass
+
+
+def _codemode_workspace():
+    """The active Code Mode workspace + store, or (CWD, None) when unavailable."""
+    try:
+        from . import codemode_state as _cms
+
+        state = _cms.codemode_state()
+        if state.enabled and state.workspace is not None:
+            return state.workspace, state.store
+    except Exception:
+        _log.exception("could not read the Code Mode workspace")
+    from pathlib import Path
+
+    return Path.cwd(), None
+
+
+def _handle_codemode(
+    ui: UI,
+    agent: AgentEngine,
+    history: HistoryStore,
+    text: str,
+    presenter: _TaskPresenter | None = None,
+    *,
+    session=None,
+) -> None:
+    """Run one persistent Code Mode session: plan → tasks → verification.
+
+    Unlike a single agent turn, this keeps working until every planned task is
+    verified (or the session is paused, cancelled, or blocked), then runs final
+    verification. The task view shows the plan and real progress, and the CLI
+    is ready for the next task in every outcome.
+    """
+    from .core import session as session_mod
+    from .core.session import CodeSession, SessionStatus
+
     lc = lifecycle()
+    workspace, store = _codemode_workspace()
+    flow = TaskFlow.for_ui(ui, mode_label="Code Mode", task=text)
+    if presenter is not None:
+        presenter.flow = flow
+    if flow is not None:
+        flow.begin()
+        flow.start()
+
+    if session is None:
+        session = CodeSession(
+            agent,
+            workspace=workspace,
+            request=text,
+            store=store,
+            on_event=presenter.on_session_event if presenter is not None else None,
+        )
+    elif presenter is not None:
+        session.set_observer(presenter.on_session_event)
+
+    session_mod.set_current_session(session)
+    status = SessionStatus.IDLE
+    try:
+        _advance(lc, "to_executing")
+        status = session.run()
+        _advance(lc, "to_verifying")
+    except KeyboardInterrupt:
+        session_mod.stop(session)
+        status = SessionStatus.CANCELLED
+        session.reason = "cancelled by the user"
+    except Exception as exc:  # an engine bug must not kill the session either
+        status = SessionStatus.FAILED
+        session.reason = f"{type(exc).__name__}: {exc}"
+        _log.exception("code mode session failed")
+    finally:
+        if presenter is not None:
+            presenter.flow = None
+
+    if session.store is not None and status is not SessionStatus.PAUSED:
+        _save_codemode_summary(agent, text, session.reason or status.value)
+
+    if status is SessionStatus.COMPLETED:
+        _advance(lc, "to_responding")
+        history.save(agent.transcript)
+        _report_session_summary(ui, session)
+        if flow is not None:
+            flow.finish("completed")
+        return
+
+    if status is SessionStatus.PAUSED:
+        # State is preserved and checkpointed: /resume continues this session.
+        if flow is not None:
+            flow.set_state("paused")
+            flow.stop()
+        ui.warning("Session paused — state saved. Send /resume to continue.")
+        session_mod.set_current_session(session)
+        return
+
+    session_mod.set_current_session(None)
+    if status is SessionStatus.CANCELLED:
+        ui.blank()
+        # v7.1.0: state is checkpointed on the way out, so say so — the session
+        # is resumable rather than lost (the terminal itself stays open).
+        ui.dim(
+            "(session stopped — the plan, completed work and the project files "
+            "were kept; /resume continues from the checkpoint)"
+        )
+        if flow is not None:
+            flow.finish("cancelled")
+        return
+    reason = session.reason or "the session could not finish the plan"
+    ui.error(reason)
+    if flow is not None:
+        flow.finish("failed", reason)
 
+
+def _report_session_summary(ui: UI, session) -> None:
+    """The final block: the evidence, in one compact summary (v7.1.0).
+
+    Completion is evidence-gated, so the closing block reports the evidence
+    itself rather than a restatement of the model's replies: the verification
+    result, the tests that actually ran, the commands that actually succeeded,
+    and the files the engine really touched. Lines that have nothing to report
+    are omitted instead of being filled in with a placeholder.
+    """
+    graph = session.graph
+    done, total = graph.progress()
+    ui.success(f"Project completed — {done}/{total} tasks verified")
+    evidence = session.session_evidence
+    if evidence.tests:
+        # What matters is the final state: the last test run passed.
+        passed = evidence.tests[-1].ok
+        ui.dim(f"  ✓ Verification: {'accepted' if passed else 'tests NOT passing'}")
+        ui.dim(f"  ✓ Tests: {'passed' if passed else 'FAILED'}")
+    else:
+        ui.dim("  ✓ Verification: accepted (no test run in this project)")
+    if session.state.changed_files:
+        ui.dim(f"  ✓ Files: {len(session.state.changed_files)} affected")
+    commands = evidence.commands
+    if commands:
+        ok = sum(1 for record in commands if record.ok)
+        ui.dim(f"  ✓ Commands: {ok}/{len(commands)} ok")
+    if session.state.inspected:
+        ui.dim(f"  • Inspected: {len(session.state.inspected)} item(s)")
+
+
+def _handle_agent(
+    ui: UI,
+    agent: AgentEngine,
+    history: HistoryStore,
+    text: str,
+    presenter: _TaskPresenter | None = None,
+) -> None:
+    """Run one full Assist/Code turn (tool loop) and render the final answer.
+
+    The turn is shown as a compact live task flow whose step states follow real
+    engine activity (see :mod:`seedcode.ui.tasks`) — never a fake progress bar.
+
+    Lifecycle note: every outcome — success, tool failure, provider error,
+    Ctrl+C — ends by printing a status, finishing the task view and RETURNING.
+    Nothing here may terminate the process; the surrounding ``task_span``
+    guarantees the lifecycle returns to IDLE and the REPL keeps prompting, and
+    the explicit task-flow finish line always says the CLI is ready for more.
+    """
+    if _codemode_enabled():
+        _handle_codemode(ui, agent, history, text, presenter)
+        return
+
+    lc = lifecycle()
+    flow = TaskFlow.for_ui(
+        ui, mode_label=_task_mode_label(agent.config), task=text
+    )
+    if presenter is not None:
+        presenter.flow = flow
+    if flow is not None:
+        flow.begin()
+        flow.start()
+
+    outcome = "completed"
+    reason = ""
+    reply: str | None = None
     try:
-        with ui.thinking("Working"):
-            lc.to_executing()
+        if flow is None:  # the task view already shows that work is happening
+            with ui.thinking("Working"):
+                _advance(lc, "to_executing")
+                reply = agent.run_turn(text)
+        else:
+            _advance(lc, "to_executing")
             reply = agent.run_turn(text)
-        lc.to_verifying()
+        _advance(lc, "to_verifying")
     except ChatError as exc:
-        ui.error(str(exc))
-        return
+        outcome, reason = "failed", str(exc)
     except KeyboardInterrupt:
-        # Ctrl+C aborts the remaining Assist steps; work already done stays.
-        ui.blank()
-        ui.dim("(assist turn cancelled — completed tool actions were kept)")
+        # Ctrl+C aborts the remaining steps; work already done stays.
+        outcome = "cancelled"
+    except Exception as exc:  # an engine bug must not kill the session either
+        outcome, reason = "failed", f"{type(exc).__name__}: {exc}"
+        _log.exception("assist turn failed")
+    finally:
+        if presenter is not None:
+            presenter.flow = None
+
+    if outcome != "completed":
+        if reason:
+            ui.error(reason)
+        else:
+            ui.blank()
+            ui.dim("(task cancelled — completed tool actions were kept)")
+        _save_codemode_summary(agent, text, reason or "task cancelled")
+        if flow is not None:
+            flow.finish(outcome, reason)
         return
 
-    lc.to_responding()
-    final = strip_tool_blocks(reply)
+    _advance(lc, "to_responding")
+    if flow is not None:
+        flow.update("verify", TaskState.RUNNING, "checking the result")
+        # Hand the screen back before streaming the answer: one live display at
+        # a time, and the answer deserves the full width.
+        flow.stop()
+    final = strip_tool_blocks(reply or "")
     if final.strip():
         with ui.streaming() as renderer:
             renderer.feed(final)
     else:
         ui.dim("(no response)")
+    if flow is not None:
+        flow.update("verify", TaskState.COMPLETED, "answer produced")
     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
+    _save_codemode_summary(agent, text, final.strip() or "(no response)")
+    if flow is not None:
+        # Prints the persistent final block and leaves the prompt ready for the
+        # next task — the terminal is never closed from here.
+        flow.finish("completed")
 
 
-def _make_agent(ui: UI, config: AppConfig) -> AgentEngine:
+def _make_agent(
+    ui: UI, config: AppConfig, presenter: "_TaskPresenter | None" = None
+) -> AgentEngine:
     """Build an Assist engine bound to the CWD and the configured permissions."""
     # Lazy import (matching _make_desktop_session): the optional, platform-
     # specific computer package stays out of app.py's top-level import graph.
@@ -318,18 +742,20 @@ def _make_agent(ui: UI, config: AppConfig) -> AgentEngine:
     if permissions.level.allows_desktop and is_available()[0]:
         permissions.desktop = _make_desktop_session(ui)
     permissions.gate = _make_action_gate(ui)
-    # Live terminal output: echo each line a running command prints.
-    permissions.on_output = lambda line: ui.dim(f"  │ {line[:200]}")
-
-    def narrate(kind: str, detail: str) -> None:
-        if kind == "call":
-            ui.dim(f"  ⚒ {detail}")
-        elif kind == "error":
-            ui.dim(f"  ✖ {detail.splitlines()[0][:120]}")
-        elif kind == "limit":
-            ui.warning(f"Assist stopped: {detail}")
 
-    return AgentEngine(config, permissions, on_event=narrate)
+    presenter = presenter or _TaskPresenter(ui)
+    # Live terminal output: a compact echo of what a running command prints.
+    permissions.on_output = presenter.on_output
+
+    engine = AgentEngine(
+        config,
+        permissions,
+        on_event=presenter.on_event,
+        on_step=presenter.on_step,
+    )
+    # Attached so /resume can continue a paused session with the same view.
+    engine.presenter = presenter  # type: ignore[attr-defined]
+    return engine
 
 
 def _make_action_gate(ui: UI):
@@ -402,14 +828,22 @@ def _chat_loop(
     history: HistoryStore,
     session: PromptSession | _PlainSession,
 ) -> None:
-    """Interactive chat until /exit (returns to the main menu)."""
+    """Interactive chat until /exit (returns to the main menu).
+
+    Only an explicit exit leaves here: a finished task (Code Mode, Assist
+    Mode, Agent Mode or a plain chat turn) returns to the prompt with
+    ``Ready for next task.`` and the session keeps running.
+    """
     ctx = CommandContext(ui=ui, config=config, engine=engine)
     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).
+    # prompt and permission gates reflect both). The presenter that owns the
+    # live step view lives for the whole chat session, so each turn can bind
+    # its own task flow to the same engine callbacks.
     agent: AgentEngine | None = None
+    presenter = _TaskPresenter(ui)
     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).
@@ -481,10 +915,12 @@ def _chat_loop(
                     or agent_perm != config.permission_mode
                     or agent_codemode != codemode_now
                 ):
-                    agent = _make_agent(ui, config)
+                    agent = _make_agent(ui, config, presenter)
                     agent_perm = config.permission_mode
                     agent_codemode = codemode_now
-                _handle_agent(ui, agent, history, text)
+                # One task flow per turn: the engine reports real activity into
+                # it, and the REPL keeps prompting when the turn ends.
+                _handle_agent(ui, agent, history, text, presenter)
             else:
                 _handle_chat(ui, engine, history, text)