shortcutxl 0.2.0

package/dist/modes/interactive/components/model-selector.js

@@ -0,0 +1,237 @@
+// SHORTCUT PATCH: simplified — removed scoped model filtering and scope toggle UI
+import { modelsAreEqual } from '@mariozechner/pi-ai';
+import { Container, fuzzyFilter, getEditorKeybindings, Input, Spacer, Text } from '../../../tui/index.js';
+import { theme } from '../../../core/theme.js';
+import { DynamicBorder } from './dynamic-border.js';
+/** Only these model IDs are shown for known providers. Unlisted providers show all models. */
+const ALLOWED_MODELS_PER_PROVIDER = {
+    shortcut: new Set(['claude-opus-4-6', 'claude-sonnet-4-6', 'gpt-5.4-2026-03-05']),
+    anthropic: new Set(['claude-opus-4-6', 'claude-sonnet-4-6']),
+    openai: new Set(['gpt-5.4']),
+    'openai-codex': new Set(['gpt-5.4'])
+};
+/**
+ * Component that renders a model selector with search.
+ * Shows all available (authenticated) models.
+ */
+export class ModelSelectorComponent extends Container {
+    searchInput;
+    // Focusable implementation - propagate to searchInput for IME cursor positioning
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.searchInput.focused = value;
+    }
+    listContainer;
+    allModels = [];
+    filteredModels = [];
+    selectedIndex = 0;
+    currentModel;
+    settingsManager;
+    modelRegistry;
+    onSelectCallback;
+    onCancelCallback;
+    errorMessage;
+    tui;
+    constructor(tui, currentModel, settingsManager, modelRegistry, _scopedModels, // kept for call-site compat, ignored
+    onSelect, onCancel, initialSearchInput) {
+        super();
+        this.tui = tui;
+        this.currentModel = currentModel;
+        this.settingsManager = settingsManager;
+        this.modelRegistry = modelRegistry;
+        this.onSelectCallback = onSelect;
+        this.onCancelCallback = onCancel;
+        // Add top border
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        const hintText = 'Only showing models with configured API keys (see README for details)';
+        this.addChild(new Text(theme.fg('warning', hintText), 0, 0));
+        this.addChild(new Spacer(1));
+        // Create search input
+        this.searchInput = new Input();
+        if (initialSearchInput) {
+            this.searchInput.setValue(initialSearchInput);
+        }
+        this.searchInput.onSubmit = () => {
+            // Enter on search input selects the first filtered item
+            if (this.filteredModels[this.selectedIndex]) {
+                this.handleSelect(this.filteredModels[this.selectedIndex].model);
+            }
+        };
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        // Create list container
+        this.listContainer = new Container();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        // Add bottom border
+        this.addChild(new DynamicBorder());
+        // Load models and do initial render
+        this.loadModels().then(() => {
+            if (initialSearchInput) {
+                this.filterModels(initialSearchInput);
+            }
+            else {
+                this.updateList();
+            }
+            // Request re-render after models are loaded
+            this.tui.requestRender();
+        });
+    }
+    async loadModels() {
+        let models;
+        // Refresh to pick up any changes to models.json
+        this.modelRegistry.refresh();
+        // Check for models.json errors
+        const loadError = this.modelRegistry.getError();
+        if (loadError) {
+            this.errorMessage = loadError;
+        }
+        // Load available models (built-in models still work even if models.json failed)
+        // For known providers, only show curated models to keep the list clean.
+        try {
+            const availableModels = await this.modelRegistry.getAvailable();
+            models = availableModels
+                .filter((model) => {
+                const allowed = ALLOWED_MODELS_PER_PROVIDER[model.provider];
+                // If no allowlist for this provider, show all its models
+                if (!allowed)
+                    return true;
+                return allowed.has(model.id);
+            })
+                .map((model) => ({
+                provider: model.provider,
+                id: model.id,
+                model
+            }));
+        }
+        catch (error) {
+            this.allModels = [];
+            this.filteredModels = [];
+            this.errorMessage = error instanceof Error ? error.message : String(error);
+            return;
+        }
+        this.allModels = this.sortModels(models);
+        this.filteredModels = this.allModels;
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredModels.length - 1));
+    }
+    sortModels(models) {
+        const sorted = [...models];
+        // Sort: current model first, then by provider
+        sorted.sort((a, b) => {
+            const aIsCurrent = modelsAreEqual(this.currentModel, a.model);
+            const bIsCurrent = modelsAreEqual(this.currentModel, b.model);
+            if (aIsCurrent && !bIsCurrent)
+                return -1;
+            if (!aIsCurrent && bIsCurrent)
+                return 1;
+            return a.provider.localeCompare(b.provider);
+        });
+        return sorted;
+    }
+    filterModels(query) {
+        this.filteredModels = query
+            ? fuzzyFilter(this.allModels, query, ({ id, provider }) => `${id} ${provider}`)
+            : this.allModels;
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredModels.length - 1));
+        this.updateList();
+    }
+    updateList() {
+        this.listContainer.clear();
+        const maxVisible = 10;
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredModels.length - maxVisible));
+        const endIndex = Math.min(startIndex + maxVisible, this.filteredModels.length);
+        // Show visible slice of filtered models
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = this.filteredModels[i];
+            if (!item)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            const isCurrent = modelsAreEqual(this.currentModel, item.model);
+            let line = '';
+            if (isSelected) {
+                const prefix = theme.fg('accent', '→ ');
+                const modelText = `${item.id}`;
+                const providerBadge = theme.fg('muted', `[${item.provider}]`);
+                const checkmark = isCurrent ? theme.fg('success', ' ✓') : '';
+                line = `${prefix + theme.fg('accent', modelText)} ${providerBadge}${checkmark}`;
+            }
+            else {
+                const modelText = `  ${item.id}`;
+                const providerBadge = theme.fg('muted', `[${item.provider}]`);
+                const checkmark = isCurrent ? theme.fg('success', ' ✓') : '';
+                line = `${modelText} ${providerBadge}${checkmark}`;
+            }
+            this.listContainer.addChild(new Text(line, 0, 0));
+        }
+        // Add scroll indicator if needed
+        if (startIndex > 0 || endIndex < this.filteredModels.length) {
+            const scrollInfo = theme.fg('muted', `  (${this.selectedIndex + 1}/${this.filteredModels.length})`);
+            this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+        }
+        // Show error message or "no results" if empty
+        if (this.errorMessage) {
+            // Show error in red
+            const errorLines = this.errorMessage.split('\n');
+            for (const line of errorLines) {
+                this.listContainer.addChild(new Text(theme.fg('error', line), 0, 0));
+            }
+        }
+        else if (this.filteredModels.length === 0) {
+            this.listContainer.addChild(new Text(theme.fg('muted', '  No matching models'), 0, 0));
+        }
+        else {
+            const selected = this.filteredModels[this.selectedIndex];
+            this.listContainer.addChild(new Spacer(1));
+            this.listContainer.addChild(new Text(theme.fg('muted', `  Model Name: ${selected.model.name}`), 0, 0));
+        }
+    }
+    handleInput(keyData) {
+        const kb = getEditorKeybindings();
+        // Up arrow - wrap to bottom when at top
+        if (kb.matches(keyData, 'selectUp')) {
+            if (this.filteredModels.length === 0)
+                return;
+            this.selectedIndex =
+                this.selectedIndex === 0 ? this.filteredModels.length - 1 : this.selectedIndex - 1;
+            this.updateList();
+        }
+        // Down arrow - wrap to top when at bottom
+        else if (kb.matches(keyData, 'selectDown')) {
+            if (this.filteredModels.length === 0)
+                return;
+            this.selectedIndex =
+                this.selectedIndex === this.filteredModels.length - 1 ? 0 : this.selectedIndex + 1;
+            this.updateList();
+        }
+        // Enter
+        else if (kb.matches(keyData, 'selectConfirm')) {
+            const selectedModel = this.filteredModels[this.selectedIndex];
+            if (selectedModel) {
+                this.handleSelect(selectedModel.model);
+            }
+        }
+        // Escape or Ctrl+C
+        else if (kb.matches(keyData, 'selectCancel')) {
+            this.onCancelCallback();
+        }
+        // Pass everything else to search input
+        else {
+            this.searchInput.handleInput(keyData);
+            this.filterModels(this.searchInput.getValue());
+        }
+    }
+    handleSelect(model) {
+        // Save as new default
+        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        this.onSelectCallback(model);
+    }
+    getSearchInput() {
+        return this.searchInput;
+    }
+}
+//# sourceMappingURL=model-selector.js.map

