erosolar-cli 2.0.5 → 2.1.2

package/dist/tools/enhancedCodeIntelligenceTools.js

@@ -1,418 +1,540 @@
 /**
  * Enhanced Code Intelligence Tools
- * Advanced code analysis, refactoring assistance, and quality improvement
+ * Production-ready code analysis, refactoring, and automation helpers.
  */
-import { readFileSync, existsSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
 import { performAdvancedAstAnalysis } from './codeAnalysisTools.js';
+import { CodeIntelligenceEngine } from '../intelligence/codeIntelligence.js';
+import { RefactoringEngine } from '../intelligence/refactoring.js';
+import { CodeIntelligenceSuite } from '../intelligence/index.js';
+const SUPPORTED_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const IGNORED_DIRECTORIES = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo']);
 export function createEnhancedCodeIntelligenceTools(workingDir) {
     return [
         {
             name: 'analyze_code_complexity',
-            description: 'Analyze code complexity metrics across files and identify refactoring opportunities.',
+            description: 'Analyze code complexity across files, highlighting hotspots and risky symbols.',
             parameters: {
                 type: 'object',
                 properties: {
                     path: {
                         type: 'string',
-                        description: 'File or directory path to analyze (default: current directory).',
+                        description: 'File or directory path to analyze (default: working directory).',
                     },
                     maxFiles: {
                         type: 'number',
-                        description: 'Maximum number of files to analyze (default: 50).',
+                        description: 'Maximum number of files to scan (default: 50).',
                     },
                 },
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const path = args['path'] ?? workingDir;
+                const target = resolveTargetPath(workingDir, args['path'] ?? workingDir);
                 const maxFiles = args['maxFiles'] ?? 50;
-                return analyzeComplexity(path, maxFiles);
+                return analyzeCodeComplexity(target, workingDir, maxFiles);
             },
         },
         {
             name: 'suggest_refactoring',
-            description: 'Generate specific refactoring suggestions for complex or problematic code.',
+            description: 'Generate refactoring suggestions with previews from the refactoring engine.',
             parameters: {
                 type: 'object',
                 properties: {
                     path: {
                         type: 'string',
-                        description: 'File or directory path to analyze for refactoring.',
+                        description: 'File or directory to scan (default: working directory).',
                     },
                     priority: {
                         type: 'string',
                         enum: ['low', 'medium', 'high'],
-                        description: 'Priority level for suggestions (default: all).',
+                        description: 'Filter suggestions by impact priority.',
                     },
                 },
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const path = args['path'] ?? workingDir;
+                const target = resolveTargetPath(workingDir, args['path'] ?? workingDir);
                 const priority = args['priority'];
-                return generateRefactoringSuggestions(path, priority);
+                return suggestRefactoring(target, workingDir, priority);
             },
         },
         {
             name: 'auto_refactor_complexity',
-            description: 'Automatically refactor complex functions by reducing nesting and improving readability.',
+            description: 'Apply safe refactorings for complex code paths. Uses previews by default.',
             parameters: {
                 type: 'object',
                 properties: {
                     path: {
                         type: 'string',
-                        description: 'File path to refactor.',
-                    },
-                    maxNestingDepth: {
-                        type: 'number',
-                        description: 'Maximum allowed nesting depth (default: 4).',
+                        description: 'File or directory to refactor.',
                     },
                     preview: {
                         type: 'boolean',
-                        description: 'Show preview without applying changes (default: true).',
+                        description: 'If true, only show planned changes without writing files (default: true).',
                     },
                 },
                 required: ['path'],
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const filePath = resolveFilePath(workingDir, args['path']);
-                const maxNestingDepth = args['maxNestingDepth'] ?? 4;
+                const target = resolveTargetPath(workingDir, args['path']);
                 const preview = args['preview'] ?? true;
-                return autoRefactorComplexity(filePath, workingDir, maxNestingDepth, preview);
+                return autoRefactorComplexity(target, workingDir, preview);
             },
         },
         {
             name: 'improve_type_safety',
-            description: 'Replace any types with proper TypeScript types and improve type safety.',
+            description: 'Find and optionally replace unsafe `any` usage with safer defaults.',
             parameters: {
                 type: 'object',
                 properties: {
                     path: {
                         type: 'string',
-                        description: 'File path to improve type safety.',
+                        description: 'File path to analyze for unsafe types.',
                     },
                     preview: {
                         type: 'boolean',
-                        description: 'Show preview without applying changes (default: true).',
+                        description: 'If true, only report findings; if false, applies safer replacements (default: true).',
                     },
                 },
                 required: ['path'],
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const filePath = resolveFilePath(workingDir, args['path']);
+                const target = resolveTargetPath(workingDir, args['path']);
                 const preview = args['preview'] ?? true;
-                return improveTypeSafety(filePath, workingDir, preview);
+                return improveTypeSafety(target, workingDir, preview);
             },
         },
         {
             name: 'detect_code_smells',
-            description: 'Detect common code smells and anti-patterns across the codebase.',
+            description: 'Detect common code smells and anti-patterns using the intelligence engine.',
             parameters: {
                 type: 'object',
                 properties: {
                     path: {
                         type: 'string',
-                        description: 'Path to analyze (default: current directory).',
-                    },
-                    maxFiles: {
-                        type: 'number',
-                        description: 'Maximum number of files to analyze (default: 50).',
+                        description: 'File or directory to scan (default: working directory).',
                     },
                 },
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const path = args['path'] ?? workingDir;
-                const maxFiles = args['maxFiles'] ?? 50;
-                return detectCodeSmells(path, maxFiles);
+                const target = resolveTargetPath(workingDir, args['path'] ?? workingDir);
+                return detectCodeSmells(target, workingDir);
             },
         },
         {
             name: 'generate_code_quality_report',
-            description: 'Generate comprehensive code quality report with actionable recommendations.',
+            description: 'Generate a quality report (issues, metrics, refactor hotspots) and return a condensed summary.',
             parameters: {
                 type: 'object',
                 properties: {
                     path: {
                         type: 'string',
-                        description: 'File or directory path to analyze (default: current directory).',
+                        description: 'File or directory to analyze (default: working directory).',
+                    },
+                },
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const target = resolveTargetPath(workingDir, args['path'] ?? workingDir);
+                return generateQualityReport(target, workingDir);
+            },
+        },
+        {
+            name: 'run_code_intelligence_suite',
+            description: 'Run the full code intelligence suite (analysis, safe auto-fixes, refactor suggestions, docs/tests generation).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    enableAutoFix: {
+                        type: 'boolean',
+                        description: 'Apply safe auto-fixes and refactorings (default: false).',
+                    },
+                    generateTests: {
+                        type: 'boolean',
+                        description: 'Generate test plans/files (default: true).',
+                    },
+                    generateDocs: {
+                        type: 'boolean',
+                        description: 'Generate documentation summaries (default: true).',
+                    },
+                    outputDir: {
+                        type: 'string',
+                        description: 'Custom output directory for reports (default: .intelligence under workingDir).',
                     },
                 },
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const path = args['path'] ?? workingDir;
-                return generateQualityReport(path);
+                const enableAutoFix = args['enableAutoFix'] === true;
+                const generateTests = args['generateTests'] !== false;
+                const generateDocs = args['generateDocs'] !== false;
+                const outputDir = typeof args['outputDir'] === 'string'
+                    ? resolveTargetPath(workingDir, args['outputDir'])
+                    : undefined;
+                return runCodeIntelligenceSuite({
+                    workingDir,
+                    enableAutoFix,
+                    generateTests,
+                    generateDocs,
+                    outputDir,
+                });
             },
         },
     ];
 }
