@greppleai/grip 0.1.4 → 0.1.6

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

@@ -72,8 +72,6 @@ function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 class ExpandableText extends Text {
-    getCollapsedText;
-    getExpandedText;
     constructor(getCollapsedText, getExpandedText, expanded = false, paddingX = 0, paddingY = 0) {
         super(expanded ? getExpandedText() : getCollapsedText(), paddingX, paddingY);
         this.getCollapsedText = getCollapsedText;
@@ -196,123 +194,6 @@ export function createInteractiveTuiReference(getTui) {
     });
 }
 export class InteractiveMode {
-    runtimeHost;
-    options;
-    onRightClickPaste = () => {
-        void this.handleRightClickPaste();
-    };
-    renderer;
-    ui;
-    mainScreenRenderState;
-    loadedResourcesContainer;
-    chatContainer;
-    documentContainer;
-    transcriptScrollView;
-    fullscreenLayoutRoot;
-    pendingMessagesContainer;
-    statusContainer;
-    defaultEditor;
-    editor;
-    editorComponentFactory;
-    autocompleteProvider;
-    autocompleteProviderWrappers = [];
-    fdPath;
-    editorContainer;
-    footer;
-    footerContainer;
-    footerDataProvider;
-    // Stored so the same manager can be injected into custom editors, selectors, and extension UI.
-    keybindings;
-    version;
-    isInitialized = false;
-    transcriptRendered = false;
-    onInputCallback;
-    pendingUserInputs = [];
-    loadingAnimation = undefined;
-    workingMessage = undefined;
-    compressionDetectionActive = false;
-    compressionDetectionOwnsLoader = false;
-    workingVisible = true;
-    workingIndicatorOptions = undefined;
-    defaultWorkingMessage = "Working...";
-    defaultHiddenThinkingLabel = "Thinking...";
-    hiddenThinkingLabel = this.defaultHiddenThinkingLabel;
-    lastSigintTime = 0;
-    lastEscapeTime = 0;
-    changelogMarkdown = undefined;
-    startupNoticesShown = false;
-    anthropicSubscriptionWarningShown = false;
-    // Status line tracking (for mutating immediately-sequential status updates)
-    lastStatusSpacer = undefined;
-    lastStatusText = undefined;
-    // Streaming message tracking
-    streamingComponent = undefined;
-    streamingMessage = undefined;
-    // Tool execution tracking: toolCallId -> component
-    pendingTools = new Map();
-    // Tool output expansion state
-    toolOutputExpanded = false;
-    activeSandboxContainerId;
-    activeSandboxBackendConnected = false;
-    sessionSandboxStates = new Map();
-    managedLimaInstances = new Map();
-    // Thinking block visibility state
-    hideThinkingBlock = false;
-    outputPad = 1;
-    mermaidMarkdownTransformer;
-    // Skill commands: command name -> skill file path
-    skillCommands = new Map();
-    // Agent subscription unsubscribe function
-    unsubscribe;
-    hookExecutionUnsubscribe;
-    hookExecutionActivityUnsubscribe;
-    hookExecutionActivityDepth = 0;
-    hookExecutionActivityOwnsLoader = false;
-    hookExecutionSession;
-    hookExecutionNotices = [];
-    hookExecutionComponents = [];
-    pendingStopHookNotifications = [];
-    activeToolHookExecutionGroups = new Map();
-    hookExecutionTurnActive = false;
-    signalCleanupHandlers = [];
-    // Track if editor is in bash mode (text starts with !)
-    isBashMode = false;
-    // Track current bash execution component
-    bashComponent = undefined;
-    // Track pending bash components (shown in pending area, moved to chat on submit)
-    pendingBashComponents = [];
-    // Auto-compaction state
-    autoCompactionLoader = undefined;
-    autoCompactionEscapeHandler;
-    branchSummaryLoader;
-    summarizationRetryLoader;
-    summarizationRetryCountdown;
-    // Auto-retry state
-    retryLoader = undefined;
-    retryCountdown = undefined;
-    retryEscapeHandler;
-    // Messages queued while compaction is running
-    compactionQueuedMessages = [];
-    // Shutdown state
-    shutdownRequested = false;
-    // Extension UI state
-    extensionSelector = undefined;
-    extensionInput = undefined;
-    extensionEditor = undefined;
-    extensionTerminalInputSubscriptions = new Set();
-    // Extension widgets (components rendered above/below the editor)
-    extensionWidgetsAbove = new Map();
-    extensionWidgetsBelow = new Map();
-    widgetContainerAbove;
-    widgetContainerBelow;
-    // Custom footer from extension (undefined = use built-in footer)
-    customFooter = undefined;
-    // Header container that holds the built-in or custom header
-    headerContainer;
-    // Built-in header (logo + keybinding hints + changelog)
-    builtInHeader = undefined;
-    // Custom header from extension (undefined = use built-in header)
-    customHeader = undefined;
     // Convenience accessors
     get session() {
         return this.runtimeHost.session;
@@ -327,6 +208,88 @@ export class InteractiveMode {
         return this.session.settingsManager;
     }
     constructor(runtimeHost, options = {}) {
+        this.onRightClickPaste = () => {
+            void this.handleRightClickPaste();
+        };
+        this.autocompleteProviderWrappers = [];
+        this.isInitialized = false;
+        this.transcriptRendered = false;
+        this.pendingUserInputs = [];
+        this.loadingAnimation = undefined;
+        this.workingMessage = undefined;
+        this.compressionDetectionActive = false;
+        this.compressionDetectionOwnsLoader = false;
+        this.workingVisible = true;
+        this.workingIndicatorOptions = undefined;
+        this.defaultWorkingMessage = "Working...";
+        this.defaultHiddenThinkingLabel = "Thinking...";
+        this.hiddenThinkingLabel = this.defaultHiddenThinkingLabel;
+        this.lastSigintTime = 0;
+        this.lastEscapeTime = 0;
+        this.changelogMarkdown = undefined;
+        this.startupNoticesShown = false;
+        this.anthropicSubscriptionWarningShown = false;
+        // Status line tracking (for mutating immediately-sequential status updates)
+        this.lastStatusSpacer = undefined;
+        this.lastStatusText = undefined;
+        // Streaming message tracking
+        this.streamingComponent = undefined;
+        this.streamingMessage = undefined;
+        // Tool execution tracking: toolCallId -> component
+        this.pendingTools = new Map();
+        // Tool output expansion state
+        this.toolOutputExpanded = false;
+        this.activeSandboxBackendConnected = false;
+        this.sessionSandboxStates = new Map();
+        this.managedLimaInstances = new Map();
+        // Thinking block visibility state
+        this.hideThinkingBlock = false;
+        this.outputPad = 1;
+        // Skill commands: command name -> skill file path
+        this.skillCommands = new Map();
+        this.hookExecutionActivityDepth = 0;
+        this.hookExecutionActivityOwnsLoader = false;
+        this.hookExecutionNotices = [];
+        this.hookExecutionComponents = [];
+        this.pendingStopHookNotifications = [];
+        this.activeToolHookExecutionGroups = new Map();
+        this.hookExecutionTurnActive = false;
+        this.signalCleanupHandlers = [];
+        // Track if editor is in bash mode (text starts with !)
+        this.isBashMode = false;
+        // Track current bash execution component
+        this.bashComponent = undefined;
+        // Track pending bash components (shown in pending area, moved to chat on submit)
+        this.pendingBashComponents = [];
+        // Auto-compaction state
+        this.autoCompactionLoader = undefined;
+        // Auto-retry state
+        this.retryLoader = undefined;
+        this.retryCountdown = undefined;
+        // Messages queued while compaction is running
+        this.compactionQueuedMessages = [];
+        // Shutdown state
+        this.shutdownRequested = false;
+        // Extension UI state
+        this.extensionSelector = undefined;
+        this.extensionInput = undefined;
+        this.extensionEditor = undefined;
+        this.extensionTerminalInputSubscriptions = new Set();
+        // Extension widgets (components rendered above/below the editor)
+        this.extensionWidgetsAbove = new Map();
+        this.extensionWidgetsBelow = new Map();
+        // Custom footer from extension (undefined = use built-in footer)
+        this.customFooter = undefined;
+        // Built-in header (logo + keybinding hints + changelog)
+        this.builtInHeader = undefined;
+        // Custom header from extension (undefined = use built-in header)
+        this.customHeader = undefined;
+        /**
+         * Gracefully shutdown the agent.
+         * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
+         * repaint the final frame while the process is exiting.
+         */
+        this.isShuttingDown = false;
         this.runtimeHost = runtimeHost;
         const tuiMode = options.tuiMode ?? this.settingsManager.getTuiMode();
         this.options = { ...options, tuiMode };
@@ -427,17 +390,93 @@ export class InteractiveMode {
             path: command.sourceInfo.path,
         }));
     }
