icopilot 2.2.0

package/dist/knowledge/style-learner.js

@@ -0,0 +1,324 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const DEFAULT_PROFILE = {
+    indentation: '2 spaces',
+    quotes: 'single',
+    semicolons: 'always',
+    trailingComma: 'always',
+    namingConvention: 'camelCase',
+    importStyle: 'named imports, single block',
+    functionStyle: 'arrow',
+    commentStyle: 'line',
+    maxLineLength: 100,
+};
+const DEFAULT_STATS = () => ({
+    indentation: {},
+    quotes: {},
+    semicolons: {},
+    trailingComma: {},
+    namingConvention: {},
+    importForms: {},
+    importGroups: 0,
+    importFiles: 0,
+    functionStyle: {},
+    commentStyle: {},
+    lineLengths: [],
+});
+const IDENTIFIER_DECLARATION = /\b(?:const|let|var|function|class|interface|type|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/g;
+export class StyleLearner {
+    profile;
+    stats;
+    constructor(profile = DEFAULT_PROFILE) {
+        this.profile = { ...profile };
+        this.stats = DEFAULT_STATS();
+    }
+    analyze(files) {
+        this.stats = DEFAULT_STATS();
+        for (const file of files) {
+            this.learnFromFile(file);
+        }
+        this.profile = this.buildProfile();
+        return this.getProfile();
+    }
+    learnFromFile(filePath) {
+        if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile())
+            return;
+        const source = fs.readFileSync(filePath, 'utf8');
+        this.collectIndentation(source);
+        this.collectQuotes(source);
+        this.collectSemicolons(source);
+        this.collectTrailingCommas(source);
+        this.collectNaming(source);
+        this.collectFunctions(source);
+        this.collectImports(source);
+        this.collectComments(source);
+        this.collectLineLengths(source);
+        this.profile = this.buildProfile();
+    }
+    getProfile() {
+        return { ...this.profile };
+    }
+    toPromptContext() {
+        const profile = this.profile;
+        return [
+            'Follow the project style profile when generating code:',
+            `- Indentation: ${profile.indentation}`,
+            `- Quotes: ${profile.quotes}`,
+            `- Semicolons: ${profile.semicolons}`,
+            `- Trailing commas: ${profile.trailingComma}`,
+            `- Naming convention: ${profile.namingConvention}`,
+            `- Imports: ${profile.importStyle}`,
+            `- Functions: prefer ${profile.functionStyle}`,
+            `- Comments: prefer ${profile.commentStyle} comments`,
+            `- Keep lines around ${profile.maxLineLength} characters when practical`,
+        ].join('\n');
+    }
+    save(filePath) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const document = {
+            profile: this.profile,
+            stats: this.stats,
+        };
+        fs.writeFileSync(filePath, `${JSON.stringify(document, null, 2)}\n`, 'utf8');
+    }
+    load(filePath) {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (isStyleProfileDocument(parsed)) {
+            this.profile = { ...DEFAULT_PROFILE, ...parsed.profile };
+            this.stats = parsed.stats ? normalizeStats(parsed.stats) : DEFAULT_STATS();
+            return;
+        }
+        this.profile = { ...DEFAULT_PROFILE, ...parsed };
+        this.stats = DEFAULT_STATS();
+    }
+    buildProfile() {
+        const importForm = dominant(this.stats.importForms, 'named');
+        const groupedImports = this.stats.importFiles > 0 && this.stats.importGroups / this.stats.importFiles > 1;
+        return {
+            indentation: dominant(this.stats.indentation, DEFAULT_PROFILE.indentation),
+            quotes: dominant(this.stats.quotes, DEFAULT_PROFILE.quotes),
+            semicolons: dominant(this.stats.semicolons, DEFAULT_PROFILE.semicolons),
+            trailingComma: dominant(this.stats.trailingComma, DEFAULT_PROFILE.trailingComma),
+            namingConvention: dominant(this.stats.namingConvention, DEFAULT_PROFILE.namingConvention),
+            importStyle: `${importForm} imports, ${groupedImports ? 'grouped' : 'single block'}`,
+            functionStyle: dominant(this.stats.functionStyle, DEFAULT_PROFILE.functionStyle),
+            commentStyle: dominant(this.stats.commentStyle, DEFAULT_PROFILE.commentStyle),
+            maxLineLength: inferLineLength(this.stats.lineLengths),
+        };
+    }
+    collectIndentation(source) {
+        for (const line of source.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const match = line.match(/^[\t ]+/);
+            if (!match)
+                continue;
+            const indent = match[0];
+            if (indent.includes('\t') && !indent.includes(' ')) {
+                bump(this.stats.indentation, 'tabs');
+                continue;
+            }
+            if (indent.includes(' ')) {
+                bump(this.stats.indentation, `${indent.length} spaces`);
+            }
+        }
+    }
+    collectQuotes(source) {
+        const single = source.match(/'([^'\\]|\\.)*'/g)?.length ?? 0;
+        const double = source.match(/"([^"\\]|\\.)*"/g)?.length ?? 0;
+        if (single > 0)
+            bump(this.stats.quotes, 'single', single);
+        if (double > 0)
+            bump(this.stats.quotes, 'double', double);
+    }
+    collectSemicolons(source) {
+        for (const line of source.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!looksLikeStatement(trimmed))
+                continue;
+            if (/;\s*(?:\/\/.*)?$/.test(trimmed)) {
+                bump(this.stats.semicolons, 'always');
+            }
+            else {
+                bump(this.stats.semicolons, 'never');
+            }
+        }
+    }
+    collectTrailingCommas(source) {
+        const lines = source.split(/\r?\n/);
+        for (let index = 0; index < lines.length - 1; index++) {
+            const current = lines[index].trimEnd();
+            const next = lines[index + 1].trimStart();
+            if (!current.trim() || !/^[}\]]/.test(next))
+                continue;
+            if (current.trim().endsWith(',')) {
+                bump(this.stats.trailingComma, 'always');
+            }
+            else if (/[A-Za-z0-9_'")\]}]$/.test(current.trim())) {
+                bump(this.stats.trailingComma, 'never');
+            }
+        }
+    }
+    collectNaming(source) {
+        for (const match of source.matchAll(IDENTIFIER_DECLARATION)) {
+            const name = match[1];
+            const convention = classifyName(name);
+            if (convention)
+                bump(this.stats.namingConvention, convention);
+        }
+    }
+    collectFunctions(source) {
+        const arrowCount = source.match(/=>/g)?.length ?? 0;
+        const functionCount = source.match(/\bfunction\b/g)?.length ?? 0;
+        if (arrowCount > 0)
+            bump(this.stats.functionStyle, 'arrow', arrowCount);
+        if (functionCount > 0)
+            bump(this.stats.functionStyle, 'function', functionCount);
+    }
+    collectImports(source) {
+        const importLines = source.match(/^import\s.+$/gm) ?? [];
+        if (importLines.length === 0)
+            return;
+        const blocks = source
+            .split(/\r?\n\r?\n+/)
+            .map((block) => block.trim())
+            .filter((block) => block.startsWith('import '));
+        this.stats.importGroups += blocks.length;
+        this.stats.importFiles += 1;
+        for (const line of importLines) {
+            const match = line.match(/^import\s+(.+?)\s+from\s+['"]/);
+            if (!match)
+                continue;
+            const specifier = match[1].trim();
+            if (specifier.startsWith('{')) {
+                bump(this.stats.importForms, 'named');
+            }
+            else if (specifier.includes('{')) {
+                bump(this.stats.importForms, 'mixed');
+            }
+            else {
+                bump(this.stats.importForms, 'default');
+            }
+        }
+    }
+    collectComments(source) {
+        const lineComments = source.match(/^\s*\/\/.+$/gm)?.length ?? 0;
+        const blockComments = source.match(/\/\*[\s\S]*?\*\//g)?.length ?? 0;
+        if (lineComments > 0)
+            bump(this.stats.commentStyle, 'line', lineComments);
+        if (blockComments > 0)
+            bump(this.stats.commentStyle, 'block', blockComments);
+    }
+    collectLineLengths(source) {
+        for (const line of source.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            this.stats.lineLengths.push(line.length);
+        }
+    }
+}
+export function resolveStyleProfilePath(cwd) {
+    return path.join(cwd, '.icopilot', 'style-profile.json');
+}
+export function loadStyleProfile(cwd) {
+    const profilePath = resolveStyleProfilePath(cwd);
+    if (!fs.existsSync(profilePath))
+        return null;
+    const learner = new StyleLearner();
+    learner.load(profilePath);
+    return learner.getProfile();
+}
+export function loadStylePromptContext(cwd) {
+    const profilePath = resolveStyleProfilePath(cwd);
+    if (!fs.existsSync(profilePath))
+        return null;
+    try {
+        const learner = new StyleLearner();
+        learner.load(profilePath);
+        return learner.toPromptContext();
+    }
+    catch {
+        return null;
+    }
+}
+export function resetStyleProfile(cwd) {
+    const profilePath = resolveStyleProfilePath(cwd);
+    if (!fs.existsSync(profilePath))
+        return false;
+    fs.rmSync(profilePath, { force: true });
+    return true;
+}
+function bump(counter, key, amount = 1) {
+    counter[key] = (counter[key] ?? 0) + amount;
+}
+function dominant(counter, fallback) {
+    let winner = fallback;
+    let score = -1;
+    for (const [key, value] of Object.entries(counter)) {
+        if (value > score) {
+            winner = key;
+            score = value;
+        }
+    }
+    return winner;
+}
+function inferLineLength(lengths) {
+    if (lengths.length === 0)
+        return DEFAULT_PROFILE.maxLineLength;
+    const sorted = [...lengths].sort((left, right) => left - right);
+    const percentile = sorted[Math.max(0, Math.floor(sorted.length * 0.9) - 1)];
+    const rounded = Math.ceil(percentile / 10) * 10;
+    const common = [80, 88, 90, 100, 120];
+    let closest = rounded;
+    let closestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of common) {
+        const distance = Math.abs(candidate - percentile);
+        if (distance < closestDistance) {
+            closest = candidate;
+            closestDistance = distance;
+        }
+    }
+    return closestDistance <= 12 ? closest : Math.max(80, rounded);
+}
+function classifyName(name) {
+    if (!name || /^[A-Z0-9_]+$/.test(name))
+        return null;
+    if (/^[a-z][A-Za-z0-9]*$/.test(name))
+        return 'camelCase';
+    if (/^[A-Z][A-Za-z0-9]*$/.test(name))
+        return 'PascalCase';
+    if (/^[a-z][a-z0-9_]*$/.test(name) && name.includes('_'))
+        return 'snake_case';
+    return null;
+}
+function looksLikeStatement(line) {
+    if (!line)
+        return false;
+    if (line.startsWith('//') || line.startsWith('/*') || line.startsWith('*'))
+        return false;
+    if (/^[{}[\],]+$/.test(line))
+        return false;
+    if (/[{:,]$/.test(line))
+        return false;
+    return true;
+}
+function isStyleProfileDocument(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    return 'profile' in value;
+}
+function normalizeStats(stats) {
+    return {
+        indentation: { ...stats.indentation },
+        quotes: { ...stats.quotes },
+        semicolons: { ...stats.semicolons },
+        trailingComma: { ...stats.trailingComma },
+        namingConvention: { ...stats.namingConvention },
+        importForms: { ...stats.importForms },
+        importGroups: Number(stats.importGroups) || 0,
+        importFiles: Number(stats.importFiles) || 0,
+        functionStyle: { ...stats.functionStyle },
+        commentStyle: { ...stats.commentStyle },
+        lineLengths: Array.isArray(stats.lineLengths) ? stats.lineLengths.filter(Number.isFinite) : [],
+    };
+}

package/dist/logger.js

@@ -0,0 +1,35 @@
+import { config } from './config.js';
+const LEVELS = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+export class Logger {
+    redact(text) {
+        return text
+            .replace(/ghp_[A-Za-z0-9_]{20,}/g, '***REDACTED***')
+            .replace(/gho_[A-Za-z0-9_]{20,}/g, '***REDACTED***')
+            .replace(/Bearer\s+[A-Za-z0-9._-]+/g, 'Bearer ***REDACTED***')
+            .replace(/(?<="token":")[^"]+/g, '***REDACTED***');
+    }
+    debug(message, fields) {
+        this.write('debug', message, fields);
+    }
+    info(message, fields) {
+        this.write('info', message, fields);
+    }
+    warn(message, fields) {
+        this.write('warn', message, fields);
+    }
+    error(message, fields) {
+        this.write('error', message, fields);
+    }
+    write(level, message, fields) {
+        if (LEVELS[level] < LEVELS[config.logLevel])
+            return;
+        const suffix = fields ? ` ${this.redact(JSON.stringify(fields))}` : '';
+        process.stderr.write(`[${new Date().toISOString()}] ${level.toUpperCase()} ${this.redact(message)}${suffix}\n`);
+    }
+}
+export const logger = new Logger();

package/dist/mcp/client.js

@@ -0,0 +1,144 @@
+import { spawn } from 'node:child_process';
+import { Buffer } from 'node:buffer';
+export class McpClient {
+    name;
+    config;
+    proc = null;
+    nextId = 1;
+    pending = new Map();
+    buffer = Buffer.alloc(0);
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+    }
+    async start() {
+        if (this.proc)
+            return;
+        this.proc = spawn(this.config.command, this.config.args || [], {
+            cwd: this.config.cwd,
+            env: { ...process.env, ...(this.config.env || {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        this.proc.stdout.on('data', (chunk) => this.onData(chunk));
+        this.proc.stderr.on('data', (chunk) => {
+            process.stderr.write(`[MCP/${this.name}] ${chunk.toString()}`);
+        });
+        this.proc.on('error', (err) => this.rejectAll(err));
+        this.proc.on('exit', (code) => {
+            this.rejectAll(new Error(`MCP server ${this.name} exited (${code ?? 'signal'})`));
+            this.proc = null;
+        });
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'icopilot', version: '0.4.0' },
+        });
+        this.notify('notifications/initialized', {});
+    }
+    async listTools() {
+        const result = await this.request('tools/list', {});
+        return Array.isArray(result?.tools) ? result.tools : [];
+    }
+    async callTool(name, args) {
+        const result = await this.request('tools/call', {
+            name,
+            arguments: args && typeof args === 'object' ? args : {},
+        });
+        if (Array.isArray(result?.content)) {
+            return result.content
+                .map((item) => {
+                if (typeof item?.text === 'string')
+                    return item.text;
+                return JSON.stringify(item);
+            })
+                .join('\n');
+        }
+        return typeof result === 'string' ? result : JSON.stringify(result);
+    }
+    stop() {
+        this.rejectAll(new Error(`MCP server ${this.name} stopped`));
+        this.proc?.kill();
+        this.proc = null;
+    }
+    request(method, params) {
+        if (!this.proc)
+            throw new Error(`MCP server ${this.name} is not running`);
+        const id = this.nextId++;
+        const payload = { jsonrpc: '2.0', id, method, params };
+        this.write(payload);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request timed out: ${method}`));
+            }, 10_000);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+    }
+    notify(method, params) {
+        if (!this.proc)
+            return;
+        this.write({ jsonrpc: '2.0', method, params });
+    }
+    write(payload) {
+        const json = JSON.stringify(payload);
+        this.proc?.stdin.write(json + '\n');
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length) {
+            const message = this.readMessage();
+            if (!message)
+                break;
+            this.handleMessage(message);
+        }
+    }
+    readMessage() {
+        if (this.buffer[0] === 67) {
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                return null;
+            const header = this.buffer.subarray(0, headerEnd).toString('utf8');
+            const match = header.match(/Content-Length:\s*(\d+)/i);
+            if (!match) {
+                this.buffer = Buffer.alloc(0);
+                return null;
+            }
+            const length = Number(match[1]);
+            const start = headerEnd + 4;
+            if (this.buffer.length < start + length)
+                return null;
+            const body = this.buffer.subarray(start, start + length).toString('utf8');
+            this.buffer = this.buffer.subarray(start + length);
+            return JSON.parse(body);
+        }
+        const newline = this.buffer.indexOf('\n');
+        if (newline === -1)
+            return null;
+        const line = this.buffer.subarray(0, newline).toString('utf8').trim();
+        this.buffer = this.buffer.subarray(newline + 1);
+        if (!line)
+            return null;
+        return JSON.parse(line);
+    }
+    handleMessage(message) {
+        if (typeof message?.id !== 'number')
+            return;
+        const pending = this.pending.get(message.id);
+        if (!pending)
+            return;
+        this.pending.delete(message.id);
+        clearTimeout(pending.timer);
+        if (message.error)
+            pending.reject(new Error(message.error.message || 'MCP error'));
+        else
+            pending.resolve(message.result);
+    }
+    rejectAll(reason) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(reason);
+        }
+        this.pending.clear();
+    }
+}

package/dist/mcp/config.js

@@ -0,0 +1,24 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export function loadMcpConfigs(cwd) {
+    const user = readConfig(path.join(os.homedir(), '.icopilot', 'mcp.json'));
+    const project = readConfig(path.join(cwd, '.mcp.json'));
+    return {
+        servers: {
+            ...user.servers,
+            ...project.servers,
+        },
+    };
+}
+function readConfig(file) {
+    try {
+        if (!fs.existsSync(file))
+            return { servers: {} };
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return { servers: parsed.servers && typeof parsed.servers === 'object' ? parsed.servers : {} };
+    }
+    catch {
+        return { servers: {} };
+    }
+}

package/dist/mcp/index.js

@@ -0,0 +1,89 @@
+import { config } from '../config.js';
+import { McpClient } from './client.js';
+import { loadMcpConfigs } from './config.js';
+const clients = new Map();
+const toolRoutes = new Map();
+let loaded = false;
+export async function loadMcpServers() {
+    if (loaded)
+        return;
+    loaded = true;
+    try {
+        const file = loadMcpConfigs(config.cwd);
+        await Promise.all(Object.entries(file.servers).map(async ([name, serverConfig]) => {
+            try {
+                const client = new McpClient(name, serverConfig);
+                await client.start();
+                clients.set(name, client);
+            }
+            catch (e) {
+                process.stderr.write(`[MCP/${name}] disabled: ${e?.message || e}\n`);
+            }
+        }));
+    }
+    catch (e) {
+        process.stderr.write(`[MCP] load failed: ${e?.message || e}\n`);
+    }
+}
+export async function getMcpTools() {
+    try {
+        await loadMcpServers();
+        const schemas = [];
+        toolRoutes.clear();
+        await Promise.all([...clients.entries()].map(async ([server, client]) => {
+            try {
+                const tools = await client.listTools();
+                for (const tool of tools) {
+                    const functionName = namespacedToolName(server, tool.name);
+                    toolRoutes.set(functionName, { server, tool: tool.name });
+                    schemas.push(toChatTool(functionName, server, tool));
+                }
+            }
+            catch (e) {
+                process.stderr.write(`[MCP/${server}] tools/list failed: ${e?.message || e}\n`);
+            }
+        }));
+        return { schemas, dispatch };
+    }
+    catch (e) {
+        process.stderr.write(`[MCP] tools unavailable: ${e?.message || e}\n`);
+        return { schemas: [], dispatch };
+    }
+}
+export async function shutdownMcp() {
+    for (const client of clients.values())
+        client.stop();
+    clients.clear();
+    toolRoutes.clear();
+    loaded = false;
+}
+async function dispatch(name, args) {
+    const route = toolRoutes.get(name);
+    if (!route)
+        return JSON.stringify({ error: `unknown MCP tool: ${name}` });
+    const client = clients.get(route.server);
+    if (!client)
+        return JSON.stringify({ error: `MCP server not loaded: ${route.server}` });
+    try {
+        return await client.callTool(route.tool, args);
+    }
+    catch (e) {
+        return JSON.stringify({ error: e?.message || String(e) });
+    }
+}
+function toChatTool(name, server, tool) {
+    return {
+        type: 'function',
+        function: {
+            name,
+            description: `[MCP/${server}] ${tool.description || tool.name}`,
+            parameters: tool.inputSchema || { type: 'object', properties: {} },
+        },
+    };
+}
+function namespacedToolName(server, tool) {
+    return `mcp__${safeName(server)}__${safeName(tool)}`;
+}
+function safeName(name) {
+    return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+}

package/dist/modes/auto-compact.js

@@ -0,0 +1,20 @@
+import { compactSession } from '../context/compactor.js';
+import { config } from '../config.js';
+import { theme } from '../ui/theme.js';
+export async function handlePostTurnContextBudget(session, signal) {
+    const used = session.tokenUsage();
+    const usageRatio = used / config.contextWindow;
+    if (config.autoCompact && usageRatio > config.autoCompactThreshold) {
+        const pct = (usageRatio * 100).toFixed(0);
+        process.stdout.write(theme.dim(`\n⚡ auto-compacting context (${pct}% full)...\n`));
+        const summary = await compactSession(session, signal);
+        session.compactInto(summary);
+        const freed = Math.max(0, used - session.tokenUsage());
+        process.stdout.write(theme.ok(`✔ auto-compacted. Freed ${freed} tokens.\n`));
+        return true;
+    }
+    if (usageRatio > config.contextWarn) {
+        process.stdout.write(theme.warn(`\n⚠  context ${(usageRatio * 100).toFixed(0)}% full — run /compact to free space.\n`));
+    }
+    return false;
+}