shortcutxl 0.2.0

package/dist/cli/file-processor.js

@@ -0,0 +1,79 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+import chalk from 'chalk';
+import { access, readFile, stat } from 'node:fs/promises';
+import { resolve } from 'path';
+import { resolveReadPath } from '../core/tools/path-utils.js';
+import { formatDimensionNote, resizeImage } from '../utils/image-resize.js';
+import { detectSupportedImageMimeTypeFromFile } from '../utils/mime.js';
+/** Process @file arguments into text content and image attachments */
+export async function processFileArguments(fileArgs, options) {
+    const autoResizeImages = options?.autoResizeImages ?? true;
+    let text = '';
+    const images = [];
+    for (const fileArg of fileArgs) {
+        // Expand and resolve path (handles ~ expansion and macOS screenshot Unicode spaces)
+        const absolutePath = resolve(resolveReadPath(fileArg, process.cwd()));
+        // Check if file exists
+        try {
+            await access(absolutePath);
+        }
+        catch {
+            console.error(chalk.red(`Error: File not found: ${absolutePath}`));
+            process.exit(1);
+        }
+        // Check if file is empty
+        const stats = await stat(absolutePath);
+        if (stats.size === 0) {
+            // Skip empty files
+            continue;
+        }
+        const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
+        if (mimeType) {
+            // Handle image file
+            const content = await readFile(absolutePath);
+            const base64Content = content.toString('base64');
+            let attachment;
+            let dimensionNote;
+            if (autoResizeImages) {
+                const resized = await resizeImage({ type: 'image', data: base64Content, mimeType });
+                dimensionNote = formatDimensionNote(resized);
+                attachment = {
+                    type: 'image',
+                    mimeType: resized.mimeType,
+                    data: resized.data
+                };
+            }
+            else {
+                attachment = {
+                    type: 'image',
+                    mimeType,
+                    data: base64Content
+                };
+            }
+            images.push(attachment);
+            // Add text reference to image with optional dimension note
+            if (dimensionNote) {
+                text += `<file name="${absolutePath}">${dimensionNote}</file>\n`;
+            }
+            else {
+                text += `<file name="${absolutePath}"></file>\n`;
+            }
+        }
+        else {
+            // Handle text file
+            try {
+                const content = await readFile(absolutePath, 'utf-8');
+                text += `<file name="${absolutePath}">\n${content}\n</file>\n`;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`Error: Could not read file ${absolutePath}: ${message}`));
+                process.exit(1);
+            }
+        }
+    }
+    return { text, images };
+}
+//# sourceMappingURL=file-processor.js.map

package/dist/cli/list-models.js

@@ -0,0 +1,92 @@
+/**
+ * List available models with optional fuzzy search
+ */
+import { fuzzyFilter } from '../tui/index.js';
+/**
+ * Format a number as human-readable (e.g., 200000 -> "200K", 1000000 -> "1M")
+ */
+function formatTokenCount(count) {
+    if (count >= 1_000_000) {
+        const millions = count / 1_000_000;
+        return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+        const thousands = count / 1_000;
+        return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
+    }
+    return count.toString();
+}
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export async function listModels(modelRegistry, searchPattern) {
+    const models = modelRegistry.getAvailable();
+    if (models.length === 0) {
+        console.log('No models available. Set API keys in environment variables.');
+        return;
+    }
+    // Apply fuzzy filter if search pattern provided
+    let filteredModels = models;
+    if (searchPattern) {
+        filteredModels = fuzzyFilter(models, searchPattern, (m) => `${m.provider} ${m.id}`);
+    }
+    if (filteredModels.length === 0) {
+        console.log(`No models matching "${searchPattern}"`);
+        return;
+    }
+    // Sort by provider, then by model id
+    filteredModels.sort((a, b) => {
+        const providerCmp = a.provider.localeCompare(b.provider);
+        if (providerCmp !== 0)
+            return providerCmp;
+        return a.id.localeCompare(b.id);
+    });
+    // Calculate column widths
+    const rows = filteredModels.map((m) => ({
+        provider: m.provider,
+        model: m.id,
+        context: formatTokenCount(m.contextWindow),
+        maxOut: formatTokenCount(m.maxTokens),
+        thinking: m.reasoning ? 'yes' : 'no',
+        images: m.input.includes('image') ? 'yes' : 'no'
+    }));
+    const headers = {
+        provider: 'provider',
+        model: 'model',
+        context: 'context',
+        maxOut: 'max-out',
+        thinking: 'thinking',
+        images: 'images'
+    };
+    const widths = {
+        provider: Math.max(headers.provider.length, ...rows.map((r) => r.provider.length)),
+        model: Math.max(headers.model.length, ...rows.map((r) => r.model.length)),
+        context: Math.max(headers.context.length, ...rows.map((r) => r.context.length)),
+        maxOut: Math.max(headers.maxOut.length, ...rows.map((r) => r.maxOut.length)),
+        thinking: Math.max(headers.thinking.length, ...rows.map((r) => r.thinking.length)),
+        images: Math.max(headers.images.length, ...rows.map((r) => r.images.length))
+    };
+    // Print header
+    const headerLine = [
+        headers.provider.padEnd(widths.provider),
+        headers.model.padEnd(widths.model),
+        headers.context.padEnd(widths.context),
+        headers.maxOut.padEnd(widths.maxOut),
+        headers.thinking.padEnd(widths.thinking),
+        headers.images.padEnd(widths.images)
+    ].join('  ');
+    console.log(headerLine);
+    // Print rows
+    for (const row of rows) {
+        const line = [
+            row.provider.padEnd(widths.provider),
+            row.model.padEnd(widths.model),
+            row.context.padEnd(widths.context),
+            row.maxOut.padEnd(widths.maxOut),
+            row.thinking.padEnd(widths.thinking),
+            row.images.padEnd(widths.images)
+        ].join('  ');
+        console.log(line);
+    }
+}
+//# sourceMappingURL=list-models.js.map