+    configureNewCommandAutocomplete(commandsByName) {
+        const command = commandsByName.get("new");
+        if (!command)
+            return;
+        command.argumentHint = "[--sandbox]";
+        command.getArgumentCompletions = (prefix) => {
+            if (prefix.includes(" "))
+                return null;
+            return fuzzyFilter(["--sandbox"], prefix, (option) => option).map((option) => ({
+                value: option,
+                label: option,
+            }));
+        };
+    }
     createBaseAutocompleteProvider() {
-        // Define commands for autocomplete
+        // Commands without arguments remain selectable after a trailing space (e.g. /quit ).
+        const noArgumentCommands = new Set([
+            "settings",
+            "scoped-models",
+            "share",
+            "copy",
+            "session",
+            "changelog",
+            "hotkeys",
+            "fork",
+            "clone",
+            "tree",
+            "login",
+            "logout",
+            "reload",
+            "resume",
+            "quit",
+        ]);
         const slashCommands = BUILTIN_SLASH_COMMANDS.map((command) => ({
             name: command.name,
             description: command.description,
+            showWithoutArguments: noArgumentCommands.has(command.name),
         }));
         const cdCommand = slashCommands.find((command) => command.name === "cd");
         if (cdCommand) {
             cdCommand.argumentHint = "<directory>";
             cdCommand.getArgumentCompletions = (prefix) => this.session.supportsDirectoryChange() ? getDirectoryCompletions(prefix, this.activeSession.getCwd()) : [];
         }
+        const choiceCompletions = (choices) => (prefix) => {
+            if (prefix.includes(" "))
+                return null;
+            return fuzzyFilter([...choices], prefix, (choice) => choice).map((choice) => ({
+                value: choice,
+                label: choice,
+            }));
+        };
+        const commandsByName = new Map();
+        for (const command of slashCommands) {
+            if (!commandsByName.has(command.name))
+                commandsByName.set(command.name, command);
+        }
+        for (const [name, hint, choices] of [
+            ["hooks", "<enable|disable>", ["enable", "disable"]],
+            ["context-compression", "[on|off]", ["on", "off"]],
+            ["compress-detection", "[on|off]", ["on", "off"]],
+        ]) {
+            const command = commandsByName.get(name);
+            if (command) {
+                command.argumentHint = hint;
+                command.getArgumentCompletions = choiceCompletions(choices);
+            }
+        }
+        this.configureNewCommandAutocomplete(commandsByName);
+        const sandboxCommand = slashCommands.find((command) => command.name === "sandbox");
+        if (sandboxCommand) {
+            sandboxCommand.argumentHint = "<status|clear|--attach|start|list|stop>";
+            sandboxCommand.getArgumentCompletions = (prefix) => {
+                if (!prefix.includes(" ")) {
+                    return fuzzyFilter(["status", "clear", "--attach", "start", "list", "stop"], prefix, (item) => item).map((item) => ({
+                        value: item === "start" || item === "stop" || item === "--attach" ? `${item} ` : item,
+                        label: item,
+                    }));
+                }
+                const startMatch = prefix.match(/^start\s+(--[^\s]*)?$/);
+                if (!startMatch)
+                    return null;
+                return fuzzyFilter(["--name", "--template", "--update"], startMatch[1] ?? "", (item) => item).map((item) => ({
+                    value: `start ${item}${item === "--update" ? "" : " "}`,
+                    label: item,
+                }));
+            };
+        }
         const modelCommand = slashCommands.find((command) => command.name === "model");
         if (modelCommand) {
             modelCommand.getArgumentCompletions = (prefix) => {
@@ -526,7 +565,7 @@ export class InteractiveMode {
             getSuggestions: async (lines, cursorLine, cursorCol, options) => {
                 const beforeCursor = (lines[cursorLine] ?? "").slice(0, cursorCol);
                 const nameMatch = beforeCursor.match(/^\/sandbox[ \t]+(start[ \t]+--name(?:[ \t]+([^\s]*))?)$/);
-                if (!options.force || !nameMatch)
+                if (!nameMatch)
                     return base.getSuggestions(lines, cursorLine, cursorCol, options);
                 if (options.signal.aborted)
                     return null;
@@ -1839,7 +1878,7 @@ export class InteractiveMode {
         this.setHiddenThinkingLabel();
     }
     // Maximum total widget lines to prevent viewport overflow
-    static MAX_WIDGET_LINES = 10;
+    static { this.MAX_WIDGET_LINES = 10; }
     /**
      * Render all extension widgets to the widget container.
      */
@@ -2499,6 +2538,19 @@ export class InteractiveMode {
                 },
             };
         }
+        if (this.matchesEditorCommand(text, "/new")) {
+            return {
+                run: async () => {
+                    this.editor.setText("");
+                    const option = text.slice("/new".length).trim();
+                    if (option && option !== "--sandbox") {
+                        this.showWarning("Usage: /new [--sandbox]");
+                        return;
+                    }
+                    await this.handleClearCommand(option === "--sandbox");
+                },
+            };
+        }
         if (this.matchesEditorCommand(text, "/compact")) {
             const customInstructions = text.slice("/compact".length).trim() || undefined;
             return {
@@ -3403,12 +3455,6 @@ export class InteractiveMode {
         // Only called when editor is empty (enforced by CustomEditor)
         void this.shutdown();
     }
-    /**
-     * Gracefully shutdown the agent.
-     * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
-     * repaint the final frame while the process is exiting.
-     */
-    isShuttingDown = false;
     async shutdown(options) {
         if (this.isShuttingDown)
             return;
@@ -4599,12 +4645,12 @@ export class InteractiveMode {
         return options.sort((a, b) => a.name.localeCompare(b.name));
     }
     showLoginAuthTypeSelector() {
-        const subscriptionLabel = "Use a subscription";
+        const browserLabel = "Sign in (subscriptions or OpenRouter credits)";
         const apiKeyLabel = "Use an API key";
         this.showSelector((done) => {
-            const selector = new ExtensionSelectorComponent("Select authentication method:", [subscriptionLabel, apiKeyLabel], (option) => {
+            const selector = new ExtensionSelectorComponent("Select authentication method:", [browserLabel, apiKeyLabel], (option) => {
                 done();
-                const authType = option === subscriptionLabel ? "oauth" : "api_key";
+                const authType = option === browserLabel ? "oauth" : "api_key";
                 this.showLoginProviderSelector(authType);
             }, () => {
                 done();
@@ -4616,7 +4662,7 @@ export class InteractiveMode {
     showLoginProviderSelector(authType) {
         const providerOptions = this.getLoginProviderOptions(authType);
         if (providerOptions.length === 0) {
-            this.showStatus(authType === "oauth" ? "No subscription providers available." : "No API key providers available.");
+            this.showStatus(authType === "oauth" ? "No browser sign-in providers available." : "No API key providers available.");
             return;
         }
         this.showSelector((done) => {
@@ -4889,13 +4935,40 @@ export class InteractiveMode {
     }
     // =========================================================================
     // Command handlers
+    async handleSandboxCdCommand(text) {
+        const backend = this.session.getToolBackendInfo();
+        if (backend.type !== "remote" || !backend.configured) {
+            this.showWarning("Changing directories is not supported with the active workspace backend.");
+            return;
+        }
+        const argument = this.getPathCommandArgument(text, "/cd");
+        if (text !== "/cd" && !argument) {
+            this.showError("Usage: /cd [directory]");
+            return;
+        }
+        try {
+            const directory = await this.session.changeSandboxWorkingDirectory(argument ?? backend.workspace.root);
+            this.showStatus(`Working directory: ${directory}`);
+        }
+        catch (error) {
+            this.showError(`Failed to change sandbox directory: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async handleUnavailableCdCommand(text) {
+        if (this.activeSandboxBackendConnected) {
+            await this.handleSandboxCdCommand(text);
+        }
+        else {
+            this.showWarning("Changing directories is not supported with the active workspace backend.");
+        }
+    }
     async handleCdCommand(text) {
         if (!this.session.isIdle || this.session.isBashRunning) {
             this.showWarning("Wait for the current operation to finish before changing directories.");
             return;
         }
         if (!this.session.supportsDirectoryChange()) {
-            this.showWarning("Changing directories is not supported with the active workspace backend.");
+            await this.handleUnavailableCdCommand(text);
             return;
         }
         const argument = this.getPathCommandArgument(text, "/cd");
@@ -5758,23 +5831,36 @@ export class InteractiveMode {
         this.chatContainer.addChild(new DynamicBorder());
         this.ui.requestRender();
     }
-    async handleClearCommand() {
+    async handleClearCommand(reuseSandbox = false) {
         if (this.loadingAnimation) {
             this.loadingAnimation.stop();
             this.loadingAnimation = undefined;
         }
         this.statusContainer.clear();
+        const sandboxState = reuseSandbox && this.activeSandboxBackendConnected
+            ? this.sessionSandboxStates.get(getSessionSandboxKey(this.activeSession))
+            : undefined;
+        let newSessionKey;
         try {
-            const result = await this.runtimeHost.newSession();
-            if (result.cancelled) {
+            const result = await this.runtimeHost.newSession(sandboxState
+                ? {
+                    setup: async (nextSession) => {
+                        newSessionKey = getSessionSandboxKey(nextSession);
+                        this.sessionSandboxStates.set(newSessionKey, sandboxState);
+                    },
+                }
+                : undefined);
+            if (result.cancelled)
                 return;
-            }
             this.renderCurrentSessionState();
             this.chatContainer.addChild(new Spacer(1));
             this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ New session started")}`, 1, 1));
             this.ui.requestRender();
         }
         catch (error) {
+            if (newSessionKey && newSessionKey !== getSessionSandboxKey(this.activeSession)) {
+                this.sessionSandboxStates.delete(newSessionKey);
+            }
             await this.handleFatalRuntimeError("Failed to create session", error);
         }
     }