scalix 0.0.1 → 1.0.0

package/dist/headless.js

@@ -0,0 +1,654 @@
+import readline from 'node:readline';
+import fs from 'node:fs/promises';
+import { execSync } from 'node:child_process';
+import { createAgent } from './agent.js';
+import { defaultTools } from './tools.js';
+import { extraTools } from './tools-extra.js';
+import { webTools } from './tools-web.js';
+import { advancedTools } from './tools-advanced.js';
+import { visionTools } from './tools-vision.js';
+import { voiceTools } from './tools-voice.js';
+import { browserTools } from './tools-browser.js';
+import { loadMcpServices } from './mcp.js';
+import { costTracker } from './cost-tracker.js';
+import { saveSession, loadSession, listSessions, generateSessionId } from './sessions.js';
+import { logger } from './logger.js';
+import { DEFAULT_MODELS, DEFAULT_INSTRUCTIONS, ENV_API_KEY, ENV_MODEL, ENV_BASE_URL, HEADLESS_DEFAULTS, fetchModelSpecs } from './constants.js';
+import { loadConfig, DEFAULT_LIMITS } from './settings.js';
+import { getModeDescription, PERMISSION_MODES, setSandboxRoot } from './sandbox.js';
+import { collectGitInfo, gitInfoToContext } from './git-context.js';
+import { loadMemory, autoDetectConventions, saveMemory, memoryToContext, addNote, detectCorrection } from './project-memory.js';
+import { buildProjectIndex } from './project-index.js';
+import { buildProjectContext, contextToInstructions } from './context-builder.js';
+import { discoverPlugins, getPluginTools, pluginsSummary } from './plugins.js';
+import { loadCustomCommands, expandCommand, commandsSummary } from './commands.js';
+import { hooksSummary } from './hooks.js';
+import { spawnSubAgent, pickCheapestModel } from './sub-agent.js';
+import { createCheckpoint, undoLastCheckpoint, listCheckpoints } from './git-undo.js';
+import { runIpcServer } from './ipc-server.js';
+function shortModel(m) {
+    return m.split('/').pop().replace(/:free$/, '').replace(/-instruct$/, '');
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let mode = 'interactive';
+    let prompt;
+    let output;
+    let format;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === 'run' && i + 1 < args.length) {
+            mode = 'run';
+            prompt = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--output' && i + 1 < args.length) {
+            output = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--format' && i + 1 < args.length) {
+            format = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--pipe' || args[i] === '-p') {
+            mode = 'pipe';
+        }
+        else if (args[i] === '--ipc') {
+            mode = 'ipc';
+        }
+        else if (args[i] === '--help' || args[i] === '-h') {
+            console.log(`
+Scalix - Headless Mode
+
+Usage:
+  scalix                    Interactive REPL
+  scalix run "prompt"       Run a single prompt and exit
+  scalix --pipe             Read prompt from stdin
+  scalix --ipc              IPC mode (JSONL over stdin/stdout, used by VS Code extension)
+  scalix run "prompt" --output file.patch --format patch
+
+Options:
+  run <prompt>       Execute a single prompt non-interactively
+  --pipe, -p         Read prompt from stdin (for piping)
+  --ipc              IPC server mode for VS Code extension integration
+  --output <file>    Write result to file instead of stdout
+  --format <fmt>     Output format: text (default), json, patch, markdown
+  --help, -h         Show this help
+`);
+            process.exit(0);
+        }
+    }
+    if (!process.stdin.isTTY && mode === 'interactive') {
+        mode = 'pipe';
+    }
+    return { mode, prompt, output, format };
+}
+async function buildEnhancedInstructions() {
+    let base = DEFAULT_INSTRUCTIONS;
+    const cwd = process.cwd();
+    try {
+        const memory = await loadMemory(cwd);
+        const autoConventions = await autoDetectConventions(cwd);
+        for (const c of autoConventions) {
+            if (!memory.conventions.some((mc) => mc.key === c.key)) {
+                memory.conventions.push(c);
+            }
+        }
+        if (memory.conventions.length > 0 || memory.patterns.length > 0 || memory.notes.length > 0) {
+            await saveMemory(cwd, memory);
+        }
+    }
+    catch { }
+    const ctx = await buildProjectContext(cwd);
+    return contextToInstructions(base, ctx);
+}
+async function runSinglePrompt(prompt, output, format) {
+    const apiKey = process.env[ENV_API_KEY];
+    if (!apiKey) {
+        console.error('Error: SCALIX_API_KEY is not set.\nSet it via: export SCALIX_API_KEY=sk-...\nOr run the interactive setup: scalix');
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const limits = config.limits || DEFAULT_LIMITS;
+    const baseUrl = process.env[ENV_BASE_URL] || config.baseUrl;
+    // Fetch model specs from API (non-blocking — uses built-in/user-defined as fallback)
+    fetchModelSpecs(baseUrl, apiKey).catch(() => { });
+    const envModels = process.env[ENV_MODEL]
+        ? process.env[ENV_MODEL].split(',').map((m) => m.trim()).filter(Boolean)
+        : [];
+    const selectedModel = envModels.length > 0 ? envModels
+        : config.models.length > 0 ? config.models : DEFAULT_MODELS;
+    if (selectedModel.length === 0) {
+        console.error('Error: No models configured.\nSet SCALIX_MODEL env var or run interactive setup: scalix');
+        process.exit(1);
+    }
+    const mcpTools = loadMcpServices();
+    const plugins = await discoverPlugins(process.cwd());
+    const pluginTools = getPluginTools(plugins);
+    const allTools = [...defaultTools, ...extraTools, ...webTools, ...advancedTools, ...visionTools, ...voiceTools, ...browserTools, ...mcpTools, ...pluginTools];
+    const instructions = await buildEnhancedInstructions();
+    const agent = createAgent({
+        apiKey,
+        baseUrl,
+        model: selectedModel,
+        instructions,
+        tools: allTools,
+        permissionMode: config.permissionMode || 'default',
+        maxSteps: limits.maxSteps,
+        maxMessages: limits.maxMessages,
+        contextManager: {
+            maxContextTokens: limits.maxContextTokens,
+            compressionThreshold: limits.compressionThreshold,
+            maxToolResultTokens: limits.maxToolResultTokens,
+        },
+        instructionLoader: buildEnhancedInstructions,
+        autoVerify: true,
+    });
+    let fullResponse = '';
+    agent.on('stream:end', (text) => { fullResponse = text; });
+    agent.on('tool:call', (name) => process.stderr.write(`\x1b[33m▶ ${name}\x1b[0m\n`));
+    agent.on('verify:pass', (r) => process.stderr.write(`\x1b[32m✓ ${r.checker} passed\x1b[0m\n`));
+    agent.on('verify:fail', (r) => process.stderr.write(`\x1b[31m✗ ${r.checker} failed: ${r.output.split('\n')[0]}\x1b[0m\n`));
+    agent.on('error', (err) => process.stderr.write(`\x1b[31mError: ${err.message}\x1b[0m\n`));
+    try {
+        await agent.send(prompt);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    let formatted;
+    switch (format) {
+        case 'json':
+            formatted = JSON.stringify({
+                prompt,
+                response: fullResponse,
+                model: selectedModel[0],
+                tokens: costTracker.totalTokens,
+                cost: costTracker.totalCost,
+            }, null, 2);
+            break;
+        case 'patch':
+            formatted = fullResponse;
+            break;
+        case 'markdown':
+            formatted = fullResponse;
+            break;
+        default:
+            formatted = fullResponse;
+    }
+    if (output) {
+        await fs.writeFile(output, formatted, 'utf-8');
+        process.stderr.write(`Output written to ${output}\n`);
+    }
+    else {
+        process.stdout.write(formatted + '\n');
+    }
+    process.exit(0);
+}
+async function runPipeMode() {
+    const MAX_PIPE_BYTES = 50 * 1024 * 1024;
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of process.stdin) {
+        const str = chunk.toString();
+        totalBytes += Buffer.byteLength(str);
+        if (totalBytes > MAX_PIPE_BYTES) {
+            console.error(`Error: Pipe input exceeds ${MAX_PIPE_BYTES / 1024 / 1024}MB limit.`);
+            process.exit(1);
+        }
+        chunks.push(str);
+    }
+    const prompt = chunks.join('').trim();
+    if (!prompt) {
+        console.error('Error: No input received from stdin.');
+        process.exit(1);
+    }
+    await runSinglePrompt(prompt);
+}
+async function runInteractive() {
+    const apiKey = process.env[ENV_API_KEY];
+    if (!apiKey) {
+        throw new Error('SCALIX_API_KEY is not set. Set it via: export SCALIX_API_KEY=sk-...');
+    }
+    const config = await loadConfig();
+    const limits = config.limits || DEFAULT_LIMITS;
+    const baseUrl = process.env[ENV_BASE_URL] || config.baseUrl;
+    // Fetch model specs from API (non-blocking)
+    fetchModelSpecs(baseUrl, apiKey).catch(() => { });
+    const envModels = process.env[ENV_MODEL]
+        ? process.env[ENV_MODEL].split(',').map((m) => m.trim()).filter(Boolean)
+        : [];
+    const selectedModel = envModels.length > 0 ? envModels
+        : config.models.length > 0 ? config.models : DEFAULT_MODELS;
+    if (selectedModel.length === 0) {
+        throw new Error('No models configured. Set SCALIX_MODEL env var or run interactive setup.');
+    }
+    const mcpTools = loadMcpServices();
+    const plugins = await discoverPlugins(process.cwd());
+    const pluginTools = getPluginTools(plugins);
+    const allTools = [...defaultTools, ...extraTools, ...webTools, ...advancedTools, ...visionTools, ...voiceTools, ...browserTools, ...mcpTools, ...pluginTools];
+    const instructions = await buildEnhancedInstructions();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    function askUser(question) {
+        return new Promise((resolve) => rl.question(question, resolve));
+    }
+    const customCmds = await loadCustomCommands(process.cwd());
+    const agent = createAgent({
+        apiKey,
+        baseUrl,
+        model: selectedModel,
+        instructions,
+        tools: allTools,
+        permissionMode: config.permissionMode || 'default',
+        maxSteps: limits.maxSteps,
+        maxMessages: limits.maxMessages,
+        contextManager: {
+            maxContextTokens: limits.maxContextTokens,
+            compressionThreshold: limits.compressionThreshold,
+            maxToolResultTokens: limits.maxToolResultTokens,
+        },
+        instructionLoader: buildEnhancedInstructions,
+        autoVerify: true,
+        confirmToolCall: async (toolName, args) => {
+            const preview = typeof args === 'string' ? args : JSON.stringify(args, null, 2);
+            console.log(`\n\u26A0  Tool "${toolName}" wants to execute:`);
+            console.log(`   ${preview.split('\n').join('\n   ')}`);
+            const answer = await askUser('   Allow? (y/N): ');
+            return answer.trim().toLowerCase() === 'y';
+        },
+    });
+    let sessionId = generateSessionId();
+    agent.on('thinking:start', () => process.stdout.write('\n\x1b[33mThinking...\x1b[0m'));
+    agent.on('tool:call', (name, args) => {
+        const argStr = typeof args === 'string' ? args : JSON.stringify(args);
+        process.stderr.write(`\x1b[33m\u25B6 ${name}\x1b[0m ${argStr}\n`);
+    });
+    agent.on('tool:blocked', (name, reason) => console.log(`\x1b[31m\u2717 ${name}: ${reason}\x1b[0m`));
+    agent.on('stream:delta', (delta) => process.stdout.write(delta));
+    agent.on('stream:end', () => {
+        process.stdout.write('\n\n');
+    });
+    agent.on('tool:result', (name, result) => {
+        let text = typeof result === 'string' ? result : JSON.stringify(result);
+        if (text.length > 500) {
+            text = text.slice(0, 500) + `... (${(text.length - 500).toLocaleString()} more chars)`;
+        }
+        process.stderr.write(`\x1b[90m  \u2514 ${name}: ${text.split('\n')[0]}\x1b[0m\n`);
+    });
+    agent.on('usage', (data) => {
+        costTracker.record(data.model || selectedModel[0], data);
+    });
+    agent.on('error', (err) => console.error('\x1b[31mError:\x1b[0m', err.message));
+    agent.on('context:compress', (info) => {
+        console.log(`\x1b[36m\u25CB Context compressed: ${info.saved} tokens saved (${info.before} \u2192 ${info.after})\x1b[0m`);
+    });
+    agent.on('context:usage', (info) => {
+        if (info.percentage > 80) {
+            console.log(`\x1b[33m\u26A0 Context usage: ${info.percentage}% (${info.tokens}/${info.maxTokens} tokens)\x1b[0m`);
+        }
+    });
+    const toolCount = allTools.length;
+    const modelDisplay = selectedModel.map(shortModel).join(' | ');
+    console.log(`\x1b[36mAgent ready\x1b[0m (${modelDisplay}) with ${toolCount} tools. Type /help for commands.`);
+    if (plugins.length > 0) {
+        console.log(`\x1b[36mPlugins:\x1b[0m ${plugins.map((p) => p.manifest.name).join(', ')}`);
+    }
+    console.log('');
+    function shutdown() {
+        const msgs = agent.getMessages();
+        if (msgs.length > 0) {
+            saveSession(sessionId, msgs, agent.getModels()[0], undefined, costTracker.getState()).catch(() => { });
+        }
+        if (costTracker.totalTokens > 0) {
+            console.log(`\n\x1b[36mSession: ${costTracker.totalTokens.toLocaleString()} tokens${costTracker.totalCost > 0 ? ` ($${costTracker.totalCost.toFixed(4)})` : ''}\x1b[0m`);
+        }
+        console.log('Goodbye!');
+        rl.close();
+        process.exit(0);
+    }
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    const handleCommand = async (input) => {
+        const cmd = input.split(' ')[0].toLowerCase();
+        if (cmd === '/help') {
+            console.log('\nCommands:');
+            console.log('  /help        \u2014 show this help');
+            console.log('  /clear       \u2014 reset conversation');
+            console.log('  /models      \u2014 list active models');
+            console.log('  /model <name>\u2014 switch model');
+            console.log('  /mode [mode] \u2014 permission mode (plan/default/auto/yolo)');
+            console.log('  /compact     \u2014 compress conversation context');
+            console.log('  /cost        \u2014 show token usage');
+            console.log('  /save [name] \u2014 save session');
+            console.log('  /load [id]   \u2014 resume a saved session');
+            console.log('  /sessions    \u2014 list saved sessions');
+            console.log('  /plugins     \u2014 show loaded plugins');
+            console.log('  /hooks       \u2014 show lifecycle hooks');
+            console.log('  /commands    \u2014 show custom commands');
+            console.log('  /delegate <t>\u2014 run task with sub-agent');
+            console.log('  /checkpoint  \u2014 create git checkpoint');
+            console.log('  /undo        \u2014 undo last checkpoint');
+            console.log('  /checkpoints \u2014 list recent checkpoints');
+            console.log('  /memory      \u2014 show project memory');
+            console.log('  /remember <n>\u2014 save a note about this project');
+            console.log('  /git         \u2014 show git context');
+            console.log('  /index       \u2014 scan & index project files');
+            console.log('  /quit        \u2014 exit');
+            console.log('');
+            console.log('Input modes:');
+            console.log('  !<cmd>       \u2014 run shell command (e.g. !ls -la)');
+            console.log('  text\\        \u2014 multiline input (end with \\ to continue)\n');
+            return true;
+        }
+        if (cmd === '/clear') {
+            const msgs = agent.getMessages();
+            if (msgs.length > 0) {
+                await saveSession(sessionId, msgs, agent.getModels()[0], undefined, costTracker.getState()).catch(() => { });
+                console.log('(auto-saved before clearing)');
+            }
+            agent.clearHistory();
+            costTracker.reset();
+            sessionId = generateSessionId();
+            console.log('\nConversation cleared.\n');
+            return true;
+        }
+        if (cmd === '/models') {
+            console.log(`\nActive: ${agent.getModels().map(shortModel).join(', ')}\n`);
+            return true;
+        }
+        if (cmd === '/model') {
+            const name = input.slice(7).trim();
+            if (!name) {
+                console.log('Usage: /model <model-name>');
+                return true;
+            }
+            if (!/^[a-zA-Z0-9][\w./:@-]*$/.test(name)) {
+                console.log(`\nInvalid model name: "${name}"\n`);
+                return true;
+            }
+            agent.setModel(name);
+            console.log(`\nSwitched to ${shortModel(name)}\n`);
+            return true;
+        }
+        if (cmd === '/compact') {
+            console.log('\nCompacting...');
+            const result = await agent.compact();
+            console.log(result + '\n');
+            return true;
+        }
+        if (cmd === '/cost') {
+            console.log('\n' + costTracker.summary() + '\n');
+            return true;
+        }
+        if (cmd === '/save') {
+            const name = input.slice(5).trim() || undefined;
+            try {
+                const meta = await saveSession(sessionId, agent.getMessages(), agent.getModels()[0], name, costTracker.getState());
+                console.log(`\nSession saved: ${meta.name} (${meta.messageCount} messages)\n`);
+            }
+            catch (e) {
+                console.log(`\nFailed to save session: ${e.message}\n`);
+            }
+            return true;
+        }
+        if (cmd === '/sessions' || cmd === '/list') {
+            const sessions = await listSessions();
+            if (sessions.length === 0) {
+                console.log('\nNo saved sessions.\n');
+                return true;
+            }
+            console.log('\nSaved sessions (use /load <id> to resume):');
+            for (const s of sessions.slice(0, 10)) {
+                console.log(`  ${s.id.slice(0, 8)} \u2014 ${s.name} (${s.messageCount} msgs, ${new Date(s.updatedAt).toLocaleDateString()})`);
+            }
+            console.log('');
+            return true;
+        }
+        if (cmd === '/load') {
+            const idPrefix = input.slice(5).trim();
+            if (!idPrefix) {
+                const sessions = await listSessions();
+                if (sessions.length === 0) {
+                    console.log('\nNo saved sessions.\n');
+                    return true;
+                }
+                console.log('\nSaved sessions (use /load <id> to resume):');
+                for (const s of sessions.slice(0, 10)) {
+                    console.log(`  ${s.id.slice(0, 8)} \u2014 ${s.name} (${s.messageCount} msgs)`);
+                }
+                console.log('');
+                return true;
+            }
+            const sessions = await listSessions();
+            const match = sessions.find((s) => s.id.startsWith(idPrefix));
+            if (!match) {
+                console.log(`\nNo session found starting with "${idPrefix}".\n`);
+                return true;
+            }
+            try {
+                const data = await loadSession(match.id);
+                agent.loadMessages(data.messages);
+                sessionId = match.id;
+                agent.setModel(match.model);
+                if (data.costState)
+                    costTracker.restore(data.costState);
+                console.log(`\nResumed: ${match.name} (${match.messageCount} messages)\n`);
+            }
+            catch (e) {
+                console.log(`\nFailed to load session: ${e.message}\n`);
+            }
+            return true;
+        }
+        if (cmd === '/mode') {
+            const arg = input.slice(6).trim().toLowerCase();
+            if (arg && PERMISSION_MODES.includes(arg)) {
+                agent.setPermissionMode(arg);
+                console.log(`\nMode: ${arg.toUpperCase()} \u2014 ${getModeDescription(arg)}\n`);
+            }
+            else {
+                const current = agent.getPermissionMode();
+                console.log(`\nCurrent mode: ${current.toUpperCase()}`);
+                for (const m of PERMISSION_MODES) {
+                    console.log(`  ${m === current ? '\u25CF' : '\u25CB'} ${m.padEnd(8)} \u2014 ${getModeDescription(m)}`);
+                }
+                console.log('');
+            }
+            return true;
+        }
+        if (cmd === '/plugins') {
+            console.log('\n' + pluginsSummary(plugins) + '\n');
+            return true;
+        }
+        if (cmd === '/hooks') {
+            console.log('\n' + hooksSummary(agent.getHooks()) + '\n');
+            return true;
+        }
+        if (cmd === '/commands') {
+            console.log('\n' + commandsSummary(customCmds) + '\n');
+            return true;
+        }
+        if (cmd === '/delegate') {
+            const prompt = input.slice(10).trim();
+            if (!prompt) {
+                console.log('Usage: /delegate <task>');
+                return true;
+            }
+            const cheapModel = pickCheapestModel(agent.getModels());
+            console.log(`\nDelegating to sub-agent (${shortModel(cheapModel)})...`);
+            try {
+                const result = await spawnSubAgent({ apiKey: apiKey, baseUrl, models: agent.getModels() }, prompt, { model: cheapModel, tools: 'read-only', maxSteps: 10 });
+                console.log(`\n${result.response}\n`);
+                console.log(`\x1b[36mSub-agent: ${result.steps} steps, ~${result.tokenEstimate} tokens\x1b[0m\n`);
+            }
+            catch (err) {
+                console.log(`\nSub-agent failed: ${err.message}\n`);
+            }
+            return true;
+        }
+        if (cmd === '/checkpoint') {
+            const label = input.slice(12).trim() || undefined;
+            const hash = await createCheckpoint(process.cwd(), label);
+            if (hash)
+                console.log(`\nCheckpoint created: ${hash}${label ? ` (${label})` : ''}\n`);
+            else
+                console.log('\nNo changes to checkpoint (or not a git repo).\n');
+            return true;
+        }
+        if (cmd === '/undo') {
+            const r = await undoLastCheckpoint(process.cwd());
+            console.log(`\n${r.message}\n`);
+            return true;
+        }
+        if (cmd === '/checkpoints') {
+            const list = await listCheckpoints(process.cwd());
+            if (list.length === 0)
+                console.log('\nNo checkpoints found.\n');
+            else {
+                console.log('\nRecent checkpoints:');
+                list.forEach((l) => console.log(`  ${l}`));
+                console.log('');
+            }
+            return true;
+        }
+        if (cmd === '/memory') {
+            const mem = await loadMemory(process.cwd());
+            if (mem.conventions.length === 0 && mem.patterns.length === 0 && mem.notes.length === 0) {
+                console.log('\nNo project memory yet. Use /remember to add notes.\n');
+            }
+            else {
+                console.log('\n' + memoryToContext(mem) + '\n');
+            }
+            return true;
+        }
+        if (cmd === '/remember') {
+            const note = input.slice(10).trim();
+            if (!note) {
+                console.log('Usage: /remember <note about this project>');
+                return true;
+            }
+            try {
+                await addNote(process.cwd(), note);
+                console.log(`\nRemembered: ${note}\n`);
+            }
+            catch {
+                console.log('\nFailed to save note.\n');
+            }
+            return true;
+        }
+        if (cmd === '/git') {
+            const gitInfo = collectGitInfo(process.cwd());
+            if (!gitInfo.isRepo) {
+                console.log('\nNot a git repository.\n');
+            }
+            else {
+                console.log('\n' + gitInfoToContext(gitInfo) + '\n');
+            }
+            return true;
+        }
+        if (cmd === '/index') {
+            console.log('\nScanning project...');
+            try {
+                const idx = await buildProjectIndex(process.cwd());
+                console.log(idx.summary);
+                console.log(`Tech stack: ${idx.techStack.join(', ') || 'Unknown'}`);
+                console.log(`Top symbols: ${idx.symbols.slice(0, 10).map((s) => s.name).join(', ')}\n`);
+            }
+            catch (err) {
+                console.log(`Index failed: ${err.message}\n`);
+            }
+            return true;
+        }
+        if (cmd === '/quit' || cmd === '/exit') {
+            shutdown();
+            return true;
+        }
+        const customCmd = customCmds.find((c) => cmd === `/${c.name}`);
+        if (customCmd) {
+            const args = input.slice(cmd.length).trim();
+            const expanded = expandCommand(customCmd, args);
+            console.log(`\nRunning: /${customCmd.name}`);
+            try {
+                await agent.send(expanded);
+            }
+            catch (err) {
+                console.log(`\nFailed: ${err.message}\n`);
+            }
+            return true;
+        }
+        return false;
+    };
+    const promptLoop = async () => {
+        while (true) {
+            let input = await askUser('\x1b[34mYou:\x1b[0m ');
+            let continuations = 0;
+            while (input.endsWith('\\') && continuations < 50) {
+                input = input.slice(0, -1) + '\n' + await askUser('\x1b[34m...\x1b[0m ');
+                continuations++;
+            }
+            if (!input.trim())
+                continue;
+            if (input.startsWith('/') && await handleCommand(input.trim()))
+                continue;
+            if (input.trim().startsWith('!')) {
+                const shellCmd = input.trim().slice(1).trim();
+                if (shellCmd) {
+                    try {
+                        let output = execSync(shellCmd, { encoding: 'utf-8', timeout: HEADLESS_DEFAULTS.commandTimeoutMs, cwd: process.cwd() }).trim();
+                        if (output) {
+                            if (output.length > HEADLESS_DEFAULTS.maxOutputTruncation) {
+                                output = output.slice(0, HEADLESS_DEFAULTS.maxOutputTruncation) + `\n... (${(output.length - HEADLESS_DEFAULTS.maxOutputTruncation).toLocaleString()} chars truncated)`;
+                            }
+                            console.log(output);
+                        }
+                    }
+                    catch (err) {
+                        console.error(err.stderr?.trim() || err.message);
+                    }
+                }
+                continue;
+            }
+            const correction = detectCorrection(input.trim());
+            if (correction)
+                addNote(process.cwd(), `[correction] ${correction}`).catch(() => { });
+            try {
+                await agent.send(input);
+            }
+            catch (err) {
+                logger.error('Send failed', { error: err.message });
+            }
+        }
+    };
+    promptLoop().catch((err) => {
+        if (err.code !== 'ERR_USE_AFTER_CLOSE') {
+            console.error('Fatal error:', err);
+            process.exit(1);
+        }
+    });
+}
+async function main() {
+    setSandboxRoot(process.cwd());
+    const { mode, prompt, output, format } = parseArgs();
+    switch (mode) {
+        case 'run':
+            if (!prompt) {
+                console.error('Error: No prompt provided. Usage: scalix run "your prompt"');
+                process.exit(1);
+            }
+            await runSinglePrompt(prompt, output, format);
+            break;
+        case 'pipe':
+            await runPipeMode();
+            break;
+        case 'ipc':
+            await runIpcServer();
+            break;
+        case 'interactive':
+        default:
+            await runInteractive();
+            break;
+    }
+}
+main().catch(console.error);