@undefineds.co/linx 0.3.22 → 0.3.23

package/dist/lib/pi-adapter/interactive.js

@@ -8,7 +8,7 @@ import { listArchivedAutoModeSessions, runAutoMode } from '../auto-mode/runner.j
 import { resolveAutoModeCommandRoute, } from '../../../vendor/agent-runtime/dist/auto-mode.js';
 import { getAIConfigProviderCatalog, getAIConfigProviderMetadata } from '../models.js';
 import { runSymphony } from '../symphony-command.js';
-import { applyLinxInteractiveBranding, requestLinxCloudLogin } from './branding.js';
+import { applyLinxInteractiveBranding, checkAndShowLinxUpdate, requestLinxCloudLogin } from './branding.js';
 import { installPodStatusOutputFilter } from './pod-status-output.js';
 import { createPodBackedExtensionUiContext } from './pod-approval.js';
 import { DEFAULT_SECRETARY_CHAT_ID, secretaryChatUri, secretaryThreadUri } from './pod-mirror-mapping.js';
@@ -41,6 +41,11 @@ const COMPACT_STATUS_LINE_TOKENS = [
     'context-remaining',
     'current-dir',
 ];
+const STATUS_LINE_CODEX_PRESET_OPTION = 'Preset: Codex-style';
+const STATUS_LINE_COMPACT_PRESET_OPTION = 'Preset: Compact';
+const STATUS_LINE_TOGGLE_COLORS_OPTION = 'Toggle colors';
+const STATUS_LINE_RESET_OPTION = 'Reset to default';
+const STATUS_LINE_DONE_OPTION = 'Done';
 /** Module-level reference to interactive for footer mode state (set during bootstrap). */
 let _linxFooterInteractive = null;
 export function bootstrapLinxInteractiveMode(runtime, options = {}) {
@@ -554,6 +559,9 @@ function parseLinxGlobalCommand(input) {
             : input.slice('/status-line'.length).trim();
         return { action: 'statusline', args: splitInteractiveCommandArgs(body) };
     }
+    if (input === '/update' || input === '/upgrade') {
+        return { action: 'update' };
+    }
     if (input === '/rewind') {
         return { action: 'rewind-select' };
     }
@@ -679,6 +687,10 @@ async function handleLinxGlobalCommand(interactive, runtime, command) {
         await handleInteractiveStatusLineCommand(interactive, command.args);
         return;
     }
+    if (command.action === 'update') {
+        await checkAndShowLinxUpdate(interactive, { manual: true });
+        return;
+    }
     if (command.action === 'rewind-select') {
         await handleInteractiveRewindSelector(interactive, runtime);
         return;
@@ -695,53 +707,133 @@ async function handleInteractiveStatusLineCommand(interactive, args) {
         return;
     }
     const summary = formatInteractiveStatusLineSummary();
-    if (typeof interactive.showExtensionSelector !== 'function') {
-        interactive.showStatus?.(`${summary} · Use /statusline set <tokens...>, /statusline tokens, /statusline colors <on|off>, or /statusline reset.`);
-        interactive.ui?.requestRender?.();
+    if (typeof interactive.showSelector === 'function') {
+        await showInteractiveStatusLineMultiSelect(interactive);
         return;
     }
-    const choice = await interactive.showExtensionSelector(`Status line\n${summary}`, [
-        'Use Codex-style preset',
-        'Use compact preset',
-        'Configure tokens manually',
-        'Toggle colors',
-        'Show available tokens',
-        'Reset to default',
-    ]);
-    if (choice === 'Use Codex-style preset') {
-        writeInteractiveStatusLineConfig(interactive, {
-            statusLine: CODEX_STYLE_STATUS_LINE_TOKENS,
-            message: 'Status line set to Codex-style preset.',
-        });
+    if (typeof interactive.showExtensionSelector === 'function') {
+        await showInteractiveStatusLineFallbackSelector(interactive);
         return;
     }
-    if (choice === 'Use compact preset') {
-        writeInteractiveStatusLineConfig(interactive, {
-            statusLine: COMPACT_STATUS_LINE_TOKENS,
-            message: 'Status line set to compact preset.',
-        });
+    {
+        interactive.showStatus?.(`${summary} · Use /statusline set <tokens...>, /statusline tokens, /statusline colors <on|off>, or /statusline reset.`);
+        interactive.ui?.requestRender?.();
         return;
     }
-    if (choice === 'Toggle colors') {
-        const current = readLinxStatusLineConfig();
-        writeInteractiveStatusLineConfig(interactive, {
-            statusLineUseColors: !current.useColors,
-            message: `Status line colors ${current.useColors ? 'disabled' : 'enabled'}.`,
-        });
-        return;
+}
+async function showInteractiveStatusLineFallbackSelector(interactive) {
+    while (true) {
+        const currentSummary = formatInteractiveStatusLineSummary();
+        const config = readLinxStatusLineConfig();
+        const options = buildInteractiveStatusLineOptions(config);
+        const choice = await interactive.showExtensionSelector(`Status line\n${currentSummary}`, options);
+        if (!choice || choice === STATUS_LINE_DONE_OPTION) {
+            return;
+        }
+        const token = parseInteractiveStatusLineTokenChoice(choice);
+        if (token) {
+            toggleInteractiveStatusLineToken(interactive, token);
+            continue;
+        }
+        if (choice === STATUS_LINE_CODEX_PRESET_OPTION) {
+            writeInteractiveStatusLineConfig(interactive, {
+                statusLine: CODEX_STYLE_STATUS_LINE_TOKENS,
+                message: 'Status line set to Codex-style preset.',
+            });
+            continue;
+        }
+        if (choice === STATUS_LINE_COMPACT_PRESET_OPTION) {
+            writeInteractiveStatusLineConfig(interactive, {
+                statusLine: COMPACT_STATUS_LINE_TOKENS,
+                message: 'Status line set to compact preset.',
+            });
+            continue;
+        }
+        if (choice === STATUS_LINE_TOGGLE_COLORS_OPTION) {
+            const current = readLinxStatusLineConfig();
+            writeInteractiveStatusLineConfig(interactive, {
+                statusLineUseColors: !current.useColors,
+                message: `Status line colors ${current.useColors ? 'disabled' : 'enabled'}.`,
+            });
+            continue;
+        }
+        if (choice === STATUS_LINE_RESET_OPTION) {
+            resetLinxStatusLineConfig();
+            finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
+        }
     }
-    if (choice === 'Show available tokens') {
-        showInteractiveStatusLineTokens(interactive);
-        return;
+}
+async function showInteractiveStatusLineMultiSelect(interactive) {
+    await new Promise((resolvePromise, rejectPromise) => {
+        let resolved = false;
+        const resolveOnce = () => {
+            if (!resolved) {
+                resolved = true;
+                resolvePromise();
+            }
+        };
+        try {
+            interactive.showSelector((done) => {
+                const close = () => {
+                    done();
+                    resolveOnce();
+                };
+                const selector = new LinxStatusLineSelectorComponent(readLinxStatusLineConfig(), ({ tokens, useColors }) => {
+                    writeInteractiveStatusLineConfig(interactive, {
+                        statusLine: tokens,
+                        statusLineUseColors: useColors,
+                        message: `Status line updated: ${tokens.join(', ')}`,
+                    });
+                    close();
+                }, () => {
+                    close();
+                    interactive.ui?.requestRender?.();
+                });
+                return { component: selector, focus: selector.getList() };
+            });
+        }
+        catch (error) {
+            rejectPromise(error);
+        }
+    });
+}
+function buildInteractiveStatusLineOptions(config = readLinxStatusLineConfig()) {
+    const enabled = new Set(config.tokens);
+    return [
+        ...LINX_STATUS_LINE_TOKEN_NAMES.map((token) => `${enabled.has(token) ? '✓' : '○'} ${token}`),
+        STATUS_LINE_CODEX_PRESET_OPTION,
+        STATUS_LINE_COMPACT_PRESET_OPTION,
+        STATUS_LINE_TOGGLE_COLORS_OPTION,
+        STATUS_LINE_RESET_OPTION,
+        STATUS_LINE_DONE_OPTION,
+    ];
+}
+function parseInteractiveStatusLineTokenChoice(choice) {
+    if (typeof choice !== 'string') {
+        return null;
     }
-    if (choice === 'Reset to default') {
-        resetLinxStatusLineConfig();
-        finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
-        return;
+    const token = choice.replace(/^[✓○]\s*/u, '').trim();
+    if (!token) {
+        return null;
     }
-    if (choice === 'Configure tokens manually') {
-        await promptInteractiveStatusLineTokens(interactive);
+    return LINX_STATUS_LINE_TOKEN_NAMES.includes(token)
+        ? token
+        : null;
+}
+function toggleInteractiveStatusLineToken(interactive, token) {
+    const current = readLinxStatusLineConfig().tokens;
+    const exists = current.includes(token);
+    if (exists && current.length <= 1) {
+        interactive.showError?.('Status line needs at least one item.');
+        return;
     }
+    const next = exists
+        ? current.filter((item) => item !== token)
+        : [...current, token];
+    writeInteractiveStatusLineConfig(interactive, {
+        statusLine: next,
+        message: `Status line ${exists ? 'removed' : 'added'}: ${token}`,
+    });
 }
 function handleInteractiveStatusLineArgs(interactive, args) {
     const action = args[0]?.toLowerCase();
@@ -779,20 +871,6 @@ function handleInteractiveStatusLineArgs(interactive, args) {
         interactive.showError?.(`${message}. Use /statusline tokens to list valid tokens.`);
     }
 }
-async function promptInteractiveStatusLineTokens(interactive) {
-    if (typeof interactive.showExtensionInput !== 'function') {
-        interactive.showStatus?.(`Use /statusline set ${CODEX_STYLE_STATUS_LINE_TOKENS.join(' ')}`);
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    const value = await interactive.showExtensionInput('Status line tokens', CODEX_STYLE_STATUS_LINE_TOKENS.join(' '));
-    if (typeof value !== 'string' || !value.trim()) {
-        interactive.showStatus?.('Status line unchanged.');
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    handleInteractiveStatusLineArgs(interactive, ['set', ...splitInteractiveCommandArgs(value)]);
-}
 function writeInteractiveStatusLineConfig(interactive, patch) {
     writeLinxStatusLineConfigPatch({
         ...(patch.statusLine ? { statusLine: patch.statusLine } : {}),
@@ -1159,6 +1237,178 @@ function refreshInteractiveTranscriptFromSessionManager(interactive) {
         interactive?.showWarning?.(`Rewind transcript refresh failed: ${message}`);
     }
 }
+class LinxMultiSelectList {
+    getRows;
+    onToggle;
+    onAction;
+    onCancel;
+    selectedIndex = 0;
+    constructor(getRows, onToggle, onAction, onCancel) {
+        this.getRows = getRows;
+        this.onToggle = onToggle;
+        this.onAction = onAction;
+        this.onCancel = onCancel;
+    }
+    invalidate() {
+        // No cached render state.
+    }
+    render(width) {
+        const rows = this.normalizedRows();
+        if (rows.length === 0) {
+            return ['  No options'];
+        }
+        const lines = [];
+        for (let index = 0; index < rows.length; index += 1) {
+            const row = rows[index];
+            const cursor = index === this.selectedIndex ? '> ' : '  ';
+            const label = row.kind === 'item'
+                ? `${row.selected ? '✓' : '○'} ${row.label}`
+                : row.label;
+            lines.push(`${cursor}${truncateToWidth(label, Math.max(1, width - 2))}`);
+            if (row.description) {
+                lines.push(`  ${truncateToWidth(row.description, Math.max(1, width - 2))}`);
+            }
+        }
+        lines.push('');
+        lines.push('↑↓ navigate  Enter toggles items/actions  Escape/Ctrl+C cancel');
+        return lines;
+    }
+    handleInput(keyData) {
+        const rows = this.normalizedRows();
+        if (rows.length === 0) {
+            return;
+        }
+        const keybindings = getKeybindings();
+        if (keybindings.matches(keyData, 'tui.select.up')) {
+            this.selectedIndex = this.selectedIndex === 0 ? rows.length - 1 : this.selectedIndex - 1;
+            return;
+        }
+        if (keybindings.matches(keyData, 'tui.select.down')) {
+            this.selectedIndex = this.selectedIndex === rows.length - 1 ? 0 : this.selectedIndex + 1;
+            return;
+        }
+        if (keybindings.matches(keyData, 'tui.select.confirm')) {
+            const selected = rows[this.selectedIndex];
+            if (selected?.kind === 'item') {
+                this.onToggle(selected.id);
+            }
+            else if (selected?.kind === 'action') {
+                this.onAction(selected.id);
+            }
+            return;
+        }
+        if (keybindings.matches(keyData, 'tui.select.cancel')) {
+            this.onCancel();
+        }
+    }
+    normalizedRows() {
+        const rows = this.getRows();
+        if (this.selectedIndex >= rows.length) {
+            this.selectedIndex = Math.max(0, rows.length - 1);
+        }
+        return rows;
+    }
+}
+class LinxStatusLineSelectorComponent extends Container {
+    list;
+    draftTokens;
+    draftUseColors;
+    notice = null;
+    constructor(config, onCommit, onCancel) {
+        super();
+        this.draftTokens = [...config.tokens];
+        this.draftUseColors = config.useColors;
+        this.addChild(new Spacer(1));
+        this.addChild(new Text('Status line', 1, 0));
+        this.addChild(new Text('Select the items that appear in the bottom TUI status line.', 1, 0));
+        this.addChild(new Text(`Current source: tokens ${config.tokenSource}, colors ${config.colorSource}.`, 1, 0));
+        this.addChild(new Spacer(1));
+        this.list = new LinxMultiSelectList(() => this.rows(), (id) => this.toggleToken(id), (id) => this.handleAction(id, onCommit), onCancel);
+        this.addChild(this.list);
+    }
+    getList() {
+        return this.list;
+    }
+    rows() {
+        const enabled = new Set(this.draftTokens);
+        const rows = LINX_STATUS_LINE_TOKEN_NAMES.map((token) => ({
+            kind: 'item',
+            id: token,
+            label: token,
+            selected: enabled.has(token),
+        }));
+        rows.push({
+            kind: 'action',
+            id: 'preset-codex',
+            label: STATUS_LINE_CODEX_PRESET_OPTION,
+            description: CODEX_STYLE_STATUS_LINE_TOKENS.join(', '),
+        }, {
+            kind: 'action',
+            id: 'preset-compact',
+            label: STATUS_LINE_COMPACT_PRESET_OPTION,
+            description: COMPACT_STATUS_LINE_TOKENS.join(', '),
+        }, {
+            kind: 'action',
+            id: 'toggle-colors',
+            label: `${STATUS_LINE_TOGGLE_COLORS_OPTION}: ${this.draftUseColors ? 'on' : 'off'}`,
+        }, {
+            kind: 'action',
+            id: 'reset',
+            label: STATUS_LINE_RESET_OPTION,
+            description: DEFAULT_STATUS_LINE_TOKENS.join(', '),
+        }, {
+            kind: 'action',
+            id: 'done',
+            label: STATUS_LINE_DONE_OPTION,
+            description: this.notice ?? 'Save changes and close.',
+        });
+        return rows;
+    }
+    toggleToken(id) {
+        const token = id;
+        if (!LINX_STATUS_LINE_TOKEN_NAMES.includes(token)) {
+            return;
+        }
+        const exists = this.draftTokens.includes(token);
+        if (exists && this.draftTokens.length <= 1) {
+            this.notice = 'Status line needs at least one item.';
+            return;
+        }
+        this.draftTokens = exists
+            ? this.draftTokens.filter((item) => item !== token)
+            : [...this.draftTokens, token];
+        this.notice = null;
+    }
+    handleAction(id, onCommit) {
+        if (id === 'preset-codex') {
+            this.draftTokens = [...CODEX_STYLE_STATUS_LINE_TOKENS];
+            this.notice = 'Draft changed to Codex-style preset.';
+            return;
+        }
+        if (id === 'preset-compact') {
+            this.draftTokens = [...COMPACT_STATUS_LINE_TOKENS];
+            this.notice = 'Draft changed to compact preset.';
+            return;
+        }
+        if (id === 'toggle-colors') {
+            this.draftUseColors = !this.draftUseColors;
+            this.notice = `Draft colors ${this.draftUseColors ? 'enabled' : 'disabled'}.`;
+            return;
+        }
+        if (id === 'reset') {
+            this.draftTokens = [...DEFAULT_STATUS_LINE_TOKENS];
+            this.draftUseColors = true;
+            this.notice = 'Draft reset to default.';
+            return;
+        }
+        if (id === 'done') {
+            onCommit({
+                tokens: this.draftTokens,
+                useColors: this.draftUseColors,
+            });
+        }
+    }
+}
 function collectRewindUserMessages(_session, sessionManager) {
     return getActiveSessionBranch(sessionManager)
         .filter((entry) => entry?.type === 'message' && entry.message?.role === 'user')
@@ -1520,6 +1770,10 @@ const LINX_INTERACTIVE_SLASH_COMMANDS = [
             { value: 'reset', description: 'Restore default status line tokens' },
         ]),
     },
+    {
+        name: 'update',
+        description: 'check for a LinX CLI update and install from the TUI',
+    },
     {
         name: 'ai',
         argumentHint: 'connect <provider>',