icopilot 2.2.0

package/dist/commands/test-cmd.js

@@ -0,0 +1,146 @@
+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 directoryHasFilePrefix(cwd, prefix) {
+    try {
+        return fs.readdirSync(cwd).some((entry) => entry.startsWith(prefix));
+    }
+    catch {
+        return false;
+    }
+}
+function fileContains(cwd, fileName, needle) {
+    return readText(path.join(cwd, fileName))?.includes(needle) ?? false;
+}
+function hasGoTestFiles(dir) {
+    try {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === '.git' || entry.name === 'node_modules')
+                    continue;
+                if (hasGoTestFiles(fullPath))
+                    return true;
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith('_test.go'))
+                return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+export function detectTestFrameworks(cwd) {
+    const matches = [];
+    const pkg = readPackageJson(cwd);
+    if (typeof pkg?.scripts?.test === 'string') {
+        matches.push({
+            name: 'npm-test',
+            command: 'npm test',
+            reason: 'package.json has "scripts.test"',
+        });
+    }
+    if (directoryHasFilePrefix(cwd, 'vitest.config.')) {
+        matches.push({
+            name: 'vitest',
+            command: 'npx vitest run',
+            reason: 'vitest.config.* is present',
+        });
+    }
+    if (directoryHasFilePrefix(cwd, 'jest.config.')) {
+        matches.push({
+            name: 'jest',
+            command: 'npx jest',
+            reason: 'jest.config.* is present',
+        });
+    }
+    if (pkg?.devDependencies?.mocha) {
+        matches.push({
+            name: 'mocha',
+            command: 'npx mocha',
+            reason: 'package.json has mocha in devDependencies',
+        });
+    }
+    if (fileExists(cwd, 'pytest.ini') || fileContains(cwd, 'pyproject.toml', '[tool.pytest]')) {
+        matches.push({
+            name: 'pytest',
+            command: 'pytest',
+            reason: fileExists(cwd, 'pytest.ini')
+                ? 'pytest.ini is present'
+                : 'pyproject.toml contains [tool.pytest]',
+        });
+    }
+    if (fileExists(cwd, 'Cargo.toml')) {
+        matches.push({
+            name: 'cargo-test',
+            command: 'cargo test',
+            reason: 'Cargo.toml is present',
+        });
+    }
+    if (fileExists(cwd, 'go.mod')) {
+        matches.push({
+            name: 'go-test',
+            command: 'go test ./...',
+            reason: 'go.mod is present',
+        });
+    }
+    else if (hasGoTestFiles(cwd)) {
+        matches.push({
+            name: 'go-test-files',
+            command: 'go test ./...',
+            reason: 'found *_test.go files',
+        });
+    }
+    if (hasAnyFile(cwd, ['phpunit.xml', 'phpunit.xml.dist'])) {
+        matches.push({
+            name: 'phpunit',
+            command: 'vendor/bin/phpunit',
+            reason: fileExists(cwd, 'phpunit.xml')
+                ? 'phpunit.xml is present'
+                : 'phpunit.xml.dist is present',
+        });
+    }
+    if (fileExists(cwd, '.rspec') || fileContains(cwd, 'Gemfile', 'rspec')) {
+        matches.push({
+            name: 'rspec',
+            command: 'bundle exec rspec',
+            reason: fileExists(cwd, '.rspec') ? '.rspec is present' : 'Gemfile mentions rspec',
+        });
+    }
+    return matches;
+}
+export function testCommand(cwd) {
+    const matches = detectTestFrameworks(cwd);
+    if (matches.length === 0) {
+        return `${theme.warn('No supported test frameworks detected.')}\n${theme.dim('Add a test script or framework configuration, then try /test again.')}\n`;
+    }
+    const lines = matches.map((match) => `  ${theme.ok(match.name)}  ${theme.hl(match.command)}  ${theme.dim(`(${match.reason})`)}`);
+    return `${theme.brand('Detected test frameworks')}\n${lines.join('\n')}\n`;
+}

package/dist/commands/todo-cmd.js

