icopilot 2.2.0

package/dist/commands/context-cmd.js

@@ -0,0 +1,247 @@
+import { config } from '../config.js';
+import { renderGitContextBlock } from '../context/git-context.js';
+import { PinnedContext } from '../context/pinned.js';
+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 { showContextUsage } from './context-viz-cmd.js';
+const FILE_REF_HEADER = '### Referenced files';
+export function buildContextBreakdown(session) {
+    const systemPrompt = session.state.systemPrompt ??
+        (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 pinnedBlock = PinnedContext.fromJSON(session.state.pinned).render();
+    const gitBlock = renderGitContextBlock(session.state.gitContext ?? []);
+    let historyTokens = 0;
+    let fileTokens = 0;
+    let toolTokens = 0;
+    for (const message of session.state.messages) {
+        const role = String(message.role || 'message');
+        const content = contentToText(message.content);
+        if (role === 'user') {
+            const { mainText, refText } = splitFileRefs(content);
+            historyTokens += safeCountTokens(mainText);
+            fileTokens += safeCountTokens(refText);
+            continue;
+        }
+        if (role === 'assistant') {
+            historyTokens += safeCountTokens(content);
+            toolTokens += safeCountTokens(toolCallsToText(message.tool_calls));
+            continue;
+        }
+        if (role === 'tool') {
+            toolTokens += safeCountTokens(content);
+            toolTokens += safeCountTokens(typeof message.tool_call_id === 'string'
+                ? message.tool_call_id
+                : '');
+            continue;
+        }
+        historyTokens += safeCountTokens(content);
+    }
+    const sources = [
+        source('System prompt', 'system', safeCountTokens(systemPrompt)),
+        source('Style profile', 'system', safeCountTokens(styleBlock)),
+        source('Conventions', 'system', safeCountTokens(conventionBlock)),
+        source('File references', 'file', fileTokens),
+        source('Memory', 'memory', safeCountTokens(memoryBlock)),
+        source('Pinned files', 'pinned', safeCountTokens(pinnedBlock)),
+        source('Git context', 'git', safeCountTokens(gitBlock)),
+        source('Conversation history', 'history', historyTokens),
+        source('Tool results', 'history', toolTokens),
+    ];
+    const total = sources.reduce((sum, entry) => sum + entry.tokens, 0);
+    for (const entry of sources) {
+        entry.percentage = total > 0 ? (entry.tokens / total) * 100 : 0;
+    }
+    const budget = config.contextWindow;
+    return {
+        sources,
+        total,
+        budget,
+        remaining: Math.max(0, budget - total),
+    };
+}
+export function renderContextBreakdown(breakdown) {
+    const usedPct = breakdown.budget > 0 ? (breakdown.total / breakdown.budget) * 100 : 0;
+    const status = usedPct >= 100
+        ? theme.err('over budget')
+        : usedPct >= config.contextWarn * 100
+            ? theme.warn('approaching budget')
+            : theme.ok('healthy');
+    const lines = [
+        theme.brand('Context hub'),
+        `  used:      ${theme.hl(String(breakdown.total))} tk / ${theme.hl(String(breakdown.budget))} tk`,
+        `  budget:    ${renderBudgetBar(breakdown.total, breakdown.budget, 28)} ${theme.dim(`(${usedPct.toFixed(1)}%)`)}`,
+        `  remaining: ${breakdown.remaining > 0 ? theme.ok(String(breakdown.remaining)) : theme.err(String(breakdown.remaining))} tk`,
+        `  status:    ${status}`,
+        '',
+        theme.brand('Sources'),
+        ...breakdown.sources.map((entry) => renderSourceLine(entry, breakdown.total)),
+        '',
+    ];
+    return lines.join('\n');
+}
+export function contextCommand(args, session) {
+    const breakdown = buildContextBreakdown(session);
+    const subcommand = args[0]?.toLowerCase();
+    switch (subcommand) {
+        case undefined:
+        case '':
+            return showContextUsage(session);
+        case 'sources':
+            return renderSources(breakdown);
+        case 'budget':
+            return renderBudget(breakdown);
+        case 'trim':
+            return renderTrimSuggestions(breakdown);
+        default:
+            return `${theme.warn(`unknown /context subcommand: ${subcommand}`)}\n${theme.dim('usage: /context [sources|budget|trim]')}\n`;
+    }
+}
+function renderSources(breakdown) {
+    return [
+        theme.brand('Context sources'),
+        ...breakdown.sources.map((entry) => `  ${colorForType(entry.type)(entry.name.padEnd(22))} ${theme.hl(String(entry.tokens).padStart(6))} tk  ${theme.dim(`${entry.percentage.toFixed(1).padStart(5)}%`)}  ${theme.dim(`(${entry.type})`)}`),
+        '',
+    ].join('\n');
+}
+function renderBudget(breakdown) {
+    const usedPct = breakdown.budget > 0 ? (breakdown.total / breakdown.budget) * 100 : 0;
+    return [
+        theme.brand('Context budget'),
+        `  ${renderBudgetBar(breakdown.total, breakdown.budget, 36)} ${theme.dim(`(${usedPct.toFixed(1)}% used)`)}`,
+        `  remaining: ${breakdown.remaining > 0 ? theme.ok(String(breakdown.remaining)) : theme.err(String(breakdown.remaining))} tk`,
+        '',
+    ].join('\n');
+}
+function renderTrimSuggestions(breakdown) {
+    const candidates = breakdown.sources
+        .filter((entry) => entry.tokens > 0 && entry.name !== 'System prompt')
+        .sort((left, right) => right.tokens - left.tokens || left.name.localeCompare(right.name));
+    if (!candidates.length) {
+        return [theme.brand('Trim suggestions'), `  ${theme.dim('No context loaded yet.')}`, ''].join('\n');
+    }
+    return [
+        theme.brand('Trim suggestions'),
+        ...candidates.map((entry, index) => {
+            const suggestion = trimSuggestion(entry);
+            return `  ${index + 1}. ${colorForType(entry.type)(entry.name)} ${theme.hl(`(${entry.tokens} tk)`)} — ${suggestion}`;
+        }),
+        '',
+    ].join('\n');
+}
+function renderSourceLine(entry, total) {
+    const label = colorForType(entry.type)(entry.name.padEnd(22));
+    return `  ${label} ${theme.hl(String(entry.tokens).padStart(6))} tk  ${renderShareBar(entry.tokens, total, 18)} ${theme.dim(`${entry.percentage.toFixed(1).padStart(5)}%`)}`;
+}
+function renderBudgetBar(used, total, width) {
+    const ratio = total <= 0 ? 0 : Math.max(0, Math.min(1, used / total));
+    const fill = Math.round(ratio * width);
+    const rawBar = '█'.repeat(fill) + '░'.repeat(Math.max(0, width - fill));
+    const colored = ratio >= 1
+        ? theme.err(rawBar)
+        : ratio >= config.contextWarn
+            ? theme.warn(rawBar)
+            : theme.ok(rawBar);
+    return `[${colored}]`;
+}
+function renderShareBar(used, total, width) {
+    const ratio = total <= 0 ? 0 : Math.max(0, Math.min(1, used / total));
+    const fill = Math.round(ratio * width);
+    return `[${'█'.repeat(fill)}${'░'.repeat(Math.max(0, width - fill))}]`;
+}
+function trimSuggestion(entry) {
+    switch (entry.name) {
+        case 'Conversation history':
+            return 'run /compact or clear older turns';
+        case 'File references':
+            return 'remove large @file injections from the next prompt';
+        case 'Pinned files':
+            return 'unpin files you no longer need';
+        case 'Git context':
+            return 'trim the auto-injected git diff context';
+        case 'Tool results':
+            return 'compact the session to collapse verbose tool output';
+        case 'Memory':
+            return 'trim .icopilot/memory.md or .icopilot/team-memory.md to the essentials';
+        case 'System prompt':
+            return 'fixed overhead; optimize other sources first';
+        default:
+            return 'trim this source first';
+    }
+}
+function colorForType(type) {
+    switch (type) {
+        case 'system':
+            return theme.brand;
+        case 'file':
+            return theme.hl;
+        case 'memory':
+            return theme.ok;
+        case 'pinned':
+            return theme.warn;
+        case 'git':
+            return theme.assistant;
+        case 'skill':
+            return theme.assistant;
+        case 'history':
+        default:
+            return theme.dim;
+    }
+}
+function source(name, type, tokens) {
+    return { name, type, tokens, percentage: 0 };
+}
+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 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 safeCountTokens(text) {
+    if (!text)
+        return 0;
+    try {
+        return countTokensSync(text);
+    }
+    catch {
+        return Math.ceil(text.length / 4);
+    }
+}

package/dist/commands/context-viz-cmd.js

@@ -0,0 +1,43 @@
+import { theme } from '../ui/theme.js';
+import { buildContextBreakdown } from './context-cmd.js';
+export function showContextUsage(session) {
+    const breakdown = buildContextBreakdown(session);
+    const buckets = summarizeContextUsage(breakdown);
+    const usedPct = breakdown.budget > 0 ? Math.round((breakdown.total / breakdown.budget) * 100) : 0;
+    const lines = [
+        theme.brand('Context usage'),
+        `  ${renderProgressBar(breakdown.total, breakdown.budget, 16)} ${usedPct}% (${formatTokenAmount(breakdown.total)} / ${formatTokenAmount(breakdown.budget)} tokens)`,
+        `  ${buckets.map((bucket) => `${bucket.label}: ${formatTokenAmount(bucket.tokens)}`).join(' | ')}`,
+        '',
+        theme.brand('Breakdown'),
+        ...buckets.map((bucket) => `  ${bucket.label.padEnd(7)} ${formatTokenAmount(bucket.tokens).padStart(6)}  ${theme.dim(bucket.details)}`),
+        '',
+    ];
+    return lines.join('\n');
+}
+export function summarizeContextUsage(breakdown) {
+    const systemTokens = sumByType(breakdown.sources, ['system', 'memory']);
+    const historyTokens = sumByType(breakdown.sources, ['history']);
+    const fileTokens = sumByType(breakdown.sources, ['file', 'pinned', 'git', 'skill']);
+    return [
+        { label: 'System', tokens: systemTokens, details: 'prompt, style, conventions, memory' },
+        { label: 'History', tokens: historyTokens, details: 'conversation turns and tool output' },
+        { label: 'Files', tokens: fileTokens, details: 'referenced, pinned, and git context' },
+        { label: 'Free', tokens: breakdown.remaining, details: 'remaining context budget' },
+    ];
+}
+function sumByType(sources, types) {
+    return sources.reduce((sum, source) => (types.includes(source.type) ? sum + source.tokens : sum), 0);
+}
+function renderProgressBar(used, total, width) {
+    const ratio = total <= 0 ? 0 : Math.max(0, Math.min(1, used / total));
+    const fill = Math.round(ratio * width);
+    return `[${'█'.repeat(fill)}${'░'.repeat(Math.max(0, width - fill))}]`;
+}
+function formatTokenAmount(tokens) {
+    if (tokens >= 1000) {
+        const compact = (tokens / 1000).toFixed(tokens >= 10_000 ? 0 : 1);
+        return `${compact.replace(/\.0$/, '')}k`;
+    }
+    return `${tokens}`;
+}

package/dist/commands/conventions-cmd.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ConventionManager, listConventionFiles, resolveConventionPath, } from '../knowledge/conventions.js';
+import { theme } from '../ui/theme.js';
+export function conventionsCommand(args, cwd) {
+    const manager = new ConventionManager();
+    const [rawSubcommand = 'list', ...rest] = args;
+    const subcommand = rawSubcommand.toLowerCase();
+    try {
+        switch (subcommand) {
+            case 'list':
+            case 'show':
+            case 'current':
+                return listConventions(manager, cwd);
+            case 'detect':
+                return detectConventions(manager, cwd);
+            case 'check':
+                return checkConventions(manager, cwd, rest);
+            case 'add':
+                return addConvention(manager, cwd, rest);
+            default:
+                return usage();
+        }
+    }
+    catch (error) {
+        return theme.err(`conventions: ${error.message}\n`);
+    }
+}
+function listConventions(manager, cwd) {
+    const set = manager.load(cwd);
+    if (set.conventions.length === 0) {
+        return `${theme.brand('Conventions')}\n  ${theme.dim('No saved conventions. Run /conventions detect or /conventions add first.')}\n`;
+    }
+    return `${theme.brand(`Conventions ${theme.dim(`(${set.name})`)}`)}\n${set.conventions
+        .map((convention) => `  ${theme.hl(convention.name)} ${theme.dim(`[${convention.severity}]`)}\n    ${convention.rule}${convention.example ? ` ${theme.dim(`e.g. ${convention.example}`)}` : ''}`)
+        .join('\n')}\n`;
+}
+function detectConventions(manager, cwd) {
+    manager.load(cwd);
+    const detected = manager.detect(cwd);
+    if (detected.length === 0) {
+        return `${theme.brand('Conventions')}\n  ${theme.dim('No source patterns detected.')}\n`;
+    }
+    for (const convention of detected) {
+        manager.add(convention);
+    }
+    manager.save(cwd);
+    return [
+        `${theme.ok('✔ detected conventions')} ${theme.dim(`(${detected.length})`)} ${theme.hl(resolveConventionPath(cwd))}`,
+        ...detected.map((convention) => `  - ${theme.hl(convention.name)} ${theme.dim(`[${convention.severity}]`)} — ${convention.rule}`),
+        '',
+    ].join('\n');
+}
+function checkConventions(manager, cwd, args) {
+    const set = manager.load(cwd);
+    if (set.conventions.length === 0) {
+        const detected = manager.detect(cwd);
+        for (const convention of detected) {
+            manager.add(convention);
+        }
+        if (manager.getConventionSet().conventions.length === 0) {
+            return `${theme.brand('Convention check')}\n  ${theme.dim('No conventions available. Run /conventions detect or /conventions add first.')}\n`;
+        }
+    }
+    const target = args.join(' ').trim();
+    const files = target ? [resolveTargetFile(cwd, target)] : listConventionFiles(cwd);
+    if (files.length === 0) {
+        return `${theme.brand('Convention check')}\n  ${theme.dim('No files found to check.')}\n`;
+    }
+    const violations = files.flatMap((file) => {
+        const code = fs.readFileSync(file, 'utf8');
+        return manager.check(code).map((violation) => ({
+            ...violation,
+            file,
+        }));
+    });
+    if (violations.length === 0) {
+        return `${theme.ok('✔ no convention violations found')}${target ? ` ${theme.dim(path.relative(cwd, files[0] ?? target))}` : ''}\n`;
+    }
+    return [
+        `${theme.warn(`Found ${violations.length} convention violation${violations.length === 1 ? '' : 's'}.`)}`,
+        ...violations.map((violation) => formatViolation(cwd, violation)),
+        '',
+    ].join('\n');
+}
+function addConvention(manager, cwd, args) {
+    const [name, ...ruleParts] = args;
+    const rule = ruleParts.join(' ').trim();
+    if (!name || !rule)
+        return theme.warn('usage: /conventions add <name> <rule>\n');
+    manager.load(cwd);
+    manager.add({
+        id: name,
+        name,
+        description: `User-defined convention: ${name}`,
+        rule,
+        severity: 'recommended',
+    });
+    manager.save(cwd);
+    return `${theme.ok('✔ saved convention')} ${theme.hl(name)} ${theme.dim('→')} ${rule}\n`;
+}
+function resolveTargetFile(cwd, target) {
+    const resolved = path.resolve(cwd, target);
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+        throw new Error(`file not found: ${resolved}`);
+    }
+    return resolved;
+}
+function formatViolation(cwd, violation) {
+    const relativePath = violation.file ? path.relative(cwd, violation.file) : '(input)';
+    const location = violation.line ? `${relativePath}:${violation.line}` : relativePath;
+    return `  ${theme.hl(location)} ${theme.dim(`(${violation.convention.name})`)} ${violation.description}`;
+}
+function usage() {
+    return theme.warn('usage: /conventions [list|detect|check [file]|add <name> <rule>]\n');
+}

