icopilot 2.2.0

package/dist/modes/autopilot.js

@@ -0,0 +1,157 @@
+import { Session } from '../session/session.js';
+import { hookManager } from '../hooks/lifecycle.js';
+import { theme } from '../ui/theme.js';
+import { runTurn } from './turn.js';
+export const AUTOPILOT_MAX_STEPS = 10;
+const AUTOPILOT_REQUIRE_APPROVAL_DEFAULT = true;
+const AUTOPILOT_COMPLETE_TOKEN = 'AUTOPILOT_COMPLETE:';
+export function buildAutopilotSystemPrompt(goal) {
+    const normalizedGoal = goal.trim();
+    return [
+        'You are operating in autopilot mode.',
+        `Goal: ${normalizedGoal || 'No goal provided.'}`,
+        '',
+        'Follow this process:',
+        '1. Break the goal into numbered steps.',
+        '2. Execute each step using the available tools.',
+        '3. Verify each step succeeded before moving to the next step.',
+        '4. Report a final summary with results, blockers, and follow-up items.',
+        '',
+        `Constraints: keep the plan within ${AUTOPILOT_MAX_STEPS} steps unless the task clearly requires fewer.`,
+        `Approval: assume destructive actions require explicit user approval when requireApproval=${String(AUTOPILOT_REQUIRE_APPROVAL_DEFAULT)}.`,
+    ].join('\n');
+}
+export function parseAutopilotPlan(response) {
+    const normalizedResponse = response.trim();
+    if (!normalizedResponse) {
+        return { goal: '', steps: [] };
+    }
+    const lines = normalizedResponse.split(/\r?\n/);
+    const steps = [];
+    const goalLines = [];
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line) {
+            continue;
+        }
+        const match = line.match(/^(\d+)[.)]\s+(.*)$/);
+        if (match) {
+            const description = match[2]?.trim();
+            if (description) {
+                steps.push({ description, status: 'pending' });
+            }
+            continue;
+        }
+        if (steps.length > 0) {
+            const currentStep = steps[steps.length - 1];
+            currentStep.description = `${currentStep.description} ${line}`.trim();
+            continue;
+        }
+        goalLines.push(line);
+    }
+    const goal = goalLines.join(' ').trim();
+    if (steps.length > 0) {
+        return { goal, steps };
+    }
+    return {
+        goal: normalizedResponse,
+        steps: [],
+    };
+}
+export async function runAutopilot(goal, opts = {}) {
+    const normalizedGoal = goal.trim();
+    if (!normalizedGoal) {
+        throw new Error('autopilot requires a goal.');
+    }
+    const maxSteps = Math.max(1, Math.min(opts.maxSteps ?? AUTOPILOT_MAX_STEPS, AUTOPILOT_MAX_STEPS));
+    const signal = opts.signal ?? new AbortController().signal;
+    const session = opts.session ??
+        new Session({
+            model: opts.model,
+            cwd: opts.cwd,
+            mode: 'ask',
+        });
+    if (!opts.session) {
+        await session.initializeGitContext();
+        await hookManager.emit('sessionStart', {
+            sessionId: session.state.id,
+            cwd: session.state.cwd,
+            mode: session.state.mode,
+            model: session.state.model,
+        });
+    }
+    const previousMode = session.state.mode;
+    const previousPrompt = session.state.systemPrompt;
+    const previousAutopilotEnabled = Boolean(session.state.autopilotEnabled);
+    session.setAutopilotEnabled(false);
+    session.setMode('ask');
+    session.setSystemPrompt(buildAutopilotSystemPrompt(normalizedGoal));
+    try {
+        for (let step = 1; step <= maxSteps; step++) {
+            process.stdout.write(theme.dim(`\n[autopilot] step ${step} of ${maxSteps}\n`));
+            await runTurn({
+                session,
+                userInput: buildAutopilotTurnPrompt(normalizedGoal, step, maxSteps),
+                signal,
+            });
+            if (isAutopilotComplete(findLastAssistantMessage(session.state.messages))) {
+                return session;
+            }
+        }
+        process.stdout.write(theme.warn(`\n⚠  autopilot stopped after ${maxSteps} steps.\n`));
+        return session;
+    }
+    finally {
+        session.setSystemPrompt(previousPrompt);
+        session.setMode(previousMode);
+        session.setAutopilotEnabled(previousAutopilotEnabled);
+        if (!opts.session) {
+            await hookManager.emit('sessionEnd', {
+                sessionId: session.state.id,
+                cwd: session.state.cwd,
+                mode: session.state.mode,
+                model: session.state.model,
+            });
+        }
+    }
+}
+function buildAutopilotTurnPrompt(goal, step, maxSteps) {
+    const progress = `Step ${step} of ${maxSteps}.`;
+    if (step === 1) {
+        return [
+            progress,
+            `Goal: ${goal}`,
+            `Start working now. When the goal is fully complete, begin your response with "${AUTOPILOT_COMPLETE_TOKEN}" followed by a concise summary.`,
+        ].join('\n');
+    }
+    return [
+        progress,
+        'Continue from the current session state and finish the next best action.',
+        `If the goal is fully complete, begin your response with "${AUTOPILOT_COMPLETE_TOKEN}" followed by a concise summary.`,
+    ].join('\n');
+}
+function findLastAssistantMessage(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message?.role === 'assistant') {
+            return contentToText(message.content);
+        }
+    }
+    return '';
+}
+function isAutopilotComplete(content) {
+    return content.trimStart().startsWith(AUTOPILOT_COMPLETE_TOKEN);
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => {
+        if (typeof part === 'string')
+            return part;
+        return 'text' in part && typeof part.text === 'string' ? part.text : '';
+    })
+        .join('\n');
+}

