@gotza02/sequential-thinking 10000.1.6 → 10000.1.8

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/analyzers/ComplexityCalculator.d.ts

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+export interface CodeMetrics {
+    complexity: number;
+    linesOfCode: number;
+    commentRatio: number;
+    functionCount: number;
+    maxNestingDepth: number;
+    duplicateCode: number;
+    testCoverage?: number;
+}
+export declare class ComplexityCalculator {
+    calculate(sourceFile: ts.SourceFile, content: string): CodeMetrics;
+}
+export declare const complexityCalculator: ComplexityCalculator;
+export default complexityCalculator;

package/dist/analyzers/ComplexityCalculator.js

@@ -0,0 +1,59 @@
+import ts from 'typescript';
+export class ComplexityCalculator {
+    calculate(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
+        };
+    }
+}
+export const complexityCalculator = new ComplexityCalculator();
+export default complexityCalculator;

package/dist/analyzers/QualityAnalyzer.d.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import { CodeMetrics } from './ComplexityCalculator.js';
+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 CodeQualityScore {
+    overall: number;
+    maintainability: number;
+    reliability: number;
+    security: number;
+    performance: number;
+    issues: QualityIssue[];
+}
+export declare class QualityAnalyzer {
+    analyze(sourceFile: ts.SourceFile, content: string, metrics: CodeMetrics): Promise<CodeQualityScore>;
+}
+export declare const qualityAnalyzer: QualityAnalyzer;
+export default qualityAnalyzer;

package/dist/analyzers/QualityAnalyzer.js

@@ -0,0 +1,89 @@
+import ts from 'typescript';
+export class QualityAnalyzer {
+    async analyze(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),
+        };
+    }
+}
+export const qualityAnalyzer = new QualityAnalyzer();
+export default qualityAnalyzer;

package/dist/analyzers/RefactoringEngine.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import { CodeMetrics } from './ComplexityCalculator.js';
+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 declare class RefactoringEngine {
+    suggest(ast: ts.SourceFile, metrics: CodeMetrics): RefactoringSuggestion[];
+    private findLongFunctions;
+    private findNestedConditionals;
+    private findAnyUsages;
+}
+export declare const refactoringEngine: RefactoringEngine;
+export default refactoringEngine;

package/dist/analyzers/RefactoringEngine.js

@@ -0,0 +1,107 @@
+import ts from 'typescript';
+export class RefactoringEngine {
+    suggest(ast, metrics) {
+        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;
+    }
+}
+export const refactoringEngine = new RefactoringEngine();
+export default refactoringEngine;

package/dist/analyzers/SymbolAnalyzer.d.ts

@@ -0,0 +1,30 @@
+import ts from 'typescript';
+export 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 class SymbolAnalyzer {
+    analyze(sourceFile: ts.SourceFile): SymbolAnalysis[];
+    private analyzeFunction;
+    private analyzeClass;
+    private analyzeInterface;
+    private extractJSDoc;
+}
+export declare const symbolAnalyzer: SymbolAnalyzer;
+export default symbolAnalyzer;

package/dist/analyzers/SymbolAnalyzer.js

@@ -0,0 +1,123 @@
+import ts from 'typescript';
+export class SymbolAnalyzer {
+    analyze(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';
+        const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false;
+        // 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;
+    }
+}
+export const symbolAnalyzer = new SymbolAnalyzer();
+export default symbolAnalyzer;

package/dist/analyzers/index.d.ts

@@ -0,0 +1,8 @@
+export { ComplexityCalculator, complexityCalculator } from './ComplexityCalculator.js';
+export type { CodeMetrics } from './ComplexityCalculator.js';
+export { QualityAnalyzer, qualityAnalyzer } from './QualityAnalyzer.js';
+export type { QualityIssue, CodeQualityScore } from './QualityAnalyzer.js';
+export { SymbolAnalyzer, symbolAnalyzer } from './SymbolAnalyzer.js';
+export type { SymbolAnalysis } from './SymbolAnalyzer.js';
+export { RefactoringEngine, refactoringEngine } from './RefactoringEngine.js';
+export type { RefactoringSuggestion } from './RefactoringEngine.js';

package/dist/analyzers/index.js

@@ -0,0 +1,4 @@
+export { ComplexityCalculator, complexityCalculator } from './ComplexityCalculator.js';
+export { QualityAnalyzer, qualityAnalyzer } from './QualityAnalyzer.js';
+export { SymbolAnalyzer, symbolAnalyzer } from './SymbolAnalyzer.js';
+export { RefactoringEngine, refactoringEngine } from './RefactoringEngine.js';

package/dist/coding.test.js

@@ -96,6 +96,10 @@ describe('Deep Coding Tools', () => {
         });
     });
     describe('deep_code_edit', () => {
+        beforeEach(() => {
+            // Mock fs.stat for file size checks
+            fs.stat.mockResolvedValue({ size: 100 });
+        });
         it('should error if target text is not found', async () => {
             registerCodingTools(mockServer, mockGraph);
             const handler = registeredTools['deep_code_edit'];