@gotza02/sequential-thinking 10000.1.6 → 10000.1.8

package/dist/intelligent-code.js

@@ -0,0 +1,425 @@
+/**
+ * INTELLIGENT CODE MODULE
+ * AI-powered code analysis, semantic search, and smart refactoring
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+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 {
+    graph;
+    program;
+    typeChecker;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    /**
+     * Comprehensive code analysis with metrics and quality scoring
+     */
+    async analyzeFile(filePath) {
+        const absolutePath = validatePath(filePath);
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        // Parse AST
+        const sourceFile = ts.createSourceFile(absolutePath, content, ts.ScriptTarget.Latest, true);
+        // 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 };
+    }
+    /**
+     * Smart impact analysis - predicts what will be affected by changes
+     */
+    async analyzeImpact(filePath, changeDescription) {
+        const absolutePath = validatePath(filePath);
+        // Get graph relationships
+        const context = this.graph.getDeepContext(filePath);
+        if (!context) {
+            await this.graph.build(process.cwd());
+        }
+        const relationships = this.graph.getRelationships(filePath);
+        if (!relationships) {
+            return {
+                filePath,
+                directImpacts: [],
+                indirectImpacts: [],
+                testFiles: [],
+                riskScore: 0,
+                breakingChanges: false,
+                estimatedReviewTime: 0,
+            };
+        }
+        // Direct impacts: files that import this file
+        const directImpacts = relationships.importedBy;
+        // Find indirect impacts (files that import the direct impacts)
+        const indirectImpacts = [];
+        for (const directFile of directImpacts) {
+            const directRel = this.graph.getRelationships(directFile);
+            if (directRel) {
+                for (const indirect of directRel.importedBy) {
+                    if (indirect !== filePath && !directImpacts.includes(indirect)) {
+                        indirectImpacts.push(indirect);
+                    }
+                }
+            }
+        }
+        // Find related test files
+        const testFiles = await this.findRelatedTests(filePath);
+        // Calculate risk score
+        let riskScore = 0;
+        // Base risk from number of dependents
+        riskScore += directImpacts.length * 10;
+        riskScore += indirectImpacts.length * 5;
+        // Higher risk if changing public API
+        if (relationships.symbols.some(s => s.includes('export'))) {
+            riskScore += 20;
+        }
+        // Check change description for risky keywords
+        if (changeDescription) {
+            const riskyKeywords = ['delete', 'remove', 'rename', 'breaking', 'api'];
+            if (riskyKeywords.some(k => changeDescription.toLowerCase().includes(k))) {
+                riskScore += 15;
+            }
+        }
+        const breakingChanges = riskScore > 50;
+        const estimatedReviewTime = Math.min(120, 5 + directImpacts.length * 2 + indirectImpacts.length + testFiles.length * 3);
+        return {
+            filePath,
+            directImpacts,
+            indirectImpacts: [...new Set(indirectImpacts)],
+            testFiles,
+            riskScore: Math.min(100, riskScore),
+            breakingChanges,
+            estimatedReviewTime,
+        };
+    }
+    async findRelatedTests(filePath) {
+        const testFiles = [];
+        const baseName = path.basename(filePath, path.extname(filePath));
+        const dir = path.dirname(filePath);
+        // Common test file patterns
+        const patterns = [
+            `${baseName}.test.ts`,
+            `${baseName}.spec.ts`,
+            `${baseName}.test.js`,
+            `${baseName}.spec.js`,
+        ];
+        for (const pattern of patterns) {
+            const testPath = path.join(dir, pattern);
+            try {
+                await fs.access(testPath);
+                testFiles.push(testPath);
+            }
+            catch {
+                // File doesn't exist
+            }
+        }
+        // Check for __tests__ directory
+        const testsDir = path.join(dir, '__tests__');
+        try {
+            const files = await fs.readdir(testsDir);
+            files.forEach(f => {
+                if (f.includes(baseName) && (f.endsWith('.test.ts') || f.endsWith('.spec.ts'))) {
+                    testFiles.push(path.join(testsDir, f));
+                }
+            });
+        }
+        catch {
+            // Directory doesn't exist
+        }
+        return testFiles;
+    }
+    /**
+     * Generate intelligent refactoring suggestions
+     */
+    async suggestRefactoring(filePath) {
+        const { ast, metrics } = await this.analyzeFile(filePath);
+        if (!ast)
+            return [];
+        // Use refactoring engine to generate suggestions
+        return refactoringEngine.suggest(ast, metrics);
+    }
+    /**
+     * Semantic code search - find code by concept, not just text
+     */
+    async semanticSearch(query, options = {}) {
+        const { filePattern = '*', maxResults = 10 } = options;
+        // Build query concepts
+        const concepts = this.extractConcepts(query);
+        // Search through codebase
+        const files = await this.getMatchingFiles(filePattern);
+        const results = [];
+        for (const filePath of files) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const relevance = this.calculateRelevance(content, concepts, query);
+                if (relevance > 0.3) {
+                    const snippet = this.extractRelevantSnippet(content, concepts);
+                    results.push({
+                        filePath,
+                        relevance,
+                        context: this.extractContext(content, snippet),
+                        matchedConcepts: concepts.filter(c => content.toLowerCase().includes(c.toLowerCase())),
+                        codeSnippet: snippet,
+                    });
+                }
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        return results
+            .sort((a, b) => b.relevance - a.relevance)
+            .slice(0, maxResults);
+    }
+    extractConcepts(query) {
+        // Extract key concepts from query
+        const stopWords = new Set(['the', 'a', 'an', 'in', 'on', 'at', 'to', 'for', 'of', 'and', 'or']);
+        return query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter(w => w.length > 2 && !stopWords.has(w))
+            .map(w => w.replace(/[^a-z0-9]/g, ''));
+    }
+    calculateRelevance(content, concepts, originalQuery) {
+        const lowerContent = content.toLowerCase();
+        let score = 0;
+        // Concept matching
+        for (const concept of concepts) {
+            const count = (lowerContent.match(new RegExp(concept, 'g')) || []).length;
+            score += Math.min(count * 0.1, 0.5);
+        }
+        // Check for function/variable names matching query
+        const camelCaseQuery = originalQuery.replace(/\s+(.)/g, (_, c) => c.toUpperCase());
+        const snakeCaseQuery = originalQuery.replace(/\s+/g, '_');
+        if (content.includes(camelCaseQuery) || content.includes(snakeCaseQuery)) {
+            score += 0.3;
+        }
+        // Boost for TypeScript/JavaScript files
+        if (content.includes('function') || content.includes('const') || content.includes('export')) {
+            score += 0.1;
+        }
+        return Math.min(1, score);
+    }
+    extractRelevantSnippet(content, concepts) {
+        const lines = content.split('\n');
+        let bestStart = 0;
+        let bestScore = 0;
+        // Find window with highest concept density
+        for (let i = 0; i < lines.length - 10; i++) {
+            const window = lines.slice(i, i + 10).join('\n').toLowerCase();
+            const score = concepts.filter(c => window.includes(c)).length;
+            if (score > bestScore) {
+                bestScore = score;
+                bestStart = i;
+            }
+        }
+        return lines.slice(bestStart, bestStart + 15).join('\n');
+    }
+    extractContext(content, snippet) {
+        const lines = content.split('\n');
+        const snippetLines = snippet.split('\n');
+        const firstLine = snippetLines[0];
+        // Try to find class/function name
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i] === firstLine) {
+                // Look backwards for function/class declaration
+                for (let j = Math.max(0, i - 5); j < i; j++) {
+                    const match = lines[j].match(/(?:export\s+)?(?:class|function|interface)\s+(\w+)/);
+                    if (match) {
+                        return `${match[0]} (line ${j + 1})`;
+                    }
+                }
+            }
+        }
+        return 'Global scope';
+    }
+    async getMatchingFiles(pattern) {
+        // Simple glob-like matching
+        const files = [];
+        try {
+            const { stdout } = await execAsync(`find . -type f -name "${pattern}" ! -path "*/node_modules/*" ! -path "*/.git/*" | head -100`, { cwd: process.cwd() });
+            return stdout.trim().split('\n').filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Auto-fix common code issues
+     */
+    async autoFix(filePath, options = {}) {
+        const absolutePath = validatePath(filePath);
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        const lines = content.split('\n');
+        const fixes = [];
+        let modifiedContent = content;
+        // Fix 1: Remove trailing whitespace
+        if (options.fixTrailingWhitespace !== false) {
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.replace(/\s+$/, '');
+                if (line !== trimmed) {
+                    fixes.push({
+                        type: 'trailing-whitespace',
+                        line: i + 1,
+                        original: line,
+                        fixed: trimmed,
+                    });
+                    lines[i] = trimmed;
+                }
+            }
+            modifiedContent = lines.join('\n');
+        }
+        // Fix 2: Add missing semicolons (simple heuristic)
+        if (options.fixMissingSemicolons) {
+            const semicolonPattern = /^(\s*)(.+?)(?<!;)(\s*)$/;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Skip comments, strings, imports, exports, function declarations, etc.
+                if (line.trim().startsWith('//') ||
+                    line.trim().startsWith('/*') ||
+                    line.trim().startsWith('*') ||
+                    line.trim().startsWith('import') ||
+                    line.trim().startsWith('export') ||
+                    line.trim().startsWith('function') ||
+                    line.trim().startsWith('async function') ||
+                    line.trim().startsWith('class') ||
+                    line.trim().startsWith('interface') ||
+                    line.trim().startsWith('type') ||
+                    line.trim().startsWith('if') ||
+                    line.trim().startsWith('for') ||
+                    line.trim().startsWith('while') ||
+                    line.trim().startsWith('switch') ||
+                    line.trim().startsWith('try') ||
+                    line.trim().startsWith('catch') ||
+                    line.trim().startsWith('finally') ||
+                    line.trim().startsWith('{') ||
+                    line.trim().startsWith('}') ||
+                    line.trim().endsWith('{') ||
+                    line.trim().endsWith('}') ||
+                    line.trim().endsWith(';') ||
+                    line.trim() === '') {
+                    continue;
+                }
+                // Add semicolon if line looks like a statement
+                if (/[a-zA-Z0-9_)\]]\s*$/.test(line) && !line.trim().endsWith(';')) {
+                    fixes.push({
+                        type: 'missing-semicolon',
+                        line: i + 1,
+                        original: line,
+                        fixed: line + ';',
+                    });
+                    lines[i] = line + ';';
+                }
+            }
+            modifiedContent = lines.join('\n');
+        }
+        // Fix 3: Optimize imports
+        if (options.optimizeImports) {
+            const importRegex = /^(import\s+(?:{[^}]*}|\*\s+as\s+\w+|\w+)\s+from\s+['"][^'"]+['"];?)$/gm;
+            const imports = [];
+            let match;
+            while ((match = importRegex.exec(content)) !== null) {
+                imports.push(match[1]);
+            }
+            if (imports.length > 0) {
+                // Sort imports
+                imports.sort((a, b) => {
+                    const aIsRelative = a.includes("from '.'") || a.includes("from '..");
+                    const bIsRelative = b.includes("from '.'") || b.includes("from '..");
+                    if (aIsRelative && !bIsRelative)
+                        return 1;
+                    if (!aIsRelative && bIsRelative)
+                        return -1;
+                    return a.localeCompare(b);
+                });
+                // Remove duplicates
+                const uniqueImports = [...new Set(imports)];
+                if (uniqueImports.length !== imports.length || imports.join('\n') !== uniqueImports.join('\n')) {
+                    fixes.push({
+                        type: 'optimize-imports',
+                        line: 1,
+                        original: `Found ${imports.length} imports`,
+                        fixed: `Optimized to ${uniqueImports.length} imports`,
+                    });
+                }
+            }
+        }
+        // Apply fixes if not dry run
+        const applied = !options.dryRun && fixes.length > 0;
+        if (applied) {
+            await fs.writeFile(absolutePath, modifiedContent, 'utf-8');
+        }
+        return { fixes, applied };
+    }
+    /**
+     * Detect code patterns and anti-patterns
+     */
+    detectPatterns(filePath, sourceFile) {
+        const patterns = [];
+        const content = sourceFile.getFullText();
+        // Pattern: Singleton
+        const singletonPattern = /class\s+(\w+).*?private\s+static\s+instance|getInstance/s;
+        if (singletonPattern.test(content)) {
+            patterns.push({
+                name: 'Singleton Pattern',
+                description: 'Ensures a class has only one instance',
+                examples: ['Database connection', 'Logger', 'Configuration'],
+                antiPattern: 'Can make testing difficult, consider dependency injection',
+                solution: 'Use factory functions or dependency injection instead',
+                confidence: 85,
+            });
+        }
+        // Pattern: Factory
+        const factoryPattern = /create[A-Z]\w+\s*\(|make[A-Z]\w+\s*\(/;
+        if (factoryPattern.test(content)) {
+            patterns.push({
+                name: 'Factory Pattern',
+                description: 'Creates objects without specifying exact class',
+                examples: ['createUser()', 'makeRequest()'],
+                solution: 'Use dependency injection container or factory pattern',
+                confidence: 70,
+            });
+        }
+        // Anti-pattern: Callback hell
+        const callbackHell = /\)\s*\{[\s\S]*?\)\s*\{[\s\S]*?\)\s*\{/;
+        if (callbackHell.test(content)) {
+            patterns.push({
+                name: 'Callback Hell (Anti-pattern)',
+                description: 'Deeply nested callbacks',
+                examples: [],
+                antiPattern: 'Makes code hard to read and maintain',
+                solution: 'Use async/await or Promise chains',
+                confidence: 90,
+            });
+        }
+        // Pattern: Dependency Injection
+        const diPattern = /constructor\s*\([^)]*(?:private|public|protected)[^)]*\)/;
+        if (diPattern.test(content)) {
+            patterns.push({
+                name: 'Dependency Injection',
+                description: 'Dependencies provided through constructor',
+                examples: ['constructor(private db: Database)'],
+                solution: 'Good practice for testability and modularity',
+                confidence: 80,
+            });
+        }
+        return patterns;
+    }
+}
+// ============= Export singleton =============
+let analyzerInstance = null;
+export function getIntelligentAnalyzer(graph) {
+    if (!analyzerInstance) {
+        analyzerInstance = new IntelligentCodeAnalyzer(graph);
+    }
+    return analyzerInstance;
+}

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;