package/dist/modes/background.js

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+import { theme } from '../ui/theme.js';
+export class TaskManager {
+    tasks = new Map();
+    startTask(goal) {
+        const task = {
+            id: crypto.randomUUID(),
+            goal: goal.trim(),
+            status: 'running',
+            startedAt: new Date().toISOString(),
+        };
+        this.tasks.set(task.id, task);
+        return task.id;
+    }
+    completeTask(id, result) {
+        const task = this.tasks.get(id);
+        if (!task)
+            return;
+        task.status = 'done';
+        task.completedAt = new Date().toISOString();
+        task.result = result;
+        delete task.error;
+    }
+    failTask(id, error) {
+        const task = this.tasks.get(id);
+        if (!task)
+            return;
+        task.status = 'failed';
+        task.completedAt = new Date().toISOString();
+        task.error = error;
+        delete task.result;
+    }
+    getTask(id) {
+        const task = this.tasks.get(id);
+        return task ? cloneTask(task) : undefined;
+    }
+    listTasks() {
+        return [...this.tasks.values()].map(cloneTask);
+    }
+    formatTaskList() {
+        const tasks = this.listTasks();
+        if (tasks.length === 0)
+            return `${theme.brand('Background tasks')}\n  ${theme.dim('No tasks.')}\n`;
+        const lines = tasks.map((task) => `  ${statusMarker(task.status)} ${theme.hl(shortId(task.id))} ${task.goal} ${theme.dim(`(${task.status})`)}`);
+        return `${theme.brand('Background tasks')}\n${lines.join('\n')}\n`;
+    }
+    formatTaskResult(id) {
+        const task = this.getTask(id);
+        if (!task)
+            return `${theme.warn(`No background task matches "${id}".`)}\n`;
+        const lines = [
+            `${theme.brand('Background task')} ${theme.hl(shortId(task.id))}`,
+            `  goal: ${task.goal}`,
+            `  status: ${task.status}`,
+            `  started: ${task.startedAt}`,
+        ];
+        if (task.completedAt)
+            lines.push(`  completed: ${task.completedAt}`);
+        if (task.result)
+            lines.push(`  result: ${task.result}`);
+        if (task.error)
+            lines.push(`  error: ${task.error}`);
+        return `${lines.join('\n')}\n`;
+    }
+}
+export const backgroundTaskManager = new TaskManager();
+function cloneTask(task) {
+    return { ...task };
+}
+function shortId(id) {
+    return id.slice(0, 8);
+}
+function statusMarker(status) {
+    switch (status) {
+        case 'done':
+            return theme.ok('✓');
+        case 'failed':
+            return theme.err('✗');
+        default:
+            return theme.dim('…');
+    }
+}

