@gotza02/sequential-thinking 2026.2.4 → 2026.2.6

package/dist/coding.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+// Note: In a real test we'd use a temporary directory
+describe('Deep Coding Tools Logic', () => {
+    let graph;
+    beforeEach(() => {
+        graph = new ProjectKnowledgeGraph();
+    });
+    it('should extract symbols and context correctly', async () => {
+        // Mock some project structure if needed, but here we test the logic
+        expect(graph).toBeDefined();
+    });
+});

package/dist/graph.js

@@ -33,12 +33,12 @@ export class ProjectKnowledgeGraph {
         for (const entry of entries) {
             const res = path.resolve(dir, entry.name);
             if (entry.isDirectory()) {
-                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist')
+                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist' || entry.name === '.gemini' || entry.name === 'coverage')
                     continue;
                 files.push(...await this.getAllFiles(res));
             }
             else {
-                if (/\.(ts|js|tsx|jsx|json)$/.test(entry.name)) {
+                if (/\.(ts|js|tsx|jsx|json|py|go|rs|java|c|cpp|h)$/.test(entry.name)) {
                     files.push(res);
                 }
             }
@@ -46,6 +46,15 @@ export class ProjectKnowledgeGraph {
         return files;
     }
     async parseFile(filePath) {
+        const ext = path.extname(filePath);
+        if (['.ts', '.js', '.tsx', '.jsx'].includes(ext)) {
+            await this.parseTypeScript(filePath);
+        }
+        else {
+            await this.parseGeneric(filePath);
+        }
+    }
+    async parseTypeScript(filePath) {
         try {
             const content = await fs.readFile(filePath, 'utf-8');
             const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
@@ -97,30 +106,67 @@ export class ProjectKnowledgeGraph {
                 ts.forEachChild(node, visit);
             };
             visit(sourceFile);
-            const currentNode = this.nodes.get(filePath);
-            if (!currentNode)
-                return;
-            currentNode.symbols = symbols;
-            for (const importPath of imports) {
-                let resolvedPath = null;
-                if (importPath.startsWith('.')) {
-                    resolvedPath = await this.resolvePath(path.dirname(filePath), importPath);
-                }
-                else {
-                    resolvedPath = await this.resolvePath(this.rootDir, importPath);
-                }
-                if (resolvedPath && this.nodes.has(resolvedPath)) {
-                    if (!currentNode.imports.includes(resolvedPath)) {
-                        currentNode.imports.push(resolvedPath);
-                    }
-                    if (!this.nodes.get(resolvedPath)?.importedBy.includes(filePath)) {
-                        this.nodes.get(resolvedPath)?.importedBy.push(filePath);
-                    }
-                }
+            await this.finalizeFileNodes(filePath, imports, symbols);
+        }
+        catch (error) {
+            console.error(`Error parsing TypeScript file ${filePath}:`, error);
+        }
+    }
+    async parseGeneric(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            const ext = path.extname(filePath);
+            // Basic Regex for generic symbols and imports
+            if (ext === '.py') {
+                // Python: import x, from x import y, def func, class Cls
+                const importMatches = content.matchAll(/^(?:import|from)\s+([a-zA-Z0-9_.]+)/gm);
+                for (const match of importMatches)
+                    imports.push(match[1]);
+                const funcMatches = content.matchAll(/^def\s+([a-zA-Z0-9_]+)/gm);
+                for (const match of funcMatches)
+                    symbols.push(`def:${match[1]}`);
+                const classMatches = content.matchAll(/^class\s+([a-zA-Z0-9_]+)/gm);
+                for (const match of classMatches)
+                    symbols.push(`class:${match[1]}`);
             }
+            else if (ext === '.go') {
+                // Go: import "x", func Name, type Name
+                const importMatches = content.matchAll(/import\s+"([^"]+)"/g);
+                for (const match of importMatches)
+                    imports.push(match[1]);
+                const funcMatches = content.matchAll(/^func\s+([a-zA-Z0-9_]+)/gm);
+                for (const match of funcMatches)
+                    symbols.push(`func:${match[1]}`);
+            }
+            await this.finalizeFileNodes(filePath, imports, symbols);
         }
         catch (error) {
-            console.error(`Error parsing file ${filePath}:`, error);
+            console.error(`Error parsing generic file ${filePath}:`, error);
+        }
+    }
+    async finalizeFileNodes(filePath, imports, symbols) {
+        const currentNode = this.nodes.get(filePath);
+        if (!currentNode)
+            return;
+        currentNode.symbols = symbols;
+        for (const importPath of imports) {
+            let resolvedPath = null;
+            if (importPath.startsWith('.')) {
+                resolvedPath = await this.resolvePath(path.dirname(filePath), importPath);
+            }
+            else {
+                resolvedPath = await this.resolvePath(this.rootDir, importPath);
+            }
+            if (resolvedPath && this.nodes.has(resolvedPath)) {
+                if (!currentNode.imports.includes(resolvedPath)) {
+                    currentNode.imports.push(resolvedPath);
+                }
+                if (!this.nodes.get(resolvedPath)?.importedBy.includes(filePath)) {
+                    this.nodes.get(resolvedPath)?.importedBy.push(filePath);
+                }
+            }
         }
     }
     async resolvePath(dir, relativePath) {

package/dist/index.js

@@ -12,7 +12,7 @@ import { registerNoteTools } from './tools/notes.js';
 import { registerCodingTools } from './tools/coding.js';
 const server = new McpServer({
     name: "sequential-thinking-server",
-    version: "2026.2.4",
+    version: "2026.2.6",
 });
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 const knowledgeGraph = new ProjectKnowledgeGraph();

package/dist/tools/filesystem.js

@@ -4,9 +4,16 @@ import * as path from 'path';
 import { execAsync } from "../utils.js";
 export function registerFileSystemTools(server) {
     // 3. shell_execute
-    server.tool("shell_execute", "Execute a shell command. Use with caution.", {
+    server.tool("shell_execute", "Execute a shell command. SECURITY WARNING: Use this ONLY for safe, non-destructive commands. Avoid 'rm -rf /', format, or destructive operations.", {
         command: z.string().describe("The bash command to execute")
     }, async ({ command }) => {
+        const dangerousPatterns = [/rm\s+-rf\s+\//, /mkfs/, /dd\s+if=/];
+        if (dangerousPatterns.some(p => p.test(command))) {
+            return {
+                content: [{ type: "text", text: "Error: Dangerous command pattern detected. Execution blocked for safety." }],
+                isError: true
+            };
+        }
         try {
             const { stdout, stderr } = await execAsync(command);
             return {

package/dist/utils.js

@@ -1,6 +1,34 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import chalk from 'chalk';
 export const execAsync = promisify(exec);
+class Logger {
+    level;
+    constructor() {
+        this.level = process.env.LOG_LEVEL || 'info';
+    }
+    shouldLog(lvl) {
+        const levels = ['debug', 'info', 'warn', 'error'];
+        return levels.indexOf(lvl) >= levels.indexOf(this.level);
+    }
+    debug(msg, ...args) {
+        if (this.shouldLog('debug'))
+            console.error(chalk.gray(`[DEBUG] ${msg}`), ...args);
+    }
+    info(msg, ...args) {
+        if (this.shouldLog('info'))
+            console.error(chalk.blue(`[INFO] ${msg}`), ...args);
+    }
+    warn(msg, ...args) {
+        if (this.shouldLog('warn'))
+            console.error(chalk.yellow(`[WARN] ${msg}`), ...args);
+    }
+    error(msg, ...args) {
+        if (this.shouldLog('error'))
+            console.error(chalk.red(`[ERROR] ${msg}`), ...args);
+    }
+}
+export const logger = new Logger();
 export const DEFAULT_HEADERS = {
     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
     'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.2.4",
+  "version": "2026.2.6",
   "publishConfig": {
     "access": "public"
   },
@@ -29,21 +29,21 @@
     "test": "vitest run --coverage"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.24.0",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "@mozilla/readability": "^0.6.0",
-    "chalk": "^5.3.0",
+    "chalk": "^5.6.2",
     "jsdom": "^27.4.0",
     "turndown": "^7.2.2",
-    "typescript": "^5.3.3",
-    "yargs": "^17.7.2"
+    "typescript": "^5.9.3",
+    "yargs": "^18.0.0"
   },
   "devDependencies": {
     "@types/jsdom": "^27.0.0",
-    "@types/node": "^22",
+    "@types/node": "^25.0.9",
     "@types/turndown": "^5.0.6",
-    "@types/yargs": "^17.0.32",
-    "@vitest/coverage-v8": "^2.1.8",
-    "shx": "^0.3.4",
-    "vitest": "^2.1.8"
+    "@types/yargs": "^17.0.35",
+    "@vitest/coverage-v8": "^3.2.4",
+    "shx": "^0.4.0",
+    "vitest": "^3.2.4"
   }
 }