@gotza02/sequential-thinking 10000.1.6 → 10000.1.7

package/dist/tools/intelligent-code.d.ts

@@ -0,0 +1,7 @@
+/**
+ * INTELLIGENT CODE TOOLS
+ * AI-powered code analysis, semantic search, and smart refactoring for MCP
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ProjectKnowledgeGraph } from '../graph.js';
+export declare function registerIntelligentCodeTools(server: McpServer, graph: ProjectKnowledgeGraph): void;

package/dist/tools/intelligent-code.js

@@ -0,0 +1,387 @@
+/**
+ * INTELLIGENT CODE TOOLS
+ * AI-powered code analysis, semantic search, and smart refactoring for MCP
+ */
+import { z } from "zod";
+import { getIntelligentAnalyzer } from '../intelligent-code.js';
+import { validatePath } from "../utils.js";
+import * as fs from 'fs/promises';
+export function registerIntelligentCodeTools(server, graph) {
+    const analyzer = getIntelligentAnalyzer(graph);
+    // 1. intelligent_code_analyze
+    server.tool("intelligent_code_analyze", "Deep AI-powered code analysis with metrics, quality scoring, and issue detection. Provides actionable recommendations.", {
+        filePath: z.string().describe("Path to the file to analyze"),
+        includeSuggestions: z.boolean().optional().default(true).describe("Include refactoring suggestions"),
+        detailLevel: z.enum(['basic', 'standard', 'comprehensive']).optional().default('standard').describe("Level of analysis detail")
+    }, async ({ filePath, includeSuggestions, detailLevel }) => {
+        try {
+            const absolutePath = validatePath(filePath);
+            const { metrics, quality, symbols } = await analyzer.analyzeFile(absolutePath);
+            let output = `🔍 INTELLIGENT CODE ANALYSIS: ${filePath}\n`;
+            output += `═`.repeat(60) + '\n\n';
+            // Quality Score Dashboard
+            output += `📊 QUALITY SCORE\n`;
+            output += `   Overall:        ${getScoreEmoji(quality.overall)} ${quality.overall}/100\n`;
+            output += `   Maintainability: ${getScoreEmoji(quality.maintainability)} ${quality.maintainability}/100\n`;
+            output += `   Reliability:     ${getScoreEmoji(quality.reliability)} ${quality.reliability}/100\n`;
+            output += `   Security:        ${getScoreEmoji(quality.security)} ${quality.security}/100\n`;
+            output += `   Performance:     ${getScoreEmoji(quality.performance)} ${quality.performance}/100\n\n`;
+            // Metrics
+            if (detailLevel !== 'basic') {
+                output += `📈 CODE METRICS\n`;
+                output += `   Lines of Code:    ${metrics.linesOfCode}\n`;
+                output += `   Functions:        ${metrics.functionCount}\n`;
+                output += `   Cyclomatic Complexity: ${metrics.complexity}\n`;
+                output += `   Max Nesting Depth: ${metrics.maxNestingDepth}\n`;
+                output += `   Comment Ratio:    ${(metrics.commentRatio * 100).toFixed(1)}%\n\n`;
+            }
+            // Issues
+            if (quality.issues.length > 0) {
+                output += `⚠️  ISSUES FOUND (${quality.issues.length})\n`;
+                const criticalIssues = quality.issues.filter(i => i.severity >= 7);
+                const warnings = quality.issues.filter(i => i.severity >= 4 && i.severity < 7);
+                const infos = quality.issues.filter(i => i.severity < 4);
+                if (criticalIssues.length > 0) {
+                    output += `\n   🔴 Critical:\n`;
+                    criticalIssues.forEach(i => {
+                        output += `      • ${i.message}\n`;
+                        if (i.suggestion)
+                            output += `        💡 ${i.suggestion}\n`;
+                        if (i.line)
+                            output += `        📍 Line ${i.line}\n`;
+                    });
+                }
+                if (warnings.length > 0) {
+                    output += `\n   🟡 Warnings:\n`;
+                    warnings.forEach(i => {
+                        output += `      • ${i.message}\n`;
+                        if (i.suggestion)
+                            output += `        💡 ${i.suggestion}\n`;
+                    });
+                }
+                if (detailLevel === 'comprehensive' && infos.length > 0) {
+                    output += `\n   🔵 Suggestions:\n`;
+                    infos.forEach(i => {
+                        output += `      • ${i.message}\n`;
+                    });
+                }
+                output += '\n';
+            }
+            // Symbols overview
+            if (detailLevel === 'comprehensive' && symbols.length > 0) {
+                output += `🔣 SYMBOLS (${symbols.length})\n`;
+                symbols.forEach(s => {
+                    const icon = s.kind === 'function' ? '⚙️' : s.kind === 'class' ? '🏗️' : s.kind === 'interface' ? '📋' : '🔹';
+                    output += `   ${icon} ${s.name} (${s.kind})\n`;
+                    if (s.documentation) {
+                        output += `      "${s.documentation.substring(0, 100)}..."\n`;
+                    }
+                });
+                output += '\n';
+            }
+            // Refactoring suggestions
+            if (includeSuggestions && detailLevel !== 'basic') {
+                const suggestions = await analyzer.suggestRefactoring(absolutePath);
+                if (suggestions.length > 0) {
+                    output += `✨ REFACTORING SUGGESTIONS (${suggestions.length})\n`;
+                    suggestions.slice(0, 5).forEach((s, idx) => {
+                        output += `\n   ${idx + 1}. ${s.type.toUpperCase()} (${s.confidence}% confidence)\n`;
+                        output += `      ${s.description}\n`;
+                        output += `      Impact: ${s.impact} | Effort: ${s.effort}\n`;
+                        output += `      Benefits: ${s.benefits.join(', ')}\n`;
+                    });
+                }
+            }
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Analysis Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 2. intelligent_impact_analysis
+    server.tool("intelligent_impact_analysis", "Predict the impact of code changes. Shows affected files, risk score, and test recommendations.", {
+        filePath: z.string().describe("Path to the file being modified"),
+        changeDescription: z.string().optional().describe("Description of the planned changes (helps risk assessment)")
+    }, async ({ filePath, changeDescription }) => {
+        try {
+            const absolutePath = validatePath(filePath);
+            const impact = await analyzer.analyzeImpact(absolutePath, changeDescription);
+            let output = `🎯 IMPACT ANALYSIS: ${filePath}\n`;
+            output += `═`.repeat(60) + '\n\n';
+            // Risk assessment
+            const riskEmoji = impact.riskScore > 70 ? '🔴' : impact.riskScore > 40 ? '🟡' : '🟢';
+            output += `${riskEmoji} RISK SCORE: ${impact.riskScore}/100\n`;
+            if (impact.breakingChanges) {
+                output += `   ⚠️  WARNING: Potential breaking changes detected!\n`;
+            }
+            output += `   Estimated Review Time: ${impact.estimatedReviewTime} minutes\n\n`;
+            // Direct impacts
+            if (impact.directImpacts.length > 0) {
+                output += `📎 DIRECT IMPACTS (${impact.directImpacts.length} files)\n`;
+                output += `   These files import the modified file:\n`;
+                impact.directImpacts.forEach(f => {
+                    output += `      • ${f}\n`;
+                });
+                output += '\n';
+            }
+            // Indirect impacts
+            if (impact.indirectImpacts.length > 0) {
+                output += `🔗 INDIRECT IMPACTS (${impact.indirectImpacts.length} files)\n`;
+                output += `   These files are transitively affected:\n`;
+                impact.indirectImpacts.slice(0, 10).forEach(f => {
+                    output += `      • ${f}\n`;
+                });
+                if (impact.indirectImpacts.length > 10) {
+                    output += `      ... and ${impact.indirectImpacts.length - 10} more\n`;
+                }
+                output += '\n';
+            }
+            // Test recommendations
+            if (impact.testFiles.length > 0) {
+                output += `🧪 TEST FILES TO RUN (${impact.testFiles.length})\n`;
+                impact.testFiles.forEach(f => {
+                    output += `      • ${f}\n`;
+                });
+                output += '\n';
+            }
+            else {
+                output += `⚠️  No test files found for this module\n\n`;
+            }
+            // Recommendations
+            output += `💡 RECOMMENDATIONS\n`;
+            if (impact.riskScore > 70) {
+                output += `   • Consider breaking this into smaller changes\n`;
+                output += `   • Add comprehensive tests before changing\n`;
+                output += `   • Request code review from domain expert\n`;
+            }
+            else if (impact.riskScore > 40) {
+                output += `   • Run the recommended test suite\n`;
+                output += `   • Update documentation if API changes\n`;
+            }
+            else {
+                output += `   • Low risk change, standard review process\n`;
+            }
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Impact Analysis Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 3. intelligent_semantic_search
+    server.tool("intelligent_semantic_search", "Search code by concept/meaning, not just text. Finds related code even with different naming.", {
+        query: z.string().describe("What you're looking for (e.g., 'authentication middleware', 'database connection pool')"),
+        filePattern: z.string().optional().default("*.ts").describe("File pattern to search (e.g., '*.ts', '*.js')"),
+        maxResults: z.number().optional().default(10).describe("Maximum results to return")
+    }, async ({ query, filePattern, maxResults }) => {
+        try {
+            const results = await analyzer.semanticSearch(query, { filePattern, maxResults });
+            if (results.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No results found for "${query}"` }]
+                };
+            }
+            let output = `🔍 SEMANTIC SEARCH: "${query}"\n`;
+            output += '═'.repeat(60) + '\n\n';
+            results.forEach((result, idx) => {
+                const relevanceBar = '█'.repeat(Math.floor(result.relevance * 10)) + '░'.repeat(10 - Math.floor(result.relevance * 10));
+                output += `${idx + 1}. ${result.filePath}\n`;
+                output += `   Relevance: [${relevanceBar}] ${(result.relevance * 100).toFixed(0)}%\n`;
+                output += `   Context: ${result.context}\n`;
+                if (result.matchedConcepts.length > 0) {
+                    output += `   Matched: ${result.matchedConcepts.join(', ')}\n`;
+                }
+                output += `\n   \`\`\`typescript\n`;
+                output += `   ${result.codeSnippet.split('\n').join('\n   ')}\n`;
+                output += `   \`\`\`\n\n`;
+            });
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Search Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 4. intelligent_refactor_suggest
+    server.tool("intelligent_refactor_suggest", "Get intelligent refactoring suggestions with code examples and impact assessment.", {
+        filePath: z.string().describe("Path to the file to analyze for refactoring"),
+        minConfidence: z.number().optional().default(70).describe("Minimum confidence threshold (0-100)")
+    }, async ({ filePath, minConfidence }) => {
+        try {
+            const absolutePath = validatePath(filePath);
+            const suggestions = await analyzer.suggestRefactoring(absolutePath);
+            const filtered = suggestions.filter(s => s.confidence >= minConfidence);
+            if (filtered.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No high-confidence refactoring suggestions found for ${filePath}` }]
+                };
+            }
+            let output = `✨ REFACTORING SUGGESTIONS: ${filePath}\n`;
+            output += `═`.repeat(60) + '\n\n';
+            filtered.forEach((s, idx) => {
+                const confidenceEmoji = s.confidence >= 90 ? '🔥' : s.confidence >= 75 ? '⭐' : '💡';
+                output += `${confidenceEmoji} SUGGESTION ${idx + 1}: ${s.type.toUpperCase()}\n`;
+                output += `   Confidence: ${s.confidence}% | Impact: ${s.impact} | Effort: ${s.effort}\n`;
+                output += `   ${s.description}\n\n`;
+                output += `   Benefits:\n`;
+                s.benefits.forEach(b => {
+                    output += `      ✓ ${b}\n`;
+                });
+                output += `\n   CURRENT CODE:\n`;
+                output += `   \`\`\`typescript\n`;
+                output += `   ${s.currentCode.split('\n').join('\n   ')}\n`;
+                output += `   \`\`\`\n\n`;
+                output += `   SUGGESTED:\n`;
+                output += `   \`\`\`typescript\n`;
+                output += `   ${s.suggestedCode.split('\n').join('\n   ')}\n`;
+                output += `   \`\`\`\n`;
+                output += '\n' + '─'.repeat(60) + '\n\n';
+            });
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Refactoring Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 5. intelligent_code_compare
+    server.tool("intelligent_code_compare", "Compare two code snippets or files with detailed difference analysis.", {
+        original: z.string().describe("Original code or file path"),
+        modified: z.string().describe("Modified code or file path"),
+        isFilePath: z.boolean().optional().default(false).describe("Whether inputs are file paths")
+    }, async ({ original, modified, isFilePath }) => {
+        try {
+            let originalCode;
+            let modifiedCode;
+            if (isFilePath) {
+                originalCode = await fs.readFile(validatePath(original), 'utf-8');
+                modifiedCode = await fs.readFile(validatePath(modified), 'utf-8');
+            }
+            else {
+                originalCode = original;
+                modifiedCode = modified;
+            }
+            // Simple line-by-line comparison
+            const originalLines = originalCode.split('\n');
+            const modifiedLines = modifiedCode.split('\n');
+            let added = 0;
+            let removed = 0;
+            let modified_lines = 0;
+            const maxLines = Math.max(originalLines.length, modifiedLines.length);
+            const diff = [];
+            for (let i = 0; i < maxLines; i++) {
+                const orig = originalLines[i] || '';
+                const mod = modifiedLines[i] || '';
+                if (orig === mod) {
+                    diff.push(` ${orig}`);
+                }
+                else if (!orig) {
+                    added++;
+                    diff.push(`+${mod}`);
+                }
+                else if (!mod) {
+                    removed++;
+                    diff.push(`-${orig}`);
+                }
+                else {
+                    modified_lines++;
+                    diff.push(`-${orig}`);
+                    diff.push(`+${mod}`);
+                }
+            }
+            let output = `📊 CODE COMPARISON\n`;
+            output += `═`.repeat(60) + '\n\n';
+            output += `STATISTICS:\n`;
+            output += `  Lines Added:    +${added}\n`;
+            output += `  Lines Removed:  -${removed}\n`;
+            output += `  Lines Modified: ~${modified_lines}\n`;
+            output += `  Net Change:     ${modifiedLines.length - originalLines.length > 0 ? '+' : ''}${modifiedLines.length - originalLines.length}\n\n`;
+            output += `DIFF:\n`;
+            output += `\`\`\`diff\n`;
+            output += diff.slice(0, 100).join('\n');
+            if (diff.length > 100) {
+                output += `\n... (${diff.length - 100} more lines)`;
+            }
+            output += `\n\`\`\`\n`;
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Comparison Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 6. intelligent_code_autofix
+    server.tool("intelligent_code_autofix", "Automatically fix common code issues like trailing whitespace, missing semicolons, and optimize imports.", {
+        filePath: z.string().describe("Path to the file to fix"),
+        fixTrailingWhitespace: z.boolean().optional().default(true).describe("Remove trailing whitespace"),
+        fixMissingSemicolons: z.boolean().optional().default(false).describe("Add missing semicolons (experimental)"),
+        optimizeImports: z.boolean().optional().default(false).describe("Sort and deduplicate imports"),
+        dryRun: z.boolean().optional().default(true).describe("Preview changes without applying")
+    }, async ({ filePath, fixTrailingWhitespace, fixMissingSemicolons, optimizeImports, dryRun }) => {
+        try {
+            const result = await analyzer.autoFix(filePath, {
+                fixTrailingWhitespace,
+                fixMissingSemicolons,
+                optimizeImports,
+                dryRun
+            });
+            let output = `🔧 CODE AUTO-FIX: ${filePath}\n`;
+            output += `═`.repeat(60) + '\n\n';
+            if (result.fixes.length === 0) {
+                output += `✅ No issues found! File is clean.\n`;
+                return { content: [{ type: "text", text: output }] };
+            }
+            output += `📊 SUMMARY:\n`;
+            output += `  Total fixes: ${result.fixes.length}\n`;
+            output += `  Mode: ${dryRun ? '🔍 DRY RUN (preview only)' : '✅ APPLIED'}\n\n`;
+            // Group fixes by type
+            const grouped = result.fixes.reduce((acc, fix) => {
+                acc[fix.type] = acc[fix.type] || [];
+                acc[fix.type].push(fix);
+                return acc;
+            }, {});
+            output += `📝 FIXES BY TYPE:\n`;
+            for (const [type, fixes] of Object.entries(grouped)) {
+                output += `\n  ${type.toUpperCase()} (${fixes.length}):\n`;
+                fixes.slice(0, 5).forEach(fix => {
+                    output += `    Line ${fix.line}: ${fix.original.substring(0, 40)}${fix.original.length > 40 ? '...' : ''}\n`;
+                    output += `    → ${fix.fixed.substring(0, 40)}${fix.fixed.length > 40 ? '...' : ''}\n`;
+                });
+                if (fixes.length > 5) {
+                    output += `    ... and ${fixes.length - 5} more\n`;
+                }
+            }
+            if (dryRun && result.fixes.length > 0) {
+                output += `\n💡 To apply these fixes, set dryRun: false\n`;
+            }
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Auto-fix Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}
+// Helper function
+function getScoreEmoji(score) {
+    if (score >= 90)
+        return '🟢';
+    if (score >= 70)
+        return '🟡';
+    if (score >= 50)
+        return '🟠';
+    return '🔴';
+}