codehere 0.2.2 → 0.3.0-rc.10

package/dist/chat.js

@@ -1,251 +0,0 @@
-import { config } from 'dotenv';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { retryWithBackoff, handleError } from './error-handler.js';
-import { optimizeContext } from './token-optimizer.js';
-import { optimizeQuery } from './query-optimizer.js';
-// Load .env from agent directory
-try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '..');
-    config({ path: join(agentDir, '.env') });
-}
-catch {
-    // Fallback
-}
-config(); // Also try current directory
-async function chatCompletion(prompt) {
-    // Route to available provider
-    if (process.env.ANTHROPIC_API_KEY) {
-        const response = await fetch('https://api.anthropic.com/v1/messages', {
-            method: 'POST',
-            headers: {
-                'x-api-key': process.env.ANTHROPIC_API_KEY,
-                'anthropic-version': '2023-06-01',
-                'content-type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 4096,
-                messages: [{ role: 'user', content: prompt }],
-            }),
-        });
-        if (!response.ok)
-            throw new Error(`Anthropic API error: ${response.status}`);
-        const data = await response.json();
-        return data.content?.[0]?.text || 'No response generated';
-    }
-    if (process.env.OPENAI_API_KEY) {
-        const response = await fetch('https://api.openai.com/v1/chat/completions', {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: 'gpt-4o-mini',
-                messages: [{ role: 'user', content: prompt }],
-                max_tokens: 4096,
-            }),
-        });
-        if (!response.ok)
-            throw new Error(`OpenAI API error: ${response.status}`);
-        const data = await response.json();
-        return data.choices?.[0]?.message?.content || 'No response generated';
-    }
-    if (process.env.COHERE_API_KEY) {
-        const { CohereClient } = require('cohere-ai');
-        const cohere = new CohereClient({ token: process.env.COHERE_API_KEY });
-        const response = await cohere.chat({ message: prompt });
-        return response.text || 'No response generated';
-    }
-    throw new Error('No API key found. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or COHERE_API_KEY.');
-}
-/**
- * Streaming chat completion — yields tokens as they arrive
- */
-async function chatCompletionStream(prompt, onToken) {
-    if (process.env.ANTHROPIC_API_KEY) {
-        const response = await fetch('https://api.anthropic.com/v1/messages', {
-            method: 'POST',
-            headers: {
-                'x-api-key': process.env.ANTHROPIC_API_KEY,
-                'anthropic-version': '2023-06-01',
-                'content-type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 4096,
-                stream: true,
-                messages: [{ role: 'user', content: prompt }],
-            }),
-        });
-        if (!response.ok)
-            throw new Error(`Anthropic API error: ${response.status}`);
-        let fullText = '';
-        const reader = response.body?.getReader();
-        if (!reader)
-            throw new Error('No response body');
-        const decoder = new TextDecoder();
-        let buffer = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.startsWith('data: '))
-                    continue;
-                const data = line.slice(6);
-                if (data === '[DONE]')
-                    continue;
-                try {
-                    const event = JSON.parse(data);
-                    if (event.type === 'content_block_delta' && event.delta?.text) {
-                        const token = event.delta.text;
-                        fullText += token;
-                        onToken(token);
-                    }
-                }
-                catch {
-                    // Skip malformed JSON
-                }
-            }
-        }
-        return fullText || 'No response generated';
-    }
-    // Fallback: non-streaming for other providers
-    const result = await chatCompletion(prompt);
-    onToken(result);
-    return result;
-}
-export async function chatWithContext(query, context) {
-    // Optimize query to understand intent and select strategy
-    const { optimizedQuery, strategy } = optimizeQuery(query);
-    // Optimize context to reduce tokens
-    const optimized = optimizeContext(context, optimizedQuery, strategy.maxTokens, strategy.contextStrategy);
-    // Use optimized chunks
-    const optimizedChunks = optimized.chunks;
-    const contextText = optimizedChunks
-        .map((chunk, idx) => `[Chunk ${idx + 1} from ${chunk.filepath}]\n${chunk.content}`)
-        .join('\n\n---\n\n');
-    const prompt = `You are a strict coding assistant for enterprise environments.
-Use ONLY the provided code context.
-
-CONTEXT:
-
-${contextText}
-
-USER QUERY:
-
-${optimizedQuery}`;
-    return await retryWithBackoff(async () => {
-        return await chatCompletion(prompt);
-    }, {
-        maxRetries: 5,
-        baseDelay: 2000,
-        maxDelay: 60000,
-        operationName: 'chatWithContext',
-        onRetry: (attempt, error) => {
-            console.warn(`Retry attempt ${attempt} for chatWithContext: ${error instanceof Error ? error.message : String(error)}`);
-        },
-    }).catch(error => {
-        handleError(error, {
-            operation: 'chatWithContext',
-            metadata: {
-                query: optimizedQuery,
-                contextCount: optimizedChunks.length,
-                originalContextCount: context.length,
-                tokenReduction: `${optimized.reductionPercent.toFixed(1)}%`,
-            },
-        });
-    });
-}
-/**
- * Chat with context — streaming version
- * Calls onToken for each token as it arrives from the LLM
- */
-export async function chatWithContextStream(query, context, onToken) {
-    const { optimizedQuery, strategy } = optimizeQuery(query);
-    const optimized = optimizeContext(context, optimizedQuery, strategy.maxTokens, strategy.contextStrategy);
-    const optimizedChunks = optimized.chunks;
-    const contextText = optimizedChunks
-        .map((chunk, idx) => `[Chunk ${idx + 1} from ${chunk.filepath}]\n${chunk.content}`)
-        .join('\n\n---\n\n');
-    const prompt = `You are a strict coding assistant for enterprise environments.
-Use ONLY the provided code context.
-
-CONTEXT:
-
-${contextText}
-
-USER QUERY:
-
-${optimizedQuery}`;
-    return chatCompletionStream(prompt, onToken);
-}
-export async function generateDiff(fileContent, instruction, filepath) {
-    const prompt = `You are a code editor. Generate ONLY a unified diff patch that applies cleanly to the file.
-Do not include any explanation, comments, or markdown formatting.
-Return ONLY the raw unified diff starting with "---" and "+++".
-
-CRITICAL RULES:
-1. If renaming a function/class/variable, you MUST update ALL references including:
-   - module.exports statements
-   - export statements
-   - Import statements in other files (if this is an exported item)
-   - All usages within the file
-2. NEVER create duplicate module.exports or export statements
-3. If a function is exported, update the export when renaming
-4. Ensure the diff is complete and correct
-
-File path: ${filepath}
-
-Current file content:
-\`\`\`
-${fileContent}
-\`\`\`
-
-Instruction: ${instruction}
-
-Return the unified diff patch:`;
-    return await retryWithBackoff(async () => {
-        const responseText = await chatCompletion(prompt);
-        return (() => {
-            let diffText = responseText;
-            // Extract diff if wrapped in markdown code blocks
-            const diffMatch = diffText.match(/```(?:diff)?\n([\s\S]*?)```/);
-            if (diffMatch) {
-                diffText = diffMatch[1];
-            }
-            // Ensure it starts with --- or +++
-            if (!diffText.trim().startsWith('---') && !diffText.trim().startsWith('+++')) {
-                // Try to find the diff in the response
-                const lines = diffText.split('\n');
-                const diffStart = lines.findIndex((line) => line.startsWith('---') || line.startsWith('+++'));
-                if (diffStart >= 0) {
-                    diffText = lines.slice(diffStart).join('\n');
-                }
-            }
-            return diffText.trim();
-        })();
-    }, {
-        maxRetries: 5,
-        baseDelay: 2000,
-        maxDelay: 60000,
-        operationName: 'generateDiff',
-        onRetry: (attempt, error) => {
-            console.warn(`Retry attempt ${attempt} for generateDiff: ${error instanceof Error ? error.message : String(error)}`);
-        },
-    }).catch(error => {
-        handleError(error, {
-            operation: 'generateDiff',
-            filepath,
-            metadata: { instruction, fileLength: fileContent.length },
-        });
-    });
-}
-//# sourceMappingURL=chat.js.map

