@gotza02/sequential-thinking 10000.1.6 → 10000.1.7

package/dist/intelligent-code.js

@@ -0,0 +1,779 @@
+/**
+ * INTELLIGENT CODE MODULE
+ * AI-powered code analysis, semantic search, and smart refactoring
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import ts from 'typescript';
+import { validatePath } from './utils.js';
+const execAsync = promisify(exec);
+// ============= Intelligent Code Analyzer =============
+export class IntelligentCodeAnalyzer {
+    graph;
+    program;
+    typeChecker;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    /**
+     * Comprehensive code analysis with metrics and quality scoring
+     */
+    async analyzeFile(filePath) {
+        const absolutePath = validatePath(filePath);
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        // Parse AST
+        const sourceFile = ts.createSourceFile(absolutePath, content, ts.ScriptTarget.Latest, true);
+        // Calculate metrics
+        const metrics = this.calculateMetrics(sourceFile, content);
+        // Analyze quality
+        const quality = await this.analyzeQuality(sourceFile, content, metrics);
+        // Extract symbols with analysis
+        const symbols = this.analyzeSymbols(sourceFile);
+        return { metrics, quality, ast: sourceFile, symbols };
+    }
+    calculateMetrics(sourceFile, content) {
+        let complexity = 0;
+        let functionCount = 0;
+        let maxNestingDepth = 0;
+        let currentDepth = 0;
+        const visit = (node) => {
+            // Cyclomatic complexity
+            if (ts.isIfStatement(node) ||
+                ts.isConditionalExpression(node) ||
+                ts.isWhileStatement(node) ||
+                ts.isForStatement(node) ||
+                ts.isForInStatement(node) ||
+                ts.isForOfStatement(node) ||
+                ts.isCaseClause(node) ||
+                (ts.isBinaryExpression(node) &&
+                    (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                        node.operatorToken.kind === ts.SyntaxKind.BarBarToken))) {
+                complexity++;
+            }
+            // Function count
+            if (ts.isFunctionDeclaration(node) ||
+                ts.isArrowFunction(node) ||
+                ts.isMethodDeclaration(node)) {
+                functionCount++;
+            }
+            // Nesting depth
+            if (ts.isBlock(node) ||
+                ts.isIfStatement(node) ||
+                ts.isForStatement(node) ||
+                ts.isWhileStatement(node)) {
+                currentDepth++;
+                maxNestingDepth = Math.max(maxNestingDepth, currentDepth);
+            }
+            ts.forEachChild(node, visit);
+            if (ts.isBlock(node) ||
+                ts.isIfStatement(node) ||
+                ts.isForStatement(node) ||
+                ts.isWhileStatement(node)) {
+                currentDepth--;
+            }
+        };
+        visit(sourceFile);
+        const lines = content.split('\n');
+        const codeLines = lines.filter(l => l.trim().length > 0 && !l.trim().startsWith('//'));
+        const commentLines = lines.filter(l => l.trim().startsWith('//') || l.trim().startsWith('/*'));
+        return {
+            complexity: complexity + 1, // Base complexity is 1
+            linesOfCode: codeLines.length,
+            commentRatio: codeLines.length > 0 ? commentLines.length / codeLines.length : 0,
+            functionCount,
+            maxNestingDepth,
+            duplicateCode: 0, // Would need cross-file analysis
+        };
+    }
+    async analyzeQuality(sourceFile, content, metrics) {
+        const issues = [];
+        // Complexity checks
+        if (metrics.complexity > 20) {
+            issues.push({
+                type: 'warning',
+                category: 'complexity',
+                message: `High cyclomatic complexity (${metrics.complexity}). Consider refactoring.`,
+                severity: 7,
+                suggestion: 'Extract smaller functions or simplify conditional logic',
+                autoFixable: false,
+            });
+        }
+        if (metrics.maxNestingDepth > 4) {
+            issues.push({
+                type: 'warning',
+                category: 'maintainability',
+                message: `Deep nesting detected (${metrics.maxNestingDepth} levels)`,
+                severity: 6,
+                suggestion: 'Use early returns or extract nested logic into functions',
+                autoFixable: false,
+            });
+        }
+        // Comment ratio
+        if (metrics.commentRatio < 0.05 && metrics.linesOfCode > 50) {
+            issues.push({
+                type: 'info',
+                category: 'maintainability',
+                message: 'Low comment ratio. Consider adding documentation.',
+                severity: 3,
+                suggestion: 'Add JSDoc comments for public APIs',
+                autoFixable: false,
+            });
+        }
+        // Function length
+        const visit = (node) => {
+            if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
+                const start = node.getStart(sourceFile);
+                const end = node.getEnd();
+                const functionLines = content.substring(start, end).split('\n').length;
+                if (functionLines > 50) {
+                    issues.push({
+                        type: 'warning',
+                        category: 'maintainability',
+                        message: `Long function detected (${functionLines} lines)`,
+                        line: ts.getLineAndCharacterOfPosition(sourceFile, node.getStart()).line + 1,
+                        severity: 6,
+                        suggestion: 'Extract helper functions to reduce function length',
+                        autoFixable: false,
+                    });
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        // Check for any types
+        const anyTypeRegex = /:\s*any\b/g;
+        const anyMatches = content.match(anyTypeRegex);
+        if (anyMatches && anyMatches.length > 5) {
+            issues.push({
+                type: 'warning',
+                category: 'maintainability',
+                message: `Excessive use of 'any' type (${anyMatches.length} occurrences)`,
+                severity: 5,
+                suggestion: 'Replace with proper types or use unknown with type guards',
+                autoFixable: false,
+            });
+        }
+        // Calculate scores
+        const maintainability = Math.max(0, 100 - metrics.complexity * 2 - metrics.maxNestingDepth * 5);
+        const reliability = Math.max(0, 100 - (anyMatches?.length || 0) * 5);
+        const security = 100; // Would need security-specific checks
+        const performance = 100; // Would need performance analysis
+        const issuePenalty = issues.reduce((sum, i) => sum + i.severity * 2, 0);
+        const overall = Math.max(0, Math.min(100, (maintainability + reliability + security + performance) / 4 - issuePenalty));
+        return {
+            overall: Math.round(overall),
+            maintainability: Math.round(maintainability),
+            reliability: Math.round(reliability),
+            security,
+            performance,
+            issues: issues.sort((a, b) => b.severity - a.severity),
+        };
+    }
+    analyzeSymbols(sourceFile) {
+        const symbols = [];
+        const visit = (node) => {
+            if (ts.isFunctionDeclaration(node) && node.name) {
+                const symbol = this.analyzeFunction(node, sourceFile);
+                if (symbol)
+                    symbols.push(symbol);
+            }
+            else if (ts.isClassDeclaration(node) && node.name) {
+                const symbol = this.analyzeClass(node, sourceFile);
+                if (symbol)
+                    symbols.push(symbol);
+            }
+            else if (ts.isInterfaceDeclaration(node)) {
+                const symbol = this.analyzeInterface(node, sourceFile);
+                if (symbol)
+                    symbols.push(symbol);
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return symbols;
+    }
+    analyzeFunction(node, sourceFile) {
+        if (!node.name)
+            return null;
+        const params = node.parameters.map(p => ({
+            name: p.name.getText(sourceFile),
+            type: p.type?.getText(sourceFile) || 'unknown',
+            optional: !!p.questionToken,
+        }));
+        const returnType = node.type?.getText(sourceFile) || 'inferred';
+        // Check for async
+        const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword);
+        // Calculate function complexity
+        let complexity = 1;
+        const countComplexity = (n) => {
+            if (ts.isIfStatement(n) ||
+                ts.isWhileStatement(n) ||
+                ts.isForStatement(n) ||
+                ts.isConditionalExpression(n)) {
+                complexity++;
+            }
+            ts.forEachChild(n, countComplexity);
+        };
+        countComplexity(node);
+        return {
+            name: node.name.text,
+            kind: 'function',
+            params,
+            returnType,
+            isAsync,
+            complexity,
+            isExported: node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) || false,
+            documentation: this.extractJSDoc(node, sourceFile),
+        };
+    }
+    analyzeClass(node, sourceFile) {
+        if (!node.name)
+            return null;
+        const methods = [];
+        const properties = [];
+        node.members.forEach(member => {
+            if (ts.isMethodDeclaration(member) && member.name) {
+                methods.push({
+                    name: member.name.getText(sourceFile),
+                    kind: 'method',
+                    params: member.parameters.map(p => ({
+                        name: p.name.getText(sourceFile),
+                        type: p.type?.getText(sourceFile) || 'unknown',
+                    })),
+                    returnType: member.type?.getText(sourceFile) || 'void',
+                    isAsync: member.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false,
+                    complexity: 1,
+                    isExported: false,
+                });
+            }
+            else if (ts.isPropertyDeclaration(member) && member.name) {
+                properties.push({
+                    name: member.name.getText(sourceFile),
+                    type: member.type?.getText(sourceFile) || 'unknown',
+                });
+            }
+        });
+        return {
+            name: node.name.text,
+            kind: 'class',
+            methods,
+            properties,
+            isExported: node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) || false,
+            documentation: this.extractJSDoc(node, sourceFile),
+        };
+    }
+    analyzeInterface(node, sourceFile) {
+        const properties = node.members.map(member => {
+            if (ts.isPropertySignature(member) && member.name) {
+                return {
+                    name: member.name.getText(sourceFile),
+                    type: member.type?.getText(sourceFile) || 'unknown',
+                    optional: !!member.questionToken,
+                };
+            }
+            return null;
+        }).filter((p) => p !== null);
+        return {
+            name: node.name.text,
+            kind: 'interface',
+            properties,
+            isExported: node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) || false,
+            documentation: this.extractJSDoc(node, sourceFile),
+        };
+    }
+    extractJSDoc(node, sourceFile) {
+        const jsDoc = node.jsDoc;
+        if (jsDoc && jsDoc.length > 0) {
+            return jsDoc[0].comment?.toString();
+        }
+        return undefined;
+    }
+    /**
+     * Smart impact analysis - predicts what will be affected by changes
+     */
+    async analyzeImpact(filePath, changeDescription) {
+        const absolutePath = validatePath(filePath);
+        // Get graph relationships
+        const context = this.graph.getDeepContext(filePath);
+        if (!context) {
+            await this.graph.build(process.cwd());
+        }
+        const relationships = this.graph.getRelationships(filePath);
+        if (!relationships) {
+            return {
+                filePath,
+                directImpacts: [],
+                indirectImpacts: [],
+                testFiles: [],
+                riskScore: 0,
+                breakingChanges: false,
+                estimatedReviewTime: 0,
+            };
+        }
+        // Direct impacts: files that import this file
+        const directImpacts = relationships.importedBy;
+        // Find indirect impacts (files that import the direct impacts)
+        const indirectImpacts = [];
+        for (const directFile of directImpacts) {
+            const directRel = this.graph.getRelationships(directFile);
+            if (directRel) {
+                for (const indirect of directRel.importedBy) {
+                    if (indirect !== filePath && !directImpacts.includes(indirect)) {
+                        indirectImpacts.push(indirect);
+                    }
+                }
+            }
+        }
+        // Find related test files
+        const testFiles = await this.findRelatedTests(filePath);
+        // Calculate risk score
+        let riskScore = 0;
+        // Base risk from number of dependents
+        riskScore += directImpacts.length * 10;
+        riskScore += indirectImpacts.length * 5;
+        // Higher risk if changing public API
+        if (relationships.symbols.some(s => s.includes('export'))) {
+            riskScore += 20;
+        }
+        // Check change description for risky keywords
+        if (changeDescription) {
+            const riskyKeywords = ['delete', 'remove', 'rename', 'breaking', 'api'];
+            if (riskyKeywords.some(k => changeDescription.toLowerCase().includes(k))) {
+                riskScore += 15;
+            }
+        }
+        const breakingChanges = riskScore > 50;
+        const estimatedReviewTime = Math.min(120, 5 + directImpacts.length * 2 + indirectImpacts.length + testFiles.length * 3);
+        return {
+            filePath,
+            directImpacts,
+            indirectImpacts: [...new Set(indirectImpacts)],
+            testFiles,
+            riskScore: Math.min(100, riskScore),
+            breakingChanges,
+            estimatedReviewTime,
+        };
+    }
+    async findRelatedTests(filePath) {
+        const testFiles = [];
+        const baseName = path.basename(filePath, path.extname(filePath));
+        const dir = path.dirname(filePath);
+        // Common test file patterns
+        const patterns = [
+            `${baseName}.test.ts`,
+            `${baseName}.spec.ts`,
+            `${baseName}.test.js`,
+            `${baseName}.spec.js`,
+        ];
+        for (const pattern of patterns) {
+            const testPath = path.join(dir, pattern);
+            try {
+                await fs.access(testPath);
+                testFiles.push(testPath);
+            }
+            catch {
+                // File doesn't exist
+            }
+        }
+        // Check for __tests__ directory
+        const testsDir = path.join(dir, '__tests__');
+        try {
+            const files = await fs.readdir(testsDir);
+            files.forEach(f => {
+                if (f.includes(baseName) && (f.endsWith('.test.ts') || f.endsWith('.spec.ts'))) {
+                    testFiles.push(path.join(testsDir, f));
+                }
+            });
+        }
+        catch {
+            // Directory doesn't exist
+        }
+        return testFiles;
+    }
+    /**
+     * Generate intelligent refactoring suggestions
+     */
+    async suggestRefactoring(filePath) {
+        const { ast, metrics, quality } = await this.analyzeFile(filePath);
+        if (!ast)
+            return [];
+        const suggestions = [];
+        // Suggest extracting long functions
+        if (metrics.complexity > 10) {
+            const longFunctions = this.findLongFunctions(ast);
+            for (const func of longFunctions) {
+                suggestions.push({
+                    type: 'extract-method',
+                    description: `Extract ${func.name} into smaller functions`,
+                    currentCode: func.code,
+                    suggestedCode: `// Suggested: Split into ${Math.ceil(func.lines / 20)} helper functions`,
+                    confidence: 85,
+                    impact: 'medium',
+                    effort: 'moderate',
+                    benefits: ['Reduced complexity', 'Better testability', 'Easier maintenance'],
+                });
+            }
+        }
+        // Simplify nested conditionals
+        const nestedConditionals = this.findNestedConditionals(ast);
+        for (const nested of nestedConditionals) {
+            suggestions.push({
+                type: 'simplify',
+                description: 'Simplify deeply nested conditionals',
+                currentCode: nested.code,
+                suggestedCode: '// Use early returns or extract into guard clauses',
+                confidence: 90,
+                impact: 'low',
+                effort: 'quick',
+                benefits: ['Improved readability', 'Reduced cognitive load'],
+            });
+        }
+        // Add types for any
+        const anyUsages = this.findAnyUsages(ast);
+        if (anyUsages.length > 0) {
+            suggestions.push({
+                type: 'add-types',
+                description: `Replace ${anyUsages.length} 'any' types with proper types`,
+                currentCode: anyUsages.map(a => a.code).join('\n'),
+                suggestedCode: '// Define proper interfaces or use unknown with type guards',
+                confidence: 80,
+                impact: 'medium',
+                effort: 'moderate',
+                benefits: ['Type safety', 'Better IDE support', 'Fewer runtime errors'],
+            });
+        }
+        return suggestions.sort((a, b) => b.confidence - a.confidence);
+    }
+    findLongFunctions(sourceFile) {
+        const functions = [];
+        const content = sourceFile.getFullText();
+        const visit = (node) => {
+            if (ts.isFunctionDeclaration(node) && node.name) {
+                const start = node.getStart(sourceFile);
+                const end = node.getEnd();
+                const code = content.substring(start, end);
+                const lines = code.split('\n').length;
+                if (lines > 30) {
+                    functions.push({
+                        name: node.name.text,
+                        lines,
+                        code: code.substring(0, 200) + '...',
+                    });
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return functions;
+    }
+    findNestedConditionals(sourceFile) {
+        const nested = [];
+        const content = sourceFile.getFullText();
+        const visit = (node, depth = 0) => {
+            if (ts.isIfStatement(node)) {
+                if (depth > 3) {
+                    const code = content.substring(node.getStart(sourceFile), node.getEnd());
+                    nested.push({ depth, code: code.substring(0, 150) + '...' });
+                }
+                ts.forEachChild(node, n => visit(n, depth + 1));
+            }
+            else {
+                ts.forEachChild(node, n => visit(n, depth));
+            }
+        };
+        visit(sourceFile);
+        return nested;
+    }
+    findAnyUsages(sourceFile) {
+        const usages = [];
+        const content = sourceFile.getFullText();
+        const visit = (node) => {
+            if (ts.isTypeReferenceNode(node) && node.typeName.getText(sourceFile) === 'any') {
+                usages.push({
+                    code: content.substring(node.getStart(sourceFile), node.getEnd()),
+                });
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return usages;
+    }
+    /**
+     * Semantic code search - find code by concept, not just text
+     */
+    async semanticSearch(query, options = {}) {
+        const { filePattern = '*', maxResults = 10 } = options;
+        // Build query concepts
+        const concepts = this.extractConcepts(query);
+        // Search through codebase
+        const files = await this.getMatchingFiles(filePattern);
+        const results = [];
+        for (const filePath of files) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const relevance = this.calculateRelevance(content, concepts, query);
+                if (relevance > 0.3) {
+                    const snippet = this.extractRelevantSnippet(content, concepts);
+                    results.push({
+                        filePath,
+                        relevance,
+                        context: this.extractContext(content, snippet),
+                        matchedConcepts: concepts.filter(c => content.toLowerCase().includes(c.toLowerCase())),
+                        codeSnippet: snippet,
+                    });
+                }
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        return results
+            .sort((a, b) => b.relevance - a.relevance)
+            .slice(0, maxResults);
+    }
+    extractConcepts(query) {
+        // Extract key concepts from query
+        const stopWords = new Set(['the', 'a', 'an', 'in', 'on', 'at', 'to', 'for', 'of', 'and', 'or']);
+        return query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter(w => w.length > 2 && !stopWords.has(w))
+            .map(w => w.replace(/[^a-z0-9]/g, ''));
+    }
+    calculateRelevance(content, concepts, originalQuery) {
+        const lowerContent = content.toLowerCase();
+        let score = 0;
+        // Concept matching
+        for (const concept of concepts) {
+            const count = (lowerContent.match(new RegExp(concept, 'g')) || []).length;
+            score += Math.min(count * 0.1, 0.5);
+        }
+        // Check for function/variable names matching query
+        const camelCaseQuery = originalQuery.replace(/\s+(.)/g, (_, c) => c.toUpperCase());
+        const snakeCaseQuery = originalQuery.replace(/\s+/g, '_');
+        if (content.includes(camelCaseQuery) || content.includes(snakeCaseQuery)) {
+            score += 0.3;
+        }
+        // Boost for TypeScript/JavaScript files
+        if (content.includes('function') || content.includes('const') || content.includes('export')) {
+            score += 0.1;
+        }
+        return Math.min(1, score);
+    }
+    extractRelevantSnippet(content, concepts) {
+        const lines = content.split('\n');
+        let bestStart = 0;
+        let bestScore = 0;
+        // Find window with highest concept density
+        for (let i = 0; i < lines.length - 10; i++) {
+            const window = lines.slice(i, i + 10).join('\n').toLowerCase();
+            const score = concepts.filter(c => window.includes(c)).length;
+            if (score > bestScore) {
+                bestScore = score;
+                bestStart = i;
+            }
+        }
+        return lines.slice(bestStart, bestStart + 15).join('\n');
+    }
+    extractContext(content, snippet) {
+        const lines = content.split('\n');
+        const snippetLines = snippet.split('\n');
+        const firstLine = snippetLines[0];
+        // Try to find class/function name
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i] === firstLine) {
+                // Look backwards for function/class declaration
+                for (let j = Math.max(0, i - 5); j < i; j++) {
+                    const match = lines[j].match(/(?:export\s+)?(?:class|function|interface)\s+(\w+)/);
+                    if (match) {
+                        return `${match[0]} (line ${j + 1})`;
+                    }
+                }
+            }
+        }
+        return 'Global scope';
+    }
+    async getMatchingFiles(pattern) {
+        // Simple glob-like matching
+        const files = [];
+        try {
+            const { stdout } = await execAsync(`find . -type f -name "${pattern}" ! -path "*/node_modules/*" ! -path "*/.git/*" | head -100`, { cwd: process.cwd() });
+            return stdout.trim().split('\n').filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Auto-fix common code issues
+     */
+    async autoFix(filePath, options = {}) {
+        const absolutePath = validatePath(filePath);
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        const lines = content.split('\n');
+        const fixes = [];
+        let modifiedContent = content;
+        // Fix 1: Remove trailing whitespace
+        if (options.fixTrailingWhitespace !== false) {
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.replace(/\s+$/, '');
+                if (line !== trimmed) {
+                    fixes.push({
+                        type: 'trailing-whitespace',
+                        line: i + 1,
+                        original: line,
+                        fixed: trimmed,
+                    });
+                    lines[i] = trimmed;
+                }
+            }
+            modifiedContent = lines.join('\n');
+        }
+        // Fix 2: Add missing semicolons (simple heuristic)
+        if (options.fixMissingSemicolons) {
+            const semicolonPattern = /^(\s*)(.+?)(?<!;)(\s*)$/;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Skip comments, strings, imports, exports, function declarations, etc.
+                if (line.trim().startsWith('//') ||
+                    line.trim().startsWith('/*') ||
+                    line.trim().startsWith('*') ||
+                    line.trim().startsWith('import') ||
+                    line.trim().startsWith('export') ||
+                    line.trim().startsWith('function') ||
+                    line.trim().startsWith('async function') ||
+                    line.trim().startsWith('class') ||
+                    line.trim().startsWith('interface') ||
+                    line.trim().startsWith('type') ||
+                    line.trim().startsWith('if') ||
+                    line.trim().startsWith('for') ||
+                    line.trim().startsWith('while') ||
+                    line.trim().startsWith('switch') ||
+                    line.trim().startsWith('try') ||
+                    line.trim().startsWith('catch') ||
+                    line.trim().startsWith('finally') ||
+                    line.trim().startsWith('{') ||
+                    line.trim().startsWith('}') ||
+                    line.trim().endsWith('{') ||
+                    line.trim().endsWith('}') ||
+                    line.trim().endsWith(';') ||
+                    line.trim() === '') {
+                    continue;
+                }
+                // Add semicolon if line looks like a statement
+                if (/[a-zA-Z0-9_)\]]\s*$/.test(line) && !line.trim().endsWith(';')) {
+                    fixes.push({
+                        type: 'missing-semicolon',
+                        line: i + 1,
+                        original: line,
+                        fixed: line + ';',
+                    });
+                    lines[i] = line + ';';
+                }
+            }
+            modifiedContent = lines.join('\n');
+        }
+        // Fix 3: Optimize imports
+        if (options.optimizeImports) {
+            const importRegex = /^(import\s+(?:{[^}]*}|\*\s+as\s+\w+|\w+)\s+from\s+['"][^'"]+['"];?)$/gm;
+            const imports = [];
+            let match;
+            while ((match = importRegex.exec(content)) !== null) {
+                imports.push(match[1]);
+            }
+            if (imports.length > 0) {
+                // Sort imports
+                imports.sort((a, b) => {
+                    const aIsRelative = a.includes("from '.'") || a.includes("from '..");
+                    const bIsRelative = b.includes("from '.'") || b.includes("from '..");
+                    if (aIsRelative && !bIsRelative)
+                        return 1;
+                    if (!aIsRelative && bIsRelative)
+                        return -1;
+                    return a.localeCompare(b);
+                });
+                // Remove duplicates
+                const uniqueImports = [...new Set(imports)];
+                if (uniqueImports.length !== imports.length || imports.join('\n') !== uniqueImports.join('\n')) {
+                    fixes.push({
+                        type: 'optimize-imports',
+                        line: 1,
+                        original: `Found ${imports.length} imports`,
+                        fixed: `Optimized to ${uniqueImports.length} imports`,
+                    });
+                }
+            }
+        }
+        // Apply fixes if not dry run
+        const applied = !options.dryRun && fixes.length > 0;
+        if (applied) {
+            await fs.writeFile(absolutePath, modifiedContent, 'utf-8');
+        }
+        return { fixes, applied };
+    }
+    /**
+     * Detect code patterns and anti-patterns
+     */
+    detectPatterns(filePath, sourceFile) {
+        const patterns = [];
+        const content = sourceFile.getFullText();
+        // Pattern: Singleton
+        const singletonPattern = /class\s+(\w+).*?private\s+static\s+instance|getInstance/s;
+        if (singletonPattern.test(content)) {
+            patterns.push({
+                name: 'Singleton Pattern',
+                description: 'Ensures a class has only one instance',
+                examples: ['Database connection', 'Logger', 'Configuration'],
+                antiPattern: 'Can make testing difficult, consider dependency injection',
+                solution: 'Use factory functions or dependency injection instead',
+                confidence: 85,
+            });
+        }
+        // Pattern: Factory
+        const factoryPattern = /create[A-Z]\w+\s*\(|make[A-Z]\w+\s*\(/;
+        if (factoryPattern.test(content)) {
+            patterns.push({
+                name: 'Factory Pattern',
+                description: 'Creates objects without specifying exact class',
+                examples: ['createUser()', 'makeRequest()'],
+                solution: 'Use dependency injection container or factory pattern',
+                confidence: 70,
+            });
+        }
+        // Anti-pattern: Callback hell
+        const callbackHell = /\)\s*\{[\s\S]*?\)\s*\{[\s\S]*?\)\s*\{/;
+        if (callbackHell.test(content)) {
+            patterns.push({
+                name: 'Callback Hell (Anti-pattern)',
+                description: 'Deeply nested callbacks',
+                examples: [],
+                antiPattern: 'Makes code hard to read and maintain',
+                solution: 'Use async/await or Promise chains',
+                confidence: 90,
+            });
+        }
+        // Pattern: Dependency Injection
+        const diPattern = /constructor\s*\([^)]*(?:private|public|protected)[^)]*\)/;
+        if (diPattern.test(content)) {
+            patterns.push({
+                name: 'Dependency Injection',
+                description: 'Dependencies provided through constructor',
+                examples: ['constructor(private db: Database)'],
+                solution: 'Good practice for testability and modularity',
+                confidence: 80,
+            });
+        }
+        return patterns;
+    }
+}
+// ============= Export singleton =============
+let analyzerInstance = null;
+export function getIntelligentAnalyzer(graph) {
+    if (!analyzerInstance) {
+        analyzerInstance = new IntelligentCodeAnalyzer(graph);
+    }
+    return analyzerInstance;
+}