icopilot 2.2.0

package/dist/commands/history-cmd.js

@@ -0,0 +1,122 @@
+import { countTokensSync } from '../util/tokens.js';
+import { theme } from '../ui/theme.js';
+const PREVIEW_LIMIT = 80;
+export function historyCommand(args, session) {
+    const subcommand = args[0]?.toLowerCase();
+    const entries = buildEntries(session);
+    if (!subcommand) {
+        return formatEntries(entries.slice(-20), 'History', `(${Math.min(20, entries.length)} of ${entries.length})`);
+    }
+    if (subcommand === 'search') {
+        const query = args.slice(1).join(' ').trim();
+        if (!query)
+            return usage();
+        const queryLower = query.toLowerCase();
+        const matches = entries.filter((entry) => contentToText(session.state.messages[entry.index].content).toLowerCase().includes(queryLower));
+        if (matches.length === 0)
+            return `${theme.warn(`No messages matched "${query}".`)}\n`;
+        return formatEntries(matches, `History search ${theme.hl(query)}`, `(${matches.length} match${matches.length === 1 ? '' : 'es'})`);
+    }
+    if (subcommand === 'show') {
+        const rawIndex = args[1];
+        const index = Number.parseInt(rawIndex ?? '', 10);
+        if (!rawIndex || Number.isNaN(index))
+            return usage();
+        const message = session.state.messages[index];
+        if (!message)
+            return `${theme.warn(`Message not found: ${rawIndex}`)}\n`;
+        const content = contentToText(message.content);
+        return [
+            theme.brand(`Message ${index}`),
+            `  role:   ${formatRole(String(message.role || 'message'))}`,
+            `  tokens: ${theme.hl(String(tokensForContent(content)))}`,
+            '',
+            content || theme.dim('(empty)'),
+            '',
+        ].join('\n');
+    }
+    if (subcommand === 'count') {
+        return [
+            theme.brand('History count'),
+            `  messages: ${theme.hl(String(session.state.messages.length))}`,
+            `  tokens:   ${theme.hl(String(session.tokenUsage()))}`,
+            '',
+        ].join('\n');
+    }
+    return usage();
+}
+function buildEntries(session) {
+    return session.state.messages.map((message, index) => buildEntry(message, index));
+}
+function buildEntry(message, index) {
+    const content = contentToText(message.content);
+    return {
+        index,
+        role: String(message.role || 'message'),
+        preview: truncatePreview(content),
+        tokens: tokensForContent(content),
+    };
+}
+function formatEntries(entries, heading, detail) {
+    if (entries.length === 0)
+        return `${theme.warn('No messages in session history.')}\n`;
+    const indexWidth = Math.max(2, String(entries[entries.length - 1]?.index ?? 0).length);
+    const roleWidth = Math.max(...entries.map((entry) => entry.role.length), 4);
+    const lines = entries.map((entry) => {
+        const preview = entry.preview || theme.dim('(empty)');
+        return `  ${theme.dim(String(entry.index).padStart(indexWidth))}  ${formatRole(entry.role.padEnd(roleWidth))}  ${preview}`;
+    });
+    const header = detail ? `${theme.brand(heading)} ${theme.dim(detail)}` : theme.brand(heading);
+    return `${header}\n${lines.join('\n')}\n`;
+}
+function formatRole(role) {
+    const normalized = role.trim().toLowerCase();
+    if (normalized === 'user')
+        return theme.user(role);
+    if (normalized === 'assistant')
+        return theme.assistant(role);
+    if (normalized === 'system')
+        return theme.system(role);
+    return theme.dim(role);
+}
+function truncatePreview(content) {
+    const normalized = content.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= PREVIEW_LIMIT)
+        return normalized;
+    return `${normalized.slice(0, PREVIEW_LIMIT - 1)}…`;
+}
+function tokensForContent(content) {
+    if (!content)
+        return 0;
+    try {
+        return countTokensSync(content);
+    }
+    catch {
+        return Math.ceil(content.length / 4);
+    }
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (!part || typeof part !== 'object')
+                return '';
+            const record = part;
+            if (typeof record.text === 'string')
+                return record.text;
+            if (typeof record.type === 'string')
+                return JSON.stringify(record);
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (content == null)
+        return '';
+    return JSON.stringify(content, null, 2);
+}
+function usage() {
+    return `Usage: /history | /history search <query> | /history show <index> | /history count\n`;
+}

