icopilot 2.2.0

package/dist/commands/agent-cmd.js

@@ -0,0 +1,144 @@
+import path from 'node:path';
+import { getCustomAgent, loadCustomAgents } from '../agents/custom-agents.js';
+import { theme } from '../ui/theme.js';
+const BUILT_IN_AGENT_CONFIGS = {
+    explore: {
+        type: 'explore',
+        systemPrompt: 'You are a codebase exploration agent. Analyze code structure, find relevant files, explain architecture. Use grep/glob tools to search. Be concise and factual.',
+    },
+    task: {
+        type: 'task',
+        systemPrompt: 'You are a task execution agent. Run commands, report results concisely. On success: brief summary. On failure: full error output.',
+    },
+    review: {
+        type: 'review',
+        systemPrompt: 'You are a code review agent. Focus only on real bugs, security issues, and logic errors. Never comment on style. Be extremely concise.',
+    },
+    plan: {
+        type: 'plan',
+        systemPrompt: "You are a planning agent. Break down the user's goal into numbered implementation steps. Each step should be actionable and specific.",
+    },
+};
+export function getAgentConfig(type) {
+    return { ...BUILT_IN_AGENT_CONFIGS[type] };
+}
+export function buildAgentPrompt(type, query, cwd) {
+    const config = getAgentConfig(type);
+    const trimmedQuery = query.trim() || defaultQuery(type);
+    return [
+        config.systemPrompt,
+        '',
+        'Project context:',
+        `- Current working directory: ${cwd}`,
+        `- Project folder name: ${path.basename(cwd) || cwd}`,
+        `- Agent type: ${type}`,
+        '',
+        'Task:',
+        trimmedQuery,
+    ].join('\n');
+}
+export function formatAgentResult(result) {
+    const metrics = theme.dim(`${result.tokensUsed} tokens • ${result.durationMs}ms`);
+    return `${theme.badge(result.type.toUpperCase())} ${metrics}\n${result.output}\n`;
+}
+export function agentCommand(args, cwd) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand)
+        return usage();
+    if (subcommand.toLowerCase() === 'list')
+        return listAgents(cwd);
+    loadCustomAgents(cwd);
+    const customAgent = getCustomAgent(subcommand);
+    if (!isAgentType(subcommand) && !customAgent) {
+        return `${theme.warn(`unknown agent subcommand: ${subcommand}`)}\n${usage()}`;
+    }
+    const startedAt = Date.now();
+    const query = normalizeQuery(subcommand, rest, customAgent);
+    const prompt = customAgent
+        ? buildCustomAgentPrompt(customAgent, query, cwd)
+        : buildAgentPrompt(subcommand, query, cwd);
+    const result = {
+        type: subcommand,
+        output: prompt,
+        tokensUsed: estimateTokens(prompt),
+        durationMs: Math.max(0, Date.now() - startedAt),
+    };
+    return formatAgentResult(result);
+}
+function usage() {
+    return [
+        theme.brand('Agent command'),
+        '  /agent explore <question>          delegate repository exploration',
+        '  /agent task <command-description>  delegate task execution',
+        '  /agent review [target]             delegate code review (default: staged changes)',
+        '  /agent plan <goal>                 delegate planning',
+        '  /agent <custom-agent> [task]       run a project custom agent from .icopilot/agents',
+        '  /agent list                        show available agents',
+        '',
+    ].join('\n');
+}
+function listAgents(cwd) {
+    const builtInLines = Object.keys(BUILT_IN_AGENT_CONFIGS).map((type) => {
+        const config = getAgentConfig(type);
+        return `  ${theme.ok(type)}  ${theme.dim(`- ${config.systemPrompt}`)}`;
+    });
+    const customAgents = loadCustomAgents(cwd);
+    const customLines = customAgents.length
+        ? customAgents.map((agent) => `  ${theme.ok(agent.name)}  ${theme.dim(`- ${agent.description}`)}`)
+        : [`  ${theme.dim('none found in .icopilot/agents/')}`];
+    return [
+        theme.brand('Available agents'),
+        theme.brand('Built-in'),
+        builtInLines.join('\n'),
+        '',
+        theme.brand('Custom'),
+        customLines.join('\n'),
+        '',
+    ].join('\n');
+}
+function isAgentType(value) {
+    return value === 'explore' || value === 'task' || value === 'review' || value === 'plan';
+}
+function normalizeQuery(type, args, customAgent) {
+    const query = args.join(' ').trim();
+    if (query)
+        return query;
+    if (customAgent)
+        return `Complete the next task as the "${customAgent.name}" agent.`;
+    return defaultQuery(type);
+}
+function defaultQuery(type) {
+    switch (type) {
+        case 'explore':
+            return 'Explore the current codebase and summarize the most relevant files and architecture.';
+        case 'task':
+            return 'Run the requested task in the current project and report the outcome.';
+        case 'review':
+            return 'Review the staged changes for bugs, security issues, and logic errors.';
+        case 'plan':
+            return "Break down the user's goal into an actionable implementation plan.";
+    }
+}
+function estimateTokens(text) {
+    return Math.max(1, Math.ceil(text.trim().length / 4));
+}
+function buildCustomAgentPrompt(agent, query, cwd) {
+    const metadata = [
+        agent.model ? `- Preferred model: ${agent.model}` : undefined,
+        agent.temperature !== undefined ? `- Temperature: ${agent.temperature}` : undefined,
+        agent.maxTokens !== undefined ? `- Max tokens: ${agent.maxTokens}` : undefined,
+        agent.tools?.length ? `- Allowed tools: ${agent.tools.join(', ')}` : undefined,
+    ].filter(Boolean);
+    return [
+        agent.systemPrompt,
+        '',
+        'Project context:',
+        `- Current working directory: ${cwd}`,
+        `- Project folder name: ${path.basename(cwd) || cwd}`,
+        `- Agent type: ${agent.name}`,
+        ...metadata,
+        '',
+        'Task:',
+        query.trim(),
+    ].join('\n');
+}

