icopilot 2.2.0

package/dist/commands/trigger-cmd.js

@@ -0,0 +1,147 @@
+import { theme } from '../ui/theme.js';
+import { getFileTriggerManager, } from '../workflows/file-trigger.js';
+import { getBuiltinWorkflow } from '../workflows/builtins.js';
+import { WorkflowEngine } from '../workflows/engine.js';
+const triggerHandlers = new WeakSet();
+export async function triggerCommand(args, cwd) {
+    const [subcommandRaw, ...rest] = args;
+    const subcommand = (subcommandRaw || 'list').toLowerCase();
+    const manager = getFileTriggerManager(cwd);
+    switch (subcommand) {
+        case 'add':
+            return addTriggerCommand(manager, rest);
+        case 'remove':
+        case 'rm':
+        case 'delete':
+            return removeTriggerCommand(manager, rest);
+        case 'list':
+            return listTriggerCommand(manager);
+        case 'start':
+            ensureTriggerHandler(manager);
+            manager.start(cwd);
+            return theme.ok(`✔ trigger watcher started ${theme.dim(cwd)}\n`);
+        case 'stop':
+            manager.stop();
+            return theme.ok('✔ trigger watcher stopped\n');
+        default:
+            return triggerUsage();
+    }
+}
+function addTriggerCommand(manager, args) {
+    const [pattern, actionRaw, ...targetParts] = args;
+    const action = actionRaw;
+    const target = targetParts.join(' ').trim();
+    if (!pattern || !action || !target) {
+        return theme.warn('usage: /trigger add <pattern> <action> <target>\n');
+    }
+    if (!['workflow', 'command', 'prompt'].includes(action)) {
+        return theme.warn(`invalid trigger action: ${action}\n`);
+    }
+    try {
+        manager.addTrigger({ pattern, action, target });
+        return theme.ok(`✔ trigger saved ${theme.dim(`${pattern} → ${action}:${target}`)}\n`);
+    }
+    catch (error) {
+        return theme.err(`trigger: ${error.message}\n`);
+    }
+}
+function removeTriggerCommand(manager, args) {
+    const [pattern] = args;
+    if (!pattern)
+        return theme.warn('usage: /trigger remove <pattern>\n');
+    const before = manager.listTriggers().length;
+    manager.removeTrigger(pattern);
+    return manager.listTriggers().length === before
+        ? theme.warn(`trigger not found: ${pattern}\n`)
+        : theme.ok(`✔ trigger removed ${pattern}\n`);
+}
+function listTriggerCommand(manager) {
+    const triggers = manager.listTriggers();
+    if (triggers.length === 0)
+        return theme.dim('No file triggers configured.\n');
+    const lines = triggers.map((trigger, index) => {
+        const debounce = trigger.debounce ?? 500;
+        return `  ${index + 1}. ${theme.hl(trigger.pattern)} ${theme.dim('→')} ${trigger.action}:${trigger.target} ${theme.dim(`(${debounce}ms)`)}`;
+    });
+    return `${theme.brand('File triggers')}\n${lines.join('\n')}\n`;
+}
+function triggerUsage() {
+    return [
+        theme.brand('Trigger command'),
+        `  ${theme.hl('/trigger add <pattern> <action> <target>')}  ${theme.dim('save a file trigger')}`,
+        `  ${theme.hl('/trigger remove <pattern>')}                 ${theme.dim('delete a file trigger')}`,
+        `  ${theme.hl('/trigger list')}                             ${theme.dim('list configured triggers')}`,
+        `  ${theme.hl('/trigger start')}                            ${theme.dim('start watching the project')}`,
+        `  ${theme.hl('/trigger stop')}                             ${theme.dim('stop watching the project')}`,
+        '',
+    ].join('\n');
+}
+function ensureTriggerHandler(manager) {
+    if (triggerHandlers.has(manager))
+        return;
+    manager.onTrigger((trigger, file) => {
+        void executeTriggerAction(trigger, file, manager.getRootDir());
+    });
+    triggerHandlers.add(manager);
+}
+async function executeTriggerAction(trigger, file, cwd) {
+    const renderedTarget = renderTriggerTarget(trigger.target, file, cwd);
+    process.stdout.write(theme.dim(`\n[file-trigger] ${file} → ${trigger.action}:${renderedTarget}\n`));
+    try {
+        switch (trigger.action) {
+            case 'workflow':
+                await runTriggeredWorkflow(renderedTarget, file, cwd);
+                break;
+            case 'command':
+                await runTriggeredCommand(renderedTarget, file, cwd);
+                break;
+            case 'prompt':
+                process.stdout.write(`${theme.brand('Trigger prompt')} ${theme.dim(file)}\n${renderedTarget}\n`);
+                break;
+        }
+    }
+    catch (error) {
+        process.stdout.write(theme.err(`trigger failed: ${error.message}\n`));
+    }
+}
+async function runTriggeredWorkflow(name, file, cwd) {
+    const engine = new WorkflowEngine({ cwd });
+    const workflow = getBuiltinWorkflow(name) ?? engine.loadWorkflows(cwd).find((entry) => entry.name === name);
+    if (!workflow)
+        throw new Error(`workflow not found: ${name}`);
+    const result = await engine.run(workflow, { cwd, file, triggerFile: file });
+    process.stdout.write(formatTriggerRunResult(workflow.name, result));
+}
+async function runTriggeredCommand(command, file, cwd) {
+    const engine = new WorkflowEngine({ cwd });
+    const workflow = {
+        name: `file-trigger:${command}`,
+        description: `Run ${command} when ${file} changes.`,
+        steps: [
+            {
+                id: 'run-trigger-command',
+                name: 'Run trigger command',
+                action: 'shell',
+                params: { command, cwd },
+                onFail: 'continue',
+            },
+        ],
+    };
+    const result = await engine.run(workflow, { cwd, file, triggerFile: file });
+    process.stdout.write(formatTriggerRunResult(workflow.name, result));
+}
+function formatTriggerRunResult(name, result) {
+    const lines = [`${theme.brand('Trigger result')} ${theme.dim(name)}`];
+    lines.push(`  success: ${theme.hl(result.success ? 'yes' : 'no')}`);
+    for (const step of result.steps) {
+        lines.push(`  - ${step.stepId}: ${step.success ? theme.ok('ok') : theme.err('failed')}`);
+        if (typeof step.output === 'string' && step.output.trim())
+            lines.push(`    ${step.output.trim()}`);
+        if (typeof step.error === 'string' && step.error.trim())
+            lines.push(`    ${step.error.trim()}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderTriggerTarget(target, file, cwd) {
+    return target.replace(/\$\{file\}/g, file).replace(/\$\{cwd\}/g, cwd);
+}

package/dist/commands/undo-cmd.js

@@ -0,0 +1,18 @@
+import { undoLast, redoLast, journalSize } from '../session/undo-journal.js';
+import { theme } from '../ui/theme.js';
+export async function undoCommand(sub) {
+    if (sub === 'status') {
+        const size = journalSize();
+        return `${theme.brand('Undo journal')} ${theme.dim(`undo: ${size.undo} redo: ${size.redo}`)}\n`;
+    }
+    if (sub === 'undo') {
+        const result = undoLast();
+        if (!result)
+            return theme.warn('Nothing to undo.\n');
+        return theme.ok(`✔ undone ${result.entry.path}\n`);
+    }
+    const result = redoLast();
+    if (!result)
+        return theme.warn('Nothing to redo.\n');
+    return theme.ok(`✔ redone ${result.entry.path}\n`);
+}

package/dist/commands/voice-cmd.js

@@ -0,0 +1,89 @@
+import { getSpeechProvider, isVoiceInputConfigured } from '../extensions/voice.js';
+import { theme } from '../ui/theme.js';
+const state = {
+    isRecording: false,
+    startedAt: 0,
+    recordedAudio: null,
+};
+export async function voiceCommand(args) {
+    if (!isVoiceInputConfigured()) {
+        return `${theme.err('Voice input is not configured.')}\n\nTo enable voice input, install a speech provider plugin:\n  /plugin install openai-whisper\n\nSee docs/extensions.md for setup instructions.\n`;
+    }
+    const [subcommand = 'start'] = args;
+    const cmd = subcommand.toLowerCase().trim();
+    if (cmd === 'start' || cmd === 'record') {
+        if (state.isRecording) {
+            return theme.warn('Already recording. Use /voice stop to finish.\n');
+        }
+        return await startRecording();
+    }
+    if (cmd === 'stop' || cmd === 'end') {
+        if (!state.isRecording) {
+            return theme.warn('Not currently recording. Use /voice start to begin.\n');
+        }
+        return await stopRecording();
+    }
+    if (cmd === 'status') {
+        return getStatus();
+    }
+    if (cmd === 'cancel') {
+        if (!state.isRecording) {
+            return theme.warn('Not currently recording.\n');
+        }
+        state.isRecording = false;
+        state.recordedAudio = null;
+        return theme.ok('✔ Recording cancelled.\n');
+    }
+    return `usage: /voice [start|stop|status|cancel]\n`;
+}
+async function startRecording() {
+    state.isRecording = true;
+    state.startedAt = Date.now();
+    state.recordedAudio = null;
+    return theme.dim('🎤 Recording started...\n  (Use /voice stop to finish, Ctrl+C to cancel)\n');
+}
+async function stopRecording() {
+    if (!state.isRecording) {
+        return theme.warn('Not recording.\n');
+    }
+    state.isRecording = false;
+    const elapsed = ((Date.now() - state.startedAt) / 1000).toFixed(1);
+    try {
+        if (!state.recordedAudio || state.recordedAudio.length === 0) {
+            return theme.warn(`Recording incomplete. Try again.\n`);
+        }
+        const provider = getSpeechProvider();
+        const transcribed = await provider.transcribe(state.recordedAudio);
+        state.recordedAudio = null;
+        if (!transcribed || !transcribed.trim()) {
+            return theme.warn(`No speech detected. Try again.\n`);
+        }
+        return `${theme.ok(`✔ Transcribed (${elapsed}s)`)}\n\n${transcribed}\n`;
+    }
+    catch (error) {
+        state.recordedAudio = null;
+        const message = error instanceof Error ? error.message : String(error);
+        return theme.err(`Voice transcription failed: ${message}\n`);
+    }
+}
+function getStatus() {
+    if (!state.isRecording) {
+        return theme.dim('Not recording.\n');
+    }
+    const elapsed = ((Date.now() - state.startedAt) / 1000).toFixed(1);
+    return theme.dim(`🎤 Recording: ${elapsed}s elapsed\n`);
+}
+export function isRecording() {
+    return state.isRecording;
+}
+export function setRecordedAudio(audio) {
+    state.recordedAudio = audio;
+}
+export function getRecordedAudio() {
+    return state.recordedAudio;
+}
+export function resetVoiceState() {
+    state.isRecording = false;
+    state.startedAt = 0;
+    state.recordedAudio = null;
+}

package/dist/commands/watch-cmd.js

@@ -0,0 +1,110 @@
+import { theme } from '../ui/theme.js';
+const DEFAULT_DEBOUNCE_MS = 500;
+const WATCH_USAGE = [
+    theme.brand('Watch command'),
+    `  ${theme.hl('/watch set <pattern> <command>')}  ${theme.dim('configure a file watch')}`,
+    `  ${theme.hl('/watch stop')}                   ${theme.dim('stop the active watch')}`,
+    `  ${theme.hl('/watch status')}                 ${theme.dim('show the current watch state')}`,
+].join('\n');
+let currentConfig = null;
+let currentState = null;
+export function parseWatchArgs(args) {
+    const [pattern, ...commandParts] = args;
+    if (!pattern || commandParts.length === 0) {
+        return { error: 'usage: /watch set <pattern> <command>' };
+    }
+    const command = commandParts.join(' ').trim();
+    if (!command) {
+        return { error: 'usage: /watch set <pattern> <command>' };
+    }
+    if (!isValidGlob(pattern)) {
+        return { error: `invalid glob pattern: ${pattern}` };
+    }
+    return {
+        pattern,
+        command,
+        debounceMs: DEFAULT_DEBOUNCE_MS,
+    };
+}
+export function formatWatchStatus(state) {
+    if (!state) {
+        return `${theme.warn('No watch configured.')}\n`;
+    }
+    return [
+        theme.brand('Watch status'),
+        `  active:        ${theme.hl(state.active ? 'yes' : 'no')}`,
+        `  pattern:       ${theme.hl(state.pattern)}`,
+        `  command:       ${theme.hl(state.command)}`,
+        `  trigger count: ${theme.hl(String(state.triggerCount))}`,
+        '',
+    ].join('\n');
+}
+export function watchCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        return `${WATCH_USAGE}\n\n${formatConfiguredStatus()}`;
+    }
+    switch (subcommand.toLowerCase()) {
+        case 'set': {
+            const parsed = parseWatchArgs(rest);
+            if ('error' in parsed) {
+                return `${theme.warn(parsed.error)}\n${theme.dim('Example: /watch set src/**/*.ts npm test')}\n`;
+            }
+            currentConfig = parsed;
+            currentState = {
+                active: true,
+                pattern: parsed.pattern,
+                command: parsed.command,
+                triggerCount: 0,
+            };
+            return `${theme.ok('✔ watch configured')}\n${formatConfiguredStatus()}`;
+        }
+        case 'stop':
+            if (!currentState) {
+                return `${theme.warn('No watch configured.')}\n`;
+            }
+            currentState = { ...currentState, active: false };
+            return `${theme.ok('✔ watch stopped')}\n${formatConfiguredStatus()}`;
+        case 'status':
+            return formatConfiguredStatus();
+        default:
+            return `${theme.warn(`unknown watch subcommand: ${subcommand}`)}\n${WATCH_USAGE}\n`;
+    }
+}
+function formatConfiguredStatus() {
+    const status = formatWatchStatus(currentState).trimEnd();
+    if (!currentConfig)
+        return `${status}\n`;
+    return `${status}\n  debounce:      ${theme.hl(`${currentConfig.debounceMs}ms`)}\n`;
+}
+function isValidGlob(pattern) {
+    if (!pattern.trim())
+        return false;
+    if (/[\0\r\n]/.test(pattern))
+        return false;
+    return hasBalancedDelimiters(pattern);
+}
+function hasBalancedDelimiters(pattern) {
+    const stack = [];
+    const pairs = {
+        '[': ']',
+        '{': '}',
+        '(': ')',
+    };
+    const closing = new Set(Object.values(pairs));
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === '\\') {
+            index += 1;
+            continue;
+        }
+        if (char in pairs) {
+            stack.push(pairs[char]);
+            continue;
+        }
+        if (closing.has(char) && stack.pop() !== char) {
+            return false;
+        }
+    }
+    return stack.length === 0;
+}

package/dist/commands/web-cmd.js

@@ -0,0 +1,183 @@
+import { countTokensSync } from '../util/tokens.js';
+const DEFAULT_MAX_CHARS = 50_000;
+const DEFAULT_TIMEOUT_MS = 15_000;
+const CODE_BLOCK_TOKEN = '__ICLI_WEB_CODE_BLOCK_';
+export async function fetchAndConvert(url) {
+    const parsedUrl = validateWebUrl(url);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), webTimeoutMs());
+    try {
+        const response = await fetch(parsedUrl, {
+            headers: {
+                accept: 'text/html,application/xhtml+xml',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`failed to fetch ${parsedUrl.toString()}: ${response.status} ${response.statusText}`);
+        }
+        const html = await response.text();
+        const title = extractTitle(html) || parsedUrl.hostname;
+        const markdown = truncateMarkdown(htmlToMarkdown(html), webMaxChars());
+        return {
+            title,
+            markdown,
+            tokens: estimateTokens(markdown),
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function validateWebUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`invalid URL: ${url}`);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error(`unsupported URL protocol: ${parsed.protocol}`);
+    }
+    return parsed;
+}
+export function htmlToMarkdown(html) {
+    const codeBlocks = [];
+    const stashProtected = (value) => {
+        const token = `${CODE_BLOCK_TOKEN}${codeBlocks.length}__`;
+        codeBlocks.push(value);
+        return token;
+    };
+    let markdown = html
+        .replace(/\r/g, '')
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .replace(/<head\b[^>]*>[\s\S]*?<\/head>/gi, '')
+        .replace(/<(script|style|noscript|template)\b[^>]*>[\s\S]*?<\/\1>/gi, '')
+        .replace(/<pre\b[^>]*>([\s\S]*?)<\/pre>/gi, (_match, inner) => {
+        const text = decodeHtmlEntities(stripTags(inner)).trim();
+        if (!text)
+            return '';
+        return stashProtected(`\n\n\`\`\`\n${text}\n\`\`\`\n\n`);
+    });
+    for (let level = 1; level <= 6; level += 1) {
+        const heading = new RegExp(`<h${level}\\b[^>]*>([\\s\\S]*?)<\\/h${level}>`, 'gi');
+        markdown = markdown.replace(heading, (_match, inner) => {
+            const text = convertInline(inner, stashProtected).trim();
+            return text ? `\n\n${'#'.repeat(level)} ${text}\n\n` : '';
+        });
+    }
+    markdown = markdown
+        .replace(/<blockquote\b[^>]*>([\s\S]*?)<\/blockquote>/gi, (_match, inner) => {
+        const body = convertInline(inner, stashProtected).trim();
+        if (!body)
+            return '';
+        return `\n\n${body
+            .split(/\n+/)
+            .map((line) => `> ${line.trim()}`)
+            .join('\n')}\n\n`;
+    })
+        .replace(/<li\b[^>]*>([\s\S]*?)<\/li>/gi, (_match, inner) => {
+        const text = convertInline(inner, stashProtected).trim();
+        return text ? `\n- ${text}` : '';
+    })
+        .replace(/<(ul|ol)\b[^>]*>/gi, '\n')
+        .replace(/<\/(ul|ol)>/gi, '\n')
+        .replace(/<(p|div|section|article|main|aside|header|footer|nav|figure|figcaption)\b[^>]*>([\s\S]*?)<\/\1>/gi, (_match, _tag, inner) => {
+        const text = convertInline(inner, stashProtected).trim();
+        return text ? `\n\n${text}\n\n` : '';
+    })
+        .replace(/<br\s*\/?>/gi, '\n');
+    markdown = decodeHtmlEntities(stripTags(markdown))
+        .replace(/\u00a0/g, ' ')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n[ \t]+/g, '\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return restoreCodeBlocks(markdown, codeBlocks);
+}
+export function truncateMarkdown(markdown, maxChars = webMaxChars()) {
+    if (maxChars <= 0 || markdown.length <= maxChars)
+        return markdown;
+    const suffix = `\n\n[Content truncated at ${maxChars} characters.]`;
+    const sliceLength = Math.max(0, maxChars - suffix.length);
+    return `${markdown.slice(0, sliceLength).trimEnd()}${suffix}`;
+}
+export function estimateTokens(text) {
+    try {
+        return countTokensSync(text);
+    }
+    catch {
+        return Math.ceil(text.length / 4);
+    }
+}
+function convertInline(fragment, stashProtected) {
+    let text = fragment;
+    text = text
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<a\b[^>]*href\s*=\s*(['"])(.*?)\1[^>]*>([\s\S]*?)<\/a>/gi, (_match, _quote, href, inner) => {
+        const label = convertInline(inner, stashProtected).trim() || String(href).trim();
+        const normalizedHref = String(href).trim();
+        return normalizedHref ? `[${label}](${normalizedHref})` : label;
+    })
+        .replace(/<code\b[^>]*>([\s\S]*?)<\/code>/gi, (_match, inner) => {
+        const code = decodeHtmlEntities(stripTags(inner)).replace(/\s+/g, ' ').trim();
+        if (!code)
+            return '';
+        const rendered = `\`${code.replace(/`/g, '\\`')}\``;
+        return stashProtected ? stashProtected(rendered) : rendered;
+    })
+        .replace(/<(strong|b)\b[^>]*>([\s\S]*?)<\/\1>/gi, (_match, _tag, inner) => {
+        const body = convertInline(inner, stashProtected).trim();
+        return body ? `**${body}**` : '';
+    })
+        .replace(/<(em|i)\b[^>]*>([\s\S]*?)<\/\1>/gi, (_match, _tag, inner) => {
+        const body = convertInline(inner, stashProtected).trim();
+        return body ? `*${body}*` : '';
+    });
+    return stripTags(text)
+        .replace(/\u00a0/g, ' ')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+}
+function extractTitle(html) {
+    const match = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
+    if (!match)
+        return '';
+    return decodeHtmlEntities(convertInline(match[1]));
+}
+function stripTags(text) {
+    return text.replace(/<[^>]+>/g, '');
+}
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/&amp;/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        .replace(/&#x27;/gi, "'")
+        .replace(/&#x2F;/gi, '/')
+        .replace(/&#(\d+);/g, (_match, codePoint) => {
+        const value = Number.parseInt(codePoint, 10);
+        return Number.isFinite(value) ? String.fromCodePoint(value) : _match;
+    })
+        .replace(/&#x([0-9a-f]+);/gi, (_match, codePoint) => {
+        const value = Number.parseInt(codePoint, 16);
+        return Number.isFinite(value) ? String.fromCodePoint(value) : _match;
+    });
+}
+function restoreCodeBlocks(markdown, codeBlocks) {
+    return codeBlocks.reduce((current, block, index) => current.replaceAll(`${CODE_BLOCK_TOKEN}${index}__`, block), markdown);
+}
+function webMaxChars() {
+    const parsed = Number.parseInt(process.env.ICOPILOT_WEB_MAX_CHARS ?? '', 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CHARS;
+}
+function webTimeoutMs() {
+    const parsed = Number.parseInt(process.env.ICOPILOT_WEB_TIMEOUT_MS ?? '', 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;
+}

package/dist/commands/worktree-cmd.js

@@ -0,0 +1,119 @@
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { theme } from '../ui/theme.js';
+export function worktreeCommand(args, cwd) {
+    if (!isGitRepo(cwd)) {
+        return `${theme.warn(`Not a git repository: ${cwd}`)}\n`;
+    }
+    const [subcommand = 'list', ...rest] = args;
+    switch (subcommand.toLowerCase()) {
+        case 'list':
+            return listWorktrees(cwd);
+        case 'add':
+            return addWorktree(rest, cwd);
+        case 'remove':
+        case 'rm':
+            return removeWorktree(rest, cwd);
+        case 'prune':
+            return pruneWorktrees(cwd);
+        default:
+            return usage();
+    }
+}
+function usage() {
+    return ('usage: /worktree list\n' +
+        '       /worktree add <branch> [path]\n' +
+        '       /worktree remove <path> [--force]\n' +
+        '       /worktree prune\n');
+}
+function listWorktrees(cwd) {
+    const result = runGit(['worktree', 'list', '--porcelain'], cwd);
+    if (result.status !== 0)
+        return `${theme.err(`git worktree list failed: ${result.stderr || 'unknown error'}`)}\n`;
+    const items = parseWorktreeList(result.stdout);
+    if (items.length === 0)
+        return `${theme.dim('No worktrees found.\n')}`;
+    const lines = [theme.brand('Git worktrees')];
+    for (const item of items) {
+        const branch = item.branch ? item.branch.replace('refs/heads/', '') : '(detached)';
+        lines.push(`  ${theme.hl(item.path)}`);
+        lines.push(`    branch: ${branch}`);
+        lines.push(`    head:   ${item.head}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function addWorktree(args, cwd) {
+    const [branch, providedPath] = args;
+    if (!branch)
+        return usage();
+    const targetPath = path.resolve(cwd, providedPath || path.join('.worktrees', sanitizeBranch(branch)));
+    const branchExists = runGit(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], cwd).status === 0;
+    const cmd = branchExists
+        ? ['worktree', 'add', targetPath, branch]
+        : ['worktree', 'add', '-b', branch, targetPath];
+    const result = runGit(cmd, cwd);
+    if (result.status !== 0) {
+        return `${theme.err(`git worktree add failed: ${result.stderr || 'unknown error'}`)}\n`;
+    }
+    return `${theme.ok(`✔ worktree added: ${targetPath}`)}\n`;
+}
+function removeWorktree(args, cwd) {
+    const force = args.includes('--force');
+    const target = args.find((value) => value !== '--force');
+    if (!target)
+        return usage();
+    const resolved = path.resolve(cwd, target);
+    const cmd = ['worktree', 'remove', ...(force ? ['--force'] : []), resolved];
+    const result = runGit(cmd, cwd);
+    if (result.status !== 0) {
+        return `${theme.err(`git worktree remove failed: ${result.stderr || 'unknown error'}`)}\n`;
+    }
+    return `${theme.ok(`✔ worktree removed: ${resolved}`)}\n`;
+}
+function pruneWorktrees(cwd) {
+    const result = runGit(['worktree', 'prune'], cwd);
+    if (result.status !== 0) {
+        return `${theme.err(`git worktree prune failed: ${result.stderr || 'unknown error'}`)}\n`;
+    }
+    return `${theme.ok('✔ pruned stale worktree metadata')}\n`;
+}
+function sanitizeBranch(branch) {
+    return branch.replace(/[\\/:\s]+/g, '-').replace(/[^a-zA-Z0-9._-]/g, '-');
+}
+function isGitRepo(cwd) {
+    return runGit(['rev-parse', '--is-inside-work-tree'], cwd).status === 0;
+}
+function runGit(args, cwd) {
+    const result = spawnSync('git', args, {
+        cwd,
+        encoding: 'utf8',
+        windowsHide: true,
+    });
+    return {
+        status: result.status,
+        stdout: (result.stdout || '').trim(),
+        stderr: (result.stderr || '').trim(),
+    };
+}
+function parseWorktreeList(stdout) {
+    const entries = [];
+    const blocks = stdout
+        .split(/\n(?=worktree )/g)
+        .map((value) => value.trim())
+        .filter(Boolean);
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        const pathLine = lines.find((line) => line.startsWith('worktree '));
+        const headLine = lines.find((line) => line.startsWith('HEAD '));
+        if (!pathLine || !headLine)
+            continue;
+        const branchLine = lines.find((line) => line.startsWith('branch '));
+        entries.push({
+            path: pathLine.slice('worktree '.length).trim(),
+            branch: branchLine ? branchLine.slice('branch '.length).trim() : undefined,
+            head: headLine.slice('HEAD '.length).trim(),
+        });
+    }
+    return entries;
+}