package/dist/commands/index-cmd.js

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { config } from '../config.js';
+import { theme } from '../ui/theme.js';
+import { buildIndex } from '../index/indexer.js';
+import { retrieve } from '../index/retrieve.js';
+export async function indexCommand(rest) {
+    const [sub = 'status', ...args] = rest;
+    switch (sub.toLowerCase()) {
+        case 'build': {
+            process.stdout.write(theme.dim('Indexing repository (this requires GITHUB_TOKEN)…\n'));
+            try {
+                const r = await buildIndex(config.cwd);
+                process.stdout.write(theme.ok(`✔ indexed ${r.files} files, ${r.chunks} new chunks in ${r.ms}ms\n`) +
+                    theme.dim(`  ${r.outPath}\n`));
+            }
+            catch (e) {
+                process.stdout.write(theme.err(`index build failed: ${e?.message || e}\n`));
+            }
+            return;
+        }
+        case 'status': {
+            const idx = path.join(config.cwd, '.icopilot', 'index.json');
+            if (!fs.existsSync(idx)) {
+                process.stdout.write(theme.warn('No index found. Run /index build first.\n'));
+                return;
+            }
+            try {
+                const parsed = JSON.parse(fs.readFileSync(idx, 'utf8'));
+                process.stdout.write(`\n  model: ${theme.hl(parsed.model || '?')}\n` +
+                    `  built: ${parsed.createdAt || '?'}\n` +
+                    `  entries: ${Array.isArray(parsed.entries) ? parsed.entries.length : 0}\n\n`);
+            }
+            catch (e) {
+                process.stdout.write(theme.err(`failed to read index: ${e?.message || e}\n`));
+            }
+            return;
+        }
+        case 'search': {
+            const query = args.join(' ').trim();
+            if (!query) {
+                process.stdout.write(theme.warn('usage: /index search <query>\n'));
+                return;
+            }
+            try {
+                const hits = await retrieve(config.cwd, query, 6);
+                if (!hits.length) {
+                    process.stdout.write(theme.dim('no matches (or index missing).\n'));
+                    return;
+                }
+                for (const h of hits) {
+                    const snippet = h.text.replace(/\s+/g, ' ').slice(0, 200);
+                    process.stdout.write(`${theme.hl(h.file)} chunk ${h.chunk} ${theme.dim(`(score ${h.score.toFixed(3)})`)}\n` +
+                        `  ${snippet}\n`);
+                }
+            }
+            catch (e) {
+                process.stdout.write(theme.err(`search failed: ${e?.message || e}\n`));
+            }
+            return;
+        }
+        default:
+            process.stdout.write(theme.warn('usage: /index build | /index status | /index search <q>\n'));
+    }
+}

package/dist/commands/init-cmd.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+import { ROLES_CONFIG_FILE, renderRolesConfig } from '../security/roles.js';
+const POLICY_FILE = '.icopilot/policy.json';
+const MEMORY_FILE = '.icopilot/memory.md';
+const TEAM_MEMORY_FILE = '.icopilot/team-memory.md';
+const ROLES_FILE = ROLES_CONFIG_FILE;
+const AGENTS_DIR = '.icopilot/agents/';
+const CONFIG_DIR = '.icopilot/';
+const DEFAULT_POLICY = {
+    allowShell: true,
+    allowWrite: true,
+    denyTools: [],
+};
+const MEMORY_TEMPLATE = '<!-- Project memory: add notes the AI should always know about this project -->\n';
+const TEAM_MEMORY_TEMPLATE = `# Team memory
+
+<!-- Shared team memory for conventions, decisions, tips, and warnings. -->
+`;
+export function initProject(cwd, opts) {
+    const force = opts?.force === true;
+    const configDir = path.join(cwd, '.icopilot');
+    const agentsDir = path.join(configDir, 'agents');
+    const policyPath = path.join(configDir, 'policy.json');
+    const memoryPath = path.join(configDir, 'memory.md');
+    const teamMemoryPath = path.join(configDir, 'team-memory.md');
+    const rolesPath = path.join(configDir, 'roles.yaml');
+    const created = [];
+    const skipped = [];
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+        created.push(CONFIG_DIR);
+    }
+    else {
+        skipped.push(CONFIG_DIR);
+    }
+    if (!fs.existsSync(agentsDir)) {
+        fs.mkdirSync(agentsDir, { recursive: true });
+        created.push(AGENTS_DIR);
+    }
+    else {
+        skipped.push(AGENTS_DIR);
+    }
+    writeProjectFile(policyPath, `${JSON.stringify(DEFAULT_POLICY, null, 2)}\n`, POLICY_FILE, force, created, skipped);
+    writeProjectFile(memoryPath, MEMORY_TEMPLATE, MEMORY_FILE, force, created, skipped);
+    writeProjectFile(teamMemoryPath, TEAM_MEMORY_TEMPLATE, TEAM_MEMORY_FILE, force, created, skipped);
+    writeProjectFile(rolesPath, renderRolesConfig(), ROLES_FILE, force, created, skipped);
+    return { created, skipped, cwd };
+}
+export function formatInitResult(result) {
+    const lines = [
+        `${theme.brand('Project initialized')} ${theme.dim(result.cwd)}`,
+        '',
+        formatSection('Created', result.created, theme.ok),
+        formatSection('Skipped', result.skipped, theme.warn),
+    ];
+    return `${lines.join('\n')}\n`;
+}
+function writeProjectFile(filePath, contents, label, force, created, skipped) {
+    if (fs.existsSync(filePath) && !force) {
+        skipped.push(label);
+        return;
+    }
+    fs.writeFileSync(filePath, contents, 'utf8');
+    created.push(label);
+}
+function formatSection(title, entries, color) {
+    if (entries.length === 0) {
+        return `  ${color(title)}  ${theme.dim('none')}`;
+    }
+    return [`  ${color(title)}`, ...entries.map((entry) => `    ${theme.hl(entry)}`)].join('\n');
+}

