@gotza02/sequential-thinking 10000.1.6 → 10000.1.7

package/CLAUDE.md

@@ -1,6 +1,6 @@
 # SmartAgent Elite Controller - System Instructions
 
-You are an AI assistant powered by the Sequential Thinking MCP server (@gotza02/sequential-thinking@10000.1.5).
+You are an AI assistant powered by the Sequential Thinking MCP server (@gotza02/sequential-thinking@10000.1.7).
 
 ## Critical Prime Directives
 
@@ -80,11 +80,31 @@ You are an AI assistant powered by the Sequential Thinking MCP server (@gotza02/
 | `get_project_graph` | Codebase structure analysis | File dependencies |
 | `get_file_relationships` | Find related files | Import/dependency graph |
 
+### 🧠 Intelligent Code Analysis Tools (v10000.1.7+)
+| Tool | Purpose | Features |
+|------|---------|----------|
+| `intelligent_code_analyze` | Deep code analysis | Quality scoring, metrics, issue detection |
+| `intelligent_impact_analysis` | Change prediction | Risk score, affected files, test recommendations |
+| `intelligent_semantic_search` | Concept-based search | Find code by meaning, not just text |
+| `intelligent_refactor_suggest` | Refactoring ideas | AI suggestions with before/after code |
+| `intelligent_code_compare` | Code comparison | Diff analysis with statistics |
+| `intelligent_code_autofix` | Auto-fix code issues | Trailing whitespace, semicolons, imports |
+
+**Intelligent Code Analysis Protocol:**
+1. Before major changes → `intelligent_impact_analysis` (know the risk)
+2. Understanding code → `intelligent_code_analyze` (quality + metrics)
+3. Finding related code → `intelligent_semantic_search` (concept search)
+4. Improving code → `intelligent_refactor_suggest` (actionable ideas)
+5. Code reviews → `intelligent_code_compare` (detailed diffs)
+6. Clean up issues → `intelligent_code_autofix` (dryRun first, then apply)
+7. Monitor quality → Check `http://localhost:3001/api/code-quality` for project overview
+
 **Code Edit Protocol:**
-1. Always use `deep_code_edit` (not raw file writes)
-2. Review backup location if rollback needed
-3. Use `search_code` first to understand context
-4. Validate changes with `get_project_graph`
+1. Before changes: Run `intelligent_impact_analysis` to assess risk
+2. Always use `deep_code_edit` (not raw file writes)
+3. Review backup location if rollback needed
+4. Use `search_code` first to understand context
+5. Validate changes with `get_project_graph`
 
 ### 📝 Knowledge & Notes Tools
 | Tool | Purpose | Persistence |
@@ -124,6 +144,10 @@ Need information?
 
 Need to take action?
 ├── Code changes → deep_code_edit
+├── Code analysis → intelligent_code_analyze
+├── Impact prediction → intelligent_impact_analysis
+├── Refactoring ideas → intelligent_refactor_suggest
+├── Auto-fix issues → intelligent_code_autofix
 ├── Store knowledge → add_note / create_knowledge_node
 ├── Track sports bet → track_prediction
 └── Complex workflow → sequentialthinking → execution
@@ -180,7 +204,8 @@ For code changes:
 📝 Files Modified: [list]
 💾 Backup Location: [path]
 ✅ Validation: [tests/status]
-🔍 Impact Analysis: [affected files]
+🔍 Impact Analysis: [use intelligent_impact_analysis]
+📊 Code Quality: [use intelligent_code_analyze for metrics]
 ```
 
 ## Error Recovery

package/README.md

@@ -115,6 +115,16 @@ Add to your `~/.claude/CLAUDE.md` or project-specific `.claude/CLAUDE.md`:
 | `search_code` | Semantic code search |
 | `get_project_graph` | Analyze codebase structure |
 
+### 🧠 Intelligent Code Analysis (v10000.1.7+)
+| Tool | Description |
+|------|-------------|
+| `intelligent_code_analyze` | AI-powered code analysis with quality scoring, metrics, and issue detection |
+| `intelligent_impact_analysis` | Predict impact of code changes with risk scoring and affected files |
+| `intelligent_semantic_search` | Search code by concept/meaning, not just text |
+| `intelligent_refactor_suggest` | Get intelligent refactoring suggestions with code examples |
+| `intelligent_code_compare` | Compare two code snippets or files with detailed diff analysis |
+| `intelligent_code_autofix` | Auto-fix common issues (trailing whitespace, missing semicolons, optimize imports) |
+
 ### 📝 Knowledge & Notes Tools
 | Tool | Description |
 |------|-------------|
@@ -150,13 +160,22 @@ CRITICAL DIRECTIVES:
    - Use analyze_football_match_structured for JSON/probability data
    - Check value_bet_calculator for betting recommendations
 4. Use deep_code_edit for structural code changes (creates backups)
-5. Track predictions with track_prediction for ROI analysis
+5. For intelligent code analysis:
+   - Use intelligent_code_analyze for quality scoring and metrics
+   - Use intelligent_impact_analysis before making changes
+   - Use intelligent_semantic_search to find related code
+   - Use intelligent_refactor_suggest for improvement ideas
+   - Use intelligent_code_autofix to clean up common issues (dryRun first!)
+6. Track predictions with track_prediction for ROI analysis
+7. Check code quality dashboard at http://localhost:3001/api/code-quality
 
 TOOL PRIORITY:
 - Information needed → web_search (Brave/Exa/DuckDuckGo)
 - Problem solving → sequentialthinking
 - Sports data → analyze_football_match_* tools
 - Code editing → deep_code_edit
+- Code analysis → intelligent_code_analyze
+- Change impact → intelligent_impact_analysis
 - Human input → ask_human
 
 SAFETY PROTOCOLS:

package/dist/dashboard/server.js

@@ -2,6 +2,8 @@ import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
+import { ProjectKnowledgeGraph } from '../graph.js';
+import { getIntelligentAnalyzer } from '../intelligent-code.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export function startDashboard(port, historyPath) {
@@ -43,6 +45,10 @@ export function startDashboard(port, historyPath) {
                     res.end(data);
                 });
             }
+            else if (req.url === '/api/code-quality') {
+                // Code Quality Dashboard API
+                handleCodeQualityRequest(res);
+            }
             else {
                 res.writeHead(404);
                 res.end('Not found');
@@ -65,3 +71,94 @@ export function startDashboard(port, historyPath) {
         });
     });
 }
+/**
+ * Handle code quality dashboard API request
+ */
+async function handleCodeQualityRequest(res) {
+    try {
+        // Find TypeScript/JavaScript files in src directory
+        const srcDir = path.join(process.cwd(), 'src');
+        const files = await findCodeFiles(srcDir);
+        // Analyze top 10 largest files
+        const fileStats = await Promise.all(files.map(async (file) => {
+            const stats = await fs.promises.stat(file);
+            return { file, size: stats.size };
+        }));
+        const largestFiles = fileStats
+            .sort((a, b) => b.size - a.size)
+            .slice(0, 10)
+            .map(f => f.file);
+        // Analyze each file
+        const graph = new ProjectKnowledgeGraph();
+        const analyzer = getIntelligentAnalyzer(graph);
+        const results = await Promise.all(largestFiles.map(async (file) => {
+            try {
+                const analysis = await analyzer.analyzeFile(file);
+                return {
+                    file: path.relative(process.cwd(), file),
+                    metrics: analysis.metrics,
+                    quality: {
+                        overall: analysis.quality.overall,
+                        maintainability: analysis.quality.maintainability,
+                        security: analysis.quality.security,
+                        performance: analysis.quality.performance,
+                    },
+                    issueCount: analysis.quality.issues.length,
+                    symbolCount: analysis.symbols.length,
+                };
+            }
+            catch (e) {
+                return {
+                    file: path.relative(process.cwd(), file),
+                    error: 'Analysis failed',
+                };
+            }
+        }));
+        // Calculate summary
+        const validResults = results.filter(r => !r.error);
+        const summary = {
+            totalFiles: files.length,
+            analyzedFiles: validResults.length,
+            averageComplexity: validResults.reduce((sum, r) => sum + r.metrics.complexity, 0) / validResults.length || 0,
+            averageMaintainability: validResults.reduce((sum, r) => sum + r.quality.maintainability, 0) / validResults.length || 0,
+            totalIssues: validResults.reduce((sum, r) => sum + r.issueCount, 0),
+        };
+        const response = {
+            summary,
+            files: results,
+            generatedAt: new Date().toISOString(),
+        };
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(response, null, 2));
+    }
+    catch (error) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            error: 'Failed to analyze code quality',
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+/**
+ * Find all code files in directory
+ */
+async function findCodeFiles(dir) {
+    const files = [];
+    async function scan(currentDir) {
+        const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip node_modules, dist, etc.
+                if (!['node_modules', 'dist', '.git', 'coverage'].includes(entry.name)) {
+                    await scan(fullPath);
+                }
+            }
+            else if (entry.isFile() && /\.(ts|js|tsx|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await scan(dir);
+    return files;
+}

package/dist/index.js

@@ -19,6 +19,7 @@ import { registerCodingTools } from './tools/coding.js';
 import { registerCodeDbTools } from './tools/codestore.js';
 import { registerHumanTools } from './tools/human.js';
 import { registerSportsTools } from './tools/sports.js';
+import { registerIntelligentCodeTools } from './tools/intelligent-code.js';
 import { startDashboard } from './dashboard/server.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -48,6 +49,7 @@ registerCodingTools(server, knowledgeGraph);
 registerCodeDbTools(server, codeDb);
 registerHumanTools(server);
 registerSportsTools(server);
+registerIntelligentCodeTools(server, knowledgeGraph);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/intelligent-code.d.ts

@@ -0,0 +1,157 @@
+/**
+ * INTELLIGENT CODE MODULE
+ * AI-powered code analysis, semantic search, and smart refactoring
+ */
+import ts from 'typescript';
+import { ProjectKnowledgeGraph } from './graph.js';
+export interface CodeMetrics {
+    complexity: number;
+    linesOfCode: number;
+    commentRatio: number;
+    functionCount: number;
+    maxNestingDepth: number;
+    duplicateCode: number;
+    testCoverage?: number;
+}
+export interface CodeQualityScore {
+    overall: number;
+    maintainability: number;
+    reliability: number;
+    security: number;
+    performance: number;
+    issues: QualityIssue[];
+}
+export interface QualityIssue {
+    type: 'error' | 'warning' | 'info';
+    category: 'complexity' | 'style' | 'security' | 'performance' | 'maintainability';
+    message: string;
+    line?: number;
+    column?: number;
+    severity: number;
+    suggestion?: string;
+    autoFixable: boolean;
+}
+export interface RefactoringSuggestion {
+    type: 'extract-method' | 'rename' | 'reorder' | 'simplify' | 'optimize-imports' | 'add-types';
+    description: string;
+    currentCode: string;
+    suggestedCode: string;
+    confidence: number;
+    impact: 'low' | 'medium' | 'high';
+    effort: 'quick' | 'moderate' | 'extensive';
+    benefits: string[];
+}
+export interface ImpactAnalysis {
+    filePath: string;
+    directImpacts: string[];
+    indirectImpacts: string[];
+    testFiles: string[];
+    riskScore: number;
+    breakingChanges: boolean;
+    estimatedReviewTime: number;
+}
+export interface SemanticSearchResult {
+    filePath: string;
+    relevance: number;
+    context: string;
+    matchedConcepts: string[];
+    codeSnippet: string;
+}
+export interface CodePattern {
+    name: string;
+    description: string;
+    examples: string[];
+    antiPattern?: string;
+    solution: string;
+    confidence: number;
+}
+export declare class IntelligentCodeAnalyzer {
+    private graph;
+    private program?;
+    private typeChecker?;
+    constructor(graph: ProjectKnowledgeGraph);
+    /**
+     * Comprehensive code analysis with metrics and quality scoring
+     */
+    analyzeFile(filePath: string): Promise<{
+        metrics: CodeMetrics;
+        quality: CodeQualityScore;
+        ast: ts.SourceFile | null;
+        symbols: SymbolAnalysis[];
+    }>;
+    private calculateMetrics;
+    private analyzeQuality;
+    private analyzeSymbols;
+    private analyzeFunction;
+    private analyzeClass;
+    private analyzeInterface;
+    private extractJSDoc;
+    /**
+     * Smart impact analysis - predicts what will be affected by changes
+     */
+    analyzeImpact(filePath: string, changeDescription?: string): Promise<ImpactAnalysis>;
+    private findRelatedTests;
+    /**
+     * Generate intelligent refactoring suggestions
+     */
+    suggestRefactoring(filePath: string): Promise<RefactoringSuggestion[]>;
+    private findLongFunctions;
+    private findNestedConditionals;
+    private findAnyUsages;
+    /**
+     * Semantic code search - find code by concept, not just text
+     */
+    semanticSearch(query: string, options?: {
+        filePattern?: string;
+        maxResults?: number;
+    }): Promise<SemanticSearchResult[]>;
+    private extractConcepts;
+    private calculateRelevance;
+    private extractRelevantSnippet;
+    private extractContext;
+    private getMatchingFiles;
+    /**
+     * Auto-fix common code issues
+     */
+    autoFix(filePath: string, options?: {
+        fixUnusedImports?: boolean;
+        fixTrailingWhitespace?: boolean;
+        fixMissingSemicolons?: boolean;
+        optimizeImports?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        fixes: Array<{
+            type: string;
+            line: number;
+            original: string;
+            fixed: string;
+        }>;
+        applied: boolean;
+    }>;
+    /**
+     * Detect code patterns and anti-patterns
+     */
+    detectPatterns(filePath: string, sourceFile: ts.SourceFile): CodePattern[];
+}
+interface SymbolAnalysis {
+    name: string;
+    kind: 'function' | 'class' | 'interface' | 'method' | 'type';
+    params?: {
+        name: string;
+        type: string;
+        optional?: boolean;
+    }[];
+    returnType?: string;
+    isAsync?: boolean;
+    complexity?: number;
+    isExported: boolean;
+    documentation?: string;
+    methods?: SymbolAnalysis[];
+    properties?: {
+        name: string;
+        type: string;
+        optional?: boolean;
+    }[];
+}
+export declare function getIntelligentAnalyzer(graph: ProjectKnowledgeGraph): IntelligentCodeAnalyzer;
+export {};