@gotza02/sequential-thinking 10000.1.7 → 10000.1.8

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'];

package/dist/dashboard/index.html

@@ -0,0 +1,95 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Thinking Dashboard</title>
+    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+    <style>
+        body { font-family: sans-serif; padding: 20px; background: #f4f4f4; }
+        .container { max-width: 1200px; margin: 0 auto; background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
+        h1 { margin-top: 0; }
+        #graph { overflow-x: auto; padding: 20px; }
+        #details { margin-top: 20px; padding: 20px; background: #eee; border-radius: 5px; white-space: pre-wrap; font-family: monospace; display: none; }
+        .status { float: right; font-weight: bold; color: #666; }
+        .error { color: red; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="status" id="status">Connecting...</div>
+        <h1>🧠 Thinking Process</h1>
+        <div id="graph" class="mermaid">
+            graph TD
+            A[Loading...]
+        </div>
+        <div id="details"></div>
+    </div>
+
+    <script>
+        mermaid.initialize({ startOnLoad: true, securityLevel: 'loose' });
+
+        let lastHistoryLength = 0;
+
+        async function fetchHistory() {
+            try {
+                const res = await fetch('/api/history');
+                const data = await res.json();
+                const history = data.thoughtHistory || [];
+                const blocks = data.blocks || [];
+
+                document.getElementById('status').innerText = `Active Block: ${data.currentBlockId || 'None'} | Thoughts: ${history.length}`;
+
+                if (history.length === lastHistoryLength) return;
+                lastHistoryLength = history.length;
+
+                renderGraph(history);
+            } catch (e) {
+                document.getElementById('status').innerText = 'Error connecting to server';
+                document.getElementById('status').classList.add('error');
+            }
+        }
+
+        function renderGraph(history) {
+            let graph = 'graph TD\n';
+            // Show last 20 thoughts to avoid huge graphs
+            const recent = history.slice(-20); 
+            
+            recent.forEach((t, i) => {
+                const id = `T${t.thoughtNumber}`;
+                let label = `${t.thoughtType || 'thought'} #${t.thoughtNumber}`;
+                // Escape quotes
+                label = label.replace(/"/g, "'");
+                
+                // Style based on type
+                let style = '';
+                if (t.thoughtType === 'execution') style = 'fill:#f9f,stroke:#333,stroke-width:2px';
+                else if (t.thoughtType === 'observation') style = 'fill:#9ff,stroke:#333,stroke-width:2px';
+                else if (t.thoughtType === 'solution') style = 'fill:#9f9,stroke:#333,stroke-width:4px';
+                else if (t.thoughtType === 'planning') style = 'fill:#ff9,stroke:#333,stroke-width:2px';
+                else style = 'fill:#fff,stroke:#333,stroke-width:1px';
+
+                graph += `${id}("${label}")\n`;
+                if (style) graph += `style ${id} ${style}\n`;
+
+                if (i > 0) {
+                    const prev = recent[i-1];
+                    const prevId = `T${prev.thoughtNumber}`;
+                    graph += `${prevId} --> ${id}\n`;
+                }
+                
+                // Click event (not fully supported in raw mermaid string without callback binding, but we visualize primarily)
+            });
+
+            // Re-render
+            const element = document.getElementById('graph');
+            element.removeAttribute('data-processed');
+            element.innerHTML = graph;
+            mermaid.init(undefined, element);
+        }
+
+        setInterval(fetchHistory, 2000);
+        fetchHistory();
+    </script>
+</body>
+</html>

package/dist/dashboard/server.js

@@ -154,7 +154,7 @@ async function findCodeFiles(dir) {
                     await scan(fullPath);
                 }
             }
-            else if (entry.isFile() && /\.(ts|js|tsx|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+            else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name)) {
                 files.push(fullPath);
             }
         }

package/dist/graph.d.ts

@@ -41,12 +41,6 @@ export declare class ProjectKnowledgeGraph {
     private getAllFiles;
     private isMonorepoRoot;
     private parseFile;
-    private parseTypeScript;
-    private parsePython;
-    private parseGo;
-    private parseRust;
-    private parseJavaLike;
-    private parseGeneric;
     private linkFileNodes;
     private resolvePath;
     getRelationships(filePath: string): {