package/dist/commands/lint-cmd.js

@@ -0,0 +1,133 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+function readText(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function readPackageJson(cwd) {
+    const text = readText(path.join(cwd, 'package.json'));
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function fileExists(cwd, fileName) {
+    return fs.existsSync(path.join(cwd, fileName));
+}
+function hasAnyFile(cwd, fileNames) {
+    return fileNames.some((fileName) => fileExists(cwd, fileName));
+}
+function hasEslintConfig(cwd) {
+    try {
+        return fs.readdirSync(cwd).some((entry) => entry.startsWith('.eslintrc'));
+    }
+    catch {
+        return false;
+    }
+}
+function hasPackageDependency(pkg, dependency) {
+    return Boolean(pkg?.dependencies?.[dependency] || pkg?.devDependencies?.[dependency]);
+}
+function hasComposerPackage(cwd, packageNamePart) {
+    const text = readText(path.join(cwd, 'composer.json'));
+    if (!text)
+        return false;
+    try {
+        const composer = JSON.parse(text);
+        const deps = { ...composer.require, ...composer['require-dev'] };
+        return Object.keys(deps).some((name) => name.includes(packageNamePart));
+    }
+    catch {
+        return false;
+    }
+}
+function fileContains(cwd, fileName, needle) {
+    return readText(path.join(cwd, fileName))?.includes(needle) ?? false;
+}
+export function detectLinters(cwd) {
+    const matches = [];
+    const pkg = readPackageJson(cwd);
+    const hasNpmLint = typeof pkg?.scripts?.lint === 'string';
+    const hasEslintDep = hasPackageDependency(pkg, 'eslint');
+    if (hasNpmLint) {
+        matches.push({
+            name: 'npm-lint',
+            command: 'npm run lint',
+            reason: 'package.json has "scripts.lint"',
+        });
+    }
+    if (hasEslintDep) {
+        matches.push({
+            name: 'eslint',
+            command: 'eslint .',
+            reason: 'package.json has eslint as a dependency',
+        });
+    }
+    if (!hasNpmLint && !hasEslintDep && hasEslintConfig(cwd)) {
+        matches.push({
+            name: 'eslint-config',
+            command: 'npx eslint .',
+            reason: '.eslintrc* is present',
+        });
+    }
+    if (fileExists(cwd, 'ruff.toml') || fileContains(cwd, 'pyproject.toml', '[tool.ruff]')) {
+        matches.push({
+            name: 'ruff',
+            command: 'ruff check .',
+            reason: 'ruff configuration is present',
+        });
+    }
+    if (fileExists(cwd, '.flake8') || fileContains(cwd, 'setup.cfg', '[flake8]')) {
+        matches.push({
+            name: 'flake8',
+            command: 'flake8 .',
+            reason: 'flake8 configuration is present',
+        });
+    }
+    if (fileContains(cwd, 'pyproject.toml', '[tool.black]')) {
+        matches.push({
+            name: 'black',
+            command: 'black --check .',
+            reason: 'pyproject.toml contains [tool.black]',
+        });
+    }
+    if (hasAnyFile(cwd, ['golangci.yml', '.golangci.yml', '.golangci.yaml'])) {
+        matches.push({
+            name: 'golangci-lint',
+            command: 'golangci-lint run',
+            reason: 'golangci-lint configuration is present',
+        });
+    }
+    if (fileExists(cwd, 'Cargo.toml')) {
+        matches.push({
+            name: 'cargo-clippy',
+            command: 'cargo clippy --all-targets -- -D warnings',
+            reason: 'Cargo.toml is present',
+        });
+    }
+    if (hasComposerPackage(cwd, 'phpstan')) {
+        matches.push({
+            name: 'phpstan',
+            command: 'vendor/bin/phpstan',
+            reason: 'composer.json has phpstan',
+        });
+    }
+    return matches;
+}
+export function lintCommand(cwd) {
+    const matches = detectLinters(cwd);
+    if (matches.length === 0) {
+        return `${theme.warn('No supported linters detected.')}\n${theme.dim('Add a lint script or linter configuration, then try /lint again.')}\n`;
+    }
+    const lines = matches.map((match) => `  ${theme.ok(match.name)}  ${theme.hl(match.command)}  ${theme.dim(`(${match.reason})`)}`);
+    return `${theme.brand('Detected linters')}\n${lines.join('\n')}\n`;
+}

package/dist/commands/memory-cmd.js

@@ -0,0 +1,98 @@
+import { AutoMemory } from '../knowledge/auto-memory.js';
+import { PersistentMemory } from '../context/persistent-memory.js';
+import { theme } from '../ui/theme.js';
+export function memoryCommand(args, cwd) {
+    const [rawSubcommand = 'list', ...rest] = args;
+    const subcommand = rawSubcommand.toLowerCase();
+    if (subcommand === 'auto') {
+        return autoMemoryCommand(rest);
+    }
+    const memory = new PersistentMemory();
+    const projectId = memory.getProjectId(cwd);
+    memory.load(projectId);
+    if (subcommand === 'list') {
+        return formatEntries(memory.recall(), 'Project memory');
+    }
+    if (subcommand === 'add') {
+        const [key, ...valueParts] = rest;
+        const value = valueParts.join(' ').trim();
+        if (!key || !value)
+            return usage();
+        memory.remember(key, value, 'user');
+        memory.save(projectId);
+        return `${theme.ok('Remembered')} ${theme.hl(key)} ${theme.dim('→')} ${value}\n`;
+    }
+    if (subcommand === 'remove') {
+        const key = rest[0]?.trim();
+        if (!key)
+            return usage();
+        if (!memory.forget(key))
+            return `${theme.warn(`No memory entry found for "${key}".`)}\n`;
+        memory.save(projectId);
+        return `${theme.ok('Forgot')} ${theme.hl(key)}\n`;
+    }
+    if (subcommand === 'clear') {
+        const entries = memory.recall();
+        for (const entry of entries)
+            memory.forget(entry.key);
+        memory.save(projectId);
+        return `${theme.ok(`Cleared ${entries.length} memory entr${entries.length === 1 ? 'y' : 'ies'}.`)}\n`;
+    }
+    if (subcommand === 'search') {
+        const query = rest.join(' ').trim();
+        if (!query)
+            return usage();
+        return formatEntries(memory.recall(query), `Project memory ${theme.dim(`(search: ${query})`)}`);
+    }
+    return usage();
+}
+function autoMemoryCommand(args) {
+    const memory = new AutoMemory();
+    memory.load();
+    const [rawAction = 'list', ...rest] = args;
+    const action = rawAction.toLowerCase();
+    if (action === 'list') {
+        return formatAutoMemories(memory.memories);
+    }
+    if (action === 'clear') {
+        const total = memory.memories.length;
+        memory.clear();
+        memory.save();
+        return `${theme.ok(`Cleared ${total} auto-memor${total === 1 ? 'y' : 'ies'}.`)}\n`;
+    }
+    if (action === 'forget') {
+        const id = rest.join(' ').trim();
+        if (!id)
+            return autoUsage();
+        if (!memory.forget(id))
+            return `${theme.warn(`No auto-memory found for "${id}".`)}\n`;
+        memory.save();
+        return `${theme.ok('Forgot auto-memory')} ${theme.hl(id)}\n`;
+    }
+    return autoUsage();
+}
+function formatEntries(entries, header) {
+    if (entries.length === 0)
+        return `${theme.brand(header)}\n  ${theme.dim('No remembered facts.')}\n`;
+    const lines = entries.map((entry) => `  ${theme.hl(entry.key)} = ${entry.value} ${theme.dim(`(${entry.source}, ${entry.addedAt})`)}`);
+    return `${theme.brand(header)}\n${lines.join('\n')}\n`;
+}
+function formatAutoMemories(entries) {
+    if (entries.length === 0) {
+        return `${theme.brand('Auto memory')}\n  ${theme.dim('No auto-learned memories.')}\n`;
+    }
+    const lines = [...entries]
+        .sort((left, right) => right.lastUsedAt.getTime() - left.lastUsedAt.getTime())
+        .map((entry) => {
+        const details = `${entry.source}, conf=${entry.confidence.toFixed(2)}, used ${entry.usageCount}x`;
+        return `  ${theme.hl(entry.id)} ${theme.dim(`(${details})`)}\n    ${entry.fact}`;
+    });
+    return `${theme.brand('Auto memory')}\n${lines.join('\n')}\n`;
+}
+function usage() {
+    return ('Usage: /memory [list] | /memory add <key> <value> | /memory remove <key> | /memory clear | /memory search <query>\n' +
+        '       /memory auto [list|clear|forget <id>]\n');
+}
+function autoUsage() {
+    return 'Usage: /memory auto [list|clear|forget <id>]\n';
+}

package/dist/commands/metrics-cmd.js

@@ -0,0 +1,97 @@
+import { theme } from '../ui/theme.js';
+export class MetricsCollector {
+    metrics = [];
+    responseTimes = [];
+    tokenThroughputs = [];
+    toolCalls = [];
+    sessionStartedAt = Date.now();
+    record(name, value, unit) {
+        const metric = {
+            name,
+            value,
+            unit,
+            timestamp: Date.now(),
+        };
+        this.metrics.push(metric);
+    }
+    recordResponseTime(ms) {
+        const metric = this.createMetric('response', ms, 'ms');
+        this.responseTimes.push(metric);
+        this.metrics.push(metric);
+    }
+    recordTokenThroughput(tokensPerSec) {
+        const metric = this.createMetric('throughput', tokensPerSec, 'tokens/s');
+        this.tokenThroughputs.push(metric);
+        this.metrics.push(metric);
+    }
+    recordToolCall(name, ms) {
+        const metric = this.createMetric(name, ms, 'ms');
+        this.toolCalls.push(metric);
+        this.metrics.push(metric);
+    }
+    summary() {
+        return {
+            avgResponseMs: average(this.responseTimes),
+            avgTokensPerSec: average(this.tokenThroughputs),
+            totalTurns: this.responseTimes.length,
+            avgToolCallMs: average(this.toolCalls),
+            sessionDurationMs: Math.max(0, Date.now() - this.sessionStartedAt),
+        };
+    }
+    topSlowestToolCalls(limit = 5) {
+        return [...this.toolCalls]
+            .sort((left, right) => right.value - left.value || left.name.localeCompare(right.name))
+            .slice(0, limit);
+    }
+    reset() {
+        this.metrics.length = 0;
+        this.responseTimes.length = 0;
+        this.tokenThroughputs.length = 0;
+        this.toolCalls.length = 0;
+        this.sessionStartedAt = Date.now();
+    }
+    createMetric(name, value, unit) {
+        return {
+            name,
+            value,
+            unit,
+            timestamp: Date.now(),
+        };
+    }
+}
+export function metricsCommand(collector) {
+    const summary = collector.summary();
+    const slowestToolCalls = collector.topSlowestToolCalls(5);
+    return [
+        theme.brand('Performance metrics'),
+        `  avg response time: ${theme.hl(formatDuration(summary.avgResponseMs))}`,
+        `  avg throughput:    ${theme.hl(formatTokensPerSec(summary.avgTokensPerSec))}`,
+        `  avg tool call:     ${theme.hl(formatDuration(summary.avgToolCallMs))}`,
+        `  total turns:       ${theme.hl(String(summary.totalTurns))}`,
+        `  session duration:  ${theme.hl(formatDuration(summary.sessionDurationMs))}`,
+        '',
+        theme.brand('Top-5 slowest tool calls'),
+        slowestToolCalls.length > 0
+            ? slowestToolCalls
+                .map((metric, index) => `  ${theme.dim(`${index + 1}.`)} ${metric.name} ${theme.hl(formatDuration(metric.value))}`)
+                .join('\n')
+            : `  ${theme.dim('none recorded yet')}`,
+        '',
+    ].join('\n');
+}
+export function formatDuration(ms) {
+    const safeMs = Number.isFinite(ms) ? Math.max(0, ms) : 0;
+    if (safeMs < 1000)
+        return `${Math.round(safeMs)}ms`;
+    return `${(safeMs / 1000).toFixed(1).replace(/\.0$/, '')}s`;
+}
+function average(metrics) {
+    if (metrics.length === 0)
+        return 0;
+    const total = metrics.reduce((sum, metric) => sum + metric.value, 0);
+    return total / metrics.length;
+}
+function formatTokensPerSec(tokensPerSec) {
+    const safe = Number.isFinite(tokensPerSec) ? Math.max(0, tokensPerSec) : 0;
+    return `${safe.toFixed(1)} tokens/s`;
+}

package/dist/commands/mode-prefix.js

@@ -0,0 +1,30 @@
+export function parseModePrefix(input) {
+    const trimmed = input.trim();
+    const match = trimmed.match(/^\/(ask|code|architect)(?:\s+(.*))?$/i);
+    if (!match) {
+        return { mode: null, message: input };
+    }
+    return {
+        mode: match[1].toLowerCase(),
+        message: (match[2] ?? '').trim(),
+    };
+}
+export function resolveModePrefix(input) {
+    const parsed = parseModePrefix(input);
+    if (!parsed.mode) {
+        return { matched: false, consumed: false };
+    }
+    if (!parsed.message) {
+        return {
+            matched: true,
+            consumed: true,
+            usage: `usage: /${parsed.mode} <message>`,
+        };
+    }
+    return {
+        matched: true,
+        consumed: false,
+        forwardInput: parsed.message,
+        turnMode: parsed.mode,
+    };
+}

package/dist/commands/multi-cmd.js

@@ -0,0 +1,44 @@
+import { theme } from '../ui/theme.js';
+const DEFAULT_MAX_TOKENS = 2048;
+const MAX_MODELS = 4;
+const MODEL_STYLERS = [theme.brand, theme.user, theme.assistant, theme.hl];
+export function buildMultiConfig(args) {
+    const raw = args.join(' ').trim();
+    if (!raw) {
+        return { error: multiUsage('Provide 1 to 4 comma-separated model names.') };
+    }
+    const models = raw
+        .split(',')
+        .map((model) => model.trim())
+        .filter((model) => model.length > 0);
+    if (models.length === 0) {
+        return { error: multiUsage('Provide 1 to 4 comma-separated model names.') };
+    }
+    if (models.length > MAX_MODELS) {
+        return { error: multiUsage(`You can compare at most ${MAX_MODELS} models at once.`) };
+    }
+    return {
+        models,
+        maxTokens: DEFAULT_MAX_TOKENS,
+    };
+}
+export function formatMultiResponses(responses) {
+    if (responses.length === 0) {
+        return `${theme.warn('No model responses to compare.')}\n`;
+    }
+    const blocks = responses.map((response, index) => {
+        const style = MODEL_STYLERS[index % MODEL_STYLERS.length];
+        const header = style(`Model ${index + 1}: ${response.model}`);
+        const metrics = theme.dim(`tokens: ${response.tokens.toLocaleString()}  •  duration: ${formatDuration(response.durationMs)}`);
+        return [header, response.content.trim() || theme.dim('(empty response)'), metrics].join('\n');
+    });
+    return `${theme.brand('Multi-model comparison')}\n\n${blocks.join(`\n\n${theme.dim('─'.repeat(48))}\n\n`)}\n`;
+}
+function multiUsage(reason) {
+    return `${theme.warn(reason)}\nusage: /multi <model-a,model-b[,model-c,model-d]>\nexample: /multi gpt-4o,gpt-4o-mini\n`;
+}
+function formatDuration(durationMs) {
+    if (durationMs < 1000)
+        return `${durationMs}ms`;
+    return `${(durationMs / 1000).toFixed(2)}s`;
+}