-function resolveFilePath(workingDir, path) {
-    if (path.startsWith('/')) {
-        return path;
+function resolveTargetPath(workingDir, targetPath) {
+    return targetPath.startsWith('/') ? targetPath : resolve(workingDir, targetPath);
+}
+function collectSourceFiles(target, maxFiles) {
+    const files = [];
+    const visit = (current) => {
+        if (files.length >= maxFiles) {
+            return;
+        }
+        const stats = statSync(current);
+        if (stats.isFile()) {
+            if (SUPPORTED_EXTENSIONS.some((ext) => current.endsWith(ext))) {
+                files.push(current);
+            }
+            return;
+        }
+        if (!stats.isDirectory()) {
+            return;
+        }
+        const entries = readdirSync(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= maxFiles) {
+                break;
+            }
+            if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) {
+                continue;
+            }
+            visit(join(current, entry.name));
+        }
+    };
+    if (existsSync(target)) {
+        visit(target);
     }
-    return join(workingDir, path);
+    return files;
 }
-function analyzeComplexity(_path, _maxFiles) {
+function analyzeCodeComplexity(target, workingDir, maxFiles) {
+    if (!existsSync(target)) {
+        return `Error: path not found: ${target}`;
+    }
+    const files = collectSourceFiles(target, Math.max(1, maxFiles));
+    if (files.length === 0) {
+        return `No TypeScript/JavaScript files found under ${target}.`;
+    }
+    const hotspots = [];
+    let totalLines = 0;
+    let totalSymbols = 0;
+    let totalCyclomatic = 0;
+    for (const file of files) {
+        const content = readFileSync(file, 'utf-8');
+        const lines = content.split(/\r?\n/).length;
+        totalLines += lines;
+        const analysis = performAdvancedAstAnalysis(content, file);
+        totalSymbols += analysis.symbols.length;
+        totalCyclomatic += analysis.totalCyclomaticComplexity;
+        const worst = selectWorstSymbol(analysis.symbols);
+        if (worst) {
+            const span = worst.endLine - worst.startLine + 1;
+            const reasons = [];
+            if (worst.cyclomaticComplexity > 10) {
+                reasons.push(`high complexity (${worst.cyclomaticComplexity})`);
+            }
+            if (worst.statementCount > 50) {
+                reasons.push(`long body (${worst.statementCount} statements)`);
+            }
+            if (span > 120) {
+                reasons.push(`spans ${span} lines`);
+            }
+            hotspots.push({ file, symbol: worst, span, reasons });
+        }
+    }
+    hotspots.sort((a, b) => {
+        if (b.symbol.cyclomaticComplexity !== a.symbol.cyclomaticComplexity) {
+            return b.symbol.cyclomaticComplexity - a.symbol.cyclomaticComplexity;
+        }
+        return b.symbol.statementCount - a.symbol.statementCount;
+    });
+    const averageCyclomatic = totalSymbols === 0 ? 0 : Math.round((totalCyclomatic / totalSymbols) * 10) / 10;
     const output = [];
     output.push('# Code Complexity Analysis');
+    output.push(`Files scanned: ${files.length} (limit ${maxFiles})`);
+    output.push(`Lines of code: ${totalLines.toLocaleString()}`);
+    output.push(`Average cyclomatic complexity per symbol: ${averageCyclomatic}`);
     output.push('');
-    // Implementation would scan files and calculate complexity metrics
-    // For now, return a placeholder implementation
-    output.push('🔍 Complexity analysis would scan files and calculate:');
-    output.push('- Cyclomatic complexity');
-    output.push('- Cognitive complexity');
-    output.push('- Maintainability index');
-    output.push('- Nesting depth analysis');
-    output.push('- Type safety metrics');
-    output.push('');
-    output.push('📊 This tool identifies complex functions, deep nesting, and type safety issues.');
+    output.push('## Top Complexity Hotspots');
+    const topHotspots = hotspots.slice(0, 10);
+    if (topHotspots.length === 0) {
+        output.push('No complex symbols detected.');
+    }
+    else {
+        topHotspots.forEach((hotspot, index) => {
+            output.push(`${index + 1}. ${relative(workingDir, hotspot.file)} :: ${hotspot.symbol.name} (lines ${hotspot.symbol.startLine}-${hotspot.symbol.endLine})`);
+            output.push(`   - CC: ${hotspot.symbol.cyclomaticComplexity}, statements: ${hotspot.symbol.statementCount}, span: ${hotspot.span} lines`);
+            if (hotspot.reasons.length > 0) {
+                output.push(`   - Reasons: ${hotspot.reasons.join(', ')}`);
+            }
+        });
+    }
     output.push('');
-    output.push('💡 Use `suggest_refactoring` for specific improvement suggestions.');
+    output.push('Use `suggest_refactoring` to get concrete improvement steps or `auto_refactor_complexity` to apply safe changes.');
     return output.join('\n');
 }
-function generateRefactoringSuggestions(_path, priority) {
+function selectWorstSymbol(symbols) {
+    if (!symbols.length) {
+        return null;
+    }
+    const initial = symbols[0];
+    return symbols.reduce((worst, current) => {
+        const score = current.cyclomaticComplexity * 2 + current.statementCount;
+        const worstScore = worst.cyclomaticComplexity * 2 + worst.statementCount;
+        return score > worstScore ? current : worst;
+    }, initial);
+}
+function suggestRefactoring(target, workingDir, priority) {
+    const engine = new RefactoringEngine(workingDir);
+    const opportunities = engine.findOpportunities(target);
+    const filtered = priority ? opportunities.filter((o) => mapImpactToPriority(o.impact) === priority) : opportunities;
+    if (filtered.length === 0) {
+        return 'No refactoring opportunities detected for the specified scope.';
+    }
     const output = [];
     output.push('# Refactoring Suggestions');
-    output.push('');
-    // Implementation would analyze code and generate specific suggestions
-    output.push('🔧 Refactoring suggestions would include:');
-    output.push('- Breaking down complex functions');
-    output.push('- Reducing nesting depth');
-    output.push('- Replacing `any` types with proper types');
-    output.push('- Improving function naming');
-    output.push('- Removing code duplication');
-    output.push('');
     if (priority) {
-        output.push(`📋 Priority filter: ${priority}`);
+        output.push(`Filtered by priority: ${priority}`);
     }
     output.push('');
-    output.push('💡 Use `auto_refactor_complexity` for automated refactoring assistance.');
+    filtered.slice(0, 20).forEach((opp, index) => {
+        const preview = opp.preview
+            ? `${opp.preview.before.trim().slice(0, 80)} → ${opp.preview.after.trim().slice(0, 80)}`
+            : 'Preview unavailable';
+        output.push(`${index + 1}. ${opp.type} (${opp.impact}/${opp.risk}) - ${opp.description}`);
+        output.push(`   • ${opp.file}:${opp.line}`);
+        output.push(`   • ${preview}`);
+    });
+    if (filtered.length > 20) {
+        output.push('');
+        output.push(`…${filtered.length - 20} additional opportunities not shown.`);
+    }
+    output.push('');
+    output.push('Run `auto_refactor_complexity` to apply safe changes automatically.');
     return output.join('\n');
 }
-function autoRefactorComplexity(filePath, workingDir, maxNestingDepth, preview) {
-    if (!existsSync(filePath)) {
-        return `Error: File not found: ${filePath}`;
+function mapImpactToPriority(impact) {
+    return impact;
+}
+function autoRefactorComplexity(target, workingDir, preview) {
+    if (!existsSync(target)) {
+        return `Error: path not found: ${target}`;
     }
-    const content = readFileSync(filePath, 'utf-8');
-    const ast = performAdvancedAstAnalysis(content, filePath);
-    const output = [];
-    output.push('# Automatic Complexity Refactoring');
-    output.push('');
-    output.push(`📁 File: ${relative(workingDir, filePath)}`);
-    output.push(`🎯 Target nesting depth: ${maxNestingDepth}`);
-    output.push(`👁️ Preview mode: ${preview ? 'ON' : 'OFF'}`);
-    output.push('');
-    // Find complex functions
-    const complexFunctions = ast.symbols.filter(symbol => symbol.kind === 'function' &&
-        (symbol.cyclomaticComplexity > 10 || symbol.statementCount > 30));
-    if (complexFunctions.length === 0) {
-        output.push('✅ No complex functions found that need refactoring.');
+    const engine = new RefactoringEngine(workingDir);
+    const opportunities = engine.findOpportunities(target);
+    const safe = opportunities.filter((o) => o.risk === 'safe');
+    if (safe.length === 0) {
+        return 'No safe refactorings available to apply.';
+    }
+    if (preview) {
+        const output = [];
+        output.push('# Preview: Safe Refactorings');
+        safe.slice(0, 15).forEach((opp, index) => {
+            output.push(`${index + 1}. ${opp.type} :: ${opp.file}:${opp.line} (${opp.description})`);
+        });
+        if (safe.length > 15) {
+            output.push(`…${safe.length - 15} additional safe refactorings not shown.`);
+        }
+        output.push('');
+        output.push('Run again with `preview: false` to apply these changes.');
         return output.join('\n');
     }
-    output.push('## Complex Functions Found');
-    complexFunctions.forEach(func => {
-        output.push(`- ${func.name}: ${func.statementCount} statements, CC: ${func.cyclomaticComplexity}`);
+    const result = engine.applySafeRefactorings(safe);
+    const output = [];
+    output.push('# Applied Safe Refactorings');
+    output.push(`Files modified: ${result.filesModified.length}`);
+    result.changes.forEach((change, index) => {
+        output.push(`${index + 1}. ${change.file} - ${change.description} (${change.linesChanged} lines changed)`);
     });
-    if (preview) {
+    if (result.errors.length > 0) {
         output.push('');
-        output.push('💡 Run with `preview: false` to apply automatic refactoring.');
+        output.push('Errors:');
+        result.errors.forEach((err) => output.push(`- ${err}`));
     }
     return output.join('\n');
 }
-function improveTypeSafety(filePath, workingDir, preview) {
-    if (!existsSync(filePath)) {
-        return `Error: File not found: ${filePath}`;
+function improveTypeSafety(target, workingDir, preview) {
+    if (!existsSync(target)) {
+        return `Error: file not found: ${target}`;
     }
-    const content = readFileSync(filePath, 'utf-8');
-    const output = [];
-    output.push('# Type Safety Improvements');
-    output.push('');
-    output.push(`📁 File: ${relative(workingDir, filePath)}`);
-    output.push(`👁️ Preview mode: ${preview ? 'ON' : 'OFF'}`);
-    output.push('');
-    // Count any types
-    const anyCount = (content.match(/\bany\b/g) || []).length;
-    output.push(`🔍 Found ${anyCount} instances of 'any' type`);
-    if (anyCount === 0) {
-        output.push('✅ No type safety issues found.');
-        return output.join('\n');
+    const content = readFileSync(target, 'utf-8');
+    const occurrences = findAnyOccurrences(content);
+    if (occurrences.length === 0) {
+        return 'No unsafe `any` usage detected.';
     }
-    output.push('');
-    output.push('## Type Safety Issues');
-    output.push('- Replace `any` with specific types');
-    output.push('- Add proper interface definitions');
-    output.push('- Improve function return types');
-    output.push('- Add parameter types');
     if (preview) {
+        const output = [];
+        output.push('# Type Safety Findings');
+        occurrences.slice(0, 20).forEach((occurrence, index) => {
+            output.push(`${index + 1}. line ${occurrence.line} → ${occurrence.snippet}`);
+        });
+        if (occurrences.length > 20) {
+            output.push(`…${occurrences.length - 20} additional occurrences not shown.`);
+        }
         output.push('');
-        output.push('💡 Run with `preview: false` to apply type safety improvements.');
+        output.push('Run with `preview: false` to replace `any` with `unknown` in-place.');
+        return output.join('\n');
+    }
+    let updated = content;
+    const replacements = [
+        { pattern: /:\s*any\b/g, replacement: ': unknown' },
+        { pattern: /\bas any\b/g, replacement: ' as unknown' },
+        { pattern: /<any>/g, replacement: '<unknown>' },
+    ];
+    replacements.forEach(({ pattern, replacement }) => {
+        updated = updated.replace(pattern, replacement);
+    });
+    if (updated === content) {
+        return 'No replaceable `any` tokens found after analysis.';
     }
+    writeFileSync(target, updated, 'utf-8');
+    const output = [];
+    output.push('# Type Safety Applied');
+    output.push(`File updated: ${relative(workingDir, target)}`);
+    output.push(`Occurrences replaced: ${occurrences.length}`);
+    output.push('Re-run type checking to validate changes.');
     return output.join('\n');
 }
-function scanFiles(basePath, maxFiles) {
-    const files = [];
-    // Simple file scanning using existsSync
-    // For a directory, we'd normally use readdirSync recursively
-    // but since we're keeping this simple, just check if it's a single file
-    if (existsSync(basePath)) {
-        const { statSync, readdirSync } = require('node:fs');
-        const stats = statSync(basePath);
-        if (stats.isFile() && (basePath.endsWith('.ts') || basePath.endsWith('.js') || basePath.endsWith('.tsx') || basePath.endsWith('.jsx'))) {
-            return [basePath];
-        }
-        if (stats.isDirectory()) {
-            const scanDir = (dir) => {
-                if (files.length >= maxFiles)
-                    return;
-                try {
-                    const entries = readdirSync(dir, { withFileTypes: true });
-                    for (const entry of entries) {
-                        if (files.length >= maxFiles)
-                            break;
-                        const fullPath = join(dir, entry.name);
-                        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules' && entry.name !== 'dist') {
-                            scanDir(fullPath);
-                        }
-                        else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js') || entry.name.endsWith('.tsx') || entry.name.endsWith('.jsx'))) {
-                            files.push(fullPath);
-                        }
-                    }
-                }
-                catch {
-                    // Ignore permission errors
-                }
-            };
-            scanDir(basePath);
-        }
+function findAnyOccurrences(content) {
+    const regex = /\bany\b/g;
+    const occurrences = [];
+    let match;
+    while ((match = regex.exec(content))) {
+        const before = content.slice(0, match.index);
+        const line = before.split(/\r?\n/).length;
+        const lineText = content.split(/\r?\n/)[line - 1] ?? '';
+        occurrences.push({ line, snippet: lineText.trim().slice(0, 120) });
     }
-    return files;
+    return occurrences;
 }
-function detectCodeSmells(path, maxFiles = 50) {
+async function detectCodeSmells(target, workingDir) {
+    if (!existsSync(target)) {
+        return `Error: path not found: ${target}`;
+    }
+    const engine = new CodeIntelligenceEngine(workingDir);
+    const result = await engine.analyze(target);
+    const smells = result.issues.filter((issue) => ['complexity', 'duplication', 'maintainability', 'bug', 'performance'].includes(issue.type));
+    if (smells.length === 0) {
+        return 'No code smells detected.';
+    }
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+    smells.sort((a, b) => (severityOrder[a.severity] ?? 5) - (severityOrder[b.severity] ?? 5));
     const output = [];
-    output.push('# Code Smell Detection Report');
+    output.push('# Code Smells');
+    output.push(`Total smells: ${smells.length}`);
     output.push('');
-    // Common code smells to detect
-    const codeSmells = [
-        {
-            name: 'Long Method',
-            pattern: /function\s+\w+\s*\([^)]*\)\s*\{[\s\S]{200,}/g,
-            description: 'Methods longer than 200 characters suggest they do too much',
-            fix: 'Extract smaller methods with single responsibilities'
-        },
-        {
-            name: 'Large Class',
-            pattern: /class\s+\w+\s*\{[\s\S]{500,}/g,
-            description: 'Classes with excessive lines violate single responsibility principle',
-            fix: 'Split into smaller, focused classes'
-        },
-        {
-            name: 'Primitive Obsession',
-            pattern: /(?:let|const|var)\s+\w+\s*:\s*(string|number|boolean)\b/g,
-            description: 'Overuse of primitives instead of domain-specific types',
-            fix: 'Create value objects or domain-specific types'
-        },
-        {
-            name: 'Data Clumps',
-            pattern: /(?:\w+,\s*){3,}\w+/g,
-            description: 'Groups of data items that appear together frequently',
-            fix: 'Extract into parameter objects or data classes'
-        },
-        {
-            name: 'Feature Envy',
-            pattern: /this\.\w+\.\w+/g,
-            description: 'Method uses more features of another class than its own',
-            fix: 'Move method to the class it envies'
-        },
-        {
-            name: 'Inappropriate Intimacy',
-            pattern: /private\s+\w+\s*:\s*\w+/g,
-            description: 'Classes know too much about each other\'s internals',
-            fix: 'Reduce coupling through interfaces or mediators'
-        },
-        {
-            name: 'Message Chains',
-            pattern: /\.\w+\(\)\.\w+\(\)\.\w+\(\)/g,
-            description: 'Long chains of method calls indicate tight coupling',
-            fix: 'Hide delegate or extract intermediate object'
-        },
-        {
-            name: 'Shotgun Surgery',
-            pattern: /\/\/\s*TODO.*change|FIXME.*multiple/i,
-            description: 'Single change requires modifications in many places',
-            fix: 'Move related behavior into single class'
+    smells.slice(0, 20).forEach((issue, index) => {
+        output.push(`${index + 1}. [${issue.severity}] ${issue.file}:${issue.line ?? '?'} - ${issue.message}`);
+        if (issue.suggestion) {
+            output.push(`   → ${issue.suggestion}`);
         }
-    ];
-    output.push('## Common Code Smells Detected');
+    });
+    if (smells.length > 20) {
+        output.push(`…${smells.length - 20} additional smells not shown.`);
+    }
+    return output.join('\n');
+}
+async function generateQualityReport(target, workingDir) {
+    const engine = new CodeIntelligenceEngine(workingDir);
+    const result = await engine.analyze(target);
+    const refEngine = new RefactoringEngine(workingDir);
+    const refOps = refEngine.findOpportunities(target).slice(0, 5);
+    const output = [];
+    output.push('# Code Quality Report');
+    output.push(`Files analyzed: ${result.files}`);
+    output.push(`Lines of code: ${result.linesOfCode.toLocaleString()}`);
+    output.push('');
+    output.push('## Metrics (0-100, higher is better)');
+    output.push(`- Complexity: ${Math.round(result.metrics.complexity)}`);
+    output.push(`- Maintainability: ${Math.round(result.metrics.maintainability)}`);
+    output.push(`- Testability: ${Math.round(result.metrics.testability)}`);
+    output.push(`- Duplication: ${Math.round(result.metrics.duplication)}`);
+    output.push(`- Documentation: ${Math.round(result.metrics.documentation)}`);
     output.push('');
-    let totalSmells = 0;
-    const files = scanFiles(path, maxFiles);
-    files.forEach(file => {
-        const content = readFileSync(file, 'utf8');
-        const fileSmells = [];
-        codeSmells.forEach(smell => {
-            const matches = content.match(smell.pattern);
-            if (matches && matches.length > 0) {
-                fileSmells.push(`- **${smell.name}**: ${matches.length} instances - ${smell.description}`);
-                totalSmells += matches.length;
+    output.push('## Top Issues');
+    const topIssues = result.issues
+        .slice()
+        .sort((a, b) => {
+        const order = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+        return (order[a.severity] ?? 5) - (order[b.severity] ?? 5);
+    })
+        .slice(0, 10);
+    if (topIssues.length === 0) {
+        output.push('No issues detected.');
+    }
+    else {
+        topIssues.forEach((issue, index) => {
+            output.push(`${index + 1}. [${issue.severity}] ${issue.file}:${issue.line ?? '?'} - ${issue.message}`);
+            if (issue.suggestion) {
+                output.push(`   → ${issue.suggestion}`);
             }
         });
-        if (fileSmells.length > 0) {
-            output.push(`### ${file}`);
-            output.push(...fileSmells);
-            output.push('');
-        }
-    });
-    if (totalSmells === 0) {
-        output.push('✅ No significant code smells detected.');
-        output.push('');
-        output.push('The codebase appears to follow good design principles.');
+    }
+    output.push('');
+    output.push('## Refactor Hotspots');
+    if (refOps.length === 0) {
+        output.push('No refactor hotspots identified.');
     }
     else {
-        output.push(`## Summary`);
-        output.push(`- **Total smells detected**: ${totalSmells}`);
-        output.push(`- **Files analyzed**: ${files.length}`);
-        output.push('');
-        output.push('## Recommended Refactoring Actions');
-        output.push('');
-        codeSmells.forEach(smell => {
-            output.push(`- **${smell.name}**: ${smell.fix}`);
+        refOps.forEach((opp, index) => {
+            output.push(`${index + 1}. ${opp.file}:${opp.line} - ${opp.description} (${opp.impact}/${opp.risk})`);
         });
     }
     output.push('');
-    output.push('💡 Use `suggest_refactoring` for specific improvement suggestions.');
-    output.push('💡 Use `auto_refactor_complexity` for automated refactoring.');
+    output.push('Use `run_code_intelligence_suite` for a full analysis + optional auto-fixes and documentation generation.');
     return output.join('\n');
 }
-function generateQualityReport(_path) {
+async function runCodeIntelligenceSuite(options) {
+    const suite = new CodeIntelligenceSuite({
+        workingDir: options.workingDir,
+        enableAutoFix: options.enableAutoFix,
+        generateTests: options.generateTests,
+        generateDocs: options.generateDocs,
+        outputDir: options.outputDir ?? join(options.workingDir, '.intelligence'),
+    });
+    const report = await suite.runFullAnalysis();
     const output = [];
-    output.push('# Comprehensive Code Quality Report');
+    output.push('# Code Intelligence Suite');
+    output.push(`Analysis completed at ${report.timestamp}`);
+    output.push(`Issues found: ${report.analysis.issues.length}`);
+    output.push(`Refactoring opportunities: ${report.refactoring.length}`);
+    output.push(`Auto-fix enabled: ${options.enableAutoFix ? 'yes' : 'no'}`);
     output.push('');
-    output.push('📊 This report provides:');
-    output.push('- Complexity metrics analysis');
-    output.push('- Type safety assessment');
-    output.push('- Code duplication detection');
-    output.push('- Performance optimization suggestions');
-    output.push('- Maintainability scoring');
-    output.push('- **Code smell detection**');
-    output.push('');
-    output.push('🔍 Analysis covers:');
-    output.push('- Function complexity (cyclomatic, cognitive)');
-    output.push('- Nesting depth violations');
-    output.push('- Type safety issues');
-    output.push('- Code style consistency');
-    output.push('- Documentation coverage');
-    output.push('- **Common code smells and anti-patterns**');
+    const actions = report.actions ?? [];
+    if (actions.length > 0) {
+        output.push('## Actions Taken');
+        actions.forEach((action, index) => {
+            output.push(`${index + 1}. [${action.type}] ${action.description} (${action.success ? 'success' : 'partial'})`);
+            if (action.filesAffected.length > 0) {
+                output.push(`   Files: ${action.filesAffected.join(', ')}`);
+            }
+        });
+        output.push('');
+    }
+    if (report.documentation) {
+        output.push('Documentation generated: API.md and API-reference.md');
+    }
+    if (report.tests) {
+        output.push('Tests generated: see .intelligence/generated-tests');
+    }
+    const dest = options.outputDir ?? join(options.workingDir, '.intelligence');
     output.push('');
-    output.push('💡 Use individual tools for specific improvements:');
-    output.push('- `analyze_code_complexity` for complexity analysis');
-    output.push('- `suggest_refactoring` for improvement suggestions');
-    output.push('- `auto_refactor_complexity` for automated refactoring');
-    output.push('- `improve_type_safety` for type improvements');
-    output.push('- `detect_code_smells` for anti-pattern detection');
+    output.push(`Artifacts written to: ${dest}`);
+    output.push('Re-run this tool to keep reports fresh after additional edits.');
     return output.join('\n');
 }
 //# sourceMappingURL=enhancedCodeIntelligenceTools.js.map