package/dist/cli/package-commands.js

@@ -0,0 +1,210 @@
+/**
+ * CLI package sub-commands: install, remove, update, list.
+ *
+ * Self-contained — only called from main.ts when the first CLI arg
+ * matches a package command name.
+ */
+import chalk from 'chalk';
+import { APP_NAME, getAgentDir } from '../config.js';
+import { DefaultPackageManager } from '../core/package-manager.js';
+import { SettingsManager } from '../core/settings-manager.js';
+import { reportSettingsErrors } from './report-settings-errors.js';
+function getPackageCommandUsage(command) {
+    switch (command) {
+        case 'install':
+            return `${APP_NAME} install <source> [-l]`;
+        case 'remove':
+            return `${APP_NAME} remove <source> [-l]`;
+        case 'update':
+            return `${APP_NAME} update [source]`;
+        case 'list':
+            return `${APP_NAME} list`;
+    }
+}
+function printPackageCommandHelp(command) {
+    switch (command) {
+        case 'install':
+            console.log(`${chalk.bold('Usage:')}
+  ${getPackageCommandUsage('install')}
+
+Install a package and add it to settings.
+
+Options:
+  -l, --local    Install project-locally (.pi/settings.json)
+
+Examples:
+  ${APP_NAME} install npm:@foo/bar
+  ${APP_NAME} install git:github.com/user/repo
+  ${APP_NAME} install git:git@github.com:user/repo
+  ${APP_NAME} install https://github.com/user/repo
+  ${APP_NAME} install ssh://git@github.com/user/repo
+  ${APP_NAME} install ./local/path
+`);
+            return;
+        case 'remove':
+            console.log(`${chalk.bold('Usage:')}
+  ${getPackageCommandUsage('remove')}
+
+Remove a package and its source from settings.
+
+Options:
+  -l, --local    Remove from project settings (.pi/settings.json)
+
+Example:
+  ${APP_NAME} remove npm:@foo/bar
+`);
+            return;
+        case 'update':
+            console.log(`${chalk.bold('Usage:')}
+  ${getPackageCommandUsage('update')}
+
+Update installed packages.
+If <source> is provided, only that package is updated.
+`);
+            return;
+        case 'list':
+            console.log(`${chalk.bold('Usage:')}
+  ${getPackageCommandUsage('list')}
+
+List installed packages from user and project settings.
+`);
+            return;
+    }
+}
+function parsePackageCommand(args) {
+    const [command, ...rest] = args;
+    if (command !== 'install' && command !== 'remove' && command !== 'update' && command !== 'list') {
+        return undefined;
+    }
+    let local = false;
+    let help = false;
+    let invalidOption;
+    let source;
+    for (const arg of rest) {
+        if (arg === '-h' || arg === '--help') {
+            help = true;
+            continue;
+        }
+        if (arg === '-l' || arg === '--local') {
+            if (command === 'install' || command === 'remove') {
+                local = true;
+            }
+            else {
+                invalidOption = invalidOption ?? arg;
+            }
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            invalidOption = invalidOption ?? arg;
+            continue;
+        }
+        if (!source) {
+            source = arg;
+        }
+    }
+    return { command, source, local, help, invalidOption };
+}
+export async function handlePackageCommand(args) {
+    const options = parsePackageCommand(args);
+    if (!options) {
+        return false;
+    }
+    if (options.help) {
+        printPackageCommandHelp(options.command);
+        return true;
+    }
+    if (options.invalidOption) {
+        console.error(chalk.red(`Unknown option ${options.invalidOption} for "${options.command}".`));
+        console.error(chalk.dim(`Use "${APP_NAME} --help" or "${getPackageCommandUsage(options.command)}".`));
+        process.exitCode = 1;
+        return true;
+    }
+    const source = options.source;
+    if ((options.command === 'install' || options.command === 'remove') && !source) {
+        console.error(chalk.red(`Missing ${options.command} source.`));
+        console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`));
+        process.exitCode = 1;
+        return true;
+    }
+    const cwd = process.cwd();
+    const agentDir = getAgentDir();
+    const settingsManager = SettingsManager.create(cwd, agentDir);
+    reportSettingsErrors(settingsManager, 'package command');
+    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+    packageManager.setProgressCallback((event) => {
+        if (event.type === 'start') {
+            process.stdout.write(chalk.dim(`${event.message}\n`));
+        }
+    });
+    try {
+        switch (options.command) {
+            case 'install':
+                await packageManager.install(source, { local: options.local });
+                packageManager.addSourceToSettings(source, { local: options.local });
+                console.log(chalk.green(`Installed ${source}`));
+                return true;
+            case 'remove': {
+                await packageManager.remove(source, { local: options.local });
+                const removed = packageManager.removeSourceFromSettings(source, { local: options.local });
+                if (!removed) {
+                    console.error(chalk.red(`No matching package found for ${source}`));
+                    process.exitCode = 1;
+                    return true;
+                }
+                console.log(chalk.green(`Removed ${source}`));
+                return true;
+            }
+            case 'list': {
+                const globalSettings = settingsManager.getGlobalSettings();
+                const projectSettings = settingsManager.getProjectSettings();
+                const globalPackages = globalSettings.packages ?? [];
+                const projectPackages = projectSettings.packages ?? [];
+                if (globalPackages.length === 0 && projectPackages.length === 0) {
+                    console.log(chalk.dim('No packages installed.'));
+                    return true;
+                }
+                const formatPackage = (pkg, scope) => {
+                    const source = typeof pkg === 'string' ? pkg : pkg.source;
+                    const filtered = typeof pkg === 'object';
+                    const display = filtered ? `${source} (filtered)` : source;
+                    console.log(`  ${display}`);
+                    const path = packageManager.getInstalledPath(source, scope);
+                    if (path) {
+                        console.log(chalk.dim(`    ${path}`));
+                    }
+                };
+                if (globalPackages.length > 0) {
+                    console.log(chalk.bold('User packages:'));
+                    for (const pkg of globalPackages) {
+                        formatPackage(pkg, 'user');
+                    }
+                }
+                if (projectPackages.length > 0) {
+                    if (globalPackages.length > 0)
+                        console.log();
+                    console.log(chalk.bold('Project packages:'));
+                    for (const pkg of projectPackages) {
+                        formatPackage(pkg, 'project');
+                    }
+                }
+                return true;
+            }
+            case 'update':
+                await packageManager.update(source);
+                if (source) {
+                    console.log(chalk.green(`Updated ${source}`));
+                }
+                else {
+                    console.log(chalk.green('Updated packages'));
+                }
+                return true;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown package command error';
+        console.error(chalk.red(`Error: ${message}`));
+        process.exitCode = 1;
+        return true;
+    }
+}
+//# sourceMappingURL=package-commands.js.map

package/dist/cli/report-settings-errors.js

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+export function reportSettingsErrors(settingsManager, context) {
+    const errors = settingsManager.drainErrors();
+    for (const { scope, error } of errors) {
+        console.error(chalk.yellow(`Warning (${context}, ${scope} settings): ${error.message}`));
+        if (error.stack) {
+            console.error(chalk.dim(error.stack));
+        }
+    }
+}
+//# sourceMappingURL=report-settings-errors.js.map

package/dist/cli/session-picker.js

@@ -0,0 +1,34 @@
+/**
+ * TUI session selector for --resume flag
+ */
+import { ProcessTerminal, TUI } from '../tui/index.js';
+import { KeybindingsManager } from '../core/keybindings.js';
+import { SessionSelectorComponent } from '../modes/interactive/components/session-selector.js';
+/** Show TUI session selector and return selected session path or null if cancelled */
+export async function selectSession(currentSessionsLoader, allSessionsLoader) {
+    return new Promise((resolve) => {
+        const ui = new TUI(new ProcessTerminal());
+        const keybindings = KeybindingsManager.create();
+        let resolved = false;
+        const selector = new SessionSelectorComponent(currentSessionsLoader, allSessionsLoader, (path) => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                resolve(path);
+            }
+        }, () => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                resolve(null);
+            }
+        }, () => {
+            ui.stop();
+            process.exit(0);
+        }, () => ui.requestRender(), { showRenameHint: false, keybindings });
+        ui.addChild(selector);
+        ui.setFocus(selector.getSessionList());
+        ui.start();
+    });
+}
+//# sourceMappingURL=session-picker.js.map

package/dist/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for the refactored coding agent.
+ * Uses main.ts with AgentSession and new mode modules.
+ *
+ * Test with: npx tsx src/cli-new.ts [args...]
+ */
+// Load .env BEFORE any app imports so constants.ts reads the correct values.
+// Must use dynamic import() because ESM hoists static imports above top-level code.
+import dotenv from 'dotenv';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const agentRoot = resolve(__dirname, '..');
+dotenv.config({ path: resolve(agentRoot, '.env.development') });
+process.title = 'shortcut';
+const { main } = await import('./main.js');
+main(process.argv.slice(2));
+//# sourceMappingURL=cli.js.map