icopilot 2.2.0

package/dist/commands/diff-review-cmd.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import simpleGit from 'simple-git';
+import { streamChat } from '../api/github-models.js';
+import { theme } from '../ui/theme.js';
+const DIFF_REVIEW_SYSTEM = `You are reviewing a git diff.
+Focus on bugs, security issues, style problems, and concrete improvements.
+Prefer specific, actionable feedback tied to files or hunks.
+If the diff looks good, say so briefly.`;
+export async function buildDiffReviewPrompt(args, cwd) {
+    const git = simpleGit({ baseDir: cwd });
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        throw new Error(`Not a git repository: ${cwd}`);
+    }
+    const selection = selectDiff(args, cwd);
+    const diff = await git.diff(selection.diffArgs);
+    const prompt = [
+        `Review this git diff (${selection.scope}).`,
+        'Check for:',
+        '- bugs and logic errors',
+        '- security issues',
+        '- style or readability problems',
+        '- missing edge cases or tests',
+        '- concrete improvement suggestions',
+        '',
+        'Diff:',
+        diff || '(no diff)',
+    ].join('\n');
+    return { diff, scope: selection.scope, prompt };
+}
+export async function reviewDiff(session, args, signal) {
+    try {
+        const payload = await buildDiffReviewPrompt(args, session.state.cwd);
+        if (!payload.diff.trim()) {
+            process.stdout.write(theme.warn(`No changes found for ${payload.scope}.\n`));
+            return;
+        }
+        const messages = [
+            { role: 'system', content: DIFF_REVIEW_SYSTEM },
+            { role: 'user', content: payload.prompt },
+        ];
+        process.stdout.write(theme.dim(`Reviewing ${payload.scope}…\n\n`));
+        await streamChat({
+            model: session.state.model,
+            messages,
+            temperature: 0.2,
+            signal,
+            onToken: (token) => process.stdout.write(token),
+        });
+        process.stdout.write('\n');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stdout.write(theme.err(`diff review failed: ${message}\n`));
+    }
+}
+function selectDiff(args, cwd) {
+    if (!args.length) {
+        return { diffArgs: [], scope: 'unstaged changes' };
+    }
+    const target = args.join(' ').trim();
+    if (target === '--staged') {
+        return { diffArgs: ['--cached'], scope: 'staged changes' };
+    }
+    if (isExistingFileTarget(target, cwd)) {
+        return {
+            diffArgs: ['--', target],
+            scope: `changes for ${path.relative(cwd, path.resolve(cwd, target)) || target}`,
+        };
+    }
+    if (/^[^\s]+\.\.[^\s]+$/.test(target)) {
+        return { diffArgs: [target], scope: `changes between ${target}` };
+    }
+    if (looksLikePathTarget(target)) {
+        return {
+            diffArgs: ['--', target],
+            scope: `changes for ${path.relative(cwd, path.resolve(cwd, target)) || target}`,
+        };
+    }
+    return { diffArgs: [`${target}...HEAD`], scope: `changes from ${target} to HEAD` };
+}
+function isExistingFileTarget(target, cwd) {
+    const resolved = path.resolve(cwd, target);
+    return fs.existsSync(resolved) && fs.statSync(resolved).isFile();
+}
+function looksLikePathTarget(target) {
+    return (target.includes('/') ||
+        target.includes('\\') ||
+        target.startsWith('.') ||
+        path.extname(target).length > 0);
+}

package/dist/commands/doc-cmd.js

