@prestyj/cli 4.3.238 → 4.4.0

package/dist/ui/App.js

@@ -12,7 +12,7 @@ import { useDoublePress } from "./hooks/useDoublePress.js";
 import { useTaskBarStore, useTaskBarPolling, focusTaskBar, exitTaskBar, expandTaskBar, collapseTaskBar, navigateTaskBar, killTask, } from "./stores/taskbar-store.js";
 import { playNotificationSound } from "../utils/sound.js";
 import {} from "@prestyj/ai";
-import { downscaleForPreview, extractImagePaths } from "../utils/image.js";
+import { downscaleForPreview, extractMediaPaths } from "../utils/image.js";
 import { useAgentLoop } from "./hooks/useAgentLoop.js";
 import { useTranscriptHistory } from "./hooks/useTranscriptHistory.js";
 import { createWebSearchTool } from "../tools/web-search.js";
@@ -23,7 +23,7 @@ import { SessionSummaryDisplay } from "./components/SessionSummary.js";
 import { useTheme, useSetTheme } from "./theme/theme.js";
 import { useTerminalTitle } from "./hooks/useTerminalTitle.js";
 import { getGitBranch } from "../utils/git.js";
-import { getModel } from "../core/model-registry.js";
+import { getModel, getVideoByteLimit } from "../core/model-registry.js";
 import { SessionManager } from "../core/session-manager.js";
 import { log } from "../core/logger.js";
 import { getPendingUpdate, startPeriodicUpdateCheck, stopPeriodicUpdateCheck, } from "../core/auto-update.js";
@@ -36,10 +36,10 @@ import { detectLanguages } from "../core/language-detector.js";
 import { detectVerifyCommands } from "../core/verify-commands.js";
 import { RewindOverlay } from "./components/RewindOverlay.js";
 import { reconcileGoalStatusEntriesWithRuns, removeGoalStatusEntry, syncGoalStatusEntries, } from "./components/GoalStatusBar.js";