package/dist/code-analysis.js

@@ -1,327 +0,0 @@
-/**
- * Code Analysis Engine
- * Call graph, dependency graph, symbol resolution, import resolution
- */
-import { parseFile, buildCallGraph, findCallers, findCallees } from './ast-parser.js';
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import { join, dirname, extname, resolve } from 'path';
-/**
- * Analyze entire codebase
- */
-export async function analyzeCodebase(baseDir, entryFiles) {
-    const files = new Map();
-    const dependencyGraph = new Map();
-    const callGraph = new Map();
-    const symbols = new Map();
-    // Find all TypeScript/JavaScript files
-    const codeFiles = findCodeFiles(baseDir);
-    // Parse all files
-    for (const filepath of codeFiles) {
-        const analysis = parseFile(filepath);
-        if (analysis) {
-            files.set(filepath, analysis);
-            // Index symbols
-            for (const symbol of analysis.symbols) {
-                symbols.set(symbol.name, {
-                    filepath,
-                    line: symbol.line,
-                    kind: symbol.kind,
-                });
-            }
-        }
-    }
-    // Build dependency graph
-    for (const [filepath, analysis] of files.entries()) {
-        const resolvedDeps = analysis.imports
-            .map(imp => resolveImport(imp, filepath, baseDir, files))
-            .filter((dep) => dep !== null);
-        const dependents = Array.from(files.entries())
-            .filter(([_, a]) => a.imports.some(imp => resolveImport(imp, filepath, baseDir, files) === filepath))
-            .map(([fp]) => fp);
-        dependencyGraph.set(filepath, {
-            filepath,
-            dependencies: resolvedDeps,
-            dependents,
-            depth: 0, // Will be calculated
-        });
-    }
-    // Calculate dependency depths
-    const entryPoints = entryFiles || findEntryPoints(files, dependencyGraph);
-    calculateDepths(dependencyGraph, entryPoints);
-    // Build call graph
-    const astCallGraph = buildCallGraph(Array.from(files.values()));
-    for (const [symbolName, calls] of astCallGraph.entries()) {
-        const symbol = symbols.get(symbolName);
-        if (!symbol)
-            continue;
-        const calledBy = findCallers(symbolName, astCallGraph);
-        const callees = findCallees(symbolName, astCallGraph);
-        callGraph.set(symbolName, {
-            symbol: symbolName,
-            filepath: symbol.filepath,
-            calls: callees,
-            calledBy,
-            depth: 0, // Will be calculated
-        });
-    }
-    // Calculate call depths
-    calculateCallDepths(callGraph, entryPoints, symbols);
-    return {
-        files,
-        dependencyGraph,
-        callGraph,
-        entryPoints,
-        symbols,
-    };
-}
-/**
- * Find all code files in directory
- */
-function findCodeFiles(dir) {
-    const files = [];
-    try {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(dir, entry.name);
-            // Skip node_modules, .git, etc.
-            if (entry.name.startsWith('.') || entry.name === 'node_modules') {
-                continue;
-            }
-            if (entry.isDirectory()) {
-                files.push(...findCodeFiles(fullPath));
-            }
-            else if (entry.isFile()) {
-                const ext = extname(entry.name).toLowerCase();
-                if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
-                    files.push(fullPath);
-                }
-            }
-        }
-    }
-    catch {
-        // Skip directories we can't read
-    }
-    return files;
-}
-/**
- * Resolve import to actual file path
- * FIXED: Better resolution for node_modules, aliases, and relative paths
- */
-function resolveImport(importPath, fromFile, baseDir, files) {
-    // Handle node_modules imports (check package.json for resolution)
-    if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
-        // Try to resolve from node_modules
-        const nodeModulesPath = join(baseDir, 'node_modules', importPath);
-        const extensions = ['.ts', '.tsx', '.js', '.jsx', ''];
-        for (const ext of extensions) {
-            const withExt = nodeModulesPath + ext;
-            if (existsSync(withExt)) {
-                return withExt;
-            }
-            // Try package.json main field
-            const packageJsonPath = join(nodeModulesPath, 'package.json');
-            if (existsSync(packageJsonPath)) {
-                try {
-                    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                    const mainFile = packageJson.main || packageJson.module || 'index.js';
-                    const mainPath = join(nodeModulesPath, mainFile);
-                    if (existsSync(mainPath)) {
-                        return mainPath;
-                    }
-                }
-                catch {
-                    // Skip invalid package.json
-                }
-            }
-            // Try index files
-            const indexFile = join(nodeModulesPath, `index${ext}`);
-            if (existsSync(indexFile)) {
-                return indexFile;
-            }
-        }
-        return null; // External dependency, not in our codebase
-    }
-    const fromDir = dirname(fromFile);
-    let resolved;
-    try {
-        resolved = resolve(fromDir, importPath);
-    }
-    catch {
-        return null;
-    }
-    // Try with extensions
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', ''];
-    for (const ext of extensions) {
-        const withExt = resolved + ext;
-        if (files.has(withExt) || existsSync(withExt)) {
-            return withExt;
-        }
-        // Try index files
-        const indexFile = join(resolved, `index${ext}`);
-        if (files.has(indexFile) || existsSync(indexFile)) {
-            return indexFile;
-        }
-    }
-    // Try resolving from baseDir (for absolute imports from project root)
-    try {
-        const fromBase = resolve(baseDir, importPath);
-        for (const ext of extensions) {
-            const withExt = fromBase + ext;
-            if (files.has(withExt) || existsSync(withExt)) {
-                return withExt;
-            }
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return null;
-}
-/**
- * Find entry points (main files, index files)
- */
-function findEntryPoints(files, dependencyGraph) {
-    const entryPoints = [];
-    // Files with no dependencies (or only external dependencies)
-    for (const [filepath, graph] of dependencyGraph.entries()) {
-        if (graph.dependencies.length === 0) {
-            entryPoints.push(filepath);
-        }
-    }
-    // Index files
-    for (const filepath of files.keys()) {
-        if (filepath.endsWith('index.ts') || filepath.endsWith('index.js') ||
-            filepath.endsWith('main.ts') || filepath.endsWith('main.js') ||
-            filepath.endsWith('app.ts') || filepath.endsWith('app.js')) {
-            if (!entryPoints.includes(filepath)) {
-                entryPoints.push(filepath);
-            }
-        }
-    }
-    return entryPoints.length > 0 ? entryPoints : Array.from(files.keys()).slice(0, 1);
-}
-/**
- * Calculate dependency depths from entry points
- */
-function calculateDepths(dependencyGraph, entryPoints) {
-    const visited = new Set();
-    const queue = entryPoints.map(ep => ({ filepath: ep, depth: 0 }));
-    while (queue.length > 0) {
-        const { filepath, depth } = queue.shift();
-        if (visited.has(filepath))
-            continue;
-        visited.add(filepath);
-        const graph = dependencyGraph.get(filepath);
-        if (!graph)
-            continue;
-        graph.depth = depth;
-        // Add dependents to queue
-        for (const dependent of graph.dependents) {
-            if (!visited.has(dependent)) {
-                queue.push({ filepath: dependent, depth: depth + 1 });
-            }
-        }
-    }
-}
-/**
- * Calculate call depths from entry points
- */
-function calculateCallDepths(callGraph, entryPoints, symbols) {
-    // Find entry symbols (exported from entry files)
-    const entrySymbols = [];
-    for (const entryFile of entryPoints) {
-        for (const [symbolName, symbol] of symbols.entries()) {
-            if (symbol.filepath === entryFile) {
-                entrySymbols.push(symbolName);
-            }
-        }
-    }
-    const visited = new Set();
-    const queue = entrySymbols.map(s => ({ symbol: s, depth: 0 }));
-    while (queue.length > 0) {
-        const { symbol, depth } = queue.shift();
-        if (visited.has(symbol))
-            continue;
-        visited.add(symbol);
-        const node = callGraph.get(symbol);
-        if (!node)
-            continue;
-        node.depth = depth;
-        // Add callees to queue
-        for (const callee of node.calls) {
-            if (!visited.has(callee)) {
-                queue.push({ symbol: callee, depth: depth + 1 });
-            }
-        }
-    }
-}
-/**
- * Find all files that depend on a given file
- */
-export function findDependents(filepath, dependencyGraph) {
-    const graph = dependencyGraph.get(filepath);
-    if (!graph)
-        return [];
-    const allDependents = new Set(graph.dependents);
-    // Recursively find dependents of dependents
-    for (const dependent of graph.dependents) {
-        const depDependents = findDependents(dependent, dependencyGraph);
-        depDependents.forEach(d => allDependents.add(d));
-    }
-    return Array.from(allDependents);
-}
-/**
- * Find all files that a given file depends on
- */
-export function findDependencies(filepath, dependencyGraph) {
-    const graph = dependencyGraph.get(filepath);
-    if (!graph)
-        return [];
-    const allDependencies = new Set(graph.dependencies);
-    // Recursively find dependencies of dependencies
-    for (const dep of graph.dependencies) {
-        const depDeps = findDependencies(dep, dependencyGraph);
-        depDeps.forEach(d => allDependencies.add(d));
-    }
-    return Array.from(allDependencies);
-}
-/**
- * Get impact of changing a file (what breaks)
- */
-export function getChangeImpact(filepath, codebaseAnalysis) {
-    const dependents = findDependents(filepath, codebaseAnalysis.dependencyGraph);
-    const fileAnalysis = codebaseAnalysis.files.get(filepath);
-    if (!fileAnalysis) {
-        return {
-            affectedFiles: [],
-            affectedSymbols: [],
-            riskLevel: 'low',
-        };
-    }
-    const affectedSymbols = [];
-    // Find all symbols that use symbols from this file
-    for (const symbol of fileAnalysis.symbols) {
-        if (symbol.isExported) {
-            // Find all usages of this symbol
-            for (const [otherFilepath, otherAnalysis] of codebaseAnalysis.files.entries()) {
-                if (otherFilepath === filepath)
-                    continue;
-                const usesSymbol = otherAnalysis.relationships.some(rel => rel.to === symbol.name || rel.from === symbol.name);
-                if (usesSymbol) {
-                    affectedSymbols.push(symbol.name);
-                }
-            }
-        }
-    }
-    const riskLevel = dependents.length > 10 || affectedSymbols.length > 5
-        ? 'high'
-        : dependents.length > 3 || affectedSymbols.length > 2
-            ? 'medium'
-            : 'low';
-    return {
-        affectedFiles: dependents,
-        affectedSymbols: [...new Set(affectedSymbols)],
-        riskLevel,
-    };
-}
-//# sourceMappingURL=code-analysis.js.map