package/dist/modes/interactive/components/oauth-selector.js

@@ -0,0 +1,111 @@
+import { getOAuthProviders } from '@mariozechner/pi-ai';
+import { Container, getEditorKeybindings, Spacer, TruncatedText } from '../../../tui/index.js';
+import { theme } from '../../../core/theme.js';
+import { DynamicBorder } from './dynamic-border.js';
+export class OAuthSelectorComponent extends Container {
+    listContainer;
+    allProviders = [];
+    selectedIndex = 0;
+    mode;
+    authStorage;
+    onSelectCallback;
+    onCancelCallback;
+    providerOrder;
+    constructor(options) {
+        super();
+        this.mode = options.mode;
+        this.authStorage = options.authStorage;
+        this.onSelectCallback = options.onSelect;
+        this.onCancelCallback = options.onCancel;
+        this.providerOrder = options.providerOrder ?? [];
+        // Load all OAuth providers
+        this.loadProviders();
+        // Add top border
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        // Add title
+        const title = this.mode === 'login' ? 'Select provider to login:' : 'Select provider to logout:';
+        this.addChild(new TruncatedText(theme.bold(title)));
+        this.addChild(new Spacer(1));
+        // Create list container
+        this.listContainer = new Container();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        // Add bottom border
+        this.addChild(new DynamicBorder());
+        // Initial render
+        this.updateList();
+    }
+    static HIDDEN_PROVIDERS = new Set([
+        'openai-codex',
+        'github-copilot',
+        'google-gemini-cli',
+        'google-antigravity'
+    ]);
+    loadProviders() {
+        const all = getOAuthProviders().filter((p) => !OAuthSelectorComponent.HIDDEN_PROVIDERS.has(p.id));
+        const order = this.providerOrder;
+        all.sort((a, b) => {
+            const ai = order.indexOf(a.id);
+            const bi = order.indexOf(b.id);
+            return (ai === -1 ? order.length : ai) - (bi === -1 ? order.length : bi);
+        });
+        this.allProviders = all;
+    }
+    updateList() {
+        this.listContainer.clear();
+        for (let i = 0; i < this.allProviders.length; i++) {
+            const provider = this.allProviders[i];
+            if (!provider)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            // Check if user is logged in for this provider
+            const credentials = this.authStorage.get(provider.id);
+            const isLoggedIn = credentials?.type === 'oauth';
+            const statusIndicator = isLoggedIn ? theme.fg('success', ' ✓ logged in') : '';
+            let line = '';
+            if (isSelected) {
+                const prefix = theme.fg('accent', '→ ');
+                const text = theme.fg('accent', provider.name);
+                line = prefix + text + statusIndicator;
+            }
+            else {
+                const text = `  ${provider.name}`;
+                line = text + statusIndicator;
+            }
+            this.listContainer.addChild(new TruncatedText(line, 0, 0));
+        }
+        // Show "no providers" if empty
+        if (this.allProviders.length === 0) {
+            const message = this.mode === 'login'
+                ? 'No OAuth providers available'
+                : 'No OAuth providers logged in. Use /login first.';
+            this.listContainer.addChild(new TruncatedText(theme.fg('muted', `  ${message}`), 0, 0));
+        }
+    }
+    handleInput(keyData) {
+        const kb = getEditorKeybindings();
+        // Up arrow
+        if (kb.matches(keyData, 'selectUp')) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.updateList();
+        }
+        // Down arrow
+        else if (kb.matches(keyData, 'selectDown')) {
+            this.selectedIndex = Math.min(this.allProviders.length - 1, this.selectedIndex + 1);
+            this.updateList();
+        }
+        // Enter
+        else if (kb.matches(keyData, 'selectConfirm')) {
+            const selectedProvider = this.allProviders[this.selectedIndex];
+            if (selectedProvider) {
+                this.onSelectCallback(selectedProvider.id);
+            }
+        }
+        // Escape or Ctrl+C
+        else if (kb.matches(keyData, 'selectCancel')) {
+            this.onCancelCallback();
+        }
+    }
+}
+//# sourceMappingURL=oauth-selector.js.map

