codehere 0.2.1 → 0.3.0-rc.1

package/dist/ast-parser.js

@@ -1,331 +0,0 @@
-/**
- * AST-Based Code Understanding System
- * Deep code analysis for 10X effectiveness
- */
-import { readFileSync } from 'fs';
-import { extname } from 'path';
-import * as ts from 'typescript';
-/**
- * Parse TypeScript/JavaScript file to AST
- */
-export function parseFile(filepath, content) {
-    const ext = extname(filepath).toLowerCase();
-    // Only parse TypeScript/JavaScript files
-    if (!['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
-        return null;
-    }
-    try {
-        const fileContent = content || readFileSync(filepath, 'utf-8');
-        // Create TypeScript compiler host
-        const compilerOptions = {
-            target: ts.ScriptTarget.Latest,
-            module: ts.ModuleKind.ESNext,
-            jsx: ts.JsxEmit.React,
-            allowJs: true,
-            checkJs: false,
-            skipLibCheck: true,
-        };
-        // Parse to AST
-        const sourceFile = ts.createSourceFile(filepath, fileContent, ts.ScriptTarget.Latest, true, ext === '.tsx' || ext === '.jsx' ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
-        const symbols = [];
-        const relationships = [];
-        const imports = [];
-        const exports = [];
-        const dependencies = [];
-        // Visit AST nodes
-        function visit(node, parent) {
-            // Extract imports
-            if (ts.isImportDeclaration(node)) {
-                const moduleSpecifier = node.moduleSpecifier;
-                if (ts.isStringLiteral(moduleSpecifier)) {
-                    imports.push(moduleSpecifier.text);
-                    dependencies.push(moduleSpecifier.text);
-                }
-            }
-            // Extract exports
-            if (ts.isExportDeclaration(node)) {
-                const moduleSpecifier = node.moduleSpecifier;
-                if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
-                    exports.push(moduleSpecifier.text);
-                }
-            }
-            // Extract functions
-            if (ts.isFunctionDeclaration(node) && node.name) {
-                const symbol = extractFunctionSymbol(node, filepath, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            // Extract methods (in classes)
-            if (ts.isMethodDeclaration(node) && node.name) {
-                const symbol = extractMethodSymbol(node, filepath, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            // Extract classes
-            if (ts.isClassDeclaration(node) && node.name) {
-                const symbol = extractClassSymbol(node, filepath, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            // Extract interfaces
-            if (ts.isInterfaceDeclaration(node) && node.name) {
-                const symbol = extractInterfaceSymbol(node, filepath, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            // Extract type aliases
-            if (ts.isTypeAliasDeclaration(node) && node.name) {
-                const symbol = extractTypeSymbol(node, filepath, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            // Extract variables (const, let, var)
-            if ((ts.isVariableDeclaration(node) || ts.isVariableStatement(node)) && parent) {
-                const symbol = extractVariableSymbol(node, filepath, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            // Extract function calls
-            if (ts.isCallExpression(node)) {
-                const callRelationship = extractCallRelationship(node, filepath, sourceFile);
-                if (callRelationship)
-                    relationships.push(callRelationship);
-            }
-            // Extract property access
-            if (ts.isPropertyAccessExpression(node)) {
-                const propRelationship = extractPropertyRelationship(node, filepath, sourceFile);
-                if (propRelationship)
-                    relationships.push(propRelationship);
-            }
-            // Recursively visit children
-            ts.forEachChild(node, (child) => visit(child, node));
-        }
-        visit(sourceFile);
-        return {
-            filepath,
-            symbols,
-            relationships,
-            imports,
-            exports,
-            dependencies: [...new Set(dependencies)],
-            dependents: [],
-            ast: sourceFile,
-        };
-    }
-    catch (error) {
-        console.warn(`Failed to parse ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-function extractFunctionSymbol(node, filepath, sourceFile) {
-    if (!node.name)
-        return null;
-    const name = node.name.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const parameters = node.parameters.map(p => ({
-        name: p.name ? (ts.isIdentifier(p.name) ? p.name.text : '') : '',
-        type: p.type ? sourceFile.text.substring(p.type.getStart(), p.type.getEnd()) : 'any',
-    }));
-    const returnType = node.type
-        ? sourceFile.text.substring(node.type.getStart(), node.type.getEnd())
-        : undefined;
-    const signature = `${name}(${parameters.map(p => `${p.name}: ${p.type}`).join(', ')})${returnType ? `: ${returnType}` : ''}`;
-    const isExported = !!(node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword));
-    const isPrivate = !!(node.modifiers?.some(m => m.kind === ts.SyntaxKind.PrivateKeyword));
-    const docComment = ts.getLeadingCommentRanges(sourceFile.text, node.getFullStart())
-        ?.map(range => sourceFile.text.substring(range.pos, range.end))
-        .join('\n');
-    return {
-        name,
-        kind: 'function',
-        filepath,
-        line: line + 1,
-        column: character + 1,
-        signature,
-        returnType,
-        parameters,
-        isExported,
-        isPrivate,
-        docComment,
-    };
-}
-function extractMethodSymbol(node, filepath, sourceFile) {
-    if (!node.name || !ts.isIdentifier(node.name))
-        return null;
-    const name = node.name.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const parameters = node.parameters.map(p => ({
-        name: p.name ? (ts.isIdentifier(p.name) ? p.name.text : '') : '',
-        type: p.type ? sourceFile.text.substring(p.type.getStart(), p.type.getEnd()) : 'any',
-    }));
-    const returnType = node.type
-        ? sourceFile.text.substring(node.type.getStart(), node.type.getEnd())
-        : undefined;
-    const signature = `${name}(${parameters.map(p => `${p.name}: ${p.type}`).join(', ')})${returnType ? `: ${returnType}` : ''}`;
-    const isExported = false; // Methods are not exported directly
-    const isPrivate = !!(node.modifiers?.some(m => m.kind === ts.SyntaxKind.PrivateKeyword));
-    return {
-        name,
-        kind: 'method',
-        filepath,
-        line: line + 1,
-        column: character + 1,
-        signature,
-        returnType,
-        parameters,
-        isExported,
-        isPrivate,
-    };
-}
-function extractClassSymbol(node, filepath, sourceFile) {
-    if (!node.name)
-        return null;
-    const name = node.name.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const isExported = !!(node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword));
-    return {
-        name,
-        kind: 'class',
-        filepath,
-        line: line + 1,
-        column: character + 1,
-        isExported,
-        isPrivate: false,
-    };
-}
-function extractInterfaceSymbol(node, filepath, sourceFile) {
-    if (!node.name)
-        return null;
-    const name = node.name.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const isExported = !!(node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword));
-    return {
-        name,
-        kind: 'interface',
-        filepath,
-        line: line + 1,
-        column: character + 1,
-        isExported,
-        isPrivate: false,
-    };
-}
-function extractTypeSymbol(node, filepath, sourceFile) {
-    if (!node.name)
-        return null;
-    const name = node.name.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const isExported = !!(node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword));
-    return {
-        name,
-        kind: 'type',
-        filepath,
-        line: line + 1,
-        column: character + 1,
-        isExported,
-        isPrivate: false,
-    };
-}
-function extractVariableSymbol(node, filepath, sourceFile) {
-    let decl;
-    if (ts.isVariableStatement(node)) {
-        if (node.declarationList.declarations.length === 0)
-            return null;
-        decl = node.declarationList.declarations[0];
-    }
-    else {
-        decl = node;
-    }
-    if (!decl.name || !ts.isIdentifier(decl.name))
-        return null;
-    const name = decl.name.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(decl.getStart());
-    const isExported = ts.isVariableStatement(node)
-        ? !!(node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword))
-        : false;
-    return {
-        name,
-        kind: 'variable',
-        filepath,
-        line: line + 1,
-        column: character + 1,
-        isExported,
-        isPrivate: false,
-    };
-}
-function extractCallRelationship(node, filepath, sourceFile) {
-    if (!ts.isIdentifier(node.expression))
-        return null;
-    const functionName = node.expression.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    return {
-        from: 'current-context', // Will be resolved later
-        to: functionName,
-        type: 'calls',
-        filepath,
-        line: line + 1,
-    };
-}
-function extractPropertyRelationship(node, filepath, sourceFile) {
-    if (!ts.isIdentifier(node.name))
-        return null;
-    const propertyName = node.name.text;
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    return {
-        from: 'current-context',
-        to: propertyName,
-        type: 'uses',
-        filepath,
-        line: line + 1,
-    };
-}
-/**
- * Build call graph from multiple files
- */
-export function buildCallGraph(analyses) {
-    const callGraph = new Map();
-    for (const analysis of analyses) {
-        for (const symbol of analysis.symbols) {
-            const calls = [];
-            for (const rel of analysis.relationships) {
-                if (rel.from === 'current-context' || rel.from === symbol.name) {
-                    // Find the target symbol
-                    const targetSymbol = analyses
-                        .flatMap(a => a.symbols)
-                        .find(s => s.name === rel.to);
-                    if (targetSymbol) {
-                        calls.push({
-                            ...rel,
-                            from: symbol.name,
-                        });
-                    }
-                }
-            }
-            if (calls.length > 0) {
-                callGraph.set(symbol.name, calls);
-            }
-        }
-    }
-    return callGraph;
-}
-/**
- * Find all symbols that call a given function
- */
-export function findCallers(functionName, callGraph) {
-    const callers = [];
-    for (const [caller, calls] of callGraph.entries()) {
-        if (calls.some(c => c.to === functionName && c.type === 'calls')) {
-            callers.push(caller);
-        }
-    }
-    return callers;
-}
-/**
- * Find all symbols called by a given function
- */
-export function findCallees(functionName, callGraph) {
-    const calls = callGraph.get(functionName);
-    if (!calls)
-        return [];
-    return calls.filter(c => c.type === 'calls').map(c => c.to);
-}
-//# sourceMappingURL=ast-parser.js.map

package/dist/cache.js

@@ -1,180 +0,0 @@
-/**
- * Performance Optimization & Caching System
- * Improve efficiency with intelligent caching
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { createHash } from 'crypto';
-class MemoryCache {
-    cache = new Map();
-    maxSize;
-    constructor(maxSize = 100) {
-        this.maxSize = maxSize;
-    }
-    set(key, value, ttl = 3600000) {
-        // Remove oldest entries if cache is full
-        if (this.cache.size >= this.maxSize) {
-            const oldestKey = Array.from(this.cache.entries())
-                .sort((a, b) => a[1].timestamp - b[1].timestamp)[0][0];
-            this.cache.delete(oldestKey);
-        }
-        this.cache.set(key, {
-            key,
-            value,
-            timestamp: Date.now(),
-            expiresAt: Date.now() + ttl,
-        });
-    }
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry) {
-            return null;
-        }
-        // Check if expired
-        if (Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            return null;
-        }
-        return entry.value;
-    }
-    has(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return false;
-        if (Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            return false;
-        }
-        return true;
-    }
-    clear() {
-        this.cache.clear();
-    }
-    size() {
-        return this.cache.size;
-    }
-}
-// Global cache instance
-export const memoryCache = new MemoryCache(200);
-/**
- * Generate cache key from parameters
- */
-export function generateCacheKey(...args) {
-    const str = JSON.stringify(args);
-    return createHash('md5').update(str).digest('hex');
-}
-/**
- * Cache wrapper for async functions
- */
-export async function cached(key, fn, ttl = 3600000 // 1 hour default
-) {
-    // Check cache
-    const cached = memoryCache.get(key);
-    if (cached !== null) {
-        return cached;
-    }
-    // Execute and cache
-    const result = await fn();
-    memoryCache.set(key, result, ttl);
-    return result;
-}
-/**
- * File-based cache for embeddings
- */
-function getCacheFilePath(key) {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '..');
-    const cacheDir = join(agentDir, 'data', 'cache');
-    if (!existsSync(cacheDir)) {
-        mkdirSync(cacheDir, { recursive: true });
-    }
-    return join(cacheDir, `${key}.json`);
-}
-/**
- * Cache embeddings to disk
- */
-export function cacheEmbedding(key, embedding) {
-    try {
-        const cacheFile = getCacheFilePath(key);
-        const data = {
-            embedding,
-            timestamp: Date.now(),
-        };
-        writeFileSync(cacheFile, JSON.stringify(data), 'utf-8');
-    }
-    catch (error) {
-        // Silently fail - caching is optional
-    }
-}
-/**
- * Get cached embedding from disk
- */
-export function getCachedEmbedding(key) {
-    try {
-        const cacheFile = getCacheFilePath(key);
-        if (!existsSync(cacheFile)) {
-            return null;
-        }
-        const data = JSON.parse(readFileSync(cacheFile, 'utf-8'));
-        // Check if cache is still valid (24 hours)
-        const maxAge = 24 * 60 * 60 * 1000;
-        if (Date.now() - data.timestamp > maxAge) {
-            return null;
-        }
-        return data.embedding;
-    }
-    catch (error) {
-        return null;
-    }
-}
-/**
- * Clear all caches
- */
-export function clearAllCaches() {
-    memoryCache.clear();
-    // Clear file cache
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        const agentDir = join(__dirname, '..');
-        const cacheDir = join(agentDir, 'data', 'cache');
-        if (existsSync(cacheDir)) {
-            const files = readdirSync(cacheDir);
-            for (const file of files) {
-                if (file.endsWith('.json')) {
-                    unlinkSync(join(cacheDir, file));
-                }
-            }
-        }
-    }
-    catch (error) {
-        // Silently fail
-    }
-}
-/**
- * Get cache statistics
- */
-export function getCacheStats() {
-    let fileCacheCount = 0;
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        const agentDir = join(__dirname, '..');
-        const cacheDir = join(agentDir, 'data', 'cache');
-        if (existsSync(cacheDir)) {
-            const files = readdirSync(cacheDir);
-            fileCacheCount = files.filter((f) => f.endsWith('.json')).length;
-        }
-    }
-    catch (error) {
-        // Ignore
-    }
-    return {
-        memorySize: memoryCache.size(),
-        memoryMaxSize: 200,
-        fileCacheCount,
-    };
-}
-//# sourceMappingURL=cache.js.map