package/dist/commands/cost-cmd.js

@@ -0,0 +1,51 @@
+import { theme } from '../ui/theme.js';
+import { countTokensSync } from '../util/tokens.js';
+import { estimateCost, formatUsd, getRate } from '../util/cost.js';
+export function costCommand(session) {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for (const message of session.state.messages) {
+        const text = contentToText(message.content);
+        if (!text)
+            continue;
+        const count = countTokensSync(text);
+        if (message.role === 'assistant') {
+            outputTokens += count;
+        }
+        else {
+            inputTokens += count;
+        }
+    }
+    const model = session.state.model;
+    const rate = getRate(model);
+    const cost = estimateCost(model, inputTokens, outputTokens);
+    return ([
+        theme.brand('Cost estimate'),
+        `  model: ${theme.hl(model)}`,
+        `  input tokens: ${theme.hl(String(inputTokens))}`,
+        `  output tokens: ${theme.hl(String(outputTokens))}`,
+        `  estimated USD: ${theme.ok(formatUsd(cost))}`,
+        `  rate used: ${formatUsd(rate.input)} / ${formatUsd(rate.output)} per 1K input/output tokens`,
+    ].join('\n') + '\n');
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part !== 'object' || part === null)
+                return '';
+            if ('text' in part && typeof part.text === 'string')
+                return part.text;
+            if ('type' in part && typeof part.type === 'string')
+                return JSON.stringify(part);
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (content == null)
+        return '';
+    return JSON.stringify(content);
+}