package/dist/modes/interactive/components/session-selector-search.js

@@ -0,0 +1,157 @@
+import { fuzzyMatch } from '../../../tui/index.js';
+function normalizeWhitespaceLower(text) {
+    return text.toLowerCase().replace(/\s+/g, ' ').trim();
+}
+function getSessionSearchText(session) {
+    return `${session.id} ${session.name ?? ''} ${session.allMessagesText} ${session.cwd}`;
+}
+export function hasSessionName(session) {
+    return Boolean(session.name?.trim());
+}
+function matchesNameFilter(session, filter) {
+    if (filter === 'all')
+        return true;
+    return hasSessionName(session);
+}
+export function parseSearchQuery(query) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        return { mode: 'tokens', tokens: [], regex: null };
+    }
+    // Regex mode: re:<pattern>
+    if (trimmed.startsWith('re:')) {
+        const pattern = trimmed.slice(3).trim();
+        if (!pattern) {
+            return { mode: 'regex', tokens: [], regex: null, error: 'Empty regex' };
+        }
+        try {
+            return { mode: 'regex', tokens: [], regex: new RegExp(pattern, 'i') };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { mode: 'regex', tokens: [], regex: null, error: msg };
+        }
+    }
+    // Token mode with quote support.
+    // Example: foo "node cve" bar
+    const tokens = [];
+    let buf = '';
+    let inQuote = false;
+    let hadUnclosedQuote = false;
+    const flush = (kind) => {
+        const v = buf.trim();
+        buf = '';
+        if (!v)
+            return;
+        tokens.push({ kind, value: v });
+    };
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (ch === '"') {
+            if (inQuote) {
+                flush('phrase');
+                inQuote = false;
+            }
+            else {
+                flush('fuzzy');
+                inQuote = true;
+            }
+            continue;
+        }
+        if (!inQuote && /\s/.test(ch)) {
+            flush('fuzzy');
+            continue;
+        }
+        buf += ch;
+    }
+    if (inQuote) {
+        hadUnclosedQuote = true;
+    }
+    // If quotes were unbalanced, fall back to plain whitespace tokenization.
+    if (hadUnclosedQuote) {
+        return {
+            mode: 'tokens',
+            tokens: trimmed
+                .split(/\s+/)
+                .map((t) => t.trim())
+                .filter((t) => t.length > 0)
+                .map((t) => ({ kind: 'fuzzy', value: t })),
+            regex: null
+        };
+    }
+    flush(inQuote ? 'phrase' : 'fuzzy');
+    return { mode: 'tokens', tokens, regex: null };
+}
+export function matchSession(session, parsed) {
+    const text = getSessionSearchText(session);
+    if (parsed.mode === 'regex') {
+        if (!parsed.regex) {
+            return { matches: false, score: 0 };
+        }
+        const idx = text.search(parsed.regex);
+        if (idx < 0)
+            return { matches: false, score: 0 };
+        return { matches: true, score: idx * 0.1 };
+    }
+    if (parsed.tokens.length === 0) {
+        return { matches: true, score: 0 };
+    }
+    let totalScore = 0;
+    let normalizedText = null;
+    for (const token of parsed.tokens) {
+        if (token.kind === 'phrase') {
+            if (normalizedText === null) {
+                normalizedText = normalizeWhitespaceLower(text);
+            }
+            const phrase = normalizeWhitespaceLower(token.value);
+            if (!phrase)
+                continue;
+            const idx = normalizedText.indexOf(phrase);
+            if (idx < 0)
+                return { matches: false, score: 0 };
+            totalScore += idx * 0.1;
+            continue;
+        }
+        const m = fuzzyMatch(token.value, text);
+        if (!m.matches)
+            return { matches: false, score: 0 };
+        totalScore += m.score;
+    }
+    return { matches: true, score: totalScore };
+}
+export function filterAndSortSessions(sessions, query, sortMode, nameFilter = 'all') {
+    const nameFiltered = nameFilter === 'all'
+        ? sessions
+        : sessions.filter((session) => matchesNameFilter(session, nameFilter));
+    const trimmed = query.trim();
+    if (!trimmed)
+        return nameFiltered;
+    const parsed = parseSearchQuery(query);
+    if (parsed.error)
+        return [];
+    // Recent mode: filter only, keep incoming order.
+    if (sortMode === 'recent') {
+        const filtered = [];
+        for (const s of nameFiltered) {
+            const res = matchSession(s, parsed);
+            if (res.matches)
+                filtered.push(s);
+        }
+        return filtered;
+    }
+    // Relevance mode: sort by score, tie-break by modified desc.
+    const scored = [];
+    for (const s of nameFiltered) {
+        const res = matchSession(s, parsed);
+        if (!res.matches)
+            continue;
+        scored.push({ session: s, score: res.score });
+    }
+    scored.sort((a, b) => {
+        if (a.score !== b.score)
+            return a.score - b.score;
+        return b.session.modified.getTime() - a.session.modified.getTime();
+    });
+    return scored.map((r) => r.session);
+}
+//# sourceMappingURL=session-selector-search.js.map