pi-jarvis 1.3.2 → 1.4.0

package/dist/index.js

@@ -1,10 +1,10 @@
 import { existsSync } from "node:fs";
-import { ModelSelectorComponent, SettingsManager, } from "@mariozechner/pi-coding-agent";
+import { JarvisModelPicker } from "./model-picker.js";
 import { buildMainSessionContext } from "./main-context.js";
 import { MainSessionTracker } from "./main-session-state.js";
 import { attachOverlayBridge, JarvisOverlayBridge, JarvisOverlayComponent } from "./overlay.js";
 import { createJarvisSessionRef, readJarvisSessionRef, JARVIS_SESSION_REF_CUSTOM_TYPE } from "./session-ref.js";
-import { clearJarvisModelSelectionSetting, clearJarvisThinkingSelectionSetting, loadJarvisModelSelectionSetting, loadJarvisThinkingSelectionSetting, saveJarvisModelSelectionSetting, saveJarvisThinkingSelectionSetting, } from "./jarvis-config.js";
+import { MalformedJarvisConfigError, clearJarvisModelSelectionSetting, clearJarvisThinkingSelectionSetting, loadJarvisModelSelectionSetting, loadJarvisThinkingSelectionSetting, saveJarvisModelSelectionSetting, saveJarvisThinkingSelectionSetting, } from "./jarvis-config.js";
 import { JarvisSideSessionRuntime, createSideSessionFile } from "./side-session.js";
 class StaleJarvisBootError extends Error {
     constructor() {
@@ -39,7 +39,16 @@ export default function jarvisExtension(pi) {
     pi.registerCommand("jarvis", {
         description: "Open the /jarvis side conversation overlay",
         handler: async (args, ctx) => {
+            if (ctx.mode !== "tui") {
+                ctx.ui.notify("/jarvis requires Pi's interactive terminal UI.", "warning");
+                return;
+            }
+            if (state.overlayOpen) {
+                ctx.ui.notify("/jarvis is already open.", "info");
+                return;
+            }
             updateContextState(pi, state, ctx);
+            state.overlayOpen = true;
             void ensureRuntime(pi, state, ctx).catch((error) => {
                 if (isStaleJarvisBootError(error)) {
                     return;
@@ -52,23 +61,37 @@ export default function jarvisExtension(pi) {
                 void flushQueuedMessages(pi, state, ctx);
             }
             const overlayView = createOverlayView(pi, state, ctx);
-            await ctx.ui.custom((tui, theme, _keybindings, done) => {
-                state.themeProvider = () => theme;
-                const closeOverlay = () => {
-                    resetTransientAccessControls(state);
-                    done(undefined);
-                    queueMicrotask(() => tui.requestRender());
-                };
-                return attachOverlayBridge(new JarvisOverlayComponent(tui, theme, state.bridge, overlayView, closeOverlay), state.bridge, tui);
-            }, {
-                overlay: true,
-                overlayOptions: {
-                    width: "68%",
-                    minWidth: 68,
-                    maxHeight: "82%",
-                    anchor: "center",
-                },
-            });
+            try {
+                await ctx.ui.custom((tui, theme, keybindings, done) => {
+                    state.themeProvider = () => theme;
+                    let closed = false;
+                    const closeOverlay = () => {
+                        if (closed)
+                            return;
+                        closed = true;
+                        resetTransientAccessControls(state);
+                        state.bridge.resolveConfirmation(false);
+                        done(undefined);
+                        queueMicrotask(() => tui.requestRender());
+                    };
+                    state.closeOverlay = closeOverlay;
+                    return attachOverlayBridge(new JarvisOverlayComponent(tui, theme, state.bridge, overlayView, closeOverlay, keybindings), state.bridge, tui);
+                }, {
+                    overlay: true,
+                    overlayOptions: {
+                        width: "68%",
+                        minWidth: 68,
+                        maxHeight: "82%",
+                        anchor: "center",
+                    },
+                });
+            }
+            finally {
+                state.overlayOpen = false;
+                state.closeOverlay = undefined;
+                resetTransientAccessControls(state);
+                state.bridge.resolveConfirmation(false);
+            }
         },
     });
     pi.registerCommand("jarvis-model", {
@@ -85,9 +108,22 @@ export default function jarvisExtension(pi) {
             }
             const { request, scope, clearScope } = parsedCommand;
             const scopeLabel = formatJarvisModelSelectionScope(scope);
-            const selectModelFromMenu = async (initialSearchInput) => {
-                const selectorSettingsManager = SettingsManager.inMemory();
-                return ctx.ui.custom((tui, _theme, _keybindings, done) => new ModelSelectorComponent(tui, getDesiredJarvisModel(state), selectorSettingsManager, ctx.modelRegistry, [], (model) => done(model), () => done(undefined), initialSearchInput));
+            const loadModels = async () => {
+                try {
+                    return await getAvailableJarvisModels(ctx.modelRegistry);
+                }
+                catch (error) {
+                    ctx.ui.notify(`Failed to refresh /jarvis models: ${error instanceof Error ? error.message : String(error)}`, "error");
+                    return [];
+                }
+            };
+            const selectModelFromMenu = async (models, initialSearchInput) => {
+                models = models.filter((model) => model.api !== "pi-virtual");
+                if (models.length === 0) {
+                    ctx.ui.notify("No /jarvis models are currently available from the main model registry.", "warning");
+                    return undefined;
+                }
+                return ctx.ui.custom((tui, theme, keybindings, done) => new JarvisModelPicker(tui, theme, keybindings, models, (model) => done(model), () => done(undefined), initialSearchInput));
             };
             const rollbackSelection = async (previousSelection, previousSource) => {
                 await applyJarvisModelSelection(state, previousSelection);
@@ -96,10 +132,12 @@ export default function jarvisExtension(pi) {
             const persistSelection = async (selection) => {
                 const previousSelection = state.jarvisModelSelection;
                 const previousSource = state.jarvisModelSelectionSource;
-                await applyJarvisModelSelection(state, selection);
+                const stored = toStoredJarvisModelSelection(selection);
+                const resolved = resolveJarvisModelSelectionFromSettings(scope === "project" ? stored : loadJarvisModelSelectionForClear(ctx.cwd, "project", ctx), scope === "global" ? stored : loadJarvisModelSelectionForClear(ctx.cwd, "global", ctx), ctx.modelRegistry);
+                await applyJarvisModelSelection(state, resolved.selection);
                 try {
-                    saveJarvisModelSelectionSetting(ctx.cwd, scope, toStoredJarvisModelSelection(selection));
-                    state.jarvisModelSelectionSource = scope;
+                    saveJarvisModelSelectionSetting(ctx.cwd, scope, stored);
+                    state.jarvisModelSelectionSource = resolved.source;
                 }
                 catch (error) {
                     await rollbackSelection(previousSelection, previousSource);
@@ -131,7 +169,7 @@ export default function jarvisExtension(pi) {
                     ctx.ui.notify(`Failed to pin /jarvis to ${formatModelLabel(model)} ${scopeLabel}: ${error instanceof Error ? error.message : String(error)}`, "error");
                     return;
                 }
-                ctx.ui.notify(`Pinned /jarvis to ${formatModelLabel(model)} ${scopeLabel}. The main model is still ${formatModelLabel(state.model)}.`, "info");
+                ctx.ui.notify(`Saved /jarvis model ${formatModelLabel(model)} ${scopeLabel}. /jarvis is ${describeJarvisModelSelection(state)}. The main model is still ${formatModelLabel(state.model)}.`, "info");
             };
             if (clearScope) {
                 let resolvedSelection;
@@ -156,35 +194,35 @@ export default function jarvisExtension(pi) {
                     ctx.ui.notify(`Failed to switch /jarvis back to follow-main ${scopeLabel}: ${error instanceof Error ? error.message : String(error)}`, "error");
                     return;
                 }
-                ctx.ui.notify(`Set /jarvis to follow the main model (${formatModelLabel(state.model)}) ${scopeLabel}.`, "info");
+                ctx.ui.notify(`Saved follow-main ${scopeLabel}. /jarvis is ${describeJarvisModelSelection(state)}.`, "info");
                 return;
             }
             if (!request) {
-                if (!ctx.hasUI) {
+                if (ctx.mode !== "tui") {
                     ctx.ui.notify(`/jarvis is ${describeJarvisModelSelection(state)}. Use /jarvis-model [--project|--global] clear, /jarvis-model [--project|--global] follow-main, or /jarvis-model [--project|--global] <provider/model>.`, "info");
                     return;
                 }
-                const selectedModel = await selectModelFromMenu();
+                const selectedModel = await selectModelFromMenu(await loadModels());
                 if (!selectedModel) {
                     return;
                 }
                 await pinSelectedModel(selectedModel);
                 return;
             }
-            const availableModels = getAvailableJarvisModels(ctx.modelRegistry);
+            const availableModels = await loadModels();
             const exactModel = findExactAvailableModelMatch(request, availableModels);
             if (exactModel) {
                 await pinSelectedModel(exactModel);
                 return;
             }
-            if (!ctx.hasUI) {
+            if (ctx.mode !== "tui") {
                 const errorMessage = availableModels.length === 0
                     ? "No /jarvis models are currently available from the main model registry."
                     : `Unknown /jarvis model "${request}". Use /jarvis-model [--project|--global] clear, /jarvis-model [--project|--global] follow-main, or an exact provider/model from the current model registry.`;
                 ctx.ui.notify(errorMessage, "error");
                 return;
             }
-            const selectedModel = await selectModelFromMenu(request);
+            const selectedModel = await selectModelFromMenu(availableModels, request);
             if (!selectedModel) {
                 return;
             }
@@ -212,10 +250,11 @@ export default function jarvisExtension(pi) {
             const persistSelection = async (selection) => {
                 const previousSelection = state.jarvisThinkingSelection;
                 const previousSource = state.jarvisThinkingSelectionSource;
-                await applyJarvisThinkingSelection(state, selection);
+                const resolved = resolveJarvisThinkingSelectionFromSettings(scope === "project" ? selection : loadJarvisThinkingSelectionForClear(ctx.cwd, "project", ctx), scope === "global" ? selection : loadJarvisThinkingSelectionForClear(ctx.cwd, "global", ctx));
+                await applyJarvisThinkingSelection(state, resolved.selection);
                 try {
                     saveJarvisThinkingSelectionSetting(ctx.cwd, scope, selection);
-                    state.jarvisThinkingSelectionSource = scope;
+                    state.jarvisThinkingSelectionSource = resolved.source;
                 }
                 catch (error) {
                     await rollbackSelection(previousSelection, previousSource);
@@ -262,7 +301,7 @@ export default function jarvisExtension(pi) {
                 selection = { mode: "pinned", thinkingLevel: normalizedRequest };
             }
             if (!selection) {
-                ctx.ui.notify(`/jarvis is ${describeJarvisThinkingSelection(state)}. Use /jarvis-thinking [--project|--global] clear, auto, follow-main, off, minimal, low, medium, high, or xhigh.`, request ? "error" : "info");
+                ctx.ui.notify(`/jarvis is ${describeJarvisThinkingSelection(state)}. Use /jarvis-thinking [--project|--global] clear, auto, follow-main, off, minimal, low, medium, high, xhigh, or max.`, request ? "error" : "info");
                 return;
             }
             try {
@@ -276,6 +315,7 @@ export default function jarvisExtension(pi) {
         },
     });
     pi.on("session_start", async (_event, ctx) => {
+        state.closeOverlay?.();
         state.bootGeneration += 1;
         state.runtime?.dispose();
         state.runtime = undefined;
@@ -324,6 +364,29 @@ export default function jarvisExtension(pi) {
         state.mainSession.handleAgentEnd();
         refreshMainContext(state);
     });
+    pi.on("agent_settled", async (_event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleAgentSettled();
+        refreshMainContext(state);
+    });
+    pi.on("session_tree", async (_event, ctx) => {
+        const sessionRef = readJarvisSessionRef(ctx.sessionManager.getBranch());
+        if (sessionRef?.file !== state.sessionRef?.file) {
+            state.closeOverlay?.();
+            state.bootGeneration += 1;
+            state.runtime?.dispose();
+            state.runtime = undefined;
+            state.bootPromise = undefined;
+            state.flushPromise = undefined;
+            state.queuedMessages = [];
+            state.lastJarvisSeenMainContext = undefined;
+            state.sessionRef = sessionRef;
+            resetTransientAccessControls(state);
+            state.bridge.reset();
+        }
+        state.mainSession.reset(formatModelLabel(ctx.model));
+        updateContextState(pi, state, ctx);
+    });
     pi.on("message_start", async (event, ctx) => {
         updateContextState(pi, state, ctx);
         state.mainSession.handleMessageStart(event);
@@ -366,7 +429,17 @@ export default function jarvisExtension(pi) {
             state.bridge.notify(`Failed to sync /jarvis model: ${error instanceof Error ? error.message : String(error)}`, "error");
         }
     });
+    pi.on("thinking_level_select", async (_event, ctx) => {
+        updateContextState(pi, state, ctx);
+        try {
+            await syncRuntimeModelSelection(state);
+        }
+        catch (error) {
+            state.bridge.notify(`Failed to sync /jarvis thinking: ${error instanceof Error ? error.message : String(error)}`, "error");
+        }
+    });
     pi.on("session_shutdown", async () => {
+        state.closeOverlay?.();
         state.bootGeneration += 1;
         state.runtime?.dispose();
         state.runtime = undefined;
@@ -399,6 +472,7 @@ function updateContextState(pi, state, ctx) {
 }
 function refreshMainContext(state) {
     state.mainContext = buildMainSessionContext(state.mainSession.snapshot());
+    state.bridge.refresh();
 }
 function resetTransientAccessControls(state) {
     state.allowSideTools = false;
@@ -471,7 +545,7 @@ function parseJarvisThinkingCommand(args) {
     };
 }
 function isJarvisThinkingLevel(value) {
-    return value === "off" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
+    return value === "off" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
 }
 function formatJarvisThinkingSelection(selection) {
     if (selection.mode === "auto") {
@@ -582,7 +656,9 @@ function loadJarvisModelSelectionForClear(cwd, scope, ctx) {
         return loadJarvisModelSelectionSetting(cwd, scope);
     }
     catch (error) {
-        ctx.ui.notify(`Ignoring malformed ${scope} /jarvis model setting while clearing the requested scope: ${error instanceof Error ? error.message : String(error)}`, "warning");
+        if (!(error instanceof MalformedJarvisConfigError))
+            throw error;
+        ctx.ui.notify(`Ignoring malformed ${scope} /jarvis model setting while resolving settings: ${error instanceof Error ? error.message : String(error)}`, "warning");
         return undefined;
     }
 }
@@ -591,7 +667,9 @@ function loadJarvisThinkingSelectionForClear(cwd, scope, ctx) {
         return loadJarvisThinkingSelectionSetting(cwd, scope);
     }
     catch (error) {
-        ctx.ui.notify(`Ignoring malformed ${scope} /jarvis thinking setting while clearing the requested scope: ${error instanceof Error ? error.message : String(error)}`, "warning");
+        if (!(error instanceof MalformedJarvisConfigError))
+            throw error;
+        ctx.ui.notify(`Ignoring malformed ${scope} /jarvis thinking setting while resolving settings: ${error instanceof Error ? error.message : String(error)}`, "warning");
         return undefined;
     }
 }
@@ -623,14 +701,9 @@ function describeJarvisModelSelection(state) {
         ? `following the main model (${activeModelLabel}; ${sourceLabel})`
         : `pinned to ${activeModelLabel} (${sourceLabel})`;
 }
-function getAvailableJarvisModels(modelRegistry) {
-    modelRegistry.refresh();
-    try {
-        return modelRegistry.getAvailable();
-    }
-    catch {
-        return [];
-    }
+async function getAvailableJarvisModels(modelRegistry) {
+    await modelRegistry.refresh();
+    return modelRegistry.getAvailable();
 }
 function findExactAvailableModelMatch(modelReference, availableModels) {
     const trimmedReference = modelReference.trim();
@@ -670,6 +743,9 @@ async function syncRuntimeModelSelection(state) {
     await state.runtime.syncModel(getDesiredJarvisModel(state), getDesiredJarvisThinkingLevel(state));
 }
 async function applyJarvisModelSelection(state, selection) {
+    if (selection.mode === "pinned" && selection.model.api === "pi-virtual") {
+        throw new Error("/jarvis requires a physical model; Pi's public registry does not expose virtual routing.");
+    }
     const previousSelection = state.jarvisModelSelection;
     state.jarvisModelSelection = selection;
     try {
@@ -721,14 +797,16 @@ async function executeJarvisSideCommand(pi, state, ctx, runtime, command) {
         });
         return runtime;
     }
-    state.bootGeneration += 1;
+    const generation = ++state.bootGeneration;
     state.runtime?.dispose();
     state.runtime = undefined;
     state.bootPromise = undefined;
-    state.flushPromise = undefined;
     state.lastJarvisSeenMainContext = undefined;
     resetTransientAccessControls(state);
+    state.bridge.reset();
     const sessionFile = await createSideSessionFile(ctx.cwd);
+    if (generation !== state.bootGeneration)
+        throw new StaleJarvisBootError();
     const sessionRef = createJarvisSessionRef(sessionFile);
     state.sessionRef = sessionRef;
     pi.appendEntry(JARVIS_SESSION_REF_CUSTOM_TYPE, sessionRef);
@@ -759,6 +837,8 @@ function parseJarvisSideCommand(message) {
     }
     if (text.startsWith("/tree ")) {
         const args = text.slice("/tree ".length).trim();
+        if (args === "--summarize")
+            throw new Error("Use /tree --summarize <entry-id> [instructions].");
         const summarizePrefix = "--summarize ";
         if (args.startsWith(summarizePrefix)) {
             const rest = args.slice(summarizePrefix.length).trim();
@@ -776,6 +856,7 @@ function parseJarvisSideCommand(message) {
     return undefined;
 }
 function createOverlayView(pi, state, ctx) {
+    const queue = state.queuedMessages;
     const syncToolAccess = () => {
         state.runtime?.setToolAccessEnabled(state.allowSideTools);
     };
@@ -814,6 +895,8 @@ function createOverlayView(pi, state, ctx) {
         },
         getDisplayEntries: () => getOverlayEntries(state),
         sendMessage: async (text) => {
+            if (state.queuedMessages !== queue)
+                return;
             queueMessage(state, text);
             await flushQueuedMessages(pi, state, ctx);
         },
@@ -875,49 +958,59 @@ function formatMainContextDeltaLabel(previousContext, currentContext) {
     return "no significant change";
 }
 async function flushQueuedMessages(pi, state, ctx) {
-    updateContextState(pi, state, ctx);
-    if (state.flushPromise) {
+    if (state.flushPromise)
         return state.flushPromise;
-    }
-    // flushQueuedMessages is awaited in fire-and-forget paths (the /jarvis command
-    // handler's initial message flush and the overlay input submit). Any error
-    // that propagates out of here becomes an unhandled promise rejection, so the
-    // IIFE must catch and surface every failure via bridge.notify rather than
-    // rethrowing.
-    state.flushPromise = (async () => {
+    // Queue identity survives a side /new, but not a main-session replacement.
+    // A stale completion must never consume or unlock a replacement queue.
+    const queue = state.queuedMessages;
+    const isCurrent = () => state.queuedMessages === queue;
+    let flushPromise;
+    flushPromise = (async () => {
         try {
+            updateContextState(pi, state, ctx);
             let runtime = await ensureRuntime(pi, state, ctx);
-            await runtime.syncModel(getDesiredJarvisModel(state), getDesiredJarvisThinkingLevel(state));
-            while (state.queuedMessages.length > 0) {
-                const message = state.queuedMessages[0];
-                const command = parseJarvisSideCommand(message);
+            if (!isCurrent())
+                return;
+            while (queue.length > 0 && isCurrent()) {
+                // Consume once: a failed command must not poison the queue, and an
+                // uncertain provider/tool send must not be retried automatically.
+                const message = queue.shift();
                 try {
+                    const command = parseJarvisSideCommand(message);
                     if (command) {
                         runtime = await executeJarvisSideCommand(pi, state, ctx, runtime, command);
                     }
                     else {
+                        await runtime.syncModel(getDesiredJarvisModel(state), getDesiredJarvisThinkingLevel(state));
+                        if (!isCurrent())
+                            return;
+                        const seenContext = state.mainContext;
                         await runtime.sendMessage(message);
-                        state.lastJarvisSeenMainContext = state.mainContext;
+                        if (isCurrent())
+                            state.lastJarvisSeenMainContext = seenContext;
                     }
-                    state.queuedMessages.shift();
+                    if (!isCurrent())
+                        return;
                 }
                 catch (error) {
-                    const action = command ? `run ${message.split(/\s+/, 1)[0]}` : "send /jarvis message";
-                    state.bridge.notify(`Failed to ${action}: ${error instanceof Error ? error.message : String(error)}`, "error");
-                    break;
+                    if (!isCurrent() || isStaleJarvisBootError(error))
+                        return;
+                    state.bridge.notify(`Failed to process /jarvis input: ${error instanceof Error ? error.message : String(error)}. Input was not retried.`, "error");
                 }
             }
         }
         catch (error) {
-            if (isStaleJarvisBootError(error)) {
+            if (!isCurrent() || isStaleJarvisBootError(error))
                 return;
-            }
-            state.bridge.notify(`/jarvis startup failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+            queue.length = 0;
+            state.bridge.notify(`/jarvis startup failed: ${error instanceof Error ? error.message : String(error)}. Please submit again.`, "error");
         }
     })().finally(() => {
-        state.flushPromise = undefined;
+        if (state.flushPromise === flushPromise)
+            state.flushPromise = undefined;
     });
-    return state.flushPromise;
+    state.flushPromise = flushPromise;
+    return flushPromise;
 }
 async function ensureRuntime(pi, state, ctx) {
     if (state.runtime) {
@@ -944,6 +1037,7 @@ async function ensureRuntime(pi, state, ctx) {
         const runtime = await JarvisSideSessionRuntime.create({
             bridge: state.bridge,
             cwd: ctx.cwd,
+            projectTrusted: ctx.isProjectTrusted(),
             modelRegistry: ctx.modelRegistry,
             model: getDesiredJarvisModel(state),
             jarvisModelModeProvider: () => state.jarvisModelSelection.mode,
@@ -951,12 +1045,14 @@ async function ensureRuntime(pi, state, ctx) {
             sessionFile,
             systemPromptProvider: () => state.systemPrompt,
             mainContextProvider: () => state.mainContext,
-            toolAccessProvider: () => state.allowSideTools,
+            toolAccessProvider: () => isCurrentBoot() && state.allowSideTools,
             communicationPermissionsProvider: () => ({
-                allowFollowUpToMain: state.allowFollowUpToMain,
-                allowSteerToMain: state.allowSteerToMain,
+                allowFollowUpToMain: isCurrentBoot() && state.allowFollowUpToMain,
+                allowSteerToMain: isCurrentBoot() && state.allowSteerToMain,
             }),
             sendFollowUpToMain: (message) => {
+                if (!isCurrentBoot() || !state.allowFollowUpToMain)
+                    throw new Error("/jarvis follow-up permission expired.");
                 pi.sendUserMessage(message, { deliverAs: "followUp" });
             },
             // Route the confirmation through the /jarvis overlay itself via the
@@ -964,8 +1060,10 @@ async function ensureRuntime(pi, state, ctx) {
             // the base layer (the pi editor container) and sit hidden behind the
             // /jarvis overlay, leaving the side-session tool execute hung on a
             // promise the user could never answer.
-            confirmSteerToMain: (message) => state.bridge.requestConfirmation("Send /jarvis steer to main?", `This will steer the main agent with:\n\n${message}`),
+            confirmSteerToMain: (message, signal) => state.bridge.requestConfirmation("Send /jarvis steer to main?", `This will steer the main agent with:\n\n${message}`, signal),
             sendSteerToMain: (message) => {
+                if (!isCurrentBoot() || !state.allowSteerToMain)
+                    throw new Error("/jarvis redirect permission expired.");
                 pi.sendUserMessage(message, { deliverAs: "steer" });
             },
             themeProvider: state.themeProvider,
@@ -978,6 +1076,8 @@ async function ensureRuntime(pi, state, ctx) {
         state.bridge.setWorkingMessage(undefined);
         return runtime;
     })().catch((error) => {
+        if (!isCurrentBoot())
+            throw new StaleJarvisBootError();
         state.bridge.setWorkingMessage(undefined);
         throw error;
     }).finally(() => {