codehere 0.2.2 → 0.3.0-rc.10

package/dist/domain/services/pattern-extractor.js

@@ -1,442 +0,0 @@
-/**
- * Domain Service: PatternExtractor
- * Extracts patterns from code, memories, and codebase analysis
- *
- * Clean Architecture: Domain Layer
- * Pattern: Strategy Pattern (different extraction strategies for different pattern types)
- *
- * Responsibilities:
- * - Extract patterns from code files
- * - Extract patterns from memory reflections
- * - Identify pattern types (architectural, structural, behavioral, etc.)
- * - Store patterns in pattern repository
- */
-import { randomUUID } from 'crypto';
-/**
- * Pattern Extractor Service
- * Uses AI to identify and extract patterns from various sources
- */
-export class PatternExtractor {
-    patternRepository;
-    aiService;
-    constructor(patternRepository, aiService) {
-        this.patternRepository = patternRepository;
-        this.aiService = aiService;
-    }
-    /**
-     * Extract patterns from code
-     */
-    async extractFromCode(request) {
-        if (!request.content || !request.filepath) {
-            throw new Error('Code extraction requires content and filepath');
-        }
-        const patterns = [];
-        // Strategy 1: Structural pattern detection (file organization)
-        const structuralPatterns = this.extractStructuralPatterns(request);
-        patterns.push(...structuralPatterns);
-        // Strategy 2: Use AI to identify architectural and behavioral patterns
-        const aiPatterns = await this.extractPatternsWithAI(request);
-        patterns.push(...aiPatterns);
-        // Strategy 3: Extract idiomatic patterns (language-specific)
-        const idiomaticPatterns = await this.extractIdiomaticPatterns(request);
-        patterns.push(...idiomaticPatterns);
-        // Store patterns in repository
-        for (const pattern of patterns) {
-            await this.patternRepository.store(pattern);
-        }
-        return {
-            patterns,
-            extractionMethod: 'code-analysis',
-            confidence: this.calculateConfidence(patterns),
-        };
-    }
-    /**
-     * Extract patterns from memory reflections
-     */
-    async extractFromMemory(memories, codebaseId, codebasePath) {
-        const patterns = [];
-        // Analyze memories for recurring patterns
-        for (const memory of memories) {
-            if (memory.type === 'reflection' && memory.description) {
-                // Extract patterns from reflection descriptions
-                const reflectionPatterns = await this.extractFromReflection(memory.description, codebaseId, codebasePath, memory);
-                patterns.push(...reflectionPatterns);
-            }
-        }
-        // Store patterns
-        for (const pattern of patterns) {
-            await this.patternRepository.store(pattern);
-        }
-        return {
-            patterns,
-            extractionMethod: 'memory-analysis',
-            confidence: this.calculateConfidence(patterns),
-        };
-    }
-    /**
-     * Extract patterns from a reflection description
-     */
-    async extractFromReflection(reflectionDescription, codebaseId, codebasePath, memory) {
-        const patterns = [];
-        // Use AI to identify patterns in reflection
-        const prompt = `Analyze this reflection and extract any code patterns, architectural decisions, or conventions mentioned:
-
-${reflectionDescription}
-
-Extract patterns in JSON format:
-[
-  {
-    "type": "architectural|structural|behavioral|idiomatic|convention|design|custom",
-    "name": "Pattern name",
-    "description": "Pattern description",
-    "confidence": 0.0-1.0,
-    "tags": ["tag1", "tag2"]
-  }
-]
-
-Only extract patterns with confidence > 0.6. Return valid JSON array.`;
-        try {
-            const response = await this.aiService.chat(prompt, []);
-            const jsonMatch = response.match(/\[[\s\S]*\]/);
-            if (jsonMatch) {
-                const extractedPatterns = JSON.parse(jsonMatch[0]);
-                for (const extracted of extractedPatterns) {
-                    if (extracted.confidence > 0.6) {
-                        const pattern = {
-                            id: randomUUID(),
-                            codebaseId,
-                            type: extracted.type,
-                            name: extracted.name,
-                            description: extracted.description,
-                            codeExample: undefined, // Can be extracted from memory description if needed
-                            filepath: memory.metadata?.filepath,
-                            lineNumbers: undefined, // Not stored in memory metadata
-                            metadata: {
-                                tags: extracted.tags || [],
-                                confidence: Math.round(extracted.confidence * 10), // Convert to 1-10 scale
-                                extractedFrom: 'reflection',
-                                source: memory.id,
-                            },
-                            createdAt: new Date(),
-                            usageCount: 0,
-                        };
-                        patterns.push(pattern);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // If AI extraction fails, fall back to keyword-based extraction
-            console.warn('AI pattern extraction failed, using keyword-based extraction:', error);
-            const keywordPatterns = this.extractPatternsByKeywords(reflectionDescription, codebaseId, codebasePath);
-            patterns.push(...keywordPatterns);
-        }
-        return patterns;
-    }
-    /**
-     * Extract structural patterns from code (file organization, naming conventions)
-     */
-    extractStructuralPatterns(request) {
-        const patterns = [];
-        const { content, filepath, codebaseId, codebasePath } = request;
-        if (!content || !filepath)
-            return patterns;
-        // Detect file organization patterns
-        const pathParts = filepath.split('/');
-        const fileName = pathParts[pathParts.length - 1];
-        const directory = pathParts.slice(0, -1).join('/');
-        // Pattern: File naming convention
-        if (this.detectNamingConvention(fileName)) {
-            patterns.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'convention',
-                name: 'File Naming Convention',
-                description: `Files follow naming pattern: ${this.getNamingPattern(fileName)}`,
-                filepath,
-                metadata: {
-                    tags: ['naming', 'convention'],
-                    confidence: 8,
-                    extractedFrom: 'code',
-                },
-                createdAt: new Date(),
-                usageCount: 0,
-            });
-        }
-        // Pattern: Directory structure
-        if (this.detectDirectoryStructure(directory)) {
-            patterns.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'structural',
-                name: 'Directory Structure Pattern',
-                description: `Code organized in: ${this.getDirectoryPattern(directory)}`,
-                filepath: directory,
-                metadata: {
-                    tags: ['structure', 'organization'],
-                    confidence: 7,
-                    extractedFrom: 'code',
-                },
-                createdAt: new Date(),
-                usageCount: 0,
-            });
-        }
-        return patterns;
-    }
-    /**
-     * Extract patterns using AI analysis
-     */
-    async extractPatternsWithAI(request) {
-        const patterns = [];
-        const { content, filepath, codebaseId, codebasePath } = request;
-        if (!content)
-            return patterns;
-        const prompt = `Analyze this code and identify patterns (architectural, design, behavioral):
-
-\`\`\`
-${content.substring(0, 3000)} // Limit to avoid token limits
-\`\`\`
-
-Extract patterns in JSON format:
-[
-  {
-    "type": "architectural|structural|behavioral|idiomatic|convention|design|custom",
-    "name": "Pattern name",
-    "description": "What this pattern does",
-    "codeExample": "Key code snippet showing pattern",
-    "confidence": 0.0-1.0,
-    "tags": ["tag1", "tag2"],
-    "complexity": 1-10
-  }
-]
-
-Only extract patterns with confidence > 0.7. Return valid JSON array.`;
-        try {
-            const response = await this.aiService.chat(prompt, []);
-            const jsonMatch = response.match(/\[[\s\S]*\]/);
-            if (jsonMatch) {
-                const extractedPatterns = JSON.parse(jsonMatch[0]);
-                for (const extracted of extractedPatterns) {
-                    if (extracted.confidence > 0.7) {
-                        const pattern = {
-                            id: randomUUID(),
-                            codebaseId,
-                            type: extracted.type,
-                            name: extracted.name,
-                            description: extracted.description,
-                            codeExample: extracted.codeExample || content.substring(0, 500),
-                            filepath,
-                            lineNumbers: request.lineNumbers,
-                            metadata: {
-                                tags: extracted.tags || [],
-                                confidence: Math.round(extracted.confidence * 10),
-                                complexity: extracted.complexity || 5,
-                                extractedFrom: 'code',
-                            },
-                            createdAt: new Date(),
-                            usageCount: 0,
-                        };
-                        patterns.push(pattern);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.warn('AI pattern extraction failed:', error);
-            // Return empty array - fail gracefully
-        }
-        return patterns;
-    }
-    /**
-     * Extract idiomatic patterns (language-specific conventions)
-     */
-    async extractIdiomaticPatterns(request) {
-        const patterns = [];
-        const { content, filepath, codebaseId } = request;
-        if (!content)
-            return patterns;
-        // Detect TypeScript/JavaScript idioms
-        const typescriptPatterns = this.detectTypeScriptIdioms(content, codebaseId, filepath);
-        patterns.push(...typescriptPatterns);
-        return patterns;
-    }
-    /**
-     * Detect TypeScript/JavaScript idioms
-     */
-    detectTypeScriptIdioms(content, codebaseId, filepath) {
-        const patterns = [];
-        // Pattern: Async/await pattern
-        if (content.includes('async') && content.includes('await')) {
-            patterns.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'idiomatic',
-                name: 'Async/Await Pattern',
-                description: 'Uses async/await for asynchronous operations',
-                codeExample: this.extractCodeExample(content, /async\s+\w+.*?await/),
-                filepath,
-                metadata: {
-                    tags: ['async', 'promises', 'typescript'],
-                    confidence: 9,
-                    extractedFrom: 'code',
-                },
-                createdAt: new Date(),
-                usageCount: 0,
-            });
-        }
-        // Pattern: Interface/Type definitions
-        if (content.match(/(interface|type)\s+\w+/)) {
-            patterns.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'idiomatic',
-                name: 'Type Definitions Pattern',
-                description: 'Uses TypeScript interfaces/types for type safety',
-                codeExample: this.extractCodeExample(content, /(interface|type)\s+\w+.*?\{[\s\S]{0,200}/),
-                filepath,
-                metadata: {
-                    tags: ['typescript', 'types', 'type-safety'],
-                    confidence: 8,
-                    extractedFrom: 'code',
-                },
-                createdAt: new Date(),
-                usageCount: 0,
-            });
-        }
-        // Pattern: Error handling pattern
-        if (content.match(/try\s*\{.*?\}\s*catch/)) {
-            patterns.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'behavioral',
-                name: 'Try-Catch Error Handling',
-                description: 'Uses try-catch for error handling',
-                codeExample: this.extractCodeExample(content, /try\s*\{[\s\S]{0,300}\}\s*catch/),
-                filepath,
-                metadata: {
-                    tags: ['error-handling', 'exception'],
-                    confidence: 9,
-                    extractedFrom: 'code',
-                },
-                createdAt: new Date(),
-                usageCount: 0,
-            });
-        }
-        return patterns;
-    }
-    /**
-     * Extract patterns by keyword matching (fallback when AI fails)
-     */
-    extractPatternsByKeywords(text, codebaseId, codebasePath) {
-        const patterns = [];
-        const lowerText = text.toLowerCase();
-        // Pattern: Authentication
-        if (lowerText.match(/(auth|authentication|login|jwt|session)/)) {
-            patterns.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'behavioral',
-                name: 'Authentication Pattern',
-                description: 'Authentication-related code pattern',
-                metadata: {
-                    tags: ['authentication', 'security'],
-                    confidence: 6,
-                    extractedFrom: 'memory',
-                },
-                createdAt: new Date(),
-                usageCount: 0,
-            });
-        }
-        // Pattern: API Route
-        if (lowerText.match(/(api|route|endpoint|controller)/)) {
-            patterns.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'architectural',
-                name: 'API Route Pattern',
-                description: 'API routing or controller pattern',
-                metadata: {
-                    tags: ['api', 'routing'],
-                    confidence: 6,
-                    extractedFrom: 'memory',
-                },
-                createdAt: new Date(),
-                usageCount: 0,
-            });
-        }
-        return patterns;
-    }
-    /**
-     * Helper: Detect naming convention
-     */
-    detectNamingConvention(fileName) {
-        // Detect kebab-case, camelCase, PascalCase, snake_case
-        return /^[a-z]+(-[a-z]+)*\.(ts|js|tsx|jsx)$/.test(fileName) || // kebab-case
-            /^[a-z]+[A-Z]/.test(fileName) || // camelCase
-            /^[A-Z]/.test(fileName) || // PascalCase
-            /^[a-z]+(_[a-z]+)*\./.test(fileName); // snake_case
-    }
-    /**
-     * Helper: Get naming pattern
-     */
-    getNamingPattern(fileName) {
-        if (/^[a-z]+(-[a-z]+)*\./.test(fileName))
-            return 'kebab-case';
-        if (/^[a-z]+[A-Z]/.test(fileName))
-            return 'camelCase';
-        if (/^[A-Z]/.test(fileName))
-            return 'PascalCase';
-        if (/^[a-z]+(_[a-z]+)*\./.test(fileName))
-            return 'snake_case';
-        return 'mixed';
-    }
-    /**
-     * Helper: Detect directory structure pattern
-     */
-    detectDirectoryStructure(directory) {
-        // Common patterns: src/, components/, services/, utils/, etc.
-        return /^(src|lib|components|services|utils|api|domain|infrastructure)/.test(directory);
-    }
-    /**
-     * Helper: Get directory pattern
-     */
-    getDirectoryPattern(directory) {
-        const parts = directory.split('/');
-        return parts.slice(0, 3).join('/'); // Return top-level structure
-    }
-    /**
-     * Helper: Extract code example matching regex
-     */
-    extractCodeExample(content, regex) {
-        const match = content.match(regex);
-        return match ? match[0].substring(0, 300) : content.substring(0, 300);
-    }
-    /**
-     * Helper: Calculate overall confidence
-     */
-    calculateConfidence(patterns) {
-        if (patterns.length === 0)
-            return 0;
-        const avgConfidence = patterns.reduce((sum, p) => {
-            return sum + (p.metadata?.confidence || 5);
-        }, 0) / patterns.length;
-        return avgConfidence / 10; // Normalize to 0-1
-    }
-    /**
-     * Get existing patterns for a codebase (useful for pattern reuse)
-     */
-    async getExistingPatterns(codebaseId, type) {
-        if (type) {
-            return await this.patternRepository.findByType(codebaseId, type);
-        }
-        return await this.patternRepository.findByCodebase(codebaseId);
-    }
-    /**
-     * Suggest patterns for a given task
-     */
-    async suggestPatterns(task, codebaseId, limit = 5) {
-        // Search patterns relevant to the task
-        return await this.patternRepository.search(codebaseId, task, limit);
-    }
-}
-//# sourceMappingURL=pattern-extractor.js.map

