@gotza02/sequential-thinking 10000.1.7 → 10000.1.8

package/dist/intelligent-code.js

@@ -8,6 +8,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import ts from 'typescript';
 import { validatePath } from './utils.js';
+import { complexityCalculator, qualityAnalyzer, symbolAnalyzer, refactoringEngine } from './analyzers/index.js';
 const execAsync = promisify(exec);
 // ============= Intelligent Code Analyzer =============
 export class IntelligentCodeAnalyzer {
@@ -25,271 +26,14 @@ export class IntelligentCodeAnalyzer {
         const content = await fs.readFile(absolutePath, 'utf-8');
         // Parse AST
         const sourceFile = ts.createSourceFile(absolutePath, content, ts.ScriptTarget.Latest, true);
-        // Calculate metrics
-        const metrics = this.calculateMetrics(sourceFile, content);
-        // Analyze quality
-        const quality = await this.analyzeQuality(sourceFile, content, metrics);
-        // Extract symbols with analysis
-        const symbols = this.analyzeSymbols(sourceFile);
+        // Calculate metrics using extracted analyzer
+        const metrics = complexityCalculator.calculate(sourceFile, content);
+        // Analyze quality using extracted analyzer
+        const quality = await qualityAnalyzer.analyze(sourceFile, content, metrics);
+        // Extract symbols with analysis using extracted analyzer
+        const symbols = symbolAnalyzer.analyze(sourceFile);
         return { metrics, quality, ast: sourceFile, symbols };
     }
-    calculateMetrics(sourceFile, content) {
-        let complexity = 0;
-        let functionCount = 0;
-        let maxNestingDepth = 0;
-        let currentDepth = 0;
-        const visit = (node) => {
-            // Cyclomatic complexity
-            if (ts.isIfStatement(node) ||
-                ts.isConditionalExpression(node) ||
-                ts.isWhileStatement(node) ||
-                ts.isForStatement(node) ||
-                ts.isForInStatement(node) ||
-                ts.isForOfStatement(node) ||
-                ts.isCaseClause(node) ||
-                (ts.isBinaryExpression(node) &&
-                    (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-                        node.operatorToken.kind === ts.SyntaxKind.BarBarToken))) {
-                complexity++;
-            }
-            // Function count
-            if (ts.isFunctionDeclaration(node) ||
-                ts.isArrowFunction(node) ||
-                ts.isMethodDeclaration(node)) {
-                functionCount++;
-            }
-            // Nesting depth
-            if (ts.isBlock(node) ||
-                ts.isIfStatement(node) ||
-                ts.isForStatement(node) ||
-                ts.isWhileStatement(node)) {
-                currentDepth++;
-                maxNestingDepth = Math.max(maxNestingDepth, currentDepth);
-            }
-            ts.forEachChild(node, visit);
-            if (ts.isBlock(node) ||
-                ts.isIfStatement(node) ||
-                ts.isForStatement(node) ||
-                ts.isWhileStatement(node)) {
-                currentDepth--;
-            }
-        };
-        visit(sourceFile);
-        const lines = content.split('\n');
-        const codeLines = lines.filter(l => l.trim().length > 0 && !l.trim().startsWith('//'));
-        const commentLines = lines.filter(l => l.trim().startsWith('//') || l.trim().startsWith('/*'));
-        return {
-            complexity: complexity + 1, // Base complexity is 1
-            linesOfCode: codeLines.length,
-            commentRatio: codeLines.length > 0 ? commentLines.length / codeLines.length : 0,
-            functionCount,
-            maxNestingDepth,
-            duplicateCode: 0, // Would need cross-file analysis
-        };
-    }
-    async analyzeQuality(sourceFile, content, metrics) {
-        const issues = [];
-        // Complexity checks
-        if (metrics.complexity > 20) {
-            issues.push({
-                type: 'warning',
-                category: 'complexity',
-                message: `High cyclomatic complexity (${metrics.complexity}). Consider refactoring.`,
-                severity: 7,
-                suggestion: 'Extract smaller functions or simplify conditional logic',
-                autoFixable: false,
-            });
-        }
-        if (metrics.maxNestingDepth > 4) {
-            issues.push({
-                type: 'warning',
-                category: 'maintainability',
-                message: `Deep nesting detected (${metrics.maxNestingDepth} levels)`,
-                severity: 6,
-                suggestion: 'Use early returns or extract nested logic into functions',
-                autoFixable: false,
-            });
-        }
-        // Comment ratio
-        if (metrics.commentRatio < 0.05 && metrics.linesOfCode > 50) {
-            issues.push({
-                type: 'info',
-                category: 'maintainability',
-                message: 'Low comment ratio. Consider adding documentation.',
-                severity: 3,
-                suggestion: 'Add JSDoc comments for public APIs',
-                autoFixable: false,
-            });
-        }
-        // Function length
-        const visit = (node) => {
-            if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
-                const start = node.getStart(sourceFile);
-                const end = node.getEnd();
-                const functionLines = content.substring(start, end).split('\n').length;
-                if (functionLines > 50) {
-                    issues.push({
-                        type: 'warning',
-                        category: 'maintainability',
-                        message: `Long function detected (${functionLines} lines)`,
-                        line: ts.getLineAndCharacterOfPosition(sourceFile, node.getStart()).line + 1,
-                        severity: 6,
-                        suggestion: 'Extract helper functions to reduce function length',
-                        autoFixable: false,
-                    });
-                }
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        // Check for any types
-        const anyTypeRegex = /:\s*any\b/g;
-        const anyMatches = content.match(anyTypeRegex);
-        if (anyMatches && anyMatches.length > 5) {
-            issues.push({
-                type: 'warning',
-                category: 'maintainability',
-                message: `Excessive use of 'any' type (${anyMatches.length} occurrences)`,
-                severity: 5,
-                suggestion: 'Replace with proper types or use unknown with type guards',
-                autoFixable: false,
-            });
-        }
-        // Calculate scores
-        const maintainability = Math.max(0, 100 - metrics.complexity * 2 - metrics.maxNestingDepth * 5);
-        const reliability = Math.max(0, 100 - (anyMatches?.length || 0) * 5);
-        const security = 100; // Would need security-specific checks
-        const performance = 100; // Would need performance analysis
-        const issuePenalty = issues.reduce((sum, i) => sum + i.severity * 2, 0);
-        const overall = Math.max(0, Math.min(100, (maintainability + reliability + security + performance) / 4 - issuePenalty));
-        return {
-            overall: Math.round(overall),
-            maintainability: Math.round(maintainability),
-            reliability: Math.round(reliability),
-            security,
-            performance,
-            issues: issues.sort((a, b) => b.severity - a.severity),
-        };
-    }
-    analyzeSymbols(sourceFile) {
-        const symbols = [];
-        const visit = (node) => {
-            if (ts.isFunctionDeclaration(node) && node.name) {
-                const symbol = this.analyzeFunction(node, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            else if (ts.isClassDeclaration(node) && node.name) {
-                const symbol = this.analyzeClass(node, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            else if (ts.isInterfaceDeclaration(node)) {
-                const symbol = this.analyzeInterface(node, sourceFile);
-                if (symbol)
-                    symbols.push(symbol);
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        return symbols;
-    }
-    analyzeFunction(node, sourceFile) {
-        if (!node.name)
-            return null;
-        const params = node.parameters.map(p => ({
-            name: p.name.getText(sourceFile),
-            type: p.type?.getText(sourceFile) || 'unknown',
-            optional: !!p.questionToken,
-        }));
-        const returnType = node.type?.getText(sourceFile) || 'inferred';
-        // Check for async
-        const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword);
-        // Calculate function complexity
-        let complexity = 1;
-        const countComplexity = (n) => {
-            if (ts.isIfStatement(n) ||
-                ts.isWhileStatement(n) ||
-                ts.isForStatement(n) ||
-                ts.isConditionalExpression(n)) {
-                complexity++;
-            }
-            ts.forEachChild(n, countComplexity);
-        };
-        countComplexity(node);
-        return {
-            name: node.name.text,
-            kind: 'function',
-            params,
-            returnType,
-            isAsync,
-            complexity,
-            isExported: node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) || false,
-            documentation: this.extractJSDoc(node, sourceFile),
-        };
-    }
-    analyzeClass(node, sourceFile) {
-        if (!node.name)
-            return null;
-        const methods = [];
-        const properties = [];
-        node.members.forEach(member => {
-            if (ts.isMethodDeclaration(member) && member.name) {
-                methods.push({
-                    name: member.name.getText(sourceFile),
-                    kind: 'method',
-                    params: member.parameters.map(p => ({
-                        name: p.name.getText(sourceFile),
-                        type: p.type?.getText(sourceFile) || 'unknown',
-                    })),
-                    returnType: member.type?.getText(sourceFile) || 'void',
-                    isAsync: member.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false,
-                    complexity: 1,
-                    isExported: false,
-                });
-            }
-            else if (ts.isPropertyDeclaration(member) && member.name) {
-                properties.push({
-                    name: member.name.getText(sourceFile),
-                    type: member.type?.getText(sourceFile) || 'unknown',
-                });
-            }
-        });
-        return {
-            name: node.name.text,
-            kind: 'class',
-            methods,
-            properties,
-            isExported: node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) || false,
-            documentation: this.extractJSDoc(node, sourceFile),
-        };
-    }
-    analyzeInterface(node, sourceFile) {
-        const properties = node.members.map(member => {
-            if (ts.isPropertySignature(member) && member.name) {
-                return {
-                    name: member.name.getText(sourceFile),
-                    type: member.type?.getText(sourceFile) || 'unknown',
-                    optional: !!member.questionToken,
-                };
-            }
-            return null;
-        }).filter((p) => p !== null);
-        return {
-            name: node.name.text,
-            kind: 'interface',
-            properties,
-            isExported: node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) || false,
-            documentation: this.extractJSDoc(node, sourceFile),
-        };
-    }
-    extractJSDoc(node, sourceFile) {
-        const jsDoc = node.jsDoc;
-        if (jsDoc && jsDoc.length > 0) {
-            return jsDoc[0].comment?.toString();
-        }
-        return undefined;
-    }
     /**
      * Smart impact analysis - predicts what will be affected by changes
      */
@@ -396,109 +140,11 @@ export class IntelligentCodeAnalyzer {
      * Generate intelligent refactoring suggestions
      */
     async suggestRefactoring(filePath) {
-        const { ast, metrics, quality } = await this.analyzeFile(filePath);
+        const { ast, metrics } = await this.analyzeFile(filePath);
         if (!ast)
             return [];
-        const suggestions = [];
-        // Suggest extracting long functions
-        if (metrics.complexity > 10) {
-            const longFunctions = this.findLongFunctions(ast);
-            for (const func of longFunctions) {
-                suggestions.push({
-                    type: 'extract-method',
-                    description: `Extract ${func.name} into smaller functions`,
-                    currentCode: func.code,
-                    suggestedCode: `// Suggested: Split into ${Math.ceil(func.lines / 20)} helper functions`,
-                    confidence: 85,
-                    impact: 'medium',
-                    effort: 'moderate',
-                    benefits: ['Reduced complexity', 'Better testability', 'Easier maintenance'],
-                });
-            }
-        }
-        // Simplify nested conditionals
-        const nestedConditionals = this.findNestedConditionals(ast);
-        for (const nested of nestedConditionals) {
-            suggestions.push({
-                type: 'simplify',
-                description: 'Simplify deeply nested conditionals',
-                currentCode: nested.code,
-                suggestedCode: '// Use early returns or extract into guard clauses',
-                confidence: 90,
-                impact: 'low',
-                effort: 'quick',
-                benefits: ['Improved readability', 'Reduced cognitive load'],
-            });
-        }
-        // Add types for any
-        const anyUsages = this.findAnyUsages(ast);
-        if (anyUsages.length > 0) {
-            suggestions.push({
-                type: 'add-types',
-                description: `Replace ${anyUsages.length} 'any' types with proper types`,
-                currentCode: anyUsages.map(a => a.code).join('\n'),
-                suggestedCode: '// Define proper interfaces or use unknown with type guards',
-                confidence: 80,
-                impact: 'medium',
-                effort: 'moderate',
-                benefits: ['Type safety', 'Better IDE support', 'Fewer runtime errors'],
-            });
-        }
-        return suggestions.sort((a, b) => b.confidence - a.confidence);
-    }
-    findLongFunctions(sourceFile) {
-        const functions = [];
-        const content = sourceFile.getFullText();
-        const visit = (node) => {
-            if (ts.isFunctionDeclaration(node) && node.name) {
-                const start = node.getStart(sourceFile);
-                const end = node.getEnd();
-                const code = content.substring(start, end);
-                const lines = code.split('\n').length;
-                if (lines > 30) {
-                    functions.push({
-                        name: node.name.text,
-                        lines,
-                        code: code.substring(0, 200) + '...',
-                    });
-                }
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        return functions;
-    }
-    findNestedConditionals(sourceFile) {
-        const nested = [];
-        const content = sourceFile.getFullText();
-        const visit = (node, depth = 0) => {
-            if (ts.isIfStatement(node)) {
-                if (depth > 3) {
-                    const code = content.substring(node.getStart(sourceFile), node.getEnd());
-                    nested.push({ depth, code: code.substring(0, 150) + '...' });
-                }
-                ts.forEachChild(node, n => visit(n, depth + 1));
-            }
-            else {
-                ts.forEachChild(node, n => visit(n, depth));
-            }
-        };
-        visit(sourceFile);
-        return nested;
-    }
-    findAnyUsages(sourceFile) {
-        const usages = [];
-        const content = sourceFile.getFullText();
-        const visit = (node) => {
-            if (ts.isTypeReferenceNode(node) && node.typeName.getText(sourceFile) === 'any') {
-                usages.push({
-                    code: content.substring(node.getStart(sourceFile), node.getEnd()),
-                });
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        return usages;
+        // Use refactoring engine to generate suggestions
+        return refactoringEngine.suggest(ast, metrics);
     }
     /**
      * Semantic code search - find code by concept, not just text

package/dist/lib.d.ts

@@ -41,6 +41,12 @@ export declare class SequentialThinkingServer {
     private contextManager;
     private ruleManager;
     private maxHistorySize;
+    private static readonly MAX_HISTORY_SIZE;
+    private static readonly AUTO_PRUNE_THRESHOLD;
+    private static readonly CONFIDENCE_CRITICAL_THRESHOLD;
+    private static readonly MAX_NESTING_DEPTH;
+    private static readonly STALLING_THRESHOLD;
+    private static readonly EXECUTION_STRUGGLE_THRESHOLD;
     constructor(storagePath?: string, delayMs?: number, maxHistorySize?: number);
     private loadHistory;
     private attemptRecovery;
@@ -58,6 +64,42 @@ export declare class SequentialThinkingServer {
     searchHistory(query: string): Promise<ThoughtData[]>;
     private addToMemory;
     private formatThought;
+    /**
+     * Handle block management - create new blocks or switch context
+     */
+    private handleBlockManagement;
+    /**
+     * Detect loops, stalling, and other thinking pattern issues
+     */
+    private detectLoopsAndStalling;
+    /**
+     * Validate solution before accepting
+     */
+    private validateSolution;
+    /**
+     * Update confidence score based on thought type and warnings
+     */
+    private updateConfidenceScore;
+    /**
+     * Get block history for current input
+     */
+    private getBlockHistory;
+    /**
+     * Check for smart branching - reset confidence on pivot
+     */
+    private checkSmartBranching;
+    /**
+     * Check semantic thought recall for analysis type
+     */
+    private checkSemanticRecall;
+    /**
+     * Check anti-insanity - prevent repeating failed executions
+     */
+    private checkAntiInsanity;
+    /**
+     * Check if confidence is critical and return critical stop response if needed
+     */
+    private checkConfidenceCritical;
     processThought(input: ThoughtData): Promise<{
         content: any[];
         isError?: boolean;