package/dist/modes/interactive.js

@@ -0,0 +1,187 @@
+import { createRequire } from 'node:module';
+import { Session } from '../session/session.js';
+import { theme, banner } from '../ui/theme.js';
+import { createPrompt, prefix } from '../ui/prompt.js';
+import { handleSlash } from '../commands/slash.js';
+import { loadAliases, resolveAlias } from '../commands/alias-cmd.js';
+import { MetricsCollector } from '../commands/metrics-cmd.js';
+import { runAutopilot } from './autopilot.js';
+import { handlePostTurnContextBudget } from './auto-compact.js';
+import { runTurn } from './turn.js';
+import { config } from '../config.js';
+import { backgroundTaskManager } from './background.js';
+import { hookManager } from '../hooks/lifecycle.js';
+import { applyKeybindingConfig, getKeybindingHelp } from '../util/keybindings.js';
+import { getCloudRoutineScheduler } from '../cloud/routine-scheduler.js';
+import { createCloudRoutineExecutor } from '../cloud/routine-executor.js';
+const require = createRequire(import.meta.url);
+const VERSION = require('../../package.json').version;
+export async function runInteractive(initialMode = 'ask', opts = {}) {
+    const session = new Session({ mode: initialMode });
+    await session.initializeGitContext();
+    await hookManager.emit('sessionStart', {
+        sessionId: session.state.id,
+        cwd: session.state.cwd,
+        mode: session.state.mode,
+        model: session.state.model,
+    });
+    const metrics = new MetricsCollector();
+    const scheduler = getCloudRoutineScheduler();
+    if (config.cloudRoutines?.enabled) {
+        const executor = createCloudRoutineExecutor();
+        scheduler.setExecutor(executor);
+        scheduler.start();
+    }
+    // Apply keybinding configuration
+    const keybindingMode = applyKeybindingConfig();
+    if (!config.quiet) {
+        process.stdout.write(banner(VERSION, session.state.model));
+        if (keybindingMode !== 'default') {
+            process.stdout.write(getKeybindingHelp(keybindingMode));
+        }
+    }
+    const rl = createPrompt(keybindingMode);
+    let running = true;
+    let processing = false;
+    let currentAbort = null;
+    const pendingInputs = [];
+    // SIGINT: abort streaming, but never exit (unless pressed at idle twice).
+    let lastSigintAt = 0;
+    const onSigint = () => {
+        if (currentAbort && !currentAbort.signal.aborted) {
+            currentAbort.abort();
+            process.stdout.write(theme.warn('\n⏸  interrupted.\n'));
+            return;
+        }
+        const now = Date.now();
+        if (now - lastSigintAt < 1500) {
+            process.stdout.write(theme.dim('\nbye.\n'));
+            running = false;
+            rl.close();
+            return;
+        }
+        lastSigintAt = now;
+        process.stdout.write(theme.dim('\n(press Ctrl-C again to exit)\n'));
+    };
+    process.on('SIGINT', onSigint);
+    const enqueueInput = (line, scheduled = false) => {
+        pendingInputs.push({ line, scheduled });
+        void processQueue();
+    };
+    const processQueue = async () => {
+        if (processing)
+            return;
+        processing = true;
+        try {
+            while (running && pendingInputs.length) {
+                const next = pendingInputs.shift();
+                if (!next)
+                    continue;
+                const resolvedLine = resolveAlias(next.line, loadAliases()) ?? next.line;
+                currentAbort = new AbortController();
+                try {
+                    if (next.scheduled) {
+                        process.stdout.write(theme.dim(`\n[schedule] ${next.line}\n`));
+                    }
+                    const slash = await handleSlash(resolvedLine, {
+                        session,
+                        abort: currentAbort,
+                        metrics,
+                        schedulePrompt: (prompt) => enqueueInput(prompt, true),
+                        exit: () => {
+                            running = false;
+                        },
+                    });
+                    if (slash.consumed)
+                        continue;
+                    const input = slash.forwardInput ?? resolvedLine;
+                    if (slash.handled && slash.forwardInput !== undefined) {
+                        process.stdout.write(formatMessagePreview(slash.forwardInput));
+                    }
+                    const trimmedInput = input.trim();
+                    if (trimmedInput.endsWith('&')) {
+                        const goal = trimmedInput.slice(0, -1).trim();
+                        if (!goal) {
+                            process.stdout.write(theme.warn('\nusage: <prompt> &\n'));
+                            continue;
+                        }
+                        const id = backgroundTaskManager.startTask(goal);
+                        process.stdout.write(theme.ok(`\n↳ started background task ${id.slice(0, 8)} for: ${goal}\n`));
+                        continue;
+                    }
+                    const explicitTurnMode = slash
+                        .turnMode;
+                    const effectiveTurnMode = explicitTurnMode ?? opts.defaultTurnMode;
+                    if (session.state.autopilotEnabled && !effectiveTurnMode) {
+                        await runAutopilot(input, {
+                            session,
+                            signal: currentAbort.signal,
+                        });
+                    }
+                    else {
+                        await runTurn({
+                            session,
+                            userInput: input,
+                            metrics,
+                            signal: currentAbort.signal,
+                            turnMode: effectiveTurnMode ?? undefined,
+                        });
+                        await handlePostTurnContextBudget(session, currentAbort.signal);
+                    }
+                }
+                catch (e) {
+                    if (e?.name === 'AbortError' || currentAbort.signal.aborted) {
+                        // already messaged
+                    }
+                    else {
+                        await hookManager.emit('errorOccurred', {
+                            scope: 'interactive',
+                            sessionId: session.state.id,
+                            message: e?.message || String(e),
+                        });
+                        process.stdout.write(theme.err(`\nerror: ${e?.message || e}\n`));
+                    }
+                }
+                finally {
+                    currentAbort = null;
+                }
+            }
+        }
+        finally {
+            processing = false;
+        }
+    };
+    try {
+        while (running) {
+            let line;
+            try {
+                line = await rl.read(prefix(session.state.mode));
+            }
+            catch {
+                break;
+            }
+            if (!line || !line.trim())
+                continue;
+            enqueueInput(line);
+        }
+    }
+    finally {
+        scheduler.stop();
+        process.off('SIGINT', onSigint);
+        rl.close();
+        await hookManager.emit('sessionEnd', {
+            sessionId: session.state.id,
+            cwd: session.state.cwd,
+            mode: session.state.mode,
+            model: session.state.model,
+        });
+    }
+}
+function formatMessagePreview(message) {
+    const lines = message.trim().split(/\r?\n/);
+    const preview = lines.slice(0, 8);
+    const suffix = lines.length > preview.length
+        ? `\n${theme.dim(`… ${lines.length - preview.length} more line(s)`)}`
+        : '';
+    return `\n${theme.brand('Message preview')}\n${preview.join('\n')}${suffix}\n\n`;
+}

