codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/cache/query-result-cache.js

@@ -1,66 +0,0 @@
-/**
- * Query Result Cache
- * Caches search query results
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { createHash } from 'crypto';
-class QueryResultCache {
-    cache = new Map();
-    hits = 0;
-    misses = 0;
-    ttl = 3600000; // 1 hour
-    get(query, maxResults) {
-        const key = this.getCacheKey(query, maxResults);
-        const cached = this.cache.get(key);
-        if (cached) {
-            const age = Date.now() - cached.timestamp;
-            if (age < this.ttl) {
-                return cached.chunks;
-            }
-            else {
-                this.cache.delete(key);
-            }
-        }
-        return null;
-    }
-    set(query, maxResults, chunks) {
-        const key = this.getCacheKey(query, maxResults);
-        this.cache.set(key, {
-            chunks,
-            timestamp: Date.now(),
-            query,
-        });
-    }
-    recordHit() {
-        this.hits++;
-    }
-    recordMiss() {
-        this.misses++;
-    }
-    getStats() {
-        const total = this.hits + this.misses;
-        return {
-            hitRate: total > 0 ? this.hits / total : 0,
-            totalHits: this.hits,
-            totalMisses: this.misses,
-        };
-    }
-    clear() {
-        this.cache.clear();
-        this.hits = 0;
-        this.misses = 0;
-    }
-    getCacheKey(query, maxResults) {
-        const normalized = query.trim().toLowerCase();
-        return createHash('sha256').update(`${normalized}:${maxResults}`).digest('hex');
-    }
-}
-let instance = null;
-export function getQueryResultCache() {
-    if (!instance) {
-        instance = new QueryResultCache();
-    }
-    return instance;
-}
-//# sourceMappingURL=query-result-cache.js.map

package/dist/infrastructure/cache/response-cache.js

@@ -1,48 +0,0 @@
-/**
- * Response Cache
- * Caches AI-generated responses
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { createHash } from 'crypto';
-class ResponseCache {
-    cache = new Map();
-    ttl = 3600000; // 1 hour
-    generateContextHash(chunks) {
-        const chunkIds = chunks.map(c => c.id || c.filepath).sort().join(',');
-        return createHash('sha256').update(chunkIds).digest('hex');
-    }
-    get(query, contextHash, checkStale = false) {
-        const key = this.getCacheKey(query, contextHash);
-        const cached = this.cache.get(key);
-        if (cached) {
-            if (!checkStale || (Date.now() - cached.timestamp) < this.ttl) {
-                return cached.response;
-            }
-            else {
-                this.cache.delete(key);
-            }
-        }
-        return null;
-    }
-    set(query, response, contextHash) {
-        const key = this.getCacheKey(query, contextHash);
-        this.cache.set(key, {
-            response,
-            timestamp: Date.now(),
-            contextHash,
-        });
-    }
-    getCacheKey(query, contextHash) {
-        const normalized = query.trim().toLowerCase();
-        return createHash('sha256').update(`${normalized}:${contextHash}`).digest('hex');
-    }
-}
-let instance = null;
-export function getResponseCache() {
-    if (!instance) {
-        instance = new ResponseCache();
-    }
-    return instance;
-}
-//# sourceMappingURL=response-cache.js.map

package/dist/infrastructure/cache/security-scan-cache.js

@@ -1,47 +0,0 @@
-/**
- * Security Scan Cache
- * Caches security scan results
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { createHash } from 'crypto';
-class SecurityScanCache {
-    cache = new Map();
-    ttl = 3600000; // 1 hour
-    get(filepath, contentHash) {
-        const key = `${filepath}:${contentHash}`;
-        const cached = this.cache.get(key);
-        if (cached) {
-            const age = Date.now() - cached.timestamp;
-            if (age < this.ttl) {
-                return cached.results;
-            }
-            else {
-                this.cache.delete(key);
-            }
-        }
-        return null;
-    }
-    set(filepath, code, sast, license, providerBias) {
-        // Create hash from code content
-        const contentHash = createHash('sha256').update(code).digest('hex');
-        const key = `${filepath}:${contentHash}`;
-        this.cache.set(key, {
-            filepath,
-            hash: contentHash,
-            results: { sast, license, providerBias },
-            timestamp: Date.now(),
-        });
-    }
-    clear() {
-        this.cache.clear();
-    }
-}
-let instance = null;
-export function getSecurityScanCache() {
-    if (!instance) {
-        instance = new SecurityScanCache();
-    }
-    return instance;
-}
-//# sourceMappingURL=security-scan-cache.js.map

package/dist/infrastructure/chunking/ast-code-chunker.js

@@ -1,19 +0,0 @@
-/**
- * Infrastructure: AST-Based Code Chunker
- * Implements ICodeChunker using code-aware chunking
- */
-import { CodeAwareChunker } from './code-aware-chunker.js';
-export class ASTCodeChunker {
-    chunker;
-    constructor() {
-        this.chunker = new CodeAwareChunker();
-    }
-    async chunk(filepath) {
-        return await this.chunker.chunk(filepath, {
-            preserveSyntax: true,
-            hierarchical: true,
-            maxChunkSize: 2000, // tokens
-        });
-    }
-}
-//# sourceMappingURL=ast-code-chunker.js.map