package/dist/domain/services/query-intent-classifier.js

@@ -1,140 +0,0 @@
-/**
- * Domain Service: QueryIntentClassifier
- * Classifies user query intent (pure business logic)
- */
-export class QueryIntentClassifier {
-    /**
-     * Classify query intent
-     */
-    classify(query) {
-        const lowerQuery = query.toLowerCase();
-        // Multi-file operations detection (check BEFORE single-file intents)
-        // These patterns indicate system-wide, multi-file operations
-        const multiFilePatterns = [
-            // Numbered step lists (compound instructions) - check first - MOST SPECIFIC
-            /\d+\.\s+[^\n]+\n\s*\d+\.\s+[^\n]+/s, // Two or more numbered steps (1. ... \n 2. ...)
-            /\d+\.\s+[^\n]+\n\s*\d+\.\s+[^\n]+\n\s*\d+\./s, // Three or more numbered steps
-            /(?:^|\n)\s*\d+\.\s+[^\n]+\n\s*\d+\.\s+[^\n]+/m, // Match numbered lists at start or after newline
-            // Compound instruction keywords with numbered steps
-            /implement.*complete.*:?\s*\n?\s*\d+\./i, // "Implement complete X: 1."
-            /create.*complete.*:?\s*\n?\s*\d+\./i, // "Create complete X: 1."
-            // System-wide refactoring
-            /refactor\s+(system|codebase|codebase|all|multiple|several|across)/i,
-            /refactor.*(system|codebase|all|multiple|several|across)/i,
-            /(system|codebase|codebase|architecture)\s+(refactor|migration|change|restructure)/i,
-            // Migration patterns
-            /migrate\s+(codebase|system|all|multiple|several|across)/i,
-            /migration\s+of\s+(codebase|system|all)/i,
-            // Update multiple files
-            /update\s+(all|multiple|several|across)\s+files/i,
-            /update.*(all|multiple|several|across).*files/i,
-            // Architecture changes - improved patterns
-            /architecture\s+(change|refactor|restructure|migration)/i,
-            /(change|implement|add|create|introduce).*architecture/i,
-            /(architecture|pattern|layer|design).*\s+(change|refactor|migration|add|create|implement|introduce)/i,
-            // Pattern additions (repository, service, etc.)
-            /add\s+(a\s+)?(repository|service|controller|middleware|pattern|layer|abstraction)/i,
-            /(repository|service|controller|middleware|pattern|layer|abstraction)\s+pattern/i,
-            /add\s+.*\s+pattern/i,
-            /introduce\s+(a\s+)?(repository|service|controller|middleware|pattern|layer|abstraction)/i,
-            /create\s+(a\s+)?(repository|service|controller|middleware|pattern|layer|abstraction)\s+(layer|pattern|abstraction)/i,
-            // Multi-file indicators
-            /(across|multiple|several|all)\s+files/i,
-            /files.*(across|multiple|several|all)/i,
-            // System-wide changes
-            /system-wide/i,
-            /codebase-wide/i,
-            // Feature implementation (often multi-file)
-            /implement\s+(complete|full|entire).*(feature|system|component)/i,
-            /create\s+(complete|full|entire).*(feature|system|component)/i,
-            // JWT/Authentication system changes (typically multi-file)
-            /refactor.*(authentication|auth)\s+system/i,
-            /(authentication|auth)\s+system.*(refactor|migrate|change)/i,
-            /(convert|switch|change).*(authentication|auth).*(to|from)/i,
-            // Component creation (often multiple files)
-            /create\s+.*components/i,
-            /generate\s+.*components/i,
-        ];
-        for (const pattern of multiFilePatterns) {
-            if (pattern.test(query)) {
-                return 'multi-file-modify';
-            }
-        }
-        // Refactor intent (single-file)
-        if (lowerQuery.includes('refactor') || lowerQuery.includes('rename') ||
-            lowerQuery.includes('extract') || lowerQuery.includes('move') ||
-            lowerQuery.includes('restructure')) {
-            return 'refactor';
-        }
-        // Debug intent
-        if (lowerQuery.includes('bug') || lowerQuery.includes('error') ||
-            lowerQuery.includes('fix') || lowerQuery.includes('issue') ||
-            lowerQuery.includes('problem') || lowerQuery.includes('wrong')) {
-            return 'debug';
-        }
-        // Implement intent
-        if (lowerQuery.includes('implement') || lowerQuery.includes('create') ||
-            lowerQuery.includes('add') || lowerQuery.includes('write') ||
-            lowerQuery.includes('build')) {
-            return 'implement';
-        }
-        // Find intent
-        if (lowerQuery.includes('find') || lowerQuery.includes('where') ||
-            lowerQuery.includes('locate') || lowerQuery.includes('search')) {
-            return 'find';
-        }
-        // Modify intent
-        if (lowerQuery.includes('modify') || lowerQuery.includes('change') ||
-            lowerQuery.includes('update') || lowerQuery.includes('edit')) {
-            return 'modify';
-        }
-        // Explain intent
-        if (lowerQuery.includes('how') || lowerQuery.includes('what') ||
-            lowerQuery.includes('explain') || lowerQuery.includes('understand') ||
-            lowerQuery.includes('does') || lowerQuery.includes('work')) {
-            return 'explain';
-        }
-        // Review intent
-        if (lowerQuery.includes('review') || lowerQuery.includes('check') ||
-            lowerQuery.includes('analyze') || lowerQuery.includes('audit')) {
-            return 'review';
-        }
-        // Test intent
-        if (lowerQuery.includes('test') || lowerQuery.includes('spec') ||
-            lowerQuery.includes('coverage')) {
-            return 'test';
-        }
-        // Index intent
-        if (lowerQuery.includes('index') || lowerQuery.includes('embed')) {
-            return 'index';
-        }
-        return 'general';
-    }
-    /**
-     * Extract symbol names from query
-     */
-    extractSymbols(query) {
-        const patterns = [
-            /function\s+(\w+)/gi,
-            /class\s+(\w+)/gi,
-            /interface\s+(\w+)/gi,
-            /type\s+(\w+)/gi,
-            /const\s+(\w+)/gi,
-            /let\s+(\w+)/gi,
-            /var\s+(\w+)/gi,
-            /([A-Z][a-zA-Z0-9]+)/g, // Capitalized words
-            /([a-z][a-zA-Z0-9]*\(\))/g, // camelCase functions
-        ];
-        const symbols = new Set();
-        for (const pattern of patterns) {
-            const matches = query.matchAll(pattern);
-            for (const match of matches) {
-                if (match[1]) {
-                    symbols.add(match[1]);
-                }
-            }
-        }
-        return Array.from(symbols);
-    }
-}
-//# sourceMappingURL=query-intent-classifier.js.map