package/dist/commands/alias-cmd.js

@@ -0,0 +1,132 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+const NAME_RE = /^[a-z0-9][a-z0-9_-]{0,32}$/i;
+const ALIASES_ENV = 'ICOPILOT_ALIASES_PATH';
+export function aliasesPath() {
+    return process.env[ALIASES_ENV] || path.join(os.homedir(), '.icopilot', 'aliases.json');
+}
+export function loadAliases() {
+    const file = aliasesPath();
+    if (!fs.existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter(isAlias).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    catch {
+        return [];
+    }
+}
+export function saveAlias(name, expansion) {
+    const trimmedName = name.trim();
+    if (!NAME_RE.test(trimmedName)) {
+        throw new Error('alias name must match /^[a-z0-9][a-z0-9_-]{0,32}$/i');
+    }
+    const trimmedExpansion = expansion.trim();
+    if (!trimmedExpansion) {
+        throw new Error('alias expansion is required');
+    }
+    const aliases = loadAliases();
+    const existing = aliases.find((alias) => alias.name.localeCompare(trimmedName, undefined, { sensitivity: 'accent' }) === 0);
+    const alias = {
+        name: trimmedName,
+        expansion: trimmedExpansion,
+        createdAt: existing?.createdAt || new Date().toISOString(),
+    };
+    const next = aliases.filter((entry) => entry.name.localeCompare(trimmedName, undefined, { sensitivity: 'accent' }) !== 0);
+    next.push(alias);
+    writeAliases(next);
+    return alias;
+}
+export function deleteAlias(name) {
+    const trimmedName = name.trim();
+    const aliases = loadAliases();
+    const next = aliases.filter((alias) => alias.name.localeCompare(trimmedName, undefined, { sensitivity: 'accent' }) !== 0);
+    if (next.length === aliases.length)
+        return false;
+    writeAliases(next);
+    return true;
+}
+export function resolveAlias(input, aliases) {
+    const trimmed = input.trimStart();
+    if (!trimmed)
+        return null;
+    const ordered = [...aliases].sort((a, b) => b.name.length - a.name.length || a.name.localeCompare(b.name));
+    for (const alias of ordered) {
+        if (!trimmed.toLowerCase().startsWith(alias.name.toLowerCase()))
+            continue;
+        const remainder = trimmed.slice(alias.name.length);
+        if (remainder.length > 0 && !/^\s/.test(remainder))
+            continue;
+        const suffix = remainder.trimStart();
+        return suffix ? `${alias.expansion} ${suffix}` : alias.expansion;
+    }
+    return null;
+}
+export function aliasCommand(args) {
+    const [subcommandRaw, ...rest] = args;
+    const subcommand = (subcommandRaw || 'list').toLowerCase();
+    try {
+        switch (subcommand) {
+            case 'list':
+                return listCommand();
+            case 'set':
+                return setCommand(rest);
+            case 'remove':
+            case 'delete':
+            case 'rm':
+                return removeCommand(rest);
+            default:
+                return usage();
+        }
+    }
+    catch (error) {
+        return theme.err(`alias: ${error.message}\n`);
+    }
+}
+function listCommand() {
+    const aliases = loadAliases();
+    if (aliases.length === 0)
+        return theme.dim('No aliases saved.\n');
+    const lines = aliases.map((alias) => `  ${theme.hl(alias.name)}  ${theme.dim('→')} ${alias.expansion}`);
+    return `${theme.brand('Aliases')}\n${lines.join('\n')}\n`;
+}
+function setCommand(args) {
+    const [name, ...expansionParts] = args;
+    const expansion = expansionParts.join(' ').trim();
+    if (!name || !expansion)
+        return theme.warn('usage: /alias set <name> <expansion...>\n');
+    const alias = saveAlias(name, expansion);
+    return theme.ok(`✔ saved alias ${alias.name} ${theme.dim('→')} ${alias.expansion}\n`);
+}
+function removeCommand(args) {
+    const [name] = args;
+    if (!name)
+        return theme.warn('usage: /alias remove <name>\n');
+    return deleteAlias(name)
+        ? theme.ok(`✔ deleted alias ${name}\n`)
+        : theme.warn(`alias not found: ${name}\n`);
+}
+function usage() {
+    return theme.warn('usage: /alias [list|set|remove]\n');
+}
+function writeAliases(aliases) {
+    const file = aliasesPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const sorted = [...aliases].sort((a, b) => a.name.localeCompare(b.name));
+    fs.writeFileSync(file, `${JSON.stringify(sorted, null, 2)}\n`, 'utf8');
+}
+function isAlias(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const alias = value;
+    return (typeof alias.name === 'string' &&
+        typeof alias.expansion === 'string' &&
+        typeof alias.createdAt === 'string' &&
+        NAME_RE.test(alias.name) &&
+        alias.expansion.trim().length > 0);
+}

package/dist/commands/bookmark-cmd.js

@@ -0,0 +1,77 @@
+import { addBookmark, deleteBookmark, getBookmark, listBookmarks } from '../session/bookmarks.js';
+import { theme } from '../ui/theme.js';
+export function bookmarkCommand(session, rest) {
+    const action = rest[0]?.toLowerCase() || 'list';
+    if (action === 'add') {
+        const name = rest[1];
+        if (!name)
+            return { message: usage() };
+        const index = session.state.messages.length - 1;
+        if (index < 0)
+            return { message: theme.warn('No messages to bookmark.') };
+        const preview = messagePreview(session.state.messages[index]);
+        const bookmark = addBookmark(session.state.id, name, index, preview);
+        return { message: `${theme.ok('Bookmarked')} ${bookmark.name} at message ${bookmark.index}.` };
+    }
+    if (action === 'go') {
+        const name = rest[1];
+        if (!name)
+            return { message: usage() };
+        const bookmark = getBookmark(session.state.id, name);
+        if (!bookmark)
+            return { message: theme.warn(`Bookmark not found: ${name}`) };
+        return {
+            message: `${theme.ok('Rewind')} to ${bookmark.name} at message ${bookmark.index}.`,
+            rewindTo: bookmark.index,
+        };
+    }
+    if (action === 'delete' || action === 'del' || action === 'rm') {
+        const name = rest[1];
+        if (!name)
+            return { message: usage() };
+        const deleted = deleteBookmark(session.state.id, name);
+        return {
+            message: deleted
+                ? `${theme.ok('Deleted')} bookmark ${name}.`
+                : theme.warn(`Bookmark not found: ${name}`),
+        };
+    }
+    if (action !== 'list')
+        return { message: usage() };
+    const bookmarks = listBookmarks(session.state.id);
+    if (!bookmarks.length)
+        return { message: 'No bookmarks for this session.' };
+    return {
+        message: bookmarks
+            .map((bookmark) => `${bookmark.name} @ ${bookmark.index}: ${bookmark.preview}`)
+            .join('\n'),
+    };
+}
+function usage() {
+    return 'Usage: /bookmark [list] | /bookmark add <name> | /bookmark go <name> | /bookmark delete <name>';
+}
+function messagePreview(message) {
+    return contentToText(message.content).slice(0, 80);
+}
+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);
+}