@@ -0,0 +1,412 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { theme } from '../ui/theme.js';
+const DOC_STYLES = new Set(['jsdoc', 'tsdoc', 'numpy', 'google']);
+const SOURCE_GLOBS = [
+    '**/*.ts',
+    '**/*.tsx',
+    '**/*.js',
+    '**/*.jsx',
+    '**/*.mjs',
+    '**/*.cjs',
+    '**/*.py',
+];
+const IGNORE_GLOBS = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/coverage/**'];
+export function generateDoc(code, style) {
+    const resolvedStyle = normalizeStyle(style);
+    const signature = parseSignature(code);
+    switch (resolvedStyle) {
+        case 'jsdoc':
+            return buildJsLikeDoc(signature, { includeThrows: true });
+        case 'tsdoc':
+            return buildJsLikeDoc(signature, { includeThrows: false });
+        case 'numpy':
+            return buildPythonDoc(signature, 'numpy');
+        case 'google':
+            return buildPythonDoc(signature, 'google');
+    }
+}
+export function findUndocumented(rootDir) {
+    const matches = [];
+    const files = fg.sync(SOURCE_GLOBS, {
+        cwd: rootDir,
+        absolute: true,
+        onlyFiles: true,
+        dot: false,
+        ignore: IGNORE_GLOBS,
+    });
+    for (const file of files) {
+        const code = safeReadFile(file);
+        if (!code)
+            continue;
+        for (const symbol of collectSymbols(code, file)) {
+            if (!symbol.documented && isProjectExport(symbol, code)) {
+                matches.push({
+                    name: symbol.name,
+                    file,
+                    line: symbol.line,
+                    kind: symbol.kind,
+                });
+            }
+        }
+    }
+    return matches.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+}
+export function docCommand(args, cwd) {
+    const parsed = parseDocArgs(args);
+    if (parsed.error)
+        return `${theme.warn(parsed.error)}\n`;
+    if (parsed.all) {
+        return handleAllDocs(cwd, parsed.style, parsed.overwrite);
+    }
+    if (!parsed.file) {
+        return `${theme.warn('usage: /doc <file> [symbol] [--style <jsdoc|tsdoc|numpy|google>] [--overwrite]')}\n`;
+    }
+    const options = {
+        file: parsed.file,
+        symbol: parsed.symbol,
+        style: parsed.style,
+        overwrite: parsed.overwrite,
+    };
+    return handleSingleDoc(options, cwd);
+}
+function handleSingleDoc(options, cwd) {
+    const resolvedFile = path.resolve(cwd, options.file);
+    const code = safeReadFile(resolvedFile);
+    if (!code)
+        return `${theme.err(`unable to read file: ${resolvedFile}`)}\n`;
+    const symbols = collectSymbols(code, resolvedFile);
+    const style = normalizeStyle(options.style, resolvedFile);
+    if (options.symbol) {
+        const symbol = symbols.find((entry) => entry.name === options.symbol);
+        if (!symbol) {
+            return `${theme.warn(`symbol not found: ${options.symbol}`)}\n`;
+        }
+        if (options.overwrite) {
+            writeDocsToFile(resolvedFile, code, [symbol], style);
+            return `${theme.ok(`✔ wrote ${style} docs for ${symbol.name}`)}\n`;
+        }
+        const doc = indentDoc(generateDoc(symbol.signature, style), symbol.language === 'python' ? nextIndent(symbol.indent) : symbol.indent);
+        return `${theme.brand('Generated docs')} ${theme.dim(`${resolvedFile}:${symbol.line}`)}\n\n${doc}\n`;
+    }
+    const targets = symbols.filter((symbol) => !symbol.documented);
+    if (targets.length === 0) {
+        return `${theme.dim(`No undocumented functions or classes found in ${resolvedFile}.\n`)}`;
+    }
+    if (options.overwrite) {
+        writeDocsToFile(resolvedFile, code, targets, style);
+        return `${theme.ok(`✔ wrote ${targets.length} ${style} doc block${targets.length === 1 ? '' : 's'} in ${resolvedFile}`)}\n`;
+    }
+    const blocks = targets.map((symbol) => {
+        const doc = indentDoc(generateDoc(symbol.signature, style), symbol.language === 'python' ? nextIndent(symbol.indent) : symbol.indent);
+        return `${theme.hl(`${symbol.kind} ${symbol.name}`)} ${theme.dim(`line ${symbol.line}`)}\n${doc}`;
+    });
+    return `${theme.brand('Generated docs')} ${theme.dim(resolvedFile)}\n\n${blocks.join('\n\n')}\n`;
+}
+function handleAllDocs(cwd, requestedStyle, overwrite = false) {
+    const missing = findUndocumented(cwd);
+    if (missing.length === 0)
+        return `${theme.dim('No undocumented exports found.\n')}`;
+    if (overwrite) {
+        const byFile = groupByFile(missing);
+        let written = 0;
+        for (const [file, symbols] of byFile) {
+            const code = safeReadFile(file);
+            if (!code)
+                continue;
+            const available = collectSymbols(code, file);
+            const targets = symbols
+                .map((entry) => available.find((candidate) => candidate.name === entry.name && candidate.line === entry.line))
+                .filter((entry) => Boolean(entry));
+            if (!targets.length)
+                continue;
+            writeDocsToFile(file, code, targets, normalizeStyle(requestedStyle, file));
+            written += targets.length;
+        }
+        return `${theme.ok(`✔ wrote ${written} doc block${written === 1 ? '' : 's'} across ${byFile.size} file${byFile.size === 1 ? '' : 's'}`)}\n`;
+    }
+    const lines = missing.map((entry) => {
+        const style = normalizeStyle(requestedStyle, entry.file);
+        return `  ${theme.ok(entry.name)} ${theme.dim(`(${entry.kind}, ${path.relative(cwd, entry.file)}:${entry.line}, ${style})`)}`;
+    });
+    return `${theme.brand('Undocumented exports')}\n${lines.join('\n')}\n`;
+}
+function writeDocsToFile(filePath, code, symbols, style) {
+    const lines = code.split(/\r?\n/);
+    const sorted = [...symbols].sort((a, b) => b.line - a.line);
+    for (const symbol of sorted) {
+        const insertAt = Math.max(0, symbol.line - 1);
+        const doc = generateDoc(symbol.signature, style);
+        const indent = symbol.language === 'python' ? nextIndent(symbol.indent) : symbol.indent;
+        const docLines = indentDoc(doc, indent).split('\n');
+        if (symbol.language === 'python') {
+            lines.splice(insertAt + 1, 0, ...docLines);
+        }
+        else {
+            lines.splice(insertAt, 0, ...docLines);
+        }
+    }
+    fs.writeFileSync(filePath, lines.join('\n'), 'utf8');
+}
+function collectSymbols(code, filePath) {
+    const language = detectLanguage(filePath);
+    return language === 'python'
+        ? collectPythonSymbols(code, filePath)
+        : collectJsLikeSymbols(code, filePath, language);
+}
+function collectJsLikeSymbols(code, filePath, language) {
+    const lines = code.split(/\r?\n/);
+    const symbols = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const signature = line.trim();
+        const match = line.match(/^(?<indent>\s*)(?<export>export\s+(?:default\s+)?)?(?:async\s+)?function\s+(?<name>[A-Za-z_$][\w$]*)\s*\(/) ??
+            line.match(/^(?<indent>\s*)(?<export>export\s+)?class\s+(?<name>[A-Za-z_$][\w$]*)\b/) ??
+            line.match(/^(?<indent>\s*)(?<export>export\s+)?const\s+(?<name>[A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/) ??
+            line.match(/^(?<indent>\s*)(?<export>export\s+)?const\s+(?<name>[A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\s*\(/);
+        if (!match?.groups?.name)
+            continue;
+        symbols.push({
+            name: match.groups.name,
+            file: filePath,
+            line: index + 1,
+            kind: signature.includes('class ') ? 'class' : 'function',
+            documented: hasLeadingBlockDoc(lines, index),
+            indent: match.groups.indent ?? '',
+            signature,
+            language,
+        });
+    }
+    return symbols;
+}
+function collectPythonSymbols(code, filePath) {
+    const lines = code.split(/\r?\n/);
+    const symbols = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const match = line.match(/^(?<indent>\s*)def\s+(?<name>[A-Za-z_][\w]*)\s*\(/) ??
+            line.match(/^(?<indent>\s*)class\s+(?<name>[A-Za-z_][\w]*)\b/);
+        if (!match?.groups?.name)
+            continue;
+        symbols.push({
+            name: match.groups.name,
+            file: filePath,
+            line: index + 1,
+            kind: line.includes('class ') ? 'class' : 'function',
+            documented: hasPythonDocstring(lines, index),
+            indent: match.groups.indent ?? '',
+            signature: line.trim(),
+            language: 'python',
+        });
+    }
+    return symbols;
+}
+function isProjectExport(symbol, code) {
+    if (symbol.language === 'python')
+        return true;
+    const line = code.split(/\r?\n/)[symbol.line - 1] ?? '';
+    return /\bexport\b/.test(line);
+}
+function hasLeadingBlockDoc(lines, symbolIndex) {
+    for (let index = symbolIndex - 1; index >= 0; index -= 1) {
+        const line = lines[index].trim();
+        if (!line)
+            continue;
+        if (line.endsWith('*/'))
+            return true;
+        return false;
+    }
+    return false;
+}
+function hasPythonDocstring(lines, symbolIndex) {
+    for (let index = symbolIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index].trim();
+        if (!line)
+            continue;
+        return line.startsWith('"""') || line.startsWith("'''");
+    }
+    return false;
+}
+function parseSignature(code) {
+    const trimmed = code.trim();
+    const kind = /\bclass\b/.test(trimmed) ? 'class' : 'function';
+    const name = trimmed.match(/\b(?:function|class|def)\s+([A-Za-z_$][\w$]*)/)?.[1] ??
+        trimmed.match(/\bconst\s+([A-Za-z_$][\w$]*)\b/)?.[1];
+    const paramSource = trimmed.match(/\((.*)\)/)?.[1] ?? '';
+    const params = splitParams(paramSource).map(cleanParamName).filter(Boolean);
+    const throws = /\bthrow\b/.test(trimmed);
+    const returns = kind === 'function' && !/\bconstructor\s*\(/.test(trimmed);
+    return {
+        kind,
+        name,
+        params,
+        returns,
+        throws,
+    };
+}
+function splitParams(input) {
+    if (!input.trim())
+        return [];
+    const params = [];
+    let current = '';
+    let depth = 0;
+    for (const char of input) {
+        if (char === ',' && depth === 0) {
+            params.push(current.trim());
+            current = '';
+            continue;
+        }
+        if (char === '(' || char === '[' || char === '{' || char === '<')
+            depth += 1;
+        if (char === ')' || char === ']' || char === '}' || char === '>')
+            depth = Math.max(0, depth - 1);
+        current += char;
+    }
+    if (current.trim())
+        params.push(current.trim());
+    return params;
+}
+function cleanParamName(param) {
+    return param
+        .replace(/^\.{3}/, '')
+        .replace(/[:=].*$/, '')
+        .replace(/\?$/, '')
+        .replace(/^\{.*\}$/s, 'options')
+        .replace(/^\[.*\]$/s, 'items')
+        .trim();
+}
+function buildJsLikeDoc(signature, options) {
+    const lines = [
+        '/**',
+        ` * ${signature.name ? `Describe ${signature.name}.` : 'Describe this symbol.'}`,
+    ];
+    for (const param of signature.params) {
+        lines.push(` * @param ${param} - Describe ${param}.`);
+    }
+    if (signature.returns) {
+        lines.push(' * @returns Describe the return value.');
+    }
+    if (options.includeThrows) {
+        lines.push(' * @throws {Error} Describe when this throws.');
+    }
+    lines.push(' */');
+    return lines.join('\n');
+}
+function buildPythonDoc(signature, style) {
+    if (style === 'numpy') {
+        const lines = ['"""Describe this symbol.', ''];
+        if (signature.params.length) {
+            lines.push('Parameters', '----------');
+            for (const param of signature.params) {
+                lines.push(`${param} : type`, `    Describe ${param}.`);
+            }
+            lines.push('');
+        }
+        if (signature.returns) {
+            lines.push('Returns', '-------', 'type', '    Describe the return value.', '');
+        }
+        lines.push('"""');
+        return lines.join('\n');
+    }
+    const lines = ['"""Describe this symbol.', ''];
+    if (signature.params.length) {
+        lines.push('Args:');
+        for (const param of signature.params) {
+            lines.push(`    ${param}: Describe ${param}.`);
+        }
+        lines.push('');
+    }
+    if (signature.returns) {
+        lines.push('Returns:', '    Describe the return value.', '');
+    }
+    lines.push('"""');
+    return lines.join('\n');
+}
+function indentDoc(doc, indent) {
+    return doc
+        .split('\n')
+        .map((line) => `${indent}${line}`)
+        .join('\n');
+}
+function nextIndent(indent) {
+    return `${indent}    `;
+}
+function normalizeStyle(style, filePath) {
+    if (style) {
+        const normalized = style.toLowerCase();
+        if (DOC_STYLES.has(normalized))
+            return normalized;
+    }
+    if (filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext === '.ts' || ext === '.tsx')
+            return 'tsdoc';
+        if (ext === '.py')
+            return 'google';
+    }
+    return 'jsdoc';
+}
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.py')
+        return 'python';
+    if (ext === '.ts' || ext === '.tsx')
+        return 'typescript';
+    return 'javascript';
+}
+function safeReadFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseDocArgs(args) {
+    const positional = [];
+    let all = false;
+    let overwrite = false;
+    let style;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--all') {
+            all = true;
+            continue;
+        }
+        if (arg === '--overwrite') {
+            overwrite = true;
+            continue;
+        }
+        if (arg === '--style') {
+            style = args[index + 1];
+            index += 1;
+            if (!style) {
+                return { all, overwrite, error: 'missing value for --style' };
+            }
+            if (!DOC_STYLES.has(style.toLowerCase())) {
+                return { all, overwrite, error: `unsupported doc style: ${style}` };
+            }
+            continue;
+        }
+        positional.push(arg);
+    }
+    if (all)
+        return { all, overwrite, style };
+    return {
+        all,
+        overwrite,
+        style,
+        file: positional[0],
+        symbol: positional[1],
+    };
+}
+function groupByFile(symbols) {
+    const grouped = new Map();
+    for (const symbol of symbols) {
+        const entries = grouped.get(symbol.file) ?? [];
+        entries.push(symbol);
+        grouped.set(symbol.file, entries);
+    }
+    return grouped;
+}