package/dist/modes/oneshot.js

@@ -0,0 +1,36 @@
+import { Session } from '../session/session.js';
+import { hookManager } from '../hooks/lifecycle.js';
+import { runTurn } from './turn.js';
+import { theme } from '../ui/theme.js';
+export async function runOneShot(prompt, opts = {}) {
+    const session = new Session({
+        model: opts.model,
+        mode: opts.plan ? 'plan' : 'ask',
+    });
+    await session.initializeGitContext();
+    await hookManager.emit('sessionStart', {
+        sessionId: session.state.id,
+        cwd: session.state.cwd,
+        mode: session.state.mode,
+        model: session.state.model,
+    });
+    const ac = new AbortController();
+    const onSigint = () => {
+        ac.abort();
+        process.stdout.write(theme.warn('\n⏸  interrupted.\n'));
+        process.exit(130);
+    };
+    process.on('SIGINT', onSigint);
+    try {
+        await runTurn({ session, userInput: prompt, signal: ac.signal, turnMode: opts.turnMode });
+    }
+    finally {
+        process.off('SIGINT', onSigint);
+        await hookManager.emit('sessionEnd', {
+            sessionId: session.state.id,
+            cwd: session.state.cwd,
+            mode: session.state.mode,
+            model: session.state.model,
+        });
+    }
+}