package/dist/commands/changelog-cmd.js

@@ -0,0 +1,99 @@
+import simpleGit from 'simple-git';
+export async function buildChangelogPrompt(args, cwd) {
+    const git = simpleGit({ baseDir: cwd });
+    try {
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            return buildEmptyPayload(`Cannot generate a changelog because "${cwd}" is not a git repository.`);
+        }
+        const parsed = parseArgs(args);
+        if (parsed.kind === 'range') {
+            const commits = mapCommits((await git.log([`${parsed.fromRef}..${parsed.toRef}`])).all);
+            return buildPayload(commits, parsed.fromRef, parsed.toRef);
+        }
+        if (parsed.kind === 'last') {
+            const commits = mapCommits((await git.log({ maxCount: parsed.count })).all);
+            return buildPayload(commits, commits.at(-1)?.hash ?? 'HEAD', 'HEAD');
+        }
+        const tags = await git.tags();
+        if (tags.latest) {
+            const commits = mapCommits((await git.log([`${tags.latest}..HEAD`])).all);
+            return buildPayload(commits, tags.latest, 'HEAD');
+        }
+        const commits = mapCommits((await git.log({ maxCount: 20 })).all);
+        return buildPayload(commits, commits.at(-1)?.hash ?? 'HEAD', 'HEAD');
+    }
+    catch (error) {
+        if (isNotGitRepositoryError(error)) {
+            return buildEmptyPayload(`Cannot generate a changelog because "${cwd}" is not a git repository.`);
+        }
+        throw error;
+    }
+}
+function parseArgs(args) {
+    if (args.length === 0) {
+        return { kind: 'default' };
+    }
+    if (args[0] === '--last') {
+        const count = Number.parseInt(args[1] ?? '', 10);
+        if (!Number.isInteger(count) || count <= 0) {
+            throw new Error('Usage: /changelog [<from>..<to> | --last <n>]');
+        }
+        return { kind: 'last', count };
+    }
+    if (args.length === 1 && args[0].includes('..')) {
+        const [fromRef, toRef] = args[0].split('..');
+        if (!fromRef || !toRef) {
+            throw new Error('Usage: /changelog [<from>..<to> | --last <n>]');
+        }
+        return { kind: 'range', fromRef, toRef };
+    }
+    throw new Error('Usage: /changelog [<from>..<to> | --last <n>]');
+}
+function mapCommits(entries) {
+    return entries.map((entry) => ({
+        hash: entry.hash,
+        subject: entry.message,
+        author: entry.author_name,
+        date: entry.date,
+    }));
+}
+function buildPayload(commits, fromRef, toRef) {
+    return {
+        commits,
+        fromRef,
+        toRef,
+        prompt: buildPrompt(commits, fromRef, toRef),
+    };
+}
+function buildEmptyPayload(message) {
+    return {
+        commits: [],
+        fromRef: '',
+        toRef: '',
+        prompt: message,
+    };
+}
+function buildPrompt(commits, fromRef, toRef) {
+    const commitLines = commits.length === 0
+        ? ['- No commits found in the selected range.']
+        : commits.map((commit) => `- ${commit.subject} (${commit.hash}) — ${commit.author} on ${commit.date}`);
+    return [
+        `Generate a markdown changelog entry for git commits from ${fromRef} to ${toRef}.`,
+        'Instructions:',
+        '- Group commits by type using these sections when applicable: Features, Fixes, Chores, Documentation.',
+        '- Infer the type from conventional commit prefixes such as feat, fix, chore, and docs.',
+        '- Include a dedicated Breaking Changes section when any commit indicates a breaking change.',
+        '- Keep the writing concise, user-facing, and release-note friendly.',
+        '- Output markdown only.',
+        '',
+        'Commits:',
+        ...commitLines,
+    ].join('\n');
+}
+function isNotGitRepositoryError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /not a git repository/i.test(error.message);
+}