-import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, segmentDisplayText, stripDoneMarkers, } from "../utils/plan-steps.js";
-import { getMCPServers } from "../core/mcp/index.js";
+import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, rebasePlanSteps, segmentDisplayText, stripDoneMarkers, } from "../utils/plan-steps.js";
+import { getAllMcpServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
-import { splitAssistantStreamingText } from "./utils/assistant-stream-split.js";
+import { splitAssistantStreamingText, estimateRenderedRows, } from "./utils/assistant-stream-split.js";
 import { getNextPendingTask, markTaskInProgress } from "../core/task-store.js";
 import { buildUserContentWithAttachments } from "./prompt-routing.js";
 import { submitPromptCommand } from "./submit-prompt-command.js";
@@ -772,6 +772,8 @@ export function App(props) {
         tools: currentTools,
         webSearch: props.webSearch,
         maxTokens: props.maxTokens,
+        supportsImages: getModel(currentModel)?.supportsImages ?? true,
+        supportsVideo: getModel(currentModel)?.supportsVideo ?? false,
         thinking: thinkingLevel,
         apiKey: activeApiKey,
         baseUrl: activeBaseUrl,
@@ -889,10 +891,32 @@ export function App(props) {
             if (planStepsRef.current.length > 0) {
                 const completed = findCompletedMarkers(text);
                 if (completed.size > 0) {
-                    const updated = markStepsCompleted(planStepsRef.current, completed);
-                    if (updated !== planStepsRef.current) {
-                        planStepsRef.current = updated;
-                        setPlanSteps(updated);
+                    const planPath = approvedPlanPathRef.current;
+                    // The agent can rewrite/expand the approved plan mid-run, so the
+                    // snapshot captured at approval goes stale (wrong total, and new
+                    // [DONE:n] markers match nothing). Re-extract from the live plan
+                    // file and re-base onto it before applying markers. The file read
+                    // is async; apply markers inside the same async step to avoid a
+                    // race with the snapshot. Fall back to the in-memory snapshot if
+                    // there is no plan path or the read fails.
+                    const applyMarkers = (base) => {
+                        const updated = markStepsCompleted(base, completed);
+                        if (updated !== planStepsRef.current) {
+                            planStepsRef.current = updated;
+                            setPlanSteps(updated);
+                        }
+                    };
+                    if (planPath) {
+                        void import("node:fs/promises")
+                            .then(({ readFile }) => readFile(planPath, "utf-8"))
+                            .then((planContent) => {
+                            const fresh = extractPlanSteps(planContent);
+                            applyMarkers(rebasePlanSteps(planStepsRef.current, fresh));
+                        })
+                            .catch(() => applyMarkers(planStepsRef.current));
+                    }
+                    else {
+                        applyMarkers(planStepsRef.current);
                     }
                     // Real progress happened — reset the stuck-guard so the next
                     // step gets its own fresh nudge budget.
@@ -1229,6 +1253,18 @@ export function App(props) {
             log("INFO", "server_tool", `Server tool call: ${name}`, { id });
             const startedAt = Date.now();
             const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
+            // Feed the pinned LiveToolPanel so provider-side tools (Anthropic's
+            // native web_search) appear in the same rolling window as client
+            // tools. `input` carries the tool args (e.g. { query }) the row reads.
+            setLiveToolFeed((prev) => [
+                ...prev,
+                {
+                    id,
+                    name,
+                    args: (input ?? {}),
+                    status: "running",
+                },
+            ].slice(-(LIVE_TOOL_PANEL_ROWS * 2)));
             // Flush completed items (including assistant text) before adding server
             // tool UI — same rationale as onToolStart.
             setLiveItems((prev) => {
@@ -1243,6 +1279,11 @@ export function App(props) {
                 if (flushed.length > 0) {
                     queueFlush(flushed);
                 }
+                // The pre-tool text was just pinned; the hook resets its streaming
+                // buffer at this same boundary. Reset the progressive-flush offset
+                // so post-tool text is measured from zero (stale flushedChars would
+                // otherwise slice into the fresh, shorter buffer).
+                streamedAssistantFlushRef.current = { flushedChars: 0, text: "" };
                 return [
                     ...remaining,
                     {
@@ -1259,6 +1300,9 @@ export function App(props) {
         }, [queueFlush]),
         onServerToolResult: useCallback((toolUseId, resultType, data) => {
             log("INFO", "server_tool", `Server tool result`, { toolUseId, resultType });
+            // Mark the panel entry done. Aborts never reach here (handled in
+            // onAborted), so a result that arrives is always a normal completion.
+            setLiveToolFeed((prev) => prev.map((entry) => entry.id === toolUseId ? { ...entry, status: "done" } : entry));
             setLiveItems((prev) => {
                 let updated;
                 const startIdx = prev.findIndex((item) => item.kind === "server_tool_start" && item.serverToolCallId === toolUseId);
@@ -1324,7 +1368,7 @@ export function App(props) {
                 return remaining;
             });
         }, [queueFlush]),
-        onDone: useCallback((durationMs, toolsUsed) => {
+        onDone: useCallback((durationMs, toolsUsed, runStats) => {
             log("INFO", "agent", `Agent done`, {
                 duration: `${durationMs}ms`,
                 toolsUsed: toolsUsed.join(",") || "none",
@@ -1337,7 +1381,13 @@ export function App(props) {
             // Still flush live transcript rows before the pane remounts; otherwise
             // setup output remains in ephemeral liveItems and appears to vanish.
             if (doneDecision.showDoneStatus) {
-                setDoneStatus({ durationMs, toolsUsed, verb: pickDurationVerb(toolsUsed) });
+                setDoneStatus({
+                    durationMs,
+                    toolsUsed,
+                    verb: pickDurationVerb(toolsUsed),
+                    counts: runStats?.counts,
+                    tokens: runStats?.tokens,
+                });
                 playNotificationSound();
             }
             // Keep the final assistant response mounted in the live frame after a
@@ -1465,10 +1515,14 @@ export function App(props) {
             const imageCount = typeof content === "string"
                 ? undefined
                 : content.filter((c) => c.type === "image").length || undefined;
+            const videoCount = typeof content === "string"
+                ? undefined
+                : content.filter((c) => c.type === "video").length || undefined;
             const userItem = {
                 kind: "user",
                 text: displayText,
                 imageCount,
+                videoCount,
                 id: getId(),
             };
             setLastUserMessage(displayText);
@@ -1505,6 +1559,13 @@ export function App(props) {
                 },
             ];
         }, []),
+        onRetry: useCallback(() => {
+            // Roll back any pending progressive flushes from the aborted attempt.
+            // Without this, a stall retry regenerates the preamble and the old
+            // flushed paragraph + the new one both end up in terminal history.
+            pendingHistoryFlushRef.current = pendingHistoryFlushRef.current.filter((item) => item.kind !== "assistant");
+            streamedAssistantFlushRef.current = { flushedChars: 0, text: "" };
+        }, []),
     });
     const continueGoalRun = useCallback((run) => {
         const cwd = cwdRef.current;
@@ -1891,6 +1952,9 @@ export function App(props) {
         void agentLoop.run(action.prompt).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
         // Intentional one-shot: run once on mount, never re-fire on re-render.
@@ -2056,31 +2120,35 @@ export function App(props) {
         }
         // ── Build user content (shared by normal + queued paths) ──
         const hasImages = inputImages.length > 0;
+        const imageCount = inputImages.filter((img) => img.kind === "image").length;
+        const videoCount = inputImages.filter((img) => img.kind === "video").length;
         const modelInfo = getModel(currentModel);
         const modelSupportsImages = modelInfo?.supportsImages ?? true;
-        const userContent = buildUserContentWithAttachments(input, inputImages, modelSupportsImages);
+        const modelSupportsVideo = modelInfo?.supportsVideo ?? false;
+        const userContent = buildUserContentWithAttachments(input, inputImages, modelSupportsImages, modelSupportsVideo);
         // ── Queue message if agent is already running ──
         if (agentLoop.isRunning) {
             log("INFO", "queue", `Queued message: ${trimmed.length > 80 ? trimmed.slice(0, 80) + "..." : trimmed}`);
             agentLoop.queueMessage(userContent, input);
             let displayText = input;
             if (hasImages) {
-                const { cleanText } = await extractImagePaths(input, props.cwd);
+                const { cleanText } = await extractMediaPaths(input, props.cwd);
                 displayText = cleanText;
             }
             const queuedItem = {
                 kind: "queued",
                 text: displayText,
-                imageCount: hasImages ? inputImages.length : undefined,
+                imageCount: imageCount > 0 ? imageCount : undefined,
+                videoCount: videoCount > 0 ? videoCount : undefined,
                 id: getId(),
             };
             setLiveItems((prev) => [...prev, queuedItem]);
             return;
         }
-        // Build display text — strip image paths, show badges instead
+        // Build display text — strip image/video paths, show badges instead
         let displayText = input;
         if (hasImages) {
-            const { cleanText } = await extractImagePaths(input, props.cwd);
+            const { cleanText } = await extractMediaPaths(input, props.cwd);
             displayText = cleanText;
         }
         let imagePreviews;
@@ -2096,7 +2164,8 @@ export function App(props) {
         const userItem = {
             kind: "user",
             text: displayText,
-            imageCount: hasImages ? inputImages.length : undefined,
+            imageCount: imageCount > 0 ? imageCount : undefined,
+            videoCount: videoCount > 0 ? videoCount : undefined,
             imagePreviews,
             pasteInfo,
             id: getId(),
@@ -2130,6 +2199,12 @@ export function App(props) {
             const msg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", msg);
             const isAbort = msg.includes("aborted") || msg.includes("abort");
+            // If the agent loop threw but left isRunning in a stale true state
+            // (can happen when the finally block hasn't been processed by React
+            // yet), reset it so the user isn't deadlocked with a non-working UI.
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [
                 ...prev,
                 isAbort
@@ -2220,8 +2295,14 @@ export function App(props) {
                     rebuildPromptWithTools(next);
                     return next;
                 });
-                // Reconnect MCP servers
-                if (props.mcpManager) {
+                // Reconnect MCP servers ONLY when the resolved server set actually
+                // changes. GLM is the only provider with a different set (Z.AI
+                // servers), so a switch that doesn't involve GLM on either side
+                // keeps the identical set — tearing down a live stdio child (e.g.
+                // kencode-search) and re-spawning `npx` there only risks a failed
+                // re-spawn that would silently drop the tools.
+                const glmInvolved = newProvider === "glm" || prevProvider === "glm";
+                if (props.mcpManager && glmInvolved) {
                     void (async () => {
                         // Disconnect old MCP servers
                         await props.mcpManager.dispose();
@@ -2240,7 +2321,11 @@ export function App(props) {
                             apiKey = props.credentialsByProvider?.["glm"]?.accessToken;
                         }
                         try {
-                            const mcpTools = await props.mcpManager.connectAll(getMCPServers(newProvider, apiKey));
+                            // Use getAllMcpServers so user-configured servers (from
+                            // ~/.ezcoder/mcp.json and ./.gg/mcp.json) survive the reconnect —
+                            // getMCPServers returns provider defaults only.
+                            const servers = await getAllMcpServers(newProvider, apiKey, props.cwd);
+                            const mcpTools = await props.mcpManager.connectAll(servers);
                             setCurrentTools((prev) => {
                                 const next = [...prev.filter((t) => !t.name.startsWith("mcp__")), ...mcpTools];
                                 rebuildPromptWithTools(next);
@@ -2262,7 +2347,26 @@ export function App(props) {
             }
             return newProvider;
         });
-        setCurrentModel(newModelId);
+        // The `read` tool's video capability (its description + native-video
+        // execute path) is baked in at creation from the model's `maxVideoBytes`.
+        // Switching to/from a video-capable model (e.g. text-only MiMo-V2.5-Pro →
+        // omnimodal MiMo-V2.5) must rebuild it, or the tool keeps telling the model
+        // it can't watch video. Rebuild reuses the read tracker, so read-before-edit
+        // history survives. Provider-change rebuilds the prompt above; this covers
+        // same-provider model switches too.
+        setCurrentModel((prevModel) => {
+            if (props.rebuildReadTool &&
+                getVideoByteLimit(prevModel) !== getVideoByteLimit(newModelId)) {
+                const newReadTool = props.rebuildReadTool(newModelId);
+                setCurrentTools((prev) => {
+                    const next = prev.map((tool) => (tool.name === "read" ? newReadTool : tool));
+                    currentToolsRef.current = next;
+                    void replaceSystemPrompt({ tools: next });
+                    return next;
+                });
+            }
+            return newModelId;
+        });
         const modelInfo = getModel(newModelId);
         const displayName = modelInfo?.name ?? newModelId;
         setLiveItems((prev) => [
@@ -2277,7 +2381,14 @@ export function App(props) {
                 await sm.set("defaultModel", newModelId);
             });
         }
-    }, [props.settingsFile, props.mcpManager, props.credentialsByProvider, props.authStorage]);
+    }, [
+        props.settingsFile,
+        props.mcpManager,
+        props.credentialsByProvider,
+        props.authStorage,
+        props.rebuildReadTool,
+        replaceSystemPrompt,
+    ]);
     const handleThemeSelect = useCallback((name) => {
         setOverlay(null);
         if (switchTheme) {
@@ -2497,6 +2608,9 @@ export function App(props) {
         setDoneStatus(null);
         setLiveItems([taskItem]);
         void agentLoop.run(fullPrompt).catch((err) => {
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
     }, [agentLoop, currentModel, currentProvider, props]);
@@ -2545,7 +2659,23 @@ export function App(props) {
     // every chunk boundary. Slicing by the prospective flush here keeps the live
     // frame height monotonic, so the footer never bounces.
     const alreadyFlushedChars = streamedAssistantFlushRef.current.flushedChars;
-    const pendingFlushChars = rawVisibleStreamingText
+    // Retry-safety gate: don't commit streamed paragraphs to permanent scrollback
+    // while the text is still small enough to live entirely in the live region.
+    // A silent stall-retry (agent-loop.ts) restarts the LLM call from scratch and
+    // regenerates the opening text — reworded, so the byte-identical dedup can't
+    // catch it. Anything already printed to scrollback can't be un-written, so the
+    // regen appends as a second ⏺ bullet that paraphrases the first. Keeping short
+    // streamed text live (it clears via setStreamingText("") on retry) closes that
+    // hole. We only start flushing once the unflushed text would overflow the live
+    // area — the original anti-jump purpose, which only matters for long responses
+    // that are far less likely to be a stalled preamble. Once flushing has begun
+    // for this turn (alreadyFlushedChars > 0) we keep flushing every boundary so
+    // committed continuation paragraphs stay consistent with the live tail.
+    const unflushedStreamingRows = rawVisibleStreamingText
+        ? estimateRenderedRows(rawVisibleStreamingText.slice(alreadyFlushedChars), columns)
+        : 0;
+    const shouldFlushStreamedText = alreadyFlushedChars > 0 || unflushedStreamingRows > measuredLiveAreaRows;
+    const pendingFlushChars = rawVisibleStreamingText && shouldFlushStreamedText
         ? splitAssistantStreamingText(rawVisibleStreamingText.slice(alreadyFlushedChars)).flushedText
             .length
         : 0;
@@ -2556,6 +2686,13 @@ export function App(props) {
         }
         if (rawVisibleStreamingText === streamedAssistantFlushRef.current.text)
             return;
+        if (!shouldFlushStreamedText) {
+            streamedAssistantFlushRef.current = {
+                ...streamedAssistantFlushRef.current,
+                text: rawVisibleStreamingText,
+            };
+            return;
+        }
         const alreadyFlushed = streamedAssistantFlushRef.current.flushedChars;
         const unflushedText = rawVisibleStreamingText.slice(alreadyFlushed);
         const split = splitAssistantStreamingText(unflushedText);
@@ -2578,7 +2715,7 @@ export function App(props) {
             ...streamedAssistantFlushRef.current,
             text: rawVisibleStreamingText,
         };
-    }, [rawVisibleStreamingText, queueFlush]);
+    }, [rawVisibleStreamingText, shouldFlushStreamedText, queueFlush]);
     const visibleStreamingText = stripDoneMarkers(rawVisibleStreamingText.slice(alreadyFlushedChars + pendingFlushChars));
     const lastLiveItem = liveItems.at(-1);
     // For spacing decisions, the previous row is the last item that actually
@@ -3018,6 +3155,9 @@ export function App(props) {
         void agentLoop.run(rejectionMsg).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
     };