icopilot 2.2.0

package/dist/intelligence/error-watch.js

@@ -0,0 +1,263 @@
+import { spawn } from 'node:child_process';
+const TYPESCRIPT_PATTERNS = [
+    /^(?<file>.+?)\((?<line>\d+),(?<column>\d+)\):\s*(?<severity>error|warning)\s+(?<code>TS\d+):\s*(?<message>.+)$/i,
+    /^(?<file>.+?):(?<line>\d+):(?<column>\d+)\s*-\s*(?<severity>error|warning)\s+(?<code>TS\d+):\s*(?<message>.+)$/i,
+    /^(?<severity>error|warning)\s+(?<code>TS\d+):\s*(?<message>.+)$/i,
+];
+const ESLINT_PATTERNS = [
+    /^(?<file>.+?):(?<line>\d+):(?<column>\d+):\s*(?<severity>error|warning)\s+(?<message>.+?)(?:\s+\((?<code>[^)]+)\))?$/i,
+    /^(?<file>.+?)\((?<line>\d+),(?<column>\d+)\):\s*(?<severity>error|warning)\s+(?<message>.+?)(?:\s+\((?<code>[^)]+)\))?$/i,
+];
+const GENERIC_PATTERNS = [
+    /^(?<file>.+?):(?<line>\d+):(?<column>\d+)\s*[:|-]\s*(?<severity>error|warning)\s*:?\s*(?<message>.+)$/i,
+    /^(?<severity>error|warning)\s*[:|-]\s*(?<message>.+)$/i,
+    /^(?<severity>warning|error)\b.*?:\s*(?<message>.+)$/i,
+    /^(?<severity>error|warning)\b(?<message>.+)$/i,
+];
+export class ErrorWatcher {
+    proc = null;
+    errors = [];
+    callbacks = new Set();
+    seen = new Set();
+    stdoutBuffer = '';
+    stderrBuffer = '';
+    command = null;
+    running = false;
+    start(command) {
+        const trimmed = command.trim();
+        if (!trimmed) {
+            throw new Error('command is required');
+        }
+        this.stop();
+        this.clear();
+        this.command = trimmed;
+        const { shell, args } = getShellInvocation(trimmed);
+        const child = spawn(shell, args, {
+            cwd: process.cwd(),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        this.proc = child;
+        this.running = true;
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => this.consumeChunk('stdout', chunk));
+        child.stderr?.on('data', (chunk) => this.consumeChunk('stderr', chunk));
+        child.on('error', (error) => {
+            this.record({
+                severity: 'error',
+                message: `Failed to start watcher: ${error.message}`,
+                raw: error.message,
+            });
+            this.running = false;
+            this.proc = null;
+        });
+        child.on('close', () => {
+            this.flushBuffer('stdout');
+            this.flushBuffer('stderr');
+            this.running = false;
+            this.proc = null;
+        });
+    }
+    stop() {
+        const child = this.proc;
+        this.proc = null;
+        this.running = false;
+        this.command = null;
+        if (!child)
+            return;
+        child.kill('SIGTERM');
+    }
+    onError(callback) {
+        this.callbacks.add(callback);
+    }
+    getErrors() {
+        return this.errors.map((error) => ({ ...error }));
+    }
+    clear() {
+        this.errors = [];
+        this.seen.clear();
+        this.stdoutBuffer = '';
+        this.stderrBuffer = '';
+    }
+    isRunning() {
+        return this.running;
+    }
+    getCommand() {
+        return this.command;
+    }
+    consumeChunk(stream, chunk) {
+        const next = `${stream === 'stdout' ? this.stdoutBuffer : this.stderrBuffer}${chunk}`;
+        const lines = next.split(/\r?\n/);
+        const remainder = lines.pop() ?? '';
+        if (stream === 'stdout') {
+            this.stdoutBuffer = remainder;
+        }
+        else {
+            this.stderrBuffer = remainder;
+        }
+        for (const line of lines) {
+            this.processLine(line);
+        }
+    }
+    flushBuffer(stream) {
+        const buffer = stream === 'stdout' ? this.stdoutBuffer : this.stderrBuffer;
+        if (buffer.trim()) {
+            this.processLine(buffer);
+        }
+        if (stream === 'stdout') {
+            this.stdoutBuffer = '';
+        }
+        else {
+            this.stderrBuffer = '';
+        }
+    }
+    processLine(line) {
+        const parsed = parseErrorLine(line);
+        if (parsed) {
+            this.record(parsed);
+        }
+    }
+    record(error) {
+        const signature = JSON.stringify({
+            file: error.file,
+            line: error.line,
+            column: error.column,
+            severity: error.severity,
+            code: error.code,
+            message: error.message,
+            raw: error.raw,
+        });
+        if (this.seen.has(signature))
+            return;
+        this.seen.add(signature);
+        this.errors.push(error);
+        for (const callback of this.callbacks) {
+            callback({ ...error });
+        }
+    }
+}
+export function suggestFix(error) {
+    const location = error.file && error.line !== undefined
+        ? `${error.file}:${error.line}${error.column !== undefined ? `:${error.column}` : ''}`
+        : error.file || 'unknown location';
+    const hint = inferHint(error);
+    const lines = [
+        `Investigate and fix this ${error.severity}:`,
+        `Location: ${location}`,
+        error.code ? `Code: ${error.code}` : undefined,
+        `Message: ${error.message}`,
+        hint ? `Hint: ${hint}` : undefined,
+        'Propose the smallest safe code change, explain why it fixes the issue, and avoid unrelated edits.',
+    ];
+    return lines.filter((line) => Boolean(line)).join('\n');
+}
+function parseErrorLine(rawLine) {
+    const raw = rawLine.trim();
+    if (!raw)
+        return null;
+    const parsed = matchPattern(raw, TYPESCRIPT_PATTERNS, normalizeTypeScriptError) ??
+        matchPattern(raw, ESLINT_PATTERNS, normalizeLintError) ??
+        matchPattern(raw, GENERIC_PATTERNS, normalizeGenericError);
+    return parsed ? { ...parsed, raw } : null;
+}
+function matchPattern(raw, patterns, normalize) {
+    for (const pattern of patterns) {
+        const match = pattern.exec(raw);
+        if (!match)
+            continue;
+        return normalize(match);
+    }
+    return null;
+}
+function normalizeTypeScriptError(match) {
+    const groups = match.groups;
+    if (!groups?.message || !groups.severity)
+        return null;
+    return {
+        file: groups.file,
+        line: toNumber(groups.line),
+        column: toNumber(groups.column),
+        severity: normalizeSeverity(groups.severity),
+        code: groups.code,
+        message: groups.message.trim(),
+    };
+}
+function normalizeLintError(match) {
+    const groups = match.groups;
+    if (!groups?.message || !groups.severity)
+        return null;
+    const lintCode = groups.code?.trim();
+    return {
+        file: groups.file,
+        line: toNumber(groups.line),
+        column: toNumber(groups.column),
+        severity: normalizeSeverity(groups.severity),
+        code: lintCode || extractTrailingRule(groups.message),
+        message: stripTrailingRule(groups.message),
+    };
+}
+function normalizeGenericError(match) {
+    const groups = match.groups;
+    if (!groups?.message || !groups.severity)
+        return null;
+    return {
+        file: groups.file,
+        line: toNumber(groups.line),
+        column: toNumber(groups.column),
+        severity: normalizeSeverity(groups.severity),
+        message: groups.message.trim(),
+    };
+}
+function normalizeSeverity(value) {
+    return value.toLowerCase() === 'warning' ? 'warning' : 'error';
+}
+function toNumber(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function stripTrailingRule(message) {
+    return message.replace(/\s+\(([^)]+)\)\s*$/, '').trim();
+}
+function extractTrailingRule(message) {
+    const explicitRule = /\s+\(([^)]+)\)\s*$/.exec(message)?.[1];
+    if (explicitRule)
+        return explicitRule;
+    const tokens = message.trim().split(/\s+/);
+    const candidate = tokens[tokens.length - 1];
+    return candidate && /^(?:@?[\w-]+\/)?[\w-]+$/.test(candidate) ? candidate : undefined;
+}
+function inferHint(error) {
+    const code = error.code?.toUpperCase();
+    const message = error.message.toLowerCase();
+    if (code === 'TS2304' || message.includes('cannot find name')) {
+        return 'Check for a missing import, a misspelled symbol, or a variable that is out of scope.';
+    }
+    if (code === 'TS2322' || code === 'TS2345' || message.includes('not assignable')) {
+        return 'Compare the expected and actual types, then narrow, convert, or update the declaration at the source.';
+    }
+    if (code?.startsWith('TS')) {
+        return 'Inspect the referenced TypeScript types, imports, and nearby declarations before changing behavior.';
+    }
+    if (error.code) {
+        return `Review the rule or diagnostic "${error.code}" and make the smallest change that satisfies it.`;
+    }
+    if (error.severity === 'warning') {
+        return 'Prefer a low-risk cleanup that addresses the warning without changing runtime behavior.';
+    }
+    return 'Trace the failing file and surrounding code path, then patch the root cause instead of silencing the symptom.';
+}
+function getShellInvocation(command) {
+    if (process.platform === 'win32') {
+        return {
+            shell: 'powershell.exe',
+            args: ['-NoProfile', '-Command', command],
+        };
+    }
+    return {
+        shell: 'bash',
+        args: ['-lc', command],
+    };
+}