package/dist/commands/changes-cmd.js

@@ -0,0 +1,120 @@
+import simpleGit from 'simple-git';
+import { theme } from '../ui/theme.js';
+const EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+let activeSession = null;
+export async function ensureChangeTracking(session) {
+    const resolved = resolveSession(session);
+    activeSession = resolved;
+    if (resolved.state.changeTracking) {
+        return resolved.state.changeTracking;
+    }
+    const sessionStartRef = await createSnapshotRef(resolved.state.cwd);
+    const tracking = {
+        sessionStartRef,
+        sessionStartAt: new Date().toISOString(),
+        turnSnapshots: [],
+    };
+    resolved.state.changeTracking = tracking;
+    resolved.persist();
+    return tracking;
+}
+export async function recordTurnSnapshot(session) {
+    const resolved = resolveSession(session);
+    const tracking = await ensureChangeTracking(resolved);
+    const turnIndex = countAssistantMessages(resolved);
+    const ref = await createSnapshotRef(resolved.state.cwd);
+    const snapshot = {
+        turnIndex,
+        ref,
+        createdAt: new Date().toISOString(),
+    };
+    if (tracking.turnSnapshots.at(-1)?.turnIndex === turnIndex) {
+        tracking.turnSnapshots[tracking.turnSnapshots.length - 1] = snapshot;
+    }
+    else {
+        tracking.turnSnapshots.push(snapshot);
+    }
+    resolved.state.changeTracking = tracking;
+    resolved.persist();
+    return snapshot;
+}
+export async function showChangesSinceSessionStart(session) {
+    const resolved = resolveSession(session);
+    const tracking = await ensureChangeTracking(resolved);
+    return formatDiff(await diffSinceRef(resolved.state.cwd, tracking.sessionStartRef), 'session start', 'No uncommitted changes since session start.');
+}
+export async function showChangesSinceLastTurn(session) {
+    const resolved = resolveSession(session);
+    const tracking = await ensureChangeTracking(resolved);
+    const snapshot = tracking.turnSnapshots.at(-1);
+    if (!snapshot) {
+        return theme.warn('No AI turns have been recorded yet.\n');
+    }
+    return formatDiff(await diffSinceRef(resolved.state.cwd, snapshot.ref), `AI turn ${snapshot.turnIndex + 1}`, 'No uncommitted changes since the last AI turn.');
+}
+export async function showChangesSinceMessage(turnIndex, session) {
+    const resolved = resolveSession(session);
+    const tracking = await ensureChangeTracking(resolved);
+    const snapshot = tracking.turnSnapshots.find((entry) => entry.turnIndex === turnIndex);
+    if (!snapshot) {
+        return theme.warn(`No snapshot recorded for AI turn ${turnIndex + 1}.\n`);
+    }
+    return formatDiff(await diffSinceRef(resolved.state.cwd, snapshot.ref), `AI turn ${turnIndex + 1}`, `No uncommitted changes since AI turn ${turnIndex + 1}.`);
+}
+function resolveSession(session) {
+    const resolved = session ?? activeSession;
+    if (!resolved) {
+        throw new Error('No active session is available for /changes.');
+    }
+    return resolved;
+}
+async function createSnapshotRef(cwd) {
+    const git = createGit(cwd);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        throw new Error(`Not a git repository: ${cwd}`);
+    }
+    const snapshot = (await git.raw(['stash', 'create', 'icli-turn-snapshot'])).trim();
+    if (snapshot)
+        return snapshot;
+    try {
+        return (await git.raw(['rev-parse', '--verify', 'HEAD'])).trim();
+    }
+    catch {
+        return EMPTY_TREE_SHA;
+    }
+}
+async function diffSinceRef(cwd, ref) {
+    const git = createGit(cwd);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        throw new Error(`Not a git repository: ${cwd}`);
+    }
+    return git.diff([ref]);
+}
+function createGit(cwd) {
+    return simpleGit({ baseDir: cwd });
+}
+function countAssistantMessages(session) {
+    return session.state.messages.filter((message) => message.role === 'assistant').length;
+}
+function formatDiff(diff, label, emptyMessage) {
+    if (!diff.trim()) {
+        return theme.dim(`${emptyMessage}\n`);
+    }
+    return `${theme.hl(`Changes since ${label}:`)}\n${colorize(diff)}\n`;
+}
+function colorize(diff) {
+    return diff
+        .split('\n')
+        .map((line) => line.startsWith('+') && !line.startsWith('+++')
+        ? theme.ok(line)
+        : line.startsWith('-') && !line.startsWith('---')
+            ? theme.err(line)
+            : line.startsWith('@@')
+                ? theme.hl(line)
+                : line.startsWith('diff ') || line.startsWith('index ')
+                    ? theme.dim(line)
+                    : line)
+        .join('\n');
+}