@mariozechner/pi-coding-agent 0.42.4 → 0.43.0

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

@@ -7,15 +7,15 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { getOAuthProviders, } from "@mariozechner/pi-ai";
-import { CombinedAutocompleteProvider, Container, getEditorKeybindings, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, Text, TruncatedText, TUI, visibleWidth, } from "@mariozechner/pi-tui";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, getEditorKeybindings, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, Text, TruncatedText, TUI, visibleWidth, } from "@mariozechner/pi-tui";
 import { spawn, spawnSync } from "child_process";
 import { APP_NAME, getAuthPath, getDebugLogPath, isBunBinary, VERSION } from "../../config.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
+import { resolveModelScope } from "../../core/model-resolver.js";
 import { SessionManager } from "../../core/session-manager.js";
 import { loadProjectContextFiles } from "../../core/system-prompt.js";
-import { allTools } from "../../core/tools/index.js";
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
@@ -36,6 +36,7 @@ import { FooterComponent } from "./components/footer.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { OAuthSelectorComponent } from "./components/oauth-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 { ToolExecutionComponent } from "./components/tool-execution.js";
@@ -56,6 +57,7 @@ export class InteractiveMode {
     defaultEditor;
     editor;
     autocompleteProvider;
+    fdPath;
     editorContainer;
     footer;
     footerDataProvider;
@@ -64,6 +66,7 @@ export class InteractiveMode {
     isInitialized = false;
     onInputCallback;
     loadingAnimation = undefined;
+    defaultWorkingMessage = "Working... (esc to interrupt)";
     lastSigintTime = 0;
     lastEscapeTime = 0;
     changelogMarkdown = undefined;
@@ -79,6 +82,8 @@ export class InteractiveMode {
     toolOutputExpanded = false;
     // Thinking block visibility state
     hideThinkingBlock = false;
+    // Skill commands: command name -> skill file path
+    skillCommands = new Map();
     // Agent subscription unsubscribe function
     unsubscribe;
     // Track if editor is in bash mode (text starts with !)
@@ -146,14 +151,41 @@ export class InteractiveMode {
         // Define commands for autocomplete
         const slashCommands = [
             { name: "settings", description: "Open settings menu" },
-            { name: "model", description: "Select model (opens selector UI)" },
+            {
+                name: "model",
+                description: "Select model (opens selector UI)",
+                getArgumentCompletions: (prefix) => {
+                    // Get available models (scoped or from registry)
+                    const models = this.session.scopedModels.length > 0
+                        ? this.session.scopedModels.map((s) => s.model)
+                        : this.session.modelRegistry.getAvailable();
+                    if (models.length === 0)
+                        return null;
+                    // Create items with provider/id format
+                    const items = models.map((m) => ({
+                        id: m.id,
+                        provider: m.provider,
+                        label: `${m.provider}/${m.id}`,
+                    }));
+                    // Fuzzy filter by model ID + provider (allows "opus anthropic" to match)
+                    const filtered = fuzzyFilter(items, prefix, (item) => `${item.id} ${item.provider}`);
+                    if (filtered.length === 0)
+                        return null;
+                    return filtered.map((item) => ({
+                        value: item.label,
+                        label: item.id,
+                        description: item.provider,
+                    }));
+                },
+            },
+            { name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
             { name: "export", description: "Export session to HTML file" },
             { name: "share", description: "Share session as a secret GitHub gist" },
             { name: "copy", description: "Copy last agent message to clipboard" },
             { name: "session", description: "Show session info and stats" },
             { name: "changelog", description: "Show changelog entries" },
             { name: "hotkeys", description: "Show all keyboard shortcuts" },
-            { name: "branch", description: "Create a new branch from a previous message" },
+            { name: "fork", description: "Create a new fork from a previous message" },
             { name: "tree", description: "Navigate session tree (switch branches)" },
             { name: "login", description: "Login with OAuth provider" },
             { name: "logout", description: "Logout from OAuth provider" },
@@ -171,18 +203,31 @@ export class InteractiveMode {
             name: cmd.name,
             description: cmd.description ?? "(extension command)",
         }));
+        // Build skill commands from session.skills (if enabled)
+        this.skillCommands.clear();
+        const skillCommandList = [];
+        if (this.settingsManager.getEnableSkillCommands()) {
+            for (const skill of this.session.skills) {
+                const commandName = `skill:${skill.name}`;
+                this.skillCommands.set(commandName, skill.filePath);
+                skillCommandList.push({ name: commandName, description: skill.description });
+            }
+        }
         // Setup autocomplete
-        this.autocompleteProvider = new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands], process.cwd(), fdPath);
+        this.autocompleteProvider = new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands, ...skillCommandList], process.cwd(), fdPath);
         this.defaultEditor.setAutocompleteProvider(this.autocompleteProvider);
     }
