@agentic-qe/v3 3.0.0-alpha.3

package/dist/domains/test-generation/services/pattern-matcher.js

@@ -0,0 +1,1271 @@
+/**
+ * Agentic QE v3 - Pattern Matching Service
+ * Implements IPatternMatchingService for learning and applying test patterns
+ *
+ * Uses TypeScript Compiler API for real AST parsing and pattern extraction
+ * Uses NomicEmbedder for semantic embeddings when available
+ */
+import { v4 as uuidv4 } from 'uuid';
+import * as ts from 'typescript';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ok, err } from '../../../shared/types';
+import { NomicEmbedder, EMBEDDING_CONFIG } from '../../../shared/embeddings';
+const DEFAULT_CONFIG = {
+    maxPatterns: 100,
+    minMatchScore: 0.5,
+    enableVectorSearch: true,
+    embeddingDimension: EMBEDDING_CONFIG.DIMENSIONS,
+    patternNamespace: 'test-generation:patterns',
+};
+/**
+ * Pattern Matching Service Implementation
+ * Manages test patterns with learning and semantic search capabilities
+ */
+export class PatternMatcherService {
+    memory;
+    config;
+    patternCache = new Map();
+    tsParser;
+    embedder;
+    constructor(memory, config = {}) {
+        this.memory = memory;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.tsParser = new TypeScriptASTParser();
+        // Use provided embedder or create NomicEmbedder with fallback enabled
+        this.embedder = config.embedder ?? new NomicEmbedder({ enableFallback: true });
+    }
+    /**
+     * Match testable patterns from a source file
+     * Uses TypeScript AST to identify functions, classes, and methods that need tests
+     */
+    async matchTestablePatterns(filePath) {
+        try {
+            // Read file content
+            let content;
+            try {
+                content = fs.readFileSync(filePath, 'utf-8');
+            }
+            catch {
+                return err(new Error(`Cannot read file: ${filePath}`));
+            }
+            return this.matchTestablePatternsFromCode(content, filePath);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Match testable patterns from source code string
+     */
+    async matchTestablePatternsFromCode(sourceCode, fileName = 'module.ts') {
+        try {
+            const patterns = [];
+            const sourceFile = this.tsParser.parseSource(sourceCode, fileName);
+            // Extract functions and generate test suggestions
+            const functions = this.tsParser.extractFunctions(sourceFile);
+            for (const fn of functions) {
+                patterns.push(this.createFunctionPattern(fn));
+            }
+            // Extract classes and their methods
+            const classes = this.tsParser.extractClasses(sourceFile);
+            for (const cls of classes) {
+                // Add class-level pattern
+                patterns.push(this.createClassPattern(cls));
+                // Add method-level patterns for each public method
+                for (const method of cls.methods) {
+                    patterns.push(this.createMethodPattern(cls.name, method));
+                }
+            }
+            return ok(patterns);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Create a testable pattern for a function
+     */
+    createFunctionPattern(fn) {
+        const suggestedTests = this.suggestTestsForFunction(fn);
+        return {
+            type: 'function',
+            name: fn.name,
+            complexity: fn.complexity,
+            lines: { start: fn.startLine, end: fn.endLine },
+            branches: this.estimateBranches(fn.complexity),
+            suggestedTests,
+            context: {
+                parameters: fn.parameters,
+                returnType: fn.returnType,
+                isAsync: fn.isAsync,
+            },
+        };
+    }
+    /**
+     * Create a testable pattern for a class
+     */
+    createClassPattern(cls) {
+        const totalComplexity = cls.methods.reduce((sum, m) => sum + m.complexity, 0);
+        const suggestedTests = this.suggestTestsForClass(cls);
+        return {
+            type: 'class',
+            name: cls.name,
+            complexity: totalComplexity,
+            lines: { start: cls.startLine, end: cls.endLine },
+            branches: this.estimateBranches(totalComplexity),
+            suggestedTests,
+            context: {
+                dependencies: cls.properties
+                    .filter((p) => !p.isPrivate)
+                    .map((p) => p.name),
+            },
+        };
+    }
+    /**
+     * Create a testable pattern for a class method
+     */
+    createMethodPattern(className, method) {
+        const suggestedTests = this.suggestTestsForMethod(className, method);
+        return {
+            type: 'method',
+            name: `${className}.${method.name}`,
+            complexity: method.complexity,
+            lines: { start: method.startLine, end: method.endLine },
+            branches: this.estimateBranches(method.complexity),
+            suggestedTests,
+            context: {
+                parameters: method.parameters,
+                returnType: method.returnType,
+                isAsync: method.isAsync,
+            },
+        };
+    }
+    /**
+     * Suggest tests for a function based on its signature and complexity
+     */
+    suggestTestsForFunction(fn) {
+        const tests = [];
+        // Happy path test
+        tests.push({
+            description: `handles valid input correctly`,
+            type: 'happy-path',
+            priority: 'high',
+            testCode: this.generateHappyPathTest(fn.name, fn.parameters, fn.isAsync),
+        });
+        // Parameter validation tests
+        for (const param of fn.parameters) {
+            if (!param.optional) {
+                tests.push({
+                    description: `handles missing ${param.name} parameter`,
+                    type: 'error-handling',
+                    priority: 'high',
+                });
+            }
+            // Type-specific tests
+            if (param.type?.includes('string')) {
+                tests.push({
+                    description: `handles empty string for ${param.name}`,
+                    type: 'boundary',
+                    priority: 'medium',
+                });
+            }
+            if (param.type?.includes('number')) {
+                tests.push({
+                    description: `handles zero value for ${param.name}`,
+                    type: 'boundary',
+                    priority: 'medium',
+                });
+                tests.push({
+                    description: `handles negative value for ${param.name}`,
+                    type: 'edge-case',
+                    priority: 'medium',
+                });
+            }
+            if (param.type?.includes('[]') || param.type?.includes('Array')) {
+                tests.push({
+                    description: `handles empty array for ${param.name}`,
+                    type: 'boundary',
+                    priority: 'medium',
+                });
+            }
+        }
+        // Async-specific tests
+        if (fn.isAsync) {
+            tests.push({
+                description: `handles async rejection`,
+                type: 'error-handling',
+                priority: 'high',
+            });
+        }
+        // Complexity-based tests
+        if (fn.complexity > 5) {
+            tests.push({
+                description: `handles complex branching logic`,
+                type: 'edge-case',
+                priority: 'medium',
+            });
+        }
+        return tests;
+    }
+    /**
+     * Suggest tests for a class
+     */
+    suggestTestsForClass(cls) {
+        const tests = [];
+        // Constructor test
+        if (cls.hasConstructor) {
+            tests.push({
+                description: `instantiates correctly`,
+                type: 'happy-path',
+                priority: 'high',
+            });
+        }
+        // Public methods coverage
+        const publicMethods = cls.methods.filter((m) => !m.name.startsWith('_') && !m.name.startsWith('#'));
+        if (publicMethods.length > 0) {
+            tests.push({
+                description: `all public methods are callable`,
+                type: 'happy-path',
+                priority: 'high',
+            });
+        }
+        // State management test
+        if (cls.properties.some((p) => !p.isReadonly)) {
+            tests.push({
+                description: `maintains correct state after operations`,
+                type: 'edge-case',
+                priority: 'medium',
+            });
+        }
+        return tests;
+    }
+    /**
+     * Suggest tests for a class method
+     */
+    suggestTestsForMethod(_className, method) {
+        // Reuse function test suggestions with method-specific context
+        const tests = this.suggestTestsForFunction(method);
+        // Add method-specific tests
+        tests.push({
+            description: `correctly modifies instance state`,
+            type: 'edge-case',
+            priority: 'medium',
+        });
+        return tests;
+    }
+    /**
+     * Generate a happy path test code snippet
+     */
+    generateHappyPathTest(fnName, params, isAsync) {
+        const paramList = params.map((p) => this.generateMockValue(p)).join(', ');
+        const call = `${fnName}(${paramList})`;
+        const assertion = isAsync ? `await ${call}` : call;
+        return `it('should handle valid input correctly', ${isAsync ? 'async ' : ''}() => {
+  const result = ${assertion};
+  expect(result).toBeDefined();
+});`;
+    }
+    /**
+     * Generate a mock value for a parameter based on its type
+     */
+    generateMockValue(param) {
+        if (param.defaultValue) {
+            return param.defaultValue;
+        }
+        const type = param.type?.toLowerCase() || 'unknown';
+        if (type.includes('string'))
+            return `'test-${param.name}'`;
+        if (type.includes('number'))
+            return '42';
+        if (type.includes('boolean'))
+            return 'true';
+        if (type.includes('[]') || type.includes('array'))
+            return '[]';
+        if (type.includes('object') || type.includes('{'))
+            return '{}';
+        if (type.includes('function'))
+            return '() => {}';
+        if (type.includes('promise'))
+            return 'Promise.resolve()';
+        if (type.includes('date'))
+            return 'new Date()';
+        if (type.includes('null'))
+            return 'null';
+        if (type.includes('undefined'))
+            return 'undefined';
+        return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
+    }
+    /**
+     * Estimate number of branches from cyclomatic complexity
+     */
+    estimateBranches(complexity) {
+        // Branches = complexity - 1 (assuming one path is the default)
+        return Math.max(0, complexity - 1);
+    }
+    /**
+     * Find patterns matching the given context
+     */
+    async findMatchingPatterns(context) {
+        try {
+            const matches = [];
+            // Strategy 1: Semantic search if enabled and query provided
+            if (this.config.enableVectorSearch && context.semanticQuery) {
+                const semanticMatches = await this.semanticSearch(context.semanticQuery);
+                matches.push(...semanticMatches);
+            }
+            // Strategy 2: Tag-based matching
+            if (context.tags && context.tags.length > 0) {
+                const tagMatches = await this.matchByTags(context.tags);
+                this.mergeMatches(matches, tagMatches);
+            }
+            // Strategy 3: File type and framework matching
+            if (context.fileType || context.framework || context.testType) {
+                const metadataMatches = await this.matchByMetadata(context);
+                this.mergeMatches(matches, metadataMatches);
+            }
+            // Strategy 4: Code structure analysis
+            if (context.sourceCode) {
+                const structureMatches = await this.matchByStructure(context.sourceCode);
+                this.mergeMatches(matches, structureMatches);
+            }
+            // Filter by minimum score and sort by relevance
+            const filteredMatches = matches
+                .filter((m) => m.score >= this.config.minMatchScore)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, this.config.maxPatterns);
+            return ok(filteredMatches);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Apply a pattern to generate code
+     */
+    async applyPattern(patternId, targetCode) {
+        try {
+            const pattern = await this.getPattern(patternId);
+            if (!pattern) {
+                return err(new Error(`Pattern not found: ${patternId}`));
+            }
+            // Analyze target code structure
+            const codeAnalysis = this.analyzeCodeStructure(targetCode);
+            // Apply pattern transformations
+            const modifications = [];
+            let generatedCode = pattern.structure;
+            // Replace placeholders in pattern with actual code elements
+            const placeholders = this.extractPlaceholders(pattern.structure);
+            for (const placeholder of placeholders) {
+                const replacement = this.resolvePlaceholder(placeholder, codeAnalysis);
+                if (replacement) {
+                    generatedCode = generatedCode.replace(new RegExp(`\\{\\{${placeholder}\\}\\}`, 'g'), replacement);
+                    modifications.push({
+                        location: placeholder,
+                        original: `{{${placeholder}}}`,
+                        replacement,
+                        reason: `Resolved from code analysis`,
+                    });
+                }
+            }
+            // Calculate confidence based on how well the pattern matched
+            const confidence = this.calculateApplicationConfidence(pattern, codeAnalysis, modifications);
+            // Update pattern usage statistics
+            await this.recordPatternUsage(patternId);
+            return ok({
+                patternId,
+                generatedCode,
+                modifications,
+                confidence,
+            });
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Record a new pattern
+     */
+    async recordPattern(definition) {
+        try {
+            const pattern = {
+                id: uuidv4(),
+                name: definition.name,
+                structure: definition.structure,
+                examples: definition.examples?.length ?? 0,
+                applicability: 0.5, // Start with neutral applicability
+            };
+            // Store pattern in memory
+            const patternKey = `${this.config.patternNamespace}:${pattern.id}`;
+            await this.memory.set(patternKey, {
+                ...pattern,
+                description: definition.description,
+                tags: definition.tags,
+                testType: definition.testType,
+                framework: definition.framework,
+                examples: definition.examples,
+                createdAt: new Date().toISOString(),
+                usageCount: 0,
+            });
+            // Store vector embedding for semantic search if enabled
+            if (this.config.enableVectorSearch) {
+                const embedding = await this.generatePatternEmbedding(definition);
+                await this.memory.storeVector(patternKey, embedding, {
+                    patternId: pattern.id,
+                    name: pattern.name,
+                    tags: definition.tags,
+                });
+            }
+            // Add to local cache
+            this.patternCache.set(pattern.id, pattern);
+            return ok(pattern);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Learn patterns from existing test files
+     */
+    async learnPatterns(request) {
+        try {
+            const { testFiles, depth } = request;
+            const patterns = [];
+            for (const file of testFiles) {
+                const filePatterns = await this.extractPatternsFromFile(file, depth);
+                patterns.push(...filePatterns);
+            }
+            // Deduplicate similar patterns
+            const uniquePatterns = this.deduplicatePatterns(patterns);
+            // Store learned patterns
+            for (const pattern of uniquePatterns) {
+                await this.recordPattern({
+                    name: pattern.name,
+                    structure: pattern.structure,
+                    tags: ['learned', 'auto-extracted'],
+                });
+            }
+            // Calculate overall confidence based on pattern consistency
+            const confidence = this.calculateLearningConfidence(uniquePatterns);
+            return ok({
+                patterns: uniquePatterns,
+                confidence,
+            });
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Get a pattern by ID
+     */
+    async getPattern(patternId) {
+        // Check cache first
+        if (this.patternCache.has(patternId)) {
+            return this.patternCache.get(patternId);
+        }
+        // Load from memory
+        const patternKey = `${this.config.patternNamespace}:${patternId}`;
+        const stored = await this.memory.get(patternKey);
+        if (stored) {
+            const pattern = {
+                id: stored.id,
+                name: stored.name,
+                structure: stored.structure,
+                examples: stored.examples,
+                applicability: stored.applicability,
+            };
+            this.patternCache.set(patternId, pattern);
+            return pattern;
+        }
+        return undefined;
+    }
+    /**
+     * List patterns with optional filtering
+     */
+    async listPatterns(filter) {
+        const patterns = [];
+        const limit = filter?.limit ?? this.config.maxPatterns;
+        // Search for patterns in memory
+        const keys = await this.memory.search(`${this.config.patternNamespace}:*`, limit * 2);
+        for (const key of keys) {
+            const stored = await this.memory.get(key);
+            if (stored) {
+                // Apply filters
+                if (filter?.testType && stored.testType !== filter.testType)
+                    continue;
+                if (filter?.framework && stored.framework !== filter.framework)
+                    continue;
+                if (filter?.minApplicability && stored.applicability < filter.minApplicability)
+                    continue;
+                if (filter?.tags && filter.tags.length > 0) {
+                    const hasTag = filter.tags.some((t) => stored.tags?.includes(t));
+                    if (!hasTag)
+                        continue;
+                }
+                patterns.push({
+                    id: stored.id,
+                    name: stored.name,
+                    structure: stored.structure,
+                    examples: stored.examples,
+                    applicability: stored.applicability,
+                });
+                if (patterns.length >= limit)
+                    break;
+            }
+        }
+        return patterns.sort((a, b) => b.applicability - a.applicability);
+    }
+    // ============================================================================
+    // Private Helper Methods
+    // ============================================================================
+    async semanticSearch(query) {
+        // Generate embedding for query and search using NomicEmbedder
+        const queryEmbedding = await this.generateQueryEmbedding(query);
+        const results = await this.memory.vectorSearch(queryEmbedding, 10);
+        const matches = [];
+        for (const result of results) {
+            const pattern = await this.getPattern(result.metadata?.patternId);
+            if (pattern) {
+                matches.push({
+                    pattern,
+                    score: result.score,
+                    matchReason: 'Semantic similarity to query',
+                    suggestedApplication: `Apply ${pattern.name} pattern to generate tests`,
+                });
+            }
+        }
+        return matches;
+    }
+    async matchByTags(tags) {
+        const matches = [];
+        const patterns = await this.listPatterns({ tags });
+        for (const pattern of patterns) {
+            matches.push({
+                pattern,
+                score: 0.7, // Tag matching gives moderate score
+                matchReason: `Pattern tags match: ${tags.join(', ')}`,
+                suggestedApplication: `Apply ${pattern.name} pattern based on tag match`,
+            });
+        }
+        return matches;
+    }
+    async matchByMetadata(context) {
+        const matches = [];
+        const patterns = await this.listPatterns({
+            testType: context.testType,
+            framework: context.framework,
+        });
+        for (const pattern of patterns) {
+            matches.push({
+                pattern,
+                score: 0.6, // Metadata matching gives moderate score
+                matchReason: `Pattern matches ${context.testType || ''} ${context.framework || ''}`.trim(),
+                suggestedApplication: `Apply ${pattern.name} pattern for ${context.testType || 'test'} generation`,
+            });
+        }
+        return matches;
+    }
+    async matchByStructure(sourceCode) {
+        // Analyze code structure using TypeScript AST and find matching patterns
+        const analysis = this.analyzeCodeStructure(sourceCode);
+        const matches = [];
+        // Look for patterns that match detected constructs
+        const allPatterns = await this.listPatterns();
+        for (const pattern of allPatterns) {
+            const structureScore = this.calculateStructureMatch(pattern, analysis);
+            if (structureScore > 0) {
+                matches.push({
+                    pattern,
+                    score: structureScore,
+                    matchReason: `Pattern structure matches code constructs`,
+                    suggestedApplication: `Apply ${pattern.name} based on code structure analysis`,
+                });
+            }
+        }
+        return matches;
+    }
+    mergeMatches(target, source) {
+        for (const match of source) {
+            const existing = target.find((m) => m.pattern.id === match.pattern.id);
+            if (existing) {
+                // Combine scores
+                existing.score = Math.min(1, existing.score + match.score * 0.5);
+                existing.matchReason += `, ${match.matchReason}`;
+            }
+            else {
+                target.push(match);
+            }
+        }
+    }
+    analyzeCodeStructure(code) {
+        // Use real TypeScript AST parsing for accurate analysis
+        const parser = new TypeScriptASTParser();
+        const sourceFile = parser.parseSource(code);
+        const functions = parser.extractFunctions(sourceFile);
+        const classes = parser.extractClasses(sourceFile);
+        // Calculate total complexity from all functions and methods
+        let totalComplexity = functions.reduce((sum, fn) => sum + fn.complexity, 0);
+        for (const cls of classes) {
+            totalComplexity += cls.methods.reduce((sum, m) => sum + m.complexity, 0);
+        }
+        return {
+            hasClasses: classes.length > 0,
+            hasFunctions: functions.length > 0,
+            hasAsyncCode: functions.some((f) => f.isAsync) ||
+                classes.some((c) => c.methods.some((m) => m.isAsync)),
+            hasExports: functions.some((f) => f.isExported) ||
+                classes.some((c) => c.isExported),
+            imports: this.extractImports(code),
+            identifiers: this.extractIdentifiers(code),
+            complexity: totalComplexity || this.estimateComplexity(code),
+            functions,
+            classes,
+        };
+    }
+    extractImports(code) {
+        const importRegex = /import\s+(?:\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/g;
+        const imports = [];
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            imports.push(match[1]);
+        }
+        return imports;
+    }
+    extractIdentifiers(code) {
+        const identifierRegex = /(?:class|function|const|let|var)\s+(\w+)/g;
+        const identifiers = [];
+        let match;
+        while ((match = identifierRegex.exec(code)) !== null) {
+            identifiers.push(match[1]);
+        }
+        return identifiers;
+    }
+    estimateComplexity(code) {
+        // Simple complexity estimation based on control flow statements
+        const controlFlowPatterns = [
+            /if\s*\(/g,
+            /else\s*{/g,
+            /for\s*\(/g,
+            /while\s*\(/g,
+            /switch\s*\(/g,
+            /\?\s*:/g, // ternary
+        ];
+        let complexity = 1;
+        for (const pattern of controlFlowPatterns) {
+            const matches = code.match(pattern);
+            complexity += matches ? matches.length : 0;
+        }
+        return complexity;
+    }
+    extractPlaceholders(structure) {
+        const placeholderRegex = /\{\{(\w+)\}\}/g;
+        const placeholders = [];
+        let match;
+        while ((match = placeholderRegex.exec(structure)) !== null) {
+            placeholders.push(match[1]);
+        }
+        return placeholders;
+    }
+    resolvePlaceholder(placeholder, analysis) {
+        // Resolve placeholders based on code analysis results
+        switch (placeholder.toLowerCase()) {
+            case 'classname':
+            case 'modulename':
+                return analysis.identifiers[0] || 'Module';
+            case 'functionname':
+                return analysis.identifiers.find((id) => /^[a-z]/.test(id)) || 'func';
+            case 'imports':
+                return analysis.imports.map((i) => `import '${i}'`).join('\n');
+            default:
+                return null;
+        }
+    }
+    calculateApplicationConfidence(pattern, analysis, modifications) {
+        // Base confidence from pattern applicability
+        let confidence = pattern.applicability;
+        // Adjust based on how many placeholders were resolved
+        const placeholders = this.extractPlaceholders(pattern.structure);
+        const resolvedRatio = modifications.length / Math.max(placeholders.length, 1);
+        confidence = confidence * 0.5 + resolvedRatio * 0.5;
+        // Adjust based on code complexity match
+        if (analysis.complexity > 10) {
+            confidence *= 0.9; // Slightly lower confidence for complex code
+        }
+        return Math.min(1, Math.max(0, confidence));
+    }
+    calculateStructureMatch(pattern, analysis) {
+        // Calculate how well pattern structure matches code using AST analysis
+        let score = 0;
+        // Check for structural similarities
+        if (analysis.hasClasses && pattern.structure.includes('class'))
+            score += 0.3;
+        if (analysis.hasFunctions && pattern.structure.includes('function'))
+            score += 0.3;
+        if (analysis.hasAsyncCode && pattern.structure.includes('async'))
+            score += 0.2;
+        if (analysis.hasExports && pattern.structure.includes('export'))
+            score += 0.2;
+        return Math.min(1, score);
+    }
+    async recordPatternUsage(patternId) {
+        const patternKey = `${this.config.patternNamespace}:${patternId}`;
+        const stored = await this.memory.get(patternKey);
+        if (stored) {
+            const usageCount = (stored.usageCount || 0) + 1;
+            // Increase applicability score based on usage
+            const newApplicability = Math.min(1, stored.applicability + 0.01);
+            await this.memory.set(patternKey, {
+                ...stored,
+                usageCount,
+                applicability: newApplicability,
+                lastUsedAt: new Date().toISOString(),
+            });
+            // Update cache
+            if (this.patternCache.has(patternId)) {
+                const cached = this.patternCache.get(patternId);
+                cached.applicability = newApplicability;
+            }
+        }
+    }
+    async extractPatternsFromFile(file, depth) {
+        const patterns = [];
+        try {
+            // Read the file content
+            let content;
+            try {
+                content = fs.readFileSync(file, 'utf-8');
+            }
+            catch {
+                // File doesn't exist or can't be read, return empty
+                return patterns;
+            }
+            // Parse with TypeScript AST
+            const parser = new TypeScriptASTParser();
+            const sourceFile = parser.parseSource(content, path.basename(file));
+            // Extract test patterns from describe/it/test blocks
+            const testPatterns = this.extractTestBlockPatterns(sourceFile, content);
+            patterns.push(...testPatterns);
+            // Deep analysis extracts more detailed patterns
+            if (depth === 'deep') {
+                // Extract setup/teardown patterns
+                const setupPatterns = this.extractSetupTeardownPatterns(sourceFile, content);
+                patterns.push(...setupPatterns);
+                // Extract assertion patterns
+                const assertionPatterns = this.extractAssertionPatterns(content);
+                patterns.push(...assertionPatterns);
+                // Extract mocking patterns
+                const mockPatterns = this.extractMockingPatterns(content);
+                patterns.push(...mockPatterns);
+            }
+        }
+        catch {
+            // If parsing fails, return a basic pattern
+            patterns.push({
+                id: uuidv4(),
+                name: `Basic pattern from ${path.basename(file)}`,
+                structure: `describe('{{moduleName}}', () => {\n  it('should {{behavior}}', () => {\n    // Test implementation\n  });\n});`,
+                examples: 1,
+                applicability: 0.5,
+            });
+        }
+        return patterns;
+    }
+    /**
+     * Extract test block patterns (describe/it/test)
+     */
+    extractTestBlockPatterns(_sourceFile, content) {
+        const patterns = [];
+        // Find describe blocks with their nested structure
+        const describeRegex = /describe\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*(?:function\s*\(\s*\)|(?:\(\s*\))?\s*=>)\s*\{/g;
+        let match;
+        while ((match = describeRegex.exec(content)) !== null) {
+            const startIndex = match.index;
+            const blockContent = this.extractBlockContent(content, startIndex + match[0].length - 1);
+            if (blockContent) {
+                // Analyze the structure of tests within this describe block
+                const itCount = (blockContent.match(/\bit\s*\(/g) || []).length;
+                const testCount = (blockContent.match(/\btest\s*\(/g) || []).length;
+                const hasBeforeEach = /beforeEach\s*\(/.test(blockContent);
+                const hasAfterEach = /afterEach\s*\(/.test(blockContent);
+                // Create a structural pattern
+                let structure = `describe('{{moduleName}}', () => {\n`;
+                if (hasBeforeEach)
+                    structure += `  beforeEach(() => {\n    // Setup\n  });\n\n`;
+                if (hasAfterEach)
+                    structure += `  afterEach(() => {\n    // Teardown\n  });\n\n`;
+                for (let i = 0; i < Math.max(itCount, testCount); i++) {
+                    structure += `  it('should {{behavior${i > 0 ? i + 1 : ''}}}', () => {\n    // Test implementation\n  });\n`;
+                }
+                structure += '});';
+                patterns.push({
+                    id: uuidv4(),
+                    name: `Test block pattern: ${match[1]}`,
+                    structure,
+                    examples: 1,
+                    applicability: 0.6,
+                });
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Extract setup/teardown patterns (beforeEach, afterEach, etc.)
+     */
+    extractSetupTeardownPatterns(_sourceFile, content) {
+        const patterns = [];
+        // beforeEach pattern
+        if (/beforeEach\s*\(/.test(content)) {
+            const beforeEachMatch = content.match(/beforeEach\s*\(\s*(?:async\s*)?\(\s*\)\s*=>\s*\{([^}]*)\}/);
+            if (beforeEachMatch) {
+                patterns.push({
+                    id: uuidv4(),
+                    name: 'beforeEach setup pattern',
+                    structure: `beforeEach(async () => {\n  {{setupCode}}\n});`,
+                    examples: 1,
+                    applicability: 0.7,
+                });
+            }
+        }
+        // afterEach pattern
+        if (/afterEach\s*\(/.test(content)) {
+            patterns.push({
+                id: uuidv4(),
+                name: 'afterEach teardown pattern',
+                structure: `afterEach(async () => {\n  {{teardownCode}}\n});`,
+                examples: 1,
+                applicability: 0.7,
+            });
+        }
+        // beforeAll pattern
+        if (/beforeAll\s*\(/.test(content)) {
+            patterns.push({
+                id: uuidv4(),
+                name: 'beforeAll setup pattern',
+                structure: `beforeAll(async () => {\n  {{setupCode}}\n});`,
+                examples: 1,
+                applicability: 0.6,
+            });
+        }
+        return patterns;
+    }
+    /**
+     * Extract assertion patterns from test code
+     */
+    extractAssertionPatterns(content) {
+        const patterns = [];
+        const assertionTypes = new Set();
+        // Detect assertion styles
+        if (/expect\([^)]+\)\.toBe\(/.test(content))
+            assertionTypes.add('toBe');
+        if (/expect\([^)]+\)\.toEqual\(/.test(content))
+            assertionTypes.add('toEqual');
+        if (/expect\([^)]+\)\.toThrow\(/.test(content))
+            assertionTypes.add('toThrow');
+        if (/expect\([^)]+\)\.toHaveBeenCalled/.test(content))
+            assertionTypes.add('toHaveBeenCalled');
+        if (/expect\([^)]+\)\.resolves/.test(content))
+            assertionTypes.add('resolves');
+        if (/expect\([^)]+\)\.rejects/.test(content))
+            assertionTypes.add('rejects');
+        if (assertionTypes.size > 0) {
+            const assertionStructures = Array.from(assertionTypes).map((type) => {
+                switch (type) {
+                    case 'toBe':
+                        return 'expect({{actual}}).toBe({{expected}})';
+                    case 'toEqual':
+                        return 'expect({{actual}}).toEqual({{expected}})';
+                    case 'toThrow':
+                        return 'expect(() => {{call}}).toThrow({{error}})';
+                    case 'toHaveBeenCalled':
+                        return 'expect({{mock}}).toHaveBeenCalledWith({{args}})';
+                    case 'resolves':
+                        return 'await expect({{promise}}).resolves.toEqual({{expected}})';
+                    case 'rejects':
+                        return 'await expect({{promise}}).rejects.toThrow({{error}})';
+                    default:
+                        return `expect({{actual}}).${type}({{expected}})`;
+                }
+            });
+            patterns.push({
+                id: uuidv4(),
+                name: 'Assertion patterns',
+                structure: assertionStructures.join('\n'),
+                examples: assertionTypes.size,
+                applicability: 0.8,
+            });
+        }
+        return patterns;
+    }
+    /**
+     * Extract mocking patterns from test code
+     */
+    extractMockingPatterns(content) {
+        const patterns = [];
+        // jest.mock pattern
+        if (/jest\.mock\(/.test(content)) {
+            patterns.push({
+                id: uuidv4(),
+                name: 'Jest module mock pattern',
+                structure: `jest.mock('{{modulePath}}', () => ({\n  {{mockImplementation}}\n}));`,
+                examples: 1,
+                applicability: 0.7,
+            });
+        }
+        // jest.fn pattern
+        if (/jest\.fn\(/.test(content)) {
+            patterns.push({
+                id: uuidv4(),
+                name: 'Jest function mock pattern',
+                structure: `const {{mockName}} = jest.fn().mockReturnValue({{returnValue}});`,
+                examples: 1,
+                applicability: 0.7,
+            });
+        }
+        // vi.mock pattern (vitest)
+        if (/vi\.mock\(/.test(content)) {
+            patterns.push({
+                id: uuidv4(),
+                name: 'Vitest module mock pattern',
+                structure: `vi.mock('{{modulePath}}', () => ({\n  {{mockImplementation}}\n}));`,
+                examples: 1,
+                applicability: 0.7,
+            });
+        }
+        // vi.fn pattern (vitest)
+        if (/vi\.fn\(/.test(content)) {
+            patterns.push({
+                id: uuidv4(),
+                name: 'Vitest function mock pattern',
+                structure: `const {{mockName}} = vi.fn().mockReturnValue({{returnValue}});`,
+                examples: 1,
+                applicability: 0.7,
+            });
+        }
+        // spyOn pattern
+        if (/(?:jest|vi)\.spyOn\(/.test(content)) {
+            patterns.push({
+                id: uuidv4(),
+                name: 'SpyOn pattern',
+                structure: `const spy = {{framework}}.spyOn({{object}}, '{{method}}').mockImplementation({{impl}});`,
+                examples: 1,
+                applicability: 0.6,
+            });
+        }
+        return patterns;
+    }
+    /**
+     * Extract a complete block of code starting from an opening brace
+     */
+    extractBlockContent(content, startIndex) {
+        let braceCount = 0;
+        let endIndex = startIndex;
+        let started = false;
+        for (let i = startIndex; i < content.length; i++) {
+            const char = content[i];
+            if (char === '{') {
+                braceCount++;
+                started = true;
+            }
+            else if (char === '}') {
+                braceCount--;
+                if (started && braceCount === 0) {
+                    endIndex = i;
+                    break;
+                }
+            }
+        }
+        if (endIndex > startIndex) {
+            return content.substring(startIndex, endIndex + 1);
+        }
+        return null;
+    }
+    deduplicatePatterns(patterns) {
+        const seen = new Map();
+        for (const pattern of patterns) {
+            // Use structure hash as key for deduplication
+            const structureKey = this.hashStructure(pattern.structure);
+            if (!seen.has(structureKey)) {
+                seen.set(structureKey, pattern);
+            }
+            else {
+                // Merge examples count
+                const existing = seen.get(structureKey);
+                existing.examples += pattern.examples;
+            }
+        }
+        return Array.from(seen.values());
+    }
+    hashStructure(structure) {
+        // Simple hash for structure comparison
+        const normalized = structure.replace(/\s+/g, ' ').trim();
+        let hash = 0;
+        for (let i = 0; i < normalized.length; i++) {
+            const char = normalized.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return hash.toString(16);
+    }
+    calculateLearningConfidence(patterns) {
+        if (patterns.length === 0)
+            return 0;
+        // Confidence based on:
+        // 1. Number of patterns found
+        // 2. Average examples per pattern
+        // 3. Structural diversity
+        const avgExamples = patterns.reduce((sum, p) => sum + p.examples, 0) / patterns.length;
+        const countFactor = Math.min(1, patterns.length / 10);
+        const examplesFactor = Math.min(1, avgExamples / 5);
+        return countFactor * 0.5 + examplesFactor * 0.5;
+    }
+    /**
+     * Generate embedding for a pattern definition
+     * Uses NomicEmbedder for semantic embeddings (falls back to pseudo-embeddings if Ollama unavailable)
+     */
+    async generatePatternEmbedding(definition) {
+        const text = this.formatPatternForEmbedding(definition);
+        return this.embedder.embed(text);
+    }
+    /**
+     * Generate embedding for a search query
+     * Uses the same embedder as patterns for consistent similarity matching
+     */
+    async generateQueryEmbedding(query) {
+        return this.embedder.embed(query);
+    }
+    /**
+     * Format a pattern definition for embedding generation
+     * Creates a semantic-rich text representation
+     */
+    formatPatternForEmbedding(definition) {
+        const parts = [
+            `Pattern: ${definition.name}`,
+            definition.description ? `Description: ${definition.description}` : '',
+            `Structure: ${definition.structure}`,
+            definition.tags?.length ? `Tags: ${definition.tags.join(', ')}` : '',
+            definition.testType ? `Test type: ${definition.testType}` : '',
+            definition.framework ? `Framework: ${definition.framework}` : '',
+        ].filter(Boolean);
+        return parts.join('\n');
+    }
+}
+/**
+ * TypeScript AST Parser Helper
+ * Provides utilities for parsing TypeScript files and extracting patterns
+ */
+class TypeScriptASTParser {
+    sourceFile = null;
+    sourceCode = '';
+    /**
+     * Parse a TypeScript file and return the source file AST
+     */
+    parseFile(filePath, content) {
+        if (content) {
+            this.sourceCode = content;
+        }
+        else {
+            this.sourceCode = fs.readFileSync(filePath, 'utf-8');
+        }
+        this.sourceFile = ts.createSourceFile(path.basename(filePath), this.sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        return this.sourceFile;
+    }
+    /**
+     * Parse source code string directly
+     */
+    parseSource(source, fileName = 'module.ts') {
+        this.sourceCode = source;
+        this.sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        return this.sourceFile;
+    }
+    /**
+     * Extract all functions from the AST
+     */
+    extractFunctions(sourceFile) {
+        const functions = [];
+        const visit = (node) => {
+            if (ts.isFunctionDeclaration(node) && node.name) {
+                functions.push(this.extractFunctionInfo(node, sourceFile));
+            }
+            else if (ts.isVariableStatement(node)) {
+                // Handle arrow functions assigned to variables
+                for (const declaration of node.declarationList.declarations) {
+                    if (ts.isVariableDeclaration(declaration) &&
+                        declaration.initializer &&
+                        (ts.isArrowFunction(declaration.initializer) ||
+                            ts.isFunctionExpression(declaration.initializer))) {
+                        const name = declaration.name.getText(sourceFile);
+                        functions.push(this.extractArrowFunctionInfo(name, declaration.initializer, sourceFile, node));
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(sourceFile, visit);
+        return functions;
+    }
+    /**
+     * Extract all classes from the AST
+     */
+    extractClasses(sourceFile) {
+        const classes = [];
+        const visit = (node) => {
+            if (ts.isClassDeclaration(node) && node.name) {
+                classes.push(this.extractClassInfo(node, sourceFile));
+            }
+            ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(sourceFile, visit);
+        return classes;
+    }
+    /**
+     * Extract information from a function declaration
+     */
+    extractFunctionInfo(node, sourceFile) {
+        const name = node.name?.getText(sourceFile) || 'anonymous';
+        const parameters = this.extractParameters(node.parameters, sourceFile);
+        const returnType = node.type?.getText(sourceFile);
+        const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        const complexity = this.calculateCyclomaticComplexity(node);
+        return {
+            name,
+            parameters,
+            returnType,
+            isAsync,
+            isExported,
+            complexity,
+            startLine: startLine + 1,
+            endLine: endLine + 1,
+            body: node.body?.getText(sourceFile),
+        };
+    }
+    /**
+     * Extract information from an arrow function or function expression
+     */
+    extractArrowFunctionInfo(name, node, sourceFile, parentNode) {
+        const parameters = this.extractParameters(node.parameters, sourceFile);
+        const returnType = node.type?.getText(sourceFile);
+        const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        // Check if parent is exported
+        const isExported = ts.isVariableStatement(parentNode) &&
+            (parentNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        const complexity = this.calculateCyclomaticComplexity(node);
+        return {
+            name,
+            parameters,
+            returnType,
+            isAsync,
+            isExported,
+            complexity,
+            startLine: startLine + 1,
+            endLine: endLine + 1,
+            body: node.body?.getText(sourceFile),
+        };
+    }
+    /**
+     * Extract class information
+     */
+    extractClassInfo(node, sourceFile) {
+        const name = node.name?.getText(sourceFile) || 'AnonymousClass';
+        const methods = [];
+        const properties = [];
+        let hasConstructor = false;
+        const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        for (const member of node.members) {
+            if (ts.isMethodDeclaration(member)) {
+                const methodName = member.name.getText(sourceFile);
+                const parameters = this.extractParameters(member.parameters, sourceFile);
+                const returnType = member.type?.getText(sourceFile);
+                const isAsync = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+                const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(member.getStart(sourceFile));
+                const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(member.getEnd());
+                methods.push({
+                    name: methodName,
+                    parameters,
+                    returnType,
+                    isAsync,
+                    isExported: false,
+                    complexity: this.calculateCyclomaticComplexity(member),
+                    startLine: startLine + 1,
+                    endLine: endLine + 1,
+                    body: member.body?.getText(sourceFile),
+                });
+            }
+            else if (ts.isConstructorDeclaration(member)) {
+                hasConstructor = true;
+            }
+            else if (ts.isPropertyDeclaration(member)) {
+                const propName = member.name.getText(sourceFile);
+                const propType = member.type?.getText(sourceFile);
+                const isPrivate = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
+                const isReadonly = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+                properties.push({
+                    name: propName,
+                    type: propType,
+                    isPrivate,
+                    isReadonly,
+                });
+            }
+        }
+        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        return {
+            name,
+            methods,
+            properties,
+            isExported,
+            hasConstructor,
+            startLine: startLine + 1,
+            endLine: endLine + 1,
+        };
+    }
+    /**
+     * Extract parameter information
+     */
+    extractParameters(params, sourceFile) {
+        return params.map((param) => ({
+            name: param.name.getText(sourceFile),
+            type: param.type?.getText(sourceFile),
+            optional: param.questionToken !== undefined,
+            defaultValue: param.initializer?.getText(sourceFile),
+        }));
+    }
+    /**
+     * Calculate cyclomatic complexity of a node
+     */
+    calculateCyclomaticComplexity(node) {
+        let complexity = 1;
+        const visit = (n) => {
+            switch (n.kind) {
+                case ts.SyntaxKind.IfStatement:
+                case ts.SyntaxKind.ForStatement:
+                case ts.SyntaxKind.ForInStatement:
+                case ts.SyntaxKind.ForOfStatement:
+                case ts.SyntaxKind.WhileStatement:
+                case ts.SyntaxKind.DoStatement:
+                case ts.SyntaxKind.CaseClause:
+                case ts.SyntaxKind.CatchClause:
+                case ts.SyntaxKind.ConditionalExpression:
+                case ts.SyntaxKind.QuestionQuestionToken:
+                    complexity++;
+                    break;
+                case ts.SyntaxKind.BinaryExpression:
+                    const binary = n;
+                    if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                        binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+                        complexity++;
+                    }
+                    break;
+            }
+            ts.forEachChild(n, visit);
+        };
+        ts.forEachChild(node, visit);
+        return complexity;
+    }
+}
+//# sourceMappingURL=pattern-matcher.js.map