package/dist/intelligence/navigation.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+const SOURCE_PATTERNS = ['**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}'];
+const DEFAULT_IGNORES = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/.git/**',
+    '**/coverage/**',
+    '**/*.d.ts',
+];
+export function goToDefinition(symbolName, rootDir) {
+    const escapedSymbol = escapeRegex(symbolName.trim());
+    if (!escapedSymbol)
+        return null;
+    const declarationRegex = new RegExp(String.raw `^\s*export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|type|interface)\s+(${escapedSymbol})\b`);
+    const assignmentRegex = new RegExp(String.raw `\b(${escapedSymbol})\b\s*=(?!=)`);
+    for (const file of listSourceFiles(rootDir)) {
+        const content = safeRead(file);
+        if (content === undefined)
+            continue;
+        const lines = content.split(/\r?\n/u);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] ?? '';
+            const declarationMatch = declarationRegex.exec(line);
+            if (declarationMatch) {
+                return createLocation(file, rootDir, index + 1, declarationMatch.index + declarationMatch[0].indexOf(declarationMatch[1]), line);
+            }
+            const assignmentMatch = assignmentRegex.exec(line);
+            if (assignmentMatch) {
+                return createLocation(file, rootDir, index + 1, assignmentMatch.index, line);
+            }
+        }
+    }
+    return null;
+}
+export function findReferences(symbolName, rootDir) {
+    const escapedSymbol = escapeRegex(symbolName.trim());
+    if (!escapedSymbol)
+        return [];
+    const referenceRegex = new RegExp(String.raw `\b${escapedSymbol}\b`, 'g');
+    const locations = [];
+    for (const file of listSourceFiles(rootDir)) {
+        const content = safeRead(file);
+        if (content === undefined)
+            continue;
+        const lines = content.split(/\r?\n/u);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] ?? '';
+            if (isDefinitionLine(line, escapedSymbol))
+                continue;
+            referenceRegex.lastIndex = 0;
+            let match = referenceRegex.exec(line);
+            while (match) {
+                locations.push(createLocation(file, rootDir, index + 1, match.index, line));
+                match = referenceRegex.exec(line);
+            }
+        }
+    }
+    return sortLocations(locations);
+}
+export function findImplementations(interfaceName, rootDir) {
+    const escapedSymbol = escapeRegex(interfaceName.trim());
+    if (!escapedSymbol)
+        return [];
+    const implementsRegex = new RegExp(String.raw `\bclass\s+[A-Za-z_$][\w$]*\b[^{\n]*\bimplements\b[^{\n]*\b(${escapedSymbol})\b`);
+    const extendsRegex = new RegExp(String.raw `\bclass\s+[A-Za-z_$][\w$]*\b[^{\n]*\bextends\s+(${escapedSymbol})\b`);
+    const locations = [];
+    for (const file of listSourceFiles(rootDir)) {
+        const content = safeRead(file);
+        if (content === undefined)
+            continue;
+        const lines = content.split(/\r?\n/u);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] ?? '';
+            const match = implementsRegex.exec(line) ?? extendsRegex.exec(line);
+            if (!match)
+                continue;
+            locations.push(createLocation(file, rootDir, index + 1, match.index + match[0].lastIndexOf(match[1]), line));
+        }
+    }
+    return sortLocations(locations);
+}
+function listSourceFiles(rootDir) {
+    const normalizedRoot = path.resolve(rootDir);
+    return fg
+        .sync(SOURCE_PATTERNS, {
+        cwd: normalizedRoot,
+        onlyFiles: true,
+        absolute: true,
+        unique: true,
+        dot: false,
+        ignore: [...DEFAULT_IGNORES, ...readGitignorePatterns(normalizedRoot)],
+    })
+        .map((file) => path.resolve(file))
+        .sort((left, right) => left.localeCompare(right));
+}
+function readGitignorePatterns(rootDir) {
+    const gitignorePath = path.join(rootDir, '.gitignore');
+    if (!fs.existsSync(gitignorePath))
+        return [];
+    return (safeRead(gitignorePath)
+        ?.split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#') && !line.startsWith('!'))
+        .flatMap((line) => {
+        const normalized = line.replace(/^\.\//u, '').replace(/^\/+/u, '');
+        if (normalized.endsWith('/'))
+            return [normalized, `${normalized}**`];
+        return [normalized];
+    }) ?? []);
+}
+function isDefinitionLine(line, escapedSymbol) {
+    const declarationRegex = new RegExp(String.raw `^\s*export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|type|interface)\s+${escapedSymbol}\b`);
+    const assignmentRegex = new RegExp(String.raw `\b${escapedSymbol}\b\s*=(?!=)`);
+    return declarationRegex.test(line) || assignmentRegex.test(line);
+}
+function createLocation(file, rootDir, line, zeroBasedColumn, context) {
+    return {
+        file: path.relative(rootDir, file),
+        line,
+        column: zeroBasedColumn + 1,
+        context: context.trim(),
+    };
+}
+function sortLocations(locations) {
+    return locations.sort((left, right) => left.file.localeCompare(right.file) ||
+        left.line - right.line ||
+        (left.column ?? 0) - (right.column ?? 0));
+}
+function safeRead(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/intelligence/stack-trace.js

@@ -0,0 +1,210 @@
+const UNKNOWN_FRAME = {
+    file: '<unknown>',
+    line: 0,
+    isNative: true,
+    isNodeModule: false,
+};
+export function parseStackTrace(text) {
+    const raw = normalizeStackTraceText(text);
+    const lines = raw.split('\n');
+    const frames = lines.map(parseFrame).filter((frame) => frame !== null);
+    const { type, error } = extractErrorMetadata(lines);
+    return {
+        error,
+        type,
+        frames,
+        raw,
+    };
+}
+export function analyzeStackTrace(trace) {
+    const isPython = trace.raw.includes('Traceback (most recent call last):');
+    const nonModuleFrames = trace.frames.filter((frame) => !frame.isNodeModule);
+    const userFrames = nonModuleFrames.filter((frame) => !frame.isNative);
+    const relevantFrames = orderRelevantFrames(userFrames.length ? userFrames : nonModuleFrames, isPython).slice(0, 6);
+    const rootCause = relevantFrames[0] ?? nonModuleFrames[0] ?? trace.frames[0] ?? UNKNOWN_FRAME;
+    const userFiles = uniqueFiles(userFrames);
+    return {
+        rootCause,
+        relevantFrames,
+        userFiles,
+        suggestion: buildSuggestion(trace, rootCause, userFiles),
+    };
+}
+export function formatForLLM(analysis) {
+    const lines = [
+        'Stack trace analysis:',
+        `- Root cause frame: ${formatFrame(analysis.rootCause)}`,
+        `- Relevant frames (${analysis.relevantFrames.length}):`,
+        ...analysis.relevantFrames.map((frame) => `  - ${formatFrame(frame)}`),
+        `- User files (${analysis.userFiles.length}):`,
+        ...(analysis.userFiles.length
+            ? analysis.userFiles.map((file) => `  - ${file}`)
+            : ['  - none detected']),
+        `- Suggested investigation: ${analysis.suggestion}`,
+    ];
+    return lines.join('\n');
+}
+function normalizeStackTraceText(text) {
+    return text
+        .trim()
+        .replace(/\r\n/g, '\n')
+        .replace(/\\r?\\n(?=\s*(?:at\s|File\s|Traceback\b|[A-Za-z_][\w.]*?(?:Error|Exception|Warning)\b|@))/g, '\n');
+}
+function parseFrame(line) {
+    return parseNodeOrV8Frame(line) ?? parseBrowserFrame(line) ?? parsePythonFrame(line);
+}
+function parseNodeOrV8Frame(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('at '))
+        return null;
+    const body = trimmed.slice(3).trim();
+    const callsite = matchCallsite(body);
+    if (!callsite)
+        return null;
+    return createFrame(callsite.location, callsite.fn);
+}
+function parseBrowserFrame(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes('@') || trimmed.startsWith('at '))
+        return null;
+    const atIndex = trimmed.lastIndexOf('@');
+    const fn = trimmed.slice(0, atIndex).trim() || undefined;
+    const location = trimmed.slice(atIndex + 1).trim();
+    return createFrame(location, fn);
+}
+function parsePythonFrame(line) {
+    const match = line.match(/^\s*File\s+"(.+?)",\s+line\s+(\d+)(?:,\s+in\s+(.+))?\s*$/);
+    if (!match)
+        return null;
+    const [, file, lineNumber, fn] = match;
+    return {
+        file,
+        line: Number(lineNumber),
+        function: fn?.trim() || undefined,
+        isNative: isNativeLocation(file),
+        isNodeModule: isNodeModuleFile(file),
+    };
+}
+function matchCallsite(body) {
+    const wrappedMatch = body.match(/^(.*?) \((.+)\)$/);
+    if (wrappedMatch) {
+        const [, fn, location] = wrappedMatch;
+        return { fn: fn.trim() || undefined, location: location.trim() };
+    }
+    return { location: body };
+}
+function createFrame(location, fn) {
+    const parsed = parseLocation(location);
+    if (parsed) {
+        return {
+            ...parsed,
+            function: fn,
+            isNative: isNativeLocation(parsed.file),
+            isNodeModule: isNodeModuleFile(parsed.file),
+        };
+    }
+    if (!isNativeLocation(location))
+        return null;
+    return {
+        file: location,
+        line: 0,
+        function: fn,
+        isNative: true,
+        isNodeModule: false,
+    };
+}
+function parseLocation(location) {
+    const cleaned = location.trim().replace(/^\(|\)$/g, '');
+    const match = cleaned.match(/^(.*):(\d+)(?::(\d+))$/);
+    if (!match)
+        return null;
+    const [, file, line, column] = match;
+    return {
+        file,
+        line: Number(line),
+        column: Number(column),
+    };
+}
+function extractErrorMetadata(lines) {
+    const nonEmptyLines = lines.map((line) => line.trim()).filter(Boolean);
+    const errorLine = [...nonEmptyLines].reverse().find((line) => looksLikeErrorLine(line)) ??
+        nonEmptyLines[0] ??
+        'Error';
+    const match = errorLine.match(/^([A-Za-z_][\w.]*)(?::\s*(.*))?$/);
+    if (!match) {
+        return { type: 'Error', error: errorLine };
+    }
+    const [, type, message] = match;
+    return {
+        type,
+        error: message?.trim() || type,
+    };
+}
+function looksLikeErrorLine(line) {
+    return (/^[A-Za-z_][\w.]*?(?:Error|Exception|Warning)?(?::|$)/.test(line) && !line.startsWith('at '));
+}
+function orderRelevantFrames(frames, isPython) {
+    return isPython ? [...frames].reverse() : [...frames];
+}
+function uniqueFiles(frames) {
+    const seen = new Set();
+    const files = [];
+    for (const frame of frames) {
+        if (seen.has(frame.file))
+            continue;
+        seen.add(frame.file);
+        files.push(frame.file);
+    }
+    return files;
+}
+function buildSuggestion(trace, rootCause, userFiles) {
+    const location = rootCause.line > 0 ? `${rootCause.file}:${rootCause.line}` : rootCause.file;
+    const prefix = userFiles.length
+        ? `Start with ${location}${rootCause.function ? ` in ${rootCause.function}` : ''}.`
+        : 'The trace is dominated by runtime or dependency frames.';
+    const type = trace.type.toLowerCase();
+    const errorText = `${trace.type} ${trace.error}`.toLowerCase();
+    if (type.includes('syntax')) {
+        return `${prefix} This looks like a syntax issue, so inspect the exact line and the tokens immediately around it.`;
+    }
+    if (type.includes('typeerror') ||
+        type.includes('attributeerror') ||
+        errorText.includes('cannot read properties') ||
+        errorText.includes('undefined')) {
+        return `${prefix} Check for null or undefined values, unexpected return shapes, and missing guards before the failing access.`;
+    }
+    if (type.includes('referenceerror') ||
+        type.includes('nameerror') ||
+        errorText.includes('is not defined')) {
+        return `${prefix} Verify that the symbol is defined in scope and imported from the expected module.`;
+    }
+    if (type.includes('modulenotfound') ||
+        type.includes('importerror') ||
+        errorText.includes('cannot find module')) {
+        return `${prefix} Re-check dependency installation, import paths, and the runtime working directory.`;
+    }
+    if (errorText.includes('enoent') || type.includes('filenotfounderror')) {
+        return `${prefix} Confirm the file path exists relative to the process working directory and that the caller passes the right path.`;
+    }
+    return `${prefix} Follow the relevant user frames outward from the failing call and verify the inputs reaching that code path.`;
+}
+function formatFrame(frame) {
+    const location = frame.line > 0
+        ? `${frame.file}:${frame.line}${frame.column ? `:${frame.column}` : ''}`
+        : frame.file;
+    const fn = frame.function ? `${frame.function} @ ` : '';
+    const flags = [frame.isNative ? 'native' : null, frame.isNodeModule ? 'node_modules' : null]
+        .filter(Boolean)
+        .join(', ');
+    return `${fn}${location}${flags ? ` [${flags}]` : ''}`;
+}
+function isNodeModuleFile(file) {
+    return /(?:^|[\\/])node_modules(?:[\\/]|$)/.test(file);
+}
+function isNativeLocation(file) {
+    return (file === 'native' ||
+        file.startsWith('node:') ||
+        file.startsWith('internal/') ||
+        file.startsWith('internal\\') ||
+        file.startsWith('<'));
+}