package/dist/infrastructure/chunking/code-aware-chunker.js

@@ -1,397 +0,0 @@
-/**
- * Infrastructure: Code-Aware Chunker
- * Implements enterprise-grade code chunking that respects code structure
- *
- * Based on enterprise architecture requirements:
- * - Split by logical units (functions, classes, modules)
- * - Preserve syntactic integrity
- * - Hierarchical strategy (high-level docs → functions → lines)
- */
-import { readFileSync, existsSync } from 'fs';
-import { parseFile } from '../../ast-parser.js';
-export class CodeAwareChunker {
-    /**
-     * Chunk code file by logical units (functions, classes, modules)
-     * Preserves syntactic integrity - all chunks are valid code blocks
-     */
-    async chunk(filepath, options = {}) {
-        const { preserveSyntax = true, hierarchical = true, maxChunkSize = 2000, // tokens (roughly 8000 chars)
-         } = options;
-        if (!existsSync(filepath)) {
-            throw new Error(`File not found: ${filepath}`);
-        }
-        const content = readFileSync(filepath, 'utf-8');
-        const ext = filepath.split('.').pop()?.toLowerCase() || '';
-        // For non-code files, use document-based chunking
-        if (!['ts', 'tsx', 'js', 'jsx', 'py', 'java', 'go', 'rs', 'cpp', 'c'].includes(ext)) {
-            return this.chunkDocument(content, filepath, maxChunkSize);
-        }
-        // For code files, use AST-based chunking
-        try {
-            const analysis = await parseFile(filepath);
-            if (!analysis) {
-                // Fallback to function-based chunking if AST parsing returns null
-                return this.chunkByFunctions(content, filepath, maxChunkSize);
-            }
-            return this.chunkByAST(analysis, content, filepath, hierarchical, maxChunkSize);
-        }
-        catch (error) {
-            // Fallback to function-based chunking if AST parsing fails
-            console.warn(`AST parsing failed for ${filepath}, using function-based chunking:`, error);
-            return this.chunkByFunctions(content, filepath, maxChunkSize);
-        }
-    }
-    /**
-     * Map symbol kind to chunk metadata type
-     */
-    mapSymbolKindToChunkType(kind) {
-        const kindMap = {
-            'function': 'function',
-            'method': 'function',
-            'class': 'class',
-            'interface': 'interface',
-            'type': 'code-block',
-            'variable': 'code-block',
-            'enum': 'code-block',
-            'property': 'code-block',
-        };
-        return kindMap[kind] || 'code-block';
-    }
-    /**
-     * Chunk using AST analysis - most precise method
-     */
-    chunkByAST(analysis, content, filepath, hierarchical, maxChunkSize) {
-        const chunks = [];
-        const lines = content.split('\n');
-        // Hierarchical strategy: classes → functions → statements
-        if (hierarchical) {
-            // Level 1: Chunk by classes/interfaces
-            for (const symbol of analysis.symbols) {
-                if (symbol.kind === 'class' || symbol.kind === 'interface') {
-                    const classChunk = this.extractSymbolContent(symbol, lines, content);
-                    if (classChunk && classChunk.length <= maxChunkSize) {
-                        chunks.push({
-                            filepath,
-                            content: classChunk,
-                            score: 1.0,
-                            lineStart: symbol.line,
-                            lineEnd: symbol.line + classChunk.split('\n').length,
-                            metadata: {
-                                symbols: [symbol.name],
-                                type: this.mapSymbolKindToChunkType(symbol.kind),
-                            },
-                        });
-                    }
-                    else if (classChunk) {
-                        // Class too large, chunk by methods
-                        const methodChunks = this.chunkLargeClass(symbol, analysis, lines, content, maxChunkSize);
-                        chunks.push(...methodChunks);
-                    }
-                }
-            }
-            // Level 2: Chunk standalone functions
-            for (const symbol of analysis.symbols) {
-                if (symbol.kind === 'function' && !this.isMethodOfClass(symbol, analysis)) {
-                    const funcChunk = this.extractSymbolContent(symbol, lines, content);
-                    if (funcChunk && funcChunk.length <= maxChunkSize) {
-                        chunks.push({
-                            filepath,
-                            content: funcChunk,
-                            score: 1.0,
-                            lineStart: symbol.line,
-                            lineEnd: symbol.line + funcChunk.split('\n').length,
-                            metadata: {
-                                symbols: [symbol.name],
-                                type: 'function',
-                            },
-                        });
-                    }
-                }
-            }
-        }
-        else {
-            // Non-hierarchical: chunk all symbols
-            for (const symbol of analysis.symbols) {
-                const symbolChunk = this.extractSymbolContent(symbol, lines, content);
-                if (symbolChunk) {
-                    chunks.push({
-                        filepath,
-                        content: symbolChunk,
-                        score: 1.0,
-                        lineStart: symbol.line,
-                        lineEnd: symbol.line + symbolChunk.split('\n').length,
-                        metadata: {
-                            symbols: [symbol.name],
-                            type: this.mapSymbolKindToChunkType(symbol.kind),
-                        },
-                    });
-                }
-            }
-        }
-        // If no chunks created (no symbols found), fallback to function-based
-        if (chunks.length === 0) {
-            return this.chunkByFunctions(content, filepath, maxChunkSize);
-        }
-        return chunks;
-    }
-    /**
-     * Chunk large class by its methods
-     */
-    chunkLargeClass(classSymbol, analysis, lines, content, maxChunkSize) {
-        const chunks = [];
-        const classStart = classSymbol.line;
-        const classEnd = this.findClassEnd(classSymbol, lines);
-        // Find methods within this class
-        const methods = analysis.symbols.filter(s => s.kind === 'function' && s.line > classStart && s.line < classEnd);
-        // Create chunk for class header + first few methods
-        let currentChunk = lines.slice(classStart - 1, classStart + 10).join('\n');
-        let currentLineStart = classStart;
-        for (const method of methods) {
-            const methodContent = this.extractSymbolContent(method, lines, content);
-            if (!methodContent)
-                continue;
-            const potentialChunk = currentChunk + '\n\n' + methodContent;
-            if (potentialChunk.length <= maxChunkSize) {
-                currentChunk = potentialChunk;
-            }
-            else {
-                // Save current chunk and start new one
-                chunks.push({
-                    filepath: classSymbol.filepath,
-                    content: currentChunk,
-                    score: 1.0,
-                    lineStart: currentLineStart,
-                    lineEnd: method.line - 1,
-                    metadata: {
-                        symbols: [classSymbol.name],
-                        type: 'class-partial',
-                    },
-                });
-                currentChunk = methodContent;
-                currentLineStart = method.line;
-            }
-        }
-        // Add final chunk
-        if (currentChunk) {
-            chunks.push({
-                filepath: classSymbol.filepath,
-                content: currentChunk,
-                score: 1.0,
-                lineStart: currentLineStart,
-                lineEnd: classEnd,
-                metadata: {
-                    symbols: [classSymbol.name],
-                    type: 'class-partial',
-                },
-            });
-        }
-        return chunks;
-    }
-    /**
-     * Chunk by function boundaries (fallback method)
-     */
-    chunkByFunctions(content, filepath, maxChunkSize) {
-        const chunks = [];
-        const lines = content.split('\n');
-        // Regex patterns for different languages
-        const functionPatterns = [
-            /^(export\s+)?(async\s+)?function\s+(\w+)/, // JavaScript/TypeScript
-            /^(export\s+)?(async\s+)?const\s+(\w+)\s*=\s*(async\s*)?\(/, // Arrow functions
-            /^(export\s+)?class\s+(\w+)/, // Classes
-            /^(export\s+)?interface\s+(\w+)/, // Interfaces
-            /^def\s+(\w+)/, // Python
-        ];
-        let currentChunk = [];
-        let currentLineStart = 1;
-        let braceCount = 0;
-        let inFunction = false;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const isFunctionStart = functionPatterns.some(pattern => pattern.test(line));
-            if (isFunctionStart && currentChunk.length > 0) {
-                // Save previous chunk
-                const chunkContent = currentChunk.join('\n');
-                if (chunkContent.trim().length > 0) {
-                    chunks.push({
-                        filepath,
-                        content: chunkContent,
-                        score: 1.0,
-                        lineStart: currentLineStart,
-                        lineEnd: i - 1,
-                        metadata: {
-                            type: 'function',
-                        },
-                    });
-                }
-                currentChunk = [line];
-                currentLineStart = i + 1;
-                inFunction = true;
-                braceCount = this.countBraces(line);
-            }
-            else {
-                currentChunk.push(line);
-                if (inFunction) {
-                    braceCount += this.countBraces(line);
-                    if (braceCount === 0 && line.trim().length > 0) {
-                        inFunction = false;
-                    }
-                }
-                // If chunk gets too large, split it
-                if (currentChunk.join('\n').length > maxChunkSize && currentChunk.length > 10) {
-                    const chunkContent = currentChunk.slice(0, -5).join('\n');
-                    chunks.push({
-                        filepath,
-                        content: chunkContent,
-                        score: 1.0,
-                        lineStart: currentLineStart,
-                        lineEnd: i - 5,
-                        metadata: {
-                            type: 'code-block',
-                        },
-                    });
-                    currentChunk = currentChunk.slice(-5);
-                    currentLineStart = i - 4;
-                }
-            }
-        }
-        // Add final chunk
-        if (currentChunk.length > 0) {
-            chunks.push({
-                filepath,
-                content: currentChunk.join('\n'),
-                score: 1.0,
-                lineStart: currentLineStart,
-                lineEnd: lines.length,
-                metadata: {
-                    type: 'code-block',
-                },
-            });
-        }
-        return chunks.length > 0 ? chunks : [{
-                filepath,
-                content,
-                score: 1.0,
-                lineStart: 1,
-                lineEnd: lines.length,
-                metadata: {
-                    type: 'file',
-                },
-            }];
-    }
-    /**
-     * Chunk document files (markdown, text, etc.)
-     */
-    chunkDocument(content, filepath, maxChunkSize) {
-        const chunks = [];
-        const paragraphs = content.split(/\n\s*\n/);
-        let currentChunk = [];
-        let currentLineStart = 1;
-        for (const paragraph of paragraphs) {
-            const potentialChunk = [...currentChunk, paragraph].join('\n\n');
-            if (potentialChunk.length <= maxChunkSize) {
-                currentChunk.push(paragraph);
-            }
-            else {
-                if (currentChunk.length > 0) {
-                    chunks.push({
-                        filepath,
-                        content: currentChunk.join('\n\n'),
-                        score: 1.0,
-                        lineStart: currentLineStart,
-                        lineEnd: currentLineStart + currentChunk.join('\n\n').split('\n').length,
-                        metadata: {
-                            type: 'document',
-                        },
-                    });
-                }
-                currentChunk = [paragraph];
-                currentLineStart += currentChunk.join('\n\n').split('\n').length;
-            }
-        }
-        if (currentChunk.length > 0) {
-            chunks.push({
-                filepath,
-                content: currentChunk.join('\n\n'),
-                score: 1.0,
-                lineStart: currentLineStart,
-                lineEnd: content.split('\n').length,
-                metadata: {
-                    type: 'document',
-                },
-            });
-        }
-        return chunks.length > 0 ? chunks : [{
-                filepath,
-                content,
-                score: 1.0,
-                lineStart: 1,
-                lineEnd: content.split('\n').length,
-                metadata: {
-                    type: 'document',
-                },
-            }];
-    }
-    /**
-     * Extract content for a symbol from AST
-     */
-    extractSymbolContent(symbol, lines, content) {
-        if (!symbol.line)
-            return null;
-        const startLine = symbol.line - 1; // 0-indexed
-        const endLine = this.findSymbolEnd(symbol, lines, startLine);
-        if (endLine <= startLine)
-            return null;
-        return lines.slice(startLine, endLine).join('\n');
-    }
-    /**
-     * Find end of symbol (class, function, etc.)
-     */
-    findSymbolEnd(symbol, lines, startLine) {
-        // Simple heuristic: find matching braces
-        let braceCount = 0;
-        let foundStart = false;
-        for (let i = startLine; i < lines.length; i++) {
-            const line = lines[i];
-            if (!foundStart) {
-                if (line.includes('{') || line.includes('class') || line.includes('function')) {
-                    foundStart = true;
-                    braceCount = this.countBraces(line);
-                }
-            }
-            else {
-                braceCount += this.countBraces(line);
-                if (braceCount === 0 && line.trim().length > 0) {
-                    return i + 1;
-                }
-            }
-        }
-        return lines.length;
-    }
-    /**
-     * Find end of class
-     */
-    findClassEnd(classSymbol, lines) {
-        return this.findSymbolEnd(classSymbol, lines, classSymbol.line - 1);
-    }
-    /**
-     * Count braces in line
-     */
-    countBraces(line) {
-        return (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
-    }
-    /**
-     * Check if function is a method of a class
-     */
-    isMethodOfClass(funcSymbol, analysis) {
-        // Find classes before this function
-        const classes = analysis.symbols.filter(s => s.kind === 'class' && s.line < funcSymbol.line);
-        // Find the closest class
-        const closestClass = classes.reduce((prev, curr) => curr.line > prev.line ? curr : prev, classes[0] || { line: 0 });
-        if (!closestClass)
-            return false;
-        // Check if function is within class bounds (simple heuristic)
-        const classEnd = this.findClassEnd(closestClass, analysis.symbols.map(() => ''));
-        return funcSymbol.line > closestClass.line && funcSymbol.line < classEnd;
-    }
-}
-//# sourceMappingURL=code-aware-chunker.js.map