@@ -0,0 +1,172 @@
+import crypto from 'node:crypto';
+import { theme } from '../ui/theme.js';
+export class TodoList {
+    items;
+    constructor(items = []) {
+        this.items = items.map(cloneTodo);
+    }
+    add(text) {
+        const item = {
+            id: crypto.randomUUID(),
+            text: text.trim(),
+            done: false,
+            createdAt: new Date().toISOString(),
+        };
+        this.items.push(item);
+        return cloneTodo(item);
+    }
+    complete(id) {
+        const item = this.items.find((candidate) => candidate.id === id);
+        if (!item)
+            return false;
+        item.done = true;
+        item.completedAt ??= new Date().toISOString();
+        return true;
+    }
+    uncomplete(id) {
+        const item = this.items.find((candidate) => candidate.id === id);
+        if (!item)
+            return false;
+        item.done = false;
+        delete item.completedAt;
+        return true;
+    }
+    remove(id) {
+        const index = this.items.findIndex((candidate) => candidate.id === id);
+        if (index < 0)
+            return false;
+        this.items.splice(index, 1);
+        return true;
+    }
+    list(filter = 'all') {
+        return this.items
+            .filter((item) => {
+            if (filter === 'pending')
+                return !item.done;
+            if (filter === 'done')
+                return item.done;
+            return true;
+        })
+            .map(cloneTodo);
+    }
+    clear() {
+        const count = this.items.length;
+        this.items = [];
+        return count;
+    }
+    toJSON() {
+        return this.items.map(cloneTodo);
+    }
+    static fromJSON(data) {
+        if (!Array.isArray(data))
+            return new TodoList();
+        const items = data.flatMap((item) => {
+            const parsed = parseTodoItem(item);
+            return parsed ? [parsed] : [];
+        });
+        return new TodoList(items);
+    }
+}
+export function todoCommand(args, todos) {
+    const [rawSubcommand = 'list', ...rest] = args;
+    const subcommand = rawSubcommand.toLowerCase();
+    if (subcommand === 'list') {
+        const filter = parseFilter(rest[0]);
+        return filter ? formatTodoList(todos, filter) : usage();
+    }
+    if (subcommand === 'add') {
+        const text = rest.join(' ').trim();
+        if (!text)
+            return usage();
+        const item = todos.add(text);
+        return `${theme.ok('Added')} ${formatMarker(item.done)} ${theme.hl(shortId(item.id))} ${item.text}\n`;
+    }
+    if (subcommand === 'done' || subcommand === 'undo' || subcommand === 'rm') {
+        const prefix = rest[0]?.trim();
+        if (!prefix)
+            return usage();
+        const match = findByPrefix(todos, prefix);
+        if (match.kind === 'missing') {
+            return `${theme.warn(`No todo matches "${prefix}".`)}\n`;
+        }
+        if (match.kind === 'ambiguous') {
+            const options = match.items.map((item) => shortId(item.id)).join(', ');
+            return `${theme.warn(`Multiple todos match "${prefix}": ${options}`)}\n`;
+        }
+        const item = match.item;
+        if (subcommand === 'done') {
+            todos.complete(item.id);
+            return `${theme.ok('Marked done')} ${formatMarker(true)} ${theme.hl(shortId(item.id))} ${item.text}\n`;
+        }
+        if (subcommand === 'undo') {
+            todos.uncomplete(item.id);
+            return `${theme.ok('Marked pending')} ${formatMarker(false)} ${theme.hl(shortId(item.id))} ${item.text}\n`;
+        }
+        todos.remove(item.id);
+        return `${theme.ok('Removed')} ${theme.hl(shortId(item.id))} ${item.text}\n`;
+    }
+    if (subcommand === 'clear') {
+        const count = todos.clear();
+        return `${theme.ok(`Cleared ${count} todo${count === 1 ? '' : 's'}.`)}\n`;
+    }
+    const filter = parseFilter(rawSubcommand);
+    return filter ? formatTodoList(todos, filter) : usage();
+}
+function formatTodoList(todos, filter = 'all') {
+    const items = todos.list(filter);
+    const suffix = filter === 'all' ? '' : ` ${theme.dim(`(${filter})`)}`;
+    const header = `${theme.brand('Todos')}${suffix}`;
+    if (items.length === 0)
+        return `${header}\n  ${theme.dim('No todos.')}\n`;
+    const lines = items.map((item) => `  ${formatMarker(item.done)} ${theme.hl(shortId(item.id))} ${item.text}`);
+    return `${header}\n${lines.join('\n')}\n`;
+}
+function formatMarker(done) {
+    return done ? theme.ok('✓') : theme.dim('○');
+}
+function parseFilter(value) {
+    if (!value)
+        return 'all';
+    if (value === 'all' || value === 'pending' || value === 'done')
+        return value;
+    return undefined;
+}
+function shortId(id) {
+    return id.slice(0, 8);
+}
+function usage() {
+    return 'Usage: /todo [list [all|pending|done]] | /todo add <text> | /todo done <id-prefix> | /todo undo <id-prefix> | /todo rm <id-prefix> | /todo clear\n';
+}
+function cloneTodo(item) {
+    return { ...item };
+}
+function parseTodoItem(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const item = value;
+    if (typeof item.id !== 'string' ||
+        typeof item.text !== 'string' ||
+        typeof item.done !== 'boolean' ||
+        typeof item.createdAt !== 'string') {
+        return null;
+    }
+    const parsed = {
+        id: item.id,
+        text: item.text,
+        done: item.done,
+        createdAt: item.createdAt,
+    };
+    if (typeof item.completedAt === 'string')
+        parsed.completedAt = item.completedAt;
+    return parsed;
+}
+function findByPrefix(todos, prefix) {
+    const matches = todos
+        .list('all')
+        .filter((item) => item.id === prefix || item.id.toLowerCase().startsWith(prefix.toLowerCase()));
+    if (matches.length === 0)
+        return { kind: 'missing' };
+    if (matches.length > 1)
+        return { kind: 'ambiguous', items: matches };
+    return { kind: 'match', item: matches[0] };
+}