package/dist/commands/doctor-cmd.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+export function runDiagnostics() {
+    const home = os.homedir();
+    const rcPath = path.join(home, '.icopilotrc.json');
+    const icopilotDir = path.join(home, '.icopilot');
+    return [
+        {
+            name: 'GITHUB_TOKEN',
+            status: process.env.GITHUB_TOKEN ? 'ok' : 'fail',
+            message: process.env.GITHUB_TOKEN ? 'set' : 'not set',
+        },
+        {
+            name: '~/.icopilotrc.json',
+            status: fs.existsSync(rcPath) ? 'ok' : 'warn',
+            message: fs.existsSync(rcPath) ? 'found' : 'using defaults',
+        },
+        nodeVersionCheck(),
+        gitCheck(),
+        {
+            name: '~/.icopilot/',
+            status: fs.existsSync(icopilotDir) ? 'ok' : 'warn',
+            message: fs.existsSync(icopilotDir) ? 'found' : 'will be created on first use',
+        },
+        sessionDirectoryCheck(home),
+        mcpConfigCheck(home),
+    ];
+}
+export function formatDiagnostics(checks) {
+    const lines = checks.map((check) => {
+        const icon = statusIcon(check.status);
+        const label = statusLabel(check.status);
+        return `  ${icon} ${theme.hl(check.name)} ${theme.dim(`(${label})`)} ${check.message}`;
+    });
+    return `${theme.brand('iCopilot doctor')}\n${lines.join('\n')}\n`;
+}
+function nodeVersionCheck() {
+    const major = Number.parseInt(process.versions.node.split('.')[0] ?? '', 10);
+    const ok = Number.isFinite(major) && major >= 18;
+    return {
+        name: 'Node.js >= 18',
+        status: ok ? 'ok' : 'fail',
+        message: `detected ${process.versions.node}`,
+    };
+}
+function gitCheck() {
+    const available = hasGitOnPath();
+    return {
+        name: 'git',
+        status: available ? 'ok' : 'warn',
+        message: available ? 'available on PATH' : 'not found on PATH',
+    };
+}
+function sessionDirectoryCheck(home) {
+    const sessionDir = process.env.ICOPILOT_SESSION_DIR || path.join(home, '.terminal-copilot', 'sessions');
+    const writable = isWritableDirectory(sessionDir);
+    return {
+        name: 'session directory',
+        status: writable ? 'ok' : 'fail',
+        message: writable ? sessionDir : `not writable: ${sessionDir}`,
+    };
+}
+function mcpConfigCheck(home) {
+    const hasUserConfig = fs.existsSync(path.join(home, '.icopilot', 'mcp.json'));
+    const hasProjectConfig = fs.existsSync(path.join(process.cwd(), '.mcp.json'));
+    return {
+        name: 'MCP config',
+        status: hasUserConfig || hasProjectConfig ? 'ok' : 'warn',
+        message: hasProjectConfig || hasUserConfig
+            ? hasProjectConfig
+                ? '.mcp.json found'
+                : '~/.icopilot/mcp.json found'
+            : 'no MCP servers configured',
+    };
+}
+function statusIcon(status) {
+    switch (status) {
+        case 'ok':
+            return theme.ok('✔');
+        case 'warn':
+            return theme.warn('⚠');
+        case 'fail':
+            return theme.err('✖');
+    }
+}
+function statusLabel(status) {
+    switch (status) {
+        case 'ok':
+            return 'ok';
+        case 'warn':
+            return 'warn';
+        case 'fail':
+            return 'fail';
+    }
+}
+function hasGitOnPath() {
+    const candidates = new Set();
+    const pathValue = process.env.PATH || '';
+    const pathEntries = pathValue.split(path.delimiter).filter(Boolean);
+    const executableNames = process.platform === 'win32' ? ['git.exe', 'git.cmd', 'git.bat', 'git'] : ['git'];
+    for (const dir of pathEntries) {
+        for (const executableName of executableNames) {
+            candidates.add(path.join(dir, executableName));
+        }
+    }
+    if (process.platform === 'win32') {
+        candidates.add(path.join('C:\\Program Files\\Git\\cmd', 'git.exe'));
+        candidates.add(path.join('C:\\Program Files\\Git\\bin', 'git.exe'));
+        candidates.add(path.join('C:\\Program Files (x86)\\Git\\cmd', 'git.exe'));
+        candidates.add(path.join('C:\\Program Files (x86)\\Git\\bin', 'git.exe'));
+    }
+    else {
+        candidates.add('/usr/bin/git');
+        candidates.add('/usr/local/bin/git');
+    }
+    for (const candidate of candidates) {
+        try {
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isFile())
+                return true;
+        }
+        catch {
+            // Ignore unreadable paths and keep checking.
+        }
+    }
+    return false;
+}
+function isWritableDirectory(target) {
+    const existing = nearestExistingPath(target);
+    if (!existing)
+        return false;
+    try {
+        const stats = fs.statSync(existing);
+        const probe = stats.isDirectory() ? existing : path.dirname(existing);
+        fs.accessSync(probe, fs.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function nearestExistingPath(target) {
+    let current = path.resolve(target);
+    while (!fs.existsSync(current)) {
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+    return current;
+}