@ai-agent-forge/agent-forge 0.88.2 → 0.88.3

package/dist/modes/interactive/interactive-selectors.js

@@ -1,17 +1,32 @@
-import { Container, SelectList, Spacer, Text } from "@agent-forge/tui";
+import { Container, SelectList, Spacer, Text, TuiAltScreen } from "@agent-forge/tui";
 import { getAgentDir } from "../../config.js";
-import { DEFAULT_THINKING_LEVEL } from "../../core/defaults.js";
-import { t } from "../../core/i18n/index.js";
+import { listAgentSessions, readAgentSession } from "../../core/agent-session-store.js";
+import { DEFAULT_THINKING_LEVEL, THINKING_LEVEL_OPTIONS } from "../../core/defaults.js";
+import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/http-dispatcher.js";
+import { setI18nLanguage, t } from "../../core/i18n/index.js";
 import { findExactModelReferenceMatch, resolveModelScopeFromModels } from "../../core/model-resolver.js";
-import { listSuiteIds } from "../../profiles/suite-loader.js";
+import { MissingSessionCwdError } from "../../core/session-cwd.js";
+import { SessionManager } from "../../core/session-manager.js";
+import { refreshModelCatalogs } from "../../host/model-catalog-refresh.js";
+import { listSuiteIds } from "../../suites/suite-loader.js";
+import { getAvailableThemes, getSelectListTheme, theme } from "../../theme/theme.js";
+import { copyToClipboard } from "../../utils/clipboard.js";
+import { AgentsViewComponent } from "./components/agents-view.js";
+import { AssistantMessageComponent } from "./components/assistant-message.js";
+import { CustomMessageComponent } from "./components/custom-message.js";
 import { DynamicBorder } from "./components/dynamic-border.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { QueueManagerSelectorComponent } from "./components/queue-manager-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
+import { SessionSelectorComponent } from "./components/session-selector.js";
+import { SettingsSelectorComponent } from "./components/settings-selector.js";
+import { BranchSummaryStatusIndicator } from "./components/status-indicator.js";
 import { ThinkingSelectorComponent } from "./components/thinking-selector.js";
+import { ToolExecutionComponent } from "./components/tool-execution.js";
+import { TreeSelectorComponent } from "./components/tree-selector.js";
+import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
-import { refreshModelCatalogs } from "./model-catalog-refresh.js";
-import { getSelectListTheme, theme } from "./theme/theme.js";
+import { WorkflowViewComponent } from "./components/workflow-view.js";
 export function handleSuiteCommand(host, suiteId) {
     const availableSuites = listSuiteIds(getAgentDir());
     if (!suiteId) {
@@ -421,4 +436,500 @@ export async function handleCloneCommand(host) {
         host.showError(error instanceof Error ? error.message : String(error));
     }
 }
+export function showSettingsSelector(host) {
+    host.showSelector((done) => {
+        let selector;
+        const defaultProvider = host.settingsManager.getDefaultProvider();
+        const defaultModelId = host.settingsManager.getDefaultModel();
+        const defaultModel = defaultProvider && defaultModelId ? `${defaultProvider}/${defaultModelId}` : t("not set");
+        selector = new SettingsSelectorComponent({
+            defaultModel,
+            currentModel: host.facade.getModel(),
+            availableDefaultModels: host.facade.getAvailableModels(),
+            showImages: host.settingsManager.getShowImages(),
+            imageWidthCells: host.settingsManager.getImageWidthCells(),
+            autoResizeImages: host.settingsManager.getImageAutoResize(),
+            blockImages: host.settingsManager.getBlockImages(),
+            steeringMode: host.facade.getSteeringMode(),
+            followUpMode: host.facade.getFollowUpMode(),
+            transport: host.settingsManager.getTransport(),
+            httpIdleTimeoutMs: host.settingsManager.getHttpIdleTimeoutMs(),
+            thinkingLevel: host.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL,
+            availableThinkingLevels: [...THINKING_LEVEL_OPTIONS],
+            modelThinkingLevels: host.settingsManager.getAllModelThinkingLevels(),
+            currentTheme: host.themeController.getThemeSelection() || "dark",
+            terminalTheme: host.themeController.getTerminalTheme(),
+            availableThemes: getAvailableThemes(),
+            hideThinkingBlock: host.hideThinkingBlock,
+            mermaidRenderingMode: host.settingsManager.getMermaidRenderingMode(),
+            collapseChangelog: host.settingsManager.getCollapseChangelog(),
+            doubleEscapeAction: host.settingsManager.getDoubleEscapeAction(),
+            uiLanguage: host.settingsManager.getUiLanguage(),
+            treeFilterMode: host.settingsManager.getTreeFilterMode(),
+            showHardwareCursor: host.settingsManager.getShowHardwareCursor(),
+            showCacheMissNotices: host.settingsManager.getShowCacheMissNotices(),
+            editorPaddingX: host.settingsManager.getEditorPaddingX(),
+            outputPad: host.settingsManager.getOutputPad(),
+            autocompleteMaxVisible: host.settingsManager.getAutocompleteMaxVisible(),
+            quietStartup: host.settingsManager.getQuietStartup(),
+            clearOnShrink: host.settingsManager.getClearOnShrink(),
+            showTerminalProgress: host.settingsManager.getShowTerminalProgress(),
+            tuiMode: host.ui.mode,
+            fullscreenExitOutput: host.settingsManager.getFullscreenExitOutput(),
+            fullscreenScrollbar: host.settingsManager.getFullscreenScrollbar(),
+            fullscreenCopyOnSelect: host.settingsManager.getFullscreenCopyOnSelect(),
+            fullscreenWheelScrollLines: host.settingsManager.getFullscreenWheelScrollLines(),
+            warnings: host.settingsManager.getWarnings(),
+        }, {
+            onShowImagesChange: (enabled) => {
+                host.settingsManager.setShowImages(enabled);
+                for (const child of host.chatContainer.children) {
+                    if (child instanceof ToolExecutionComponent) {
+                        child.setShowImages(enabled);
+                    }
+                }
+            },
+            onImageWidthCellsChange: (width) => {
+                host.settingsManager.setImageWidthCells(width);
+                for (const child of host.chatContainer.children) {
+                    if (child instanceof ToolExecutionComponent) {
+                        child.setImageWidthCells(width);
+                    }
+                }
+            },
+            onAutoResizeImagesChange: (enabled) => {
+                host.settingsManager.setImageAutoResize(enabled);
+            },
+            onBlockImagesChange: (blocked) => {
+                host.settingsManager.setBlockImages(blocked);
+            },
+            onSteeringModeChange: (mode) => {
+                host.facade.setSteeringMode(mode);
+            },
+            onFollowUpModeChange: (mode) => {
+                host.facade.setFollowUpMode(mode);
+            },
+            onTransportChange: (transport) => {
+                host.settingsManager.setTransport(transport);
+                host.session.host.setTransport(transport);
+            },
+            onHttpIdleTimeoutMsChange: (timeoutMs) => {
+                host.settingsManager.setHttpIdleTimeoutMs(timeoutMs);
+                configureHttpDispatcher(timeoutMs);
+                host.showStatus(t("HTTP idle timeout: {value}", { value: formatHttpIdleTimeoutMs(timeoutMs) }));
+            },
+            onModelThinkingLevelChange: (provider, modelId, level) => {
+                host.settingsManager.setModelThinkingLevel(provider, modelId, level);
+                // If the override is for the current model, apply it to the session too
+                const current = host.facade.getModel();
+                if (current && current.provider === provider && current.id === modelId) {
+                    host.facade.setThinkingLevel(level);
+                    host.footer.invalidate();
+                    host.updateEditorBorderColor();
+                }
+            },
+            onModelThinkingLevelRemove: (provider, modelId) => {
+                host.settingsManager.removeModelThinkingLevel(provider, modelId);
+                // If the override was for the current model, revert to global default
+                const current = host.facade.getModel();
+                if (current && current.provider === provider && current.id === modelId) {
+                    const globalDefault = host.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+                    host.facade.setThinkingLevel(globalDefault);
+                    host.footer.invalidate();
+                    host.updateEditorBorderColor();
+                }
+            },
+            onThemeChange: (themeSetting) => {
+                host.settingsManager.setTheme(themeSetting);
+                void host.themeController.setThemeSetting(themeSetting);
+            },
+            onThemePreview: (themeName) => host.themeController.preview(themeName),
+            onHideThinkingBlockChange: (hidden) => {
+                host.hideThinkingBlock = hidden;
+                host.settingsManager.setHideThinkingBlock(hidden);
+                host.updateThinkingBlockVisibility();
+            },
+            onMermaidRenderingModeChange: (mode) => {
+                host.settingsManager.setMermaidRenderingMode(mode);
+                host.chatContainer.invalidate();
+                host.ui.requestRender();
+            },
+            onShowCacheMissNoticesChange: (shown) => {
+                host.settingsManager.setShowCacheMissNotices(shown);
+                host.rebuildChatFromMessages();
+            },
+            onCollapseChangelogChange: (collapsed) => {
+                host.settingsManager.setCollapseChangelog(collapsed);
+            },
+            onQuietStartupChange: (enabled) => {
+                host.settingsManager.setQuietStartup(enabled);
+            },
+            onDoubleEscapeActionChange: (action) => {
+                host.settingsManager.setDoubleEscapeAction(action);
+            },
+            onUiLanguageChange: (language) => {
+                host.settingsManager.setUiLanguage(language);
+                setI18nLanguage(language);
+                host.ui.requestRender();
+            },
+            onTreeFilterModeChange: (mode) => {
+                host.settingsManager.setTreeFilterMode(mode);
+            },
+            onShowHardwareCursorChange: (enabled) => {
+                host.settingsManager.setShowHardwareCursor(enabled);
+                host.ui.setShowHardwareCursor(enabled);
+            },
+            onEditorPaddingXChange: (padding) => {
+                host.settingsManager.setEditorPaddingX(padding);
+                host.defaultEditor.setPaddingX(padding);
+                if (host.editor !== host.defaultEditor && host.editor.setPaddingX !== undefined) {
+                    host.editor.setPaddingX(padding);
+                }
+            },
+            onOutputPadChange: (padding) => {
+                host.settingsManager.setOutputPad(padding);
+                host.outputPad = padding;
+                if (host.streamingComponent || host.facade.isStreaming()) {
+                    for (const child of host.chatContainer.children) {
+                        if (child instanceof AssistantMessageComponent ||
+                            child instanceof CustomMessageComponent ||
+                            child instanceof UserMessageComponent) {
+                            child.setOutputPad(padding);
+                        }
+                    }
+                    if (host.streamingComponent) {
+                        host.streamingComponent.setOutputPad(padding);
+                    }
+                    host.ui.requestRender();
+                    return;
+                }
+                host.rebuildChatFromMessages();
+            },
+            onAutocompleteMaxVisibleChange: (maxVisible) => {
+                host.settingsManager.setAutocompleteMaxVisible(maxVisible);
+                host.defaultEditor.setAutocompleteMaxVisible(maxVisible);
+                if (host.editor !== host.defaultEditor && host.editor.setAutocompleteMaxVisible !== undefined) {
+                    host.editor.setAutocompleteMaxVisible(maxVisible);
+                }
+            },
+            onClearOnShrinkChange: (enabled) => {
+                host.settingsManager.setClearOnShrink(enabled);
+                host.ui.setClearOnShrink(enabled);
+                if (!enabled && !host.activeStatusIndicator) {
+                    host.statusContainer.clear();
+                }
+            },
+            onShowTerminalProgressChange: (enabled) => {
+                host.settingsManager.setShowTerminalProgress(enabled);
+            },
+            onTuiModeChange: (mode) => {
+                if (!host.switchTuiMode(mode)) {
+                    selector?.getSettingsList().updateValue("tui-mode", host.ui.mode);
+                    host.showStatus(t("Close active overlays before changing TUI mode"));
+                    return;
+                }
+                host.settingsManager.setTuiMode(mode);
+                if (!host.activeStatusIndicator)
+                    host.statusContainer.clear();
+                host.showStatus(t("TUI mode: {mode}", { mode }));
+            },
+            onFullscreenExitOutputChange: (output) => {
+                host.settingsManager.setFullscreenExitOutput(output);
+            },
+            onFullscreenScrollbarChange: (mode) => {
+                host.settingsManager.setFullscreenScrollbar(mode);
+                host.applyFullscreenScrollbarSetting();
+            },
+            onFullscreenCopyOnSelectChange: (enabled) => {
+                host.settingsManager.setFullscreenCopyOnSelect(enabled);
+                if (host.renderer instanceof TuiAltScreen)
+                    host.renderer.setCopyOnSelect(enabled);
+            },
+            onFullscreenWheelScrollLinesChange: (lines) => {
+                host.settingsManager.setFullscreenWheelScrollLines(lines);
+                if (host.renderer instanceof TuiAltScreen)
+                    host.renderer.setWheelScrollLines(lines);
+            },
+            onWarningsChange: (warnings) => {
+                host.settingsManager.setWarnings(warnings);
+            },
+            onCancel: () => {
+                done();
+                host.ui.requestRender();
+            },
+        });
+        return { component: selector, focus: selector.getSettingsList() };
+    });
+}
+/**
+ * Workflow overlay (§9 L2/L3): read-only panorama + transition log from
+ * `workflow.state`/`workflow.transition` entries. Actions are forwarded to
+ * the editor as reviewable text; the main agent executes them via
+ * workflow_advance (rendering and execution stay separated).
+ */
+export function showWorkflowView(host) {
+    const hasSnapshot = host.facade
+        .getEntries()
+        .some((entry) => entry.type === "custom" && entry.customType === "workflow.state");
+    if (!hasSnapshot) {
+        host.showStatus(t("No workflow in this session"));
+        return;
+    }
+    host.showSelector((done) => {
+        const view = new WorkflowViewComponent({
+            getEntries: () => host.facade.getEntries(),
+            maxRows: Math.max(6, Math.floor(host.ui.terminal.rows / 2)),
+            requestRender: () => host.ui.requestRender(),
+        });
+        view.onClose = done;
+        view.onForwardAction = (text) => {
+            done();
+            host.editor.setText(text);
+            host.ui.requestRender();
+            host.showStatus(t("Workflow action staged — review in the editor and submit"));
+        };
+        return { component: view, focus: view, dispose: () => view.dispose() };
+    });
+}
+/**
+ * Subagent session browser (/agents): read-only list + detail of this
+ * session's subagent transcripts from the D-060 §3 on-disk store — the same
+ * parent-scoped summary source as the subagent_list model tool (only this
+ * session's children, newest first). Detail entries load lazily per
+ * session; a failed load renders inside the view instead of throwing.
+ */
+export function showAgentsView(host) {
+    const agentDir = getAgentDir();
+    const sessions = listAgentSessions({ agentDir, parentAgentSession: host.facade.getSessionId() });
+    if (sessions.length === 0) {
+        host.showStatus(t("No subagent sessions in this session"));
+        return;
+    }
+    host.showSelector((done) => {
+        const view = new AgentsViewComponent({
+            sessions,
+            loadEntries: (sessionId) => readAgentSession({ agentDir, sessionId }),
+            maxRows: Math.max(6, Math.floor(host.ui.terminal.rows / 2)),
+            requestRender: () => host.ui.requestRender(),
+        });
+        view.onClose = done;
+        return { component: view, focus: view };
+    });
+}
+export function showTreeSelector(host, initialSelectedId) {
+    const tree = host.facade.getTree();
+    const realLeafId = host.facade.getLeafId();
+    const initialFilterMode = host.settingsManager.getTreeFilterMode();
+    if (tree.length === 0) {
+        host.showStatus(t("No entries in session"));
+        return;
+    }
+    host.showSelector((done) => {
+        const selector = new TreeSelectorComponent(tree, realLeafId, host.ui.terminal.rows, async (entryId) => {
+            // Selecting the current leaf is a no-op (already there)
+            if (entryId === host.facade.getLeafId()) {
+                done();
+                host.showStatus(t("Already at this point"));
+                return;
+            }
+            // Ask about summarization
+            done(); // Close selector first
+            // Loop until user makes a complete choice or cancels to tree
+            let wantsSummary = false;
+            let customInstructions;
+            // Check if we should skip the prompt (user preference to always default to no summary)
+            if (!host.settingsManager.getBranchSummarySkipPrompt()) {
+                while (true) {
+                    const summaryChoice = await host.showDialogSelector(t("Summarize branch?"), [
+                        t("No summary"),
+                        t("Summarize"),
+                        t("Summarize with custom prompt"),
+                    ]);
+                    if (summaryChoice === undefined) {
+                        // User pressed escape - re-show tree selector with same selection
+                        showTreeSelector(host, entryId);
+                        return;
+                    }
+                    wantsSummary = summaryChoice !== t("No summary");
+                    if (summaryChoice === t("Summarize with custom prompt")) {
+                        customInstructions = await host.showDialogEditor(t("Custom summarization instructions"));
+                        if (customInstructions === undefined) {
+                            // User cancelled - loop back to summary selector
+                            continue;
+                        }
+                    }
+                    // User made a complete choice
+                    break;
+                }
+            }
+            // The user committed to navigating: stop the active response first.
+            // 中断分级：导航清场只停回合，不终止后台子代理（设计 §4.2）。
+            if (host.facade.isStreaming()) {
+                host.restoreQueuedMessagesToEditor();
+                await host.facade.abort({ cancelAgentTasks: false });
+            }
+            // Set up escape handler and status indicator if summarizing
+            let showingSummaryIndicator = false;
+            const originalOnEscape = host.defaultEditor.onEscape;
+            if (wantsSummary) {
+                host.defaultEditor.onEscape = () => {
+                    host.facade.abortBranchSummary();
+                };
+                host.chatContainer.addChild(new Spacer(1));
+                host.showStatusIndicator(new BranchSummaryStatusIndicator(host.ui));
+                showingSummaryIndicator = true;
+                host.ui.requestRender();
+            }
+            try {
+                const result = await host.facade.navigateTree(entryId, {
+                    summarize: wantsSummary,
+                    customInstructions,
+                });
+                if (result.aborted) {
+                    // Summarization aborted - re-show tree selector with same selection
+                    host.showStatus(t("Branch summarization cancelled"));
+                    showTreeSelector(host, entryId);
+                    return;
+                }
+                if (result.cancelled) {
+                    host.showStatus(t("Navigation cancelled"));
+                    return;
+                }
+                // Update UI
+                host.chatContainer.clear();
+                host.renderInitialMessages();
+                if (result.editorText && !host.editor.getText().trim()) {
+                    host.editor.setText(result.editorText);
+                }
+                host.showStatus(t("Navigated to selected point"));
+                void host.flushCompactionQueue({ willRetry: false });
+            }
+            catch (error) {
+                host.showError(error instanceof Error ? error.message : String(error));
+            }
+            finally {
+                if (showingSummaryIndicator) {
+                    host.clearStatusIndicator("branchSummary");
+                }
+                host.defaultEditor.onEscape = originalOnEscape;
+            }
+        }, () => {
+            done();
+            host.ui.requestRender();
+        }, (entryId, label) => {
+            host.facade.appendLabelChange(entryId, label);
+            host.ui.requestRender();
+        }, initialSelectedId, initialFilterMode);
+        selector.onCopy = async (text) => {
+            if (!text) {
+                host.showError(t("Selected entry has no text to copy"));
+                return;
+            }
+            try {
+                await copyToClipboard(text);
+                host.showStatus(t("Copied selected message to clipboard"));
+            }
+            catch (error) {
+                host.showError(error instanceof Error ? error.message : String(error));
+            }
+        };
+        return { component: selector, focus: selector };
+    });
+}
+export function showSessionSelector(host) {
+    host.showSelector((done) => {
+        const selector = new SessionSelectorComponent((onProgress, signal) => host.runtimeFacade.listSessions(onProgress, signal), (onProgress, signal) => host.runtimeFacade.listAllSessions(onProgress, signal), async (sessionPath) => {
+            done();
+            await handleResumeSession(host, sessionPath);
+        }, () => {
+            done();
+            host.ui.requestRender();
+        }, () => {
+            void host.shutdown();
+        }, () => host.ui.requestRender(), {
+            renameSession: async (sessionFilePath, nextName) => {
+                const next = (nextName ?? "").trim();
+                if (!next)
+                    return;
+                const mgr = SessionManager.open(sessionFilePath);
+                mgr.appendSessionInfo(next);
+            },
+            showRenameHint: true,
+            keybindings: host.keybindings,
+            // 会话选择器默认只列当前方案的会话；跨方案会话仅在显式
+            // "show all" 后可见（设计 §10.1）。
+            suiteFilter: {
+                currentSuiteId: host.getCurrentSessionSuiteId(),
+                getSessionSuiteId: (session) => host.readSessionSuiteId(session.path),
+            },
+        }, host.runtimeFacade.getSessionFile());
+        return { component: selector, focus: selector };
+    });
+}
+export async function handleResumeSession(host, sessionPath, options) {
+    host.clearStatusIndicator();
+    try {
+        const result = await host.runtimeFacade.switchSession(sessionPath, {
+            withSession: options?.withSession,
+        });
+        if (result.cancelled) {
+            return result;
+        }
+        host.showStatus(t("Resumed session"));
+        host.detectCrossSuiteResume();
+        return result;
+    }
+    catch (error) {
+        if (error instanceof MissingSessionCwdError) {
+            const selectedCwd = await host.promptForMissingSessionCwd(error);
+            if (!selectedCwd) {
+                host.showStatus(t("Resume cancelled"));
+                return { cancelled: true };
+            }
+            const result = await host.runtimeFacade.switchSession(sessionPath, {
+                cwdOverride: selectedCwd,
+                withSession: options?.withSession,
+            });
+            if (result.cancelled) {
+                return result;
+            }
+            host.showStatus(t("Resumed session in current cwd"));
+            host.detectCrossSuiteResume();
+            return result;
+        }
+        return host.handleFatalRuntimeError(t("Failed to resume session"), error);
+    }
+}
+/**
+ * Interactive recovery for an unresolved startup suite id (设计 §9): pick a
+ * suite, persist it as the project setting, then rebuild the session with
+ * the selected suite via the same /new assembly path. Cancelling keeps the
+ * fallback assembly the runtime started with.
+ */
+export async function showStartupSuiteSelector(host, pending) {
+    const selected = await new Promise((resolve) => {
+        openSuiteListSelector(host, {
+            availableSuites: pending.available,
+            note: t('Suite "{id}" was not found. The selected suite applies to the new session.', {
+                id: pending.requestedId,
+            }),
+            onSelect: (suiteId) => resolve(suiteId),
+            onCancel: () => resolve(undefined),
+        });
+    });
+    if (selected === undefined) {
+        host.showWarning(t('Suite "{id}" was not found — continuing without a suite. Use /suite to choose one.', {
+            id: pending.requestedId,
+        }));
+        return;
+    }
+    host.settingsManager.setProjectSuite(selected);
+    try {
+        await host.runtimeFacade.newSession();
+        host.showStatus(t("Suite set to {id} — new session started", { id: selected }));
+    }
+    catch (error) {
+        await host.handleFatalRuntimeError(t("Failed to create session"), error);
+    }
+}
 //# sourceMappingURL=interactive-selectors.js.map