package/dist/commands/tokens-cmd.js

@@ -0,0 +1,277 @@
+import { PLAN_SYSTEM, getAskSystemPrompt } from './prompts.js';
+import { loadMemoryBlock } from '../context/memory.js';
+import { loadConventionPromptContext } from '../knowledge/conventions.js';
+import { loadStylePromptContext } from '../knowledge/style-learner.js';
+import { theme } from '../ui/theme.js';
+import { countTokensSync } from '../util/tokens.js';
+import { config } from '../config.js';
+const FILE_REF_HEADER = '### Referenced files';
+export function tokensCommand(session) {
+    const baseSystemPrompt = session.state.mode === 'plan' ? PLAN_SYSTEM : getAskSystemPrompt();
+    const memoryBlock = loadMemoryBlock(session.state.cwd) ?? '';
+    const styleBlock = loadStylePromptContext(session.state.cwd) ?? '';
+    const conventionBlock = loadConventionPromptContext(session.state.cwd) ?? '';
+    const systemPrompt = segmentForText(baseSystemPrompt);
+    const stylePrompt = segmentForText(styleBlock);
+    const conventionPrompt = segmentForText(conventionBlock);
+    const memoryPrompt = segmentForText(memoryBlock);
+    const userMessages = { tokens: 0, bytes: 0 };
+    const assistantResponses = { tokens: 0, bytes: 0 };
+    const toolCalls = { tokens: 0, bytes: 0 };
+    const fileRefs = { tokens: 0, bytes: 0 };
+    const messageBreakdowns = [];
+    let fileRefBlocks = 0;
+    let assistantToolCalls = 0;
+    let toolMessages = 0;
+    for (const [index, message] of session.state.messages.entries()) {
+        const role = String(message.role || 'message');
+        const content = contentToText(message.content);
+        if (role === 'user') {
+            const { mainText, refText } = splitFileRefs(content);
+            const mainSegment = segmentForText(mainText);
+            const refSegment = segmentForText(refText);
+            userMessages.tokens += mainSegment.tokens;
+            userMessages.bytes += mainSegment.bytes;
+            fileRefs.tokens += refSegment.tokens;
+            fileRefs.bytes += refSegment.bytes;
+            if (refSegment.tokens > 0)
+                fileRefBlocks += 1;
+            messageBreakdowns.push({
+                index,
+                role,
+                tokens: mainSegment.tokens + refSegment.tokens,
+                bytes: mainSegment.bytes + refSegment.bytes,
+                details: refSegment.tokens > 0
+                    ? `${mainSegment.tokens} user + ${refSegment.tokens} refs`
+                    : `${mainSegment.tokens} user`,
+            });
+            continue;
+        }
+        if (role === 'assistant') {
+            const contentSegment = segmentForText(content);
+            assistantResponses.tokens += contentSegment.tokens;
+            assistantResponses.bytes += contentSegment.bytes;
+            const toolCallPayload = toolCallsToText(message.tool_calls);
+            const toolCallSegment = segmentForText(toolCallPayload);
+            toolCalls.tokens += toolCallSegment.tokens;
+            toolCalls.bytes += toolCallSegment.bytes;
+            if (toolCallSegment.tokens > 0)
+                assistantToolCalls += 1;
+            const totalTokens = contentSegment.tokens + toolCallSegment.tokens;
+            const totalBytes = contentSegment.bytes + toolCallSegment.bytes;
+            const detailParts = [];
+            if (contentSegment.tokens > 0)
+                detailParts.push(`${contentSegment.tokens} reply`);
+            if (toolCallSegment.tokens > 0)
+                detailParts.push(`${toolCallSegment.tokens} tool-call`);
+            messageBreakdowns.push({
+                index,
+                role,
+                tokens: totalTokens,
+                bytes: totalBytes,
+                details: detailParts.join(' + ') || undefined,
+            });
+            continue;
+        }
+        if (role === 'tool') {
+            const contentSegment = segmentForText(content);
+            const toolCallIdSegment = segmentForText(typeof message.tool_call_id === 'string'
+                ? message.tool_call_id
+                : '');
+            toolCalls.tokens += contentSegment.tokens + toolCallIdSegment.tokens;
+            toolCalls.bytes += contentSegment.bytes + toolCallIdSegment.bytes;
+            if (contentSegment.tokens > 0 || toolCallIdSegment.tokens > 0)
+                toolMessages += 1;
+            messageBreakdowns.push({
+                index,
+                role,
+                tokens: contentSegment.tokens + toolCallIdSegment.tokens,
+                bytes: contentSegment.bytes + toolCallIdSegment.bytes,
+                details: `${contentSegment.tokens} result`,
+            });
+            continue;
+        }
+        const segment = segmentForText(content);
+        if (role === 'system') {
+            systemPrompt.tokens += segment.tokens;
+            systemPrompt.bytes += segment.bytes;
+        }
+        messageBreakdowns.push({
+            index,
+            role,
+            tokens: segment.tokens,
+            bytes: segment.bytes,
+            details: role === 'system' ? `${segment.tokens} persisted system` : undefined,
+        });
+    }
+    const categories = [
+        {
+            category: 'System prompt',
+            tokens: systemPrompt.tokens,
+            percentage: 0,
+            details: session.state.mode === 'plan' ? 'plan mode prompt' : 'ask mode prompt',
+            bytes: systemPrompt.bytes,
+        },
+        {
+            category: 'Style profile',
+            tokens: stylePrompt.tokens,
+            percentage: 0,
+            details: stylePrompt.tokens > 0 ? 'loaded from .icopilot/style-profile.json' : 'none loaded',
+            bytes: stylePrompt.bytes,
+        },
+        {
+            category: 'Conventions',
+            tokens: conventionPrompt.tokens,
+            percentage: 0,
+            details: conventionPrompt.tokens > 0 ? 'loaded from .icopilot/conventions.yaml' : 'none loaded',
+            bytes: conventionPrompt.bytes,
+        },
+        {
+            category: 'User messages',
+            tokens: userMessages.tokens,
+            percentage: 0,
+            details: `${countByRole(session, 'user')} message(s)`,
+            bytes: userMessages.bytes,
+        },
+        {
+            category: 'Assistant responses',
+            tokens: assistantResponses.tokens,
+            percentage: 0,
+            details: `${countByRole(session, 'assistant')} message(s)`,
+            bytes: assistantResponses.bytes,
+        },
+        {
+            category: 'Tool calls',
+            tokens: toolCalls.tokens,
+            percentage: 0,
+            details: `${assistantToolCalls} assistant call(s), ${toolMessages} tool result(s)`,
+            bytes: toolCalls.bytes,
+        },
+        {
+            category: 'File references',
+            tokens: fileRefs.tokens,
+            percentage: 0,
+            details: `${fileRefBlocks} injected block(s)`,
+            bytes: fileRefs.bytes,
+        },
+        {
+            category: 'Memory block',
+            tokens: memoryPrompt.tokens,
+            percentage: 0,
+            details: memoryPrompt.tokens > 0
+                ? 'loaded from .icopilot memory files (including team memory)'
+                : 'none loaded',
+            bytes: memoryPrompt.bytes,
+        },
+    ];
+    const total = categories.reduce((sum, category) => sum + category.tokens, 0);
+    for (const category of categories) {
+        category.percentage = total > 0 ? (category.tokens / total) * 100 : 0;
+    }
+    const totalBytes = categories.reduce((sum, category) => sum + category.bytes, 0);
+    const budget = config.contextWindow;
+    const remaining = Math.max(0, budget - total);
+    const usedPct = budget > 0 ? (total / budget) * 100 : 0;
+    const largest = [...categories].sort((a, b) => b.tokens - a.tokens || a.category.localeCompare(b.category))[0];
+    const categoryLines = categories.map((category) => {
+        const name = category.category.padEnd(20);
+        const tokens = theme.hl(String(category.tokens).padStart(6));
+        const bytes = theme.dim(formatBytes(category.bytes).padStart(8));
+        const details = category.details ? ` ${theme.dim(`(${category.details})`)}` : '';
+        const badge = largest && largest.category === category.category && category.tokens > 0
+            ? ` ${theme.ok('← largest')}`
+            : '';
+        return `  ${name} ${tokens} tk  ${renderTokenBar(category.tokens, total, 18)}  ${bytes}${details}${badge}`;
+    });
+    const messageLines = messageBreakdowns.length > 0
+        ? messageBreakdowns.map((entry) => {
+            const label = `#${entry.index} ${entry.role}`.padEnd(16);
+            const details = entry.details ? ` ${theme.dim(`(${entry.details})`)}` : '';
+            return `  ${label} ${theme.hl(String(entry.tokens).padStart(6))} tk  ${theme.dim(formatBytes(entry.bytes).padStart(8))}${details}`;
+        })
+        : [`  ${theme.dim('No persisted messages.')}`];
+    return [
+        theme.brand('Token analysis'),
+        `  budget:    ${theme.hl(String(budget))} tk`,
+        `  used:      ${theme.hl(String(total))} tk  ${renderTokenBar(total, budget, 24)}  ${theme.dim(formatBytes(totalBytes))}`,
+        `  remaining: ${remaining > 0 ? theme.ok(String(remaining)) : theme.err(String(remaining))} tk`,
+        largest && largest.tokens > 0
+            ? `  largest:   ${theme.warn(`${largest.category} (${largest.tokens} tk, ${largest.percentage.toFixed(1)}%)`)}`
+            : `  largest:   ${theme.dim('none')}`,
+        usedPct >= 100
+            ? `  status:    ${theme.err('over budget')}`
+            : usedPct >= config.contextWarn * 100
+                ? `  status:    ${theme.warn('approaching budget')}`
+                : `  status:    ${theme.ok('healthy')}`,
+        '',
+        theme.brand('By category'),
+        ...categoryLines,
+        '',
+        theme.brand('By message'),
+        ...messageLines,
+        '',
+    ].join('\n');
+}
+export function renderTokenBar(used, total, width) {
+    const safeWidth = Math.max(1, width);
+    const ratio = total <= 0 ? 0 : Math.max(0, Math.min(1, used / total));
+    const fill = Math.round(ratio * safeWidth);
+    const bar = '█'.repeat(fill) + '░'.repeat(Math.max(0, safeWidth - fill));
+    return `[${bar}] ${Math.round(ratio * 100)}%`;
+}
+function countByRole(session, role) {
+    return session.state.messages.filter((message) => String(message.role || '') === role).length;
+}
+function splitFileRefs(text) {
+    if (!text)
+        return { mainText: '', refText: '' };
+    const markerIndex = text.indexOf(FILE_REF_HEADER);
+    if (markerIndex === -1)
+        return { mainText: text, refText: '' };
+    return {
+        mainText: text.slice(0, markerIndex).trimEnd(),
+        refText: text.slice(markerIndex),
+    };
+}
+function segmentForText(text) {
+    if (!text)
+        return { tokens: 0, bytes: 0 };
+    return {
+        tokens: countTokensSync(text),
+        bytes: Buffer.byteLength(text, 'utf8'),
+    };
+}
+function toolCallsToText(toolCalls) {
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0)
+        return '';
+    return JSON.stringify(toolCalls);
+}
+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 formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}