+    rebuildAutocomplete() {
+        this.setupAutocomplete(this.fdPath);
+    }
     async init() {
         if (this.isInitialized)
             return;
         // Load changelog (only show new entries, skip for resumed sessions)
         this.changelogMarkdown = this.getChangelogForDisplay();
         // Setup autocomplete with fd tool for file path completion
-        const fdPath = await ensureTool("fd");
-        this.setupAutocomplete(fdPath);
+        this.fdPath = await ensureTool("fd");
+        this.setupAutocomplete(this.fdPath);
         // Add header with keybindings from config
         const logo = theme.bold(theme.fg("accent", APP_NAME)) + theme.fg("dim", ` v${this.version}`);
         // Format keybinding for startup display (lowercase, compact)
@@ -527,15 +572,15 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 return { cancelled: false };
             },
-            branch: async (entryId) => {
-                const result = await this.session.branch(entryId);
+            fork: async (entryId) => {
+                const result = await this.session.fork(entryId);
                 if (result.cancelled) {
                     return { cancelled: true };
                 }
                 this.chatContainer.clear();
                 this.renderInitialMessages();
                 this.editor.setText(result.selectedText);
-                this.showStatus("Branched to new session");
+                this.showStatus("Forked to new session");
                 return { cancelled: false };
             },
             navigateTree: async (targetId, options) => {
@@ -565,14 +610,6 @@ export class InteractiveMode {
             this.chatContainer.addChild(new Text(theme.fg("muted", "Loaded extensions:\n") + extList, 0, 0));
             this.chatContainer.addChild(new Spacer(1));
         }
-        // Warn about built-in tool overrides
-        const builtInToolNames = new Set(Object.keys(allTools));
-        const registeredTools = extensionRunner.getAllRegisteredTools();
-        for (const tool of registeredTools) {
-            if (builtInToolNames.has(tool.definition.name)) {
-                this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: Extension "${tool.extensionPath}" overrides built-in tool "${tool.definition.name}"`), 0, 0));
-            }
-        }
         // Emit session_start event
         await extensionRunner.emit({
             type: "session_start",
@@ -747,6 +784,11 @@ export class InteractiveMode {
             input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
             notify: (message, type) => this.showExtensionNotify(message, type),
             setStatus: (key, text) => this.setExtensionStatus(key, text),
+            setWorkingMessage: (message) => {
+                if (this.loadingAnimation) {
+                    this.loadingAnimation.setMessage(message ?? this.defaultWorkingMessage);
+                }
+            },
             setWidget: (key, content) => this.setExtensionWidget(key, content),
             setFooter: (factory) => this.setExtensionFooter(factory),
             setHeader: (factory) => this.setExtensionHeader(factory),
@@ -1047,7 +1089,7 @@ export class InteractiveMode {
                 this.updateEditorBorderColor();
             }
             else if (!this.editor.getText().trim()) {
-                // Double-escape with empty editor triggers /tree or /branch based on setting
+                // Double-escape with empty editor triggers /tree or /fork based on setting
                 const now = Date.now();
                 if (now - this.lastEscapeTime < 500) {
                     if (this.settingsManager.getDoubleEscapeAction() === "tree") {
@@ -1121,6 +1163,11 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
+            if (text === "/scoped-models") {
+                this.editor.setText("");
+                await this.showModelsSelector();
+                return;
+            }
             if (text === "/model" || text.startsWith("/model ")) {
                 const searchTerm = text.startsWith("/model ") ? text.slice(7).trim() : undefined;
                 this.editor.setText("");
@@ -1157,7 +1204,7 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
-            if (text === "/branch") {
+            if (text === "/fork") {
                 this.showUserMessageSelector();
                 this.editor.setText("");
                 return;
@@ -1208,6 +1255,19 @@ export class InteractiveMode {
                 await this.shutdown();
                 return;
             }
+            // Handle skill commands (/skill:name [args])
+            if (text.startsWith("/skill:")) {
+                const spaceIndex = text.indexOf(" ");
+                const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+                const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
+                const skillPath = this.skillCommands.get(commandName);
+                if (skillPath) {
+                    this.editor.addToHistory?.(text);
+                    this.editor.setText("");
+                    await this.handleSkillCommand(skillPath, args);
+                    return;
+                }
+            }
             // Handle bash command (! for normal, !! for excluded from context)
             if (text.startsWith("!")) {
                 const isExcluded = text.startsWith("!!");
@@ -1282,7 +1342,7 @@ export class InteractiveMode {
                     this.loadingAnimation.stop();
                 }
                 this.statusContainer.clear();
-                this.loadingAnimation = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), "Working... (esc to interrupt)");
+                this.loadingAnimation = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), this.defaultWorkingMessage);
                 this.statusContainer.addChild(this.loadingAnimation);
                 this.ui.requestRender();
                 break;
@@ -1864,7 +1924,8 @@ export class InteractiveMode {
             }
             // Restart TUI
             this.ui.start();
-            this.ui.requestRender();
+            // Force full re-render since external editor uses alternate screen
+            this.ui.requestRender(true);
         }
     }
     // =========================================================================
@@ -2058,6 +2119,7 @@ export class InteractiveMode {
                 showImages: this.settingsManager.getShowImages(),
                 autoResizeImages: this.settingsManager.getImageAutoResize(),
                 blockImages: this.settingsManager.getBlockImages(),
+                enableSkillCommands: this.settingsManager.getEnableSkillCommands(),
                 steeringMode: this.session.steeringMode,
                 followUpMode: this.session.followUpMode,
                 thinkingLevel: this.session.thinkingLevel,
@@ -2086,6 +2148,10 @@ export class InteractiveMode {
                 onBlockImagesChange: (blocked) => {
                     this.settingsManager.setBlockImages(blocked);
                 },
+                onEnableSkillCommandsChange: (enabled) => {
+                    this.settingsManager.setEnableSkillCommands(enabled);
+                    this.rebuildAutocomplete();
+                },
                 onSteeringModeChange: (mode) => {
                     this.session.setSteeringMode(mode);
                 },
@@ -2214,17 +2280,125 @@ export class InteractiveMode {
             return { component: selector, focus: selector };
         });
     }
+    async showModelsSelector() {
+        // Get all available models
+        this.session.modelRegistry.refresh();
+        const allModels = this.session.modelRegistry.getAvailable();
+        if (allModels.length === 0) {
+            this.showStatus("No models available");
+            return;
+        }
+        // Check if session has scoped models (from previous session-only changes or CLI --models)
+        const sessionScopedModels = this.session.scopedModels;
+        const hasSessionScope = sessionScopedModels.length > 0;
+        // Build enabled model IDs from session state or settings
+        const enabledModelIds = new Set();
+        let hasFilter = false;
+        if (hasSessionScope) {
+            // Use current session's scoped models
+            for (const sm of sessionScopedModels) {
+                enabledModelIds.add(`${sm.model.provider}/${sm.model.id}`);
+            }
+            hasFilter = true;
+        }
+        else {
+            // Fall back to settings
+            const patterns = this.settingsManager.getEnabledModels();
+            if (patterns !== undefined && patterns.length > 0) {
+                hasFilter = true;
+                const scopedModels = await resolveModelScope(patterns, this.session.modelRegistry);
+                for (const sm of scopedModels) {
+                    enabledModelIds.add(`${sm.model.provider}/${sm.model.id}`);
+                }
+            }
+        }
+        // Track current enabled state (session-only until persisted)
+        const currentEnabledIds = new Set(enabledModelIds);
+        let currentHasFilter = hasFilter;
+        // Helper to update session's scoped models (session-only, no persist)
+        const updateSessionModels = async (enabledIds) => {
+            if (enabledIds.size > 0 && enabledIds.size < allModels.length) {
+                // Use current session thinking level, not settings default
+                const currentThinkingLevel = this.session.thinkingLevel;
+                const newScopedModels = await resolveModelScope(Array.from(enabledIds), this.session.modelRegistry);
+                this.session.setScopedModels(newScopedModels.map((sm) => ({
+                    model: sm.model,
+                    thinkingLevel: sm.thinkingLevel ?? currentThinkingLevel,
+                })));
+            }
+            else {
+                // All enabled or none enabled = no filter
+                this.session.setScopedModels([]);
+            }
+        };
+        this.showSelector((done) => {
+            const selector = new ScopedModelsSelectorComponent({
+                allModels,
+                enabledModelIds: currentEnabledIds,
+                hasEnabledModelsFilter: currentHasFilter,
+            }, {
+                onModelToggle: async (modelId, enabled) => {
+                    if (enabled) {
+                        currentEnabledIds.add(modelId);
+                    }
+                    else {
+                        currentEnabledIds.delete(modelId);
+                    }
+                    currentHasFilter = true;
+                    await updateSessionModels(currentEnabledIds);
+                },
+                onEnableAll: async (allModelIds) => {
+                    currentEnabledIds.clear();
+                    for (const id of allModelIds) {
+                        currentEnabledIds.add(id);
+                    }
+                    currentHasFilter = false;
+                    await updateSessionModels(currentEnabledIds);
+                },
+                onClearAll: async () => {
+                    currentEnabledIds.clear();
+                    currentHasFilter = true;
+                    await updateSessionModels(currentEnabledIds);
+                },
+                onToggleProvider: async (_provider, modelIds, enabled) => {
+                    for (const id of modelIds) {
+                        if (enabled) {
+                            currentEnabledIds.add(id);
+                        }
+                        else {
+                            currentEnabledIds.delete(id);
+                        }
+                    }
+                    currentHasFilter = true;
+                    await updateSessionModels(currentEnabledIds);
+                },
+                onPersist: (enabledIds) => {
+                    // Persist to settings
+                    const newPatterns = enabledIds.length === allModels.length
+                        ? undefined // All enabled = clear filter
+                        : enabledIds;
+                    this.settingsManager.setEnabledModels(newPatterns);
+                    this.showStatus("Model selection saved to settings");
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            return { component: selector, focus: selector };
+        });
+    }
     showUserMessageSelector() {
-        const userMessages = this.session.getUserMessagesForBranching();
+        const userMessages = this.session.getUserMessagesForForking();
         if (userMessages.length === 0) {
-            this.showStatus("No messages to branch from");
+            this.showStatus("No messages to fork from");
             return;
         }
         this.showSelector((done) => {
             const selector = new UserMessageSelectorComponent(userMessages.map((m) => ({ id: m.entryId, text: m.text })), async (entryId) => {
-                const result = await this.session.branch(entryId);
+                const result = await this.session.fork(entryId);
                 if (result.cancelled) {
-                    // Extension cancelled the branch
+                    // Extension cancelled the fork
                     done();
                     this.ui.requestRender();
                     return;
@@ -2241,7 +2415,7 @@ export class InteractiveMode {
             return { component: selector, focus: selector.getMessageList() };
         });
     }
-    showTreeSelector() {
+    showTreeSelector(initialSelectedId) {
         const tree = this.sessionManager.getTree();
         const realLeafId = this.sessionManager.getLeafId();
         // Find the visible leaf for display (skip metadata entries like labels)
@@ -2268,7 +2442,31 @@ export class InteractiveMode {
                 }
                 // Ask about summarization
                 done(); // Close selector first
-                const wantsSummary = await this.showExtensionConfirm("Summarize branch?", "Create a summary of the branch you're leaving?");
+                // Loop until user makes a complete choice or cancels to tree
+                let wantsSummary = false;
+                let customInstructions;
+                while (true) {
+                    const summaryChoice = await this.showExtensionSelector("Summarize branch?", [
+                        "No summary",
+                        "Summarize",
+                        "Summarize with custom prompt",
+                    ]);
+                    if (summaryChoice === undefined) {
+                        // User pressed escape - re-show tree selector with same selection
+                        this.showTreeSelector(entryId);
+                        return;
+                    }
+                    wantsSummary = summaryChoice !== "No summary";
+                    if (summaryChoice === "Summarize with custom prompt") {
+                        customInstructions = await this.showExtensionEditor("Custom summarization instructions");
+                        if (customInstructions === undefined) {
+                            // User cancelled - loop back to summary selector
+                            continue;
+                        }
+                    }
+                    // User made a complete choice
+                    break;
+                }
                 // Set up escape handler and loader if summarizing
                 let summaryLoader;
                 const originalOnEscape = this.defaultEditor.onEscape;
@@ -2282,11 +2480,14 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 }
                 try {
-                    const result = await this.session.navigateTree(entryId, { summarize: wantsSummary });
+                    const result = await this.session.navigateTree(entryId, {
+                        summarize: wantsSummary,
+                        customInstructions,
+                    });
                     if (result.aborted) {
-                        // Summarization aborted - re-show tree selector
+                        // Summarization aborted - re-show tree selector with same selection
                         this.showStatus("Branch summarization cancelled");
-                        this.showTreeSelector();
+                        this.showTreeSelector(entryId);
                         return;
                     }
                     if (result.cancelled) {
@@ -2317,14 +2518,13 @@ export class InteractiveMode {
             }, (entryId, label) => {
                 this.sessionManager.appendLabelChange(entryId, label);
                 this.ui.requestRender();
-            });
+            }, initialSelectedId);
             return { component: selector, focus: selector };
         });
     }
     showSessionSelector() {
         this.showSelector((done) => {
-            const sessions = SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir());
-            const selector = new SessionSelectorComponent(sessions, async (sessionPath) => {
+            const selector = new SessionSelectorComponent((onProgress) => SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir(), onProgress), SessionManager.listAll, async (sessionPath) => {
                 done();
                 await this.handleResumeSession(sessionPath);
             }, () => {
@@ -2332,7 +2532,7 @@ export class InteractiveMode {
                 this.ui.requestRender();
             }, () => {
                 void this.shutdown();
-            });
+            }, () => this.ui.requestRender());
             return { component: selector, focus: selector.getSessionList() };
         });
     }
@@ -2612,6 +2812,18 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(info, 1, 0));
         this.ui.requestRender();
     }
+    async handleSkillCommand(skillPath, args) {
+        try {
+            const content = fs.readFileSync(skillPath, "utf-8");
+            // Strip YAML frontmatter if present
+            const body = content.replace(/^---\n[\s\S]*?\n---\n/, "").trim();
+            const message = args ? `${body}\n\n---\n\nUser: ${args}` : body;
+            await this.session.prompt(message);
+        }
+        catch (err) {
+            this.showError(`Failed to load skill: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     handleChangelogCommand() {
         const changelogPath = getChangelogPath();
         const allEntries = parseChangelog(changelogPath);
@@ -2623,8 +2835,8 @@ export class InteractiveMode {
             : "No changelog entries found.";
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new DynamicBorder());
-        this.ui.addChild(new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0));
-        this.ui.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0));
+        this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Markdown(changelogMarkdown, 1, 1, getMarkdownTheme()));
         this.chatContainer.addChild(new DynamicBorder());
         this.ui.requestRender();