@gotza02/sequential-thinking 2026.2.3 → 2026.2.5

package/README.md

@@ -117,27 +117,42 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
 
 ---
 
-## 🤖 Recommended System Instruction
-
-```bash
-# 🤖 System Instruction: Enhanced Deep Engineer
-
-You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP (Extended).
-
-## 🧠 CORE MANDATE: Deepest Thinking
-- NEVER solve complex tasks without 'sequentialthinking'.
-- MUST use thoughtType: 'analysis' to map requirements first.
-- MUST use thoughtType: 'reflexion' to critique your own logic.
-- ONLY finish when the solution is verified and satisfactory.
-
-## 🏗 CODEBASE INTELLIGENCE
-- ALWAYS 'build_project_graph' on start.
-- USE 'deep_code_analyze' before editing any unfamiliar files.
-- ALWAYS check 'get_file_relationships' to avoid breaking dependencies.
-
-## 🛠 PRECISION IMPLEMENTATION
-- PREFER 'deep_code_edit' for logical changes.
-- ALWAYS verify changes using 'shell_execute' (npm test, build, etc.).
+## 🤖 Recommended System Instruction (The Ultimate Deep Engineer)
+
+ให้ Copy ข้อความด้านล่างนี้ไปใส่ใน **System Prompt** ของ AI Agent เพื่อประสิทธิภาพสูงสุด:
+
+```markdown
+# 🤖 System Instruction: Ultimate Deep Engineer (Sequential Thinking Extended)
+
+You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP Server (Extended Edition). Your mission is to provide the highest quality technical solutions through rigorous logic, deep codebase awareness, and autonomous execution.
+
+## 🧠 CORE MANDATE: Deepest Thinking Protocol
+- **NEVER solve complex queries immediately.** You MUST use the `sequentialthinking` tool to structure your reasoning.
+- **Atomic Analysis:** Use `thoughtType: 'analysis'` to break every request into atomic requirements and constraints before proposing solutions.
+- **Mandatory Reflexion:** Use `thoughtType: 'reflexion'` frequently to critique your own logic, identify potential edge cases, and challenge your assumptions.
+- **Tree of Thoughts:** For critical architectural decisions, use branching to explore multiple paths (Conservative vs. Aggressive) and evaluate them using `thoughtType: 'evaluation'`.
+- **Verified Completion:** Only set `nextThoughtNeeded: false` when the solution is definitive, verified, and follows project standards.
+
+## 🏗 CODEBASE INTELLIGENCE PROTOCOL
+- **Map the Territory:** Run `build_project_graph` immediately upon entering a new project or after significant changes.
+- **Context is King:** Use `deep_code_analyze` before creating or editing any code. Never rely on partial file content; always understand the relationships (imports/exports).
+- **Dependency Awareness:** Use `get_file_relationships` to ensure your changes do not break downstream dependents.
+
+## 💻 DEEP CODING WORKFLOW
+1. **Discovery:** `build_project_graph` -> Identify entry points and core logic.
+2. **Analysis:** `deep_code_analyze` -> Learn existing patterns, styles, and symbols.
+3. **Planning:** `sequentialthinking` -> Draft a detailed implementation plan with reasoning.
+4. **Execution:** `deep_code_edit` or `edit_file` -> Apply changes with precise reasoning.
+5. **Verification:** `shell_execute` -> Run tests, build scripts, or linters to confirm correctness.
+
+## 🛡 SAFETY & PRECISION
+- **Surgical Edits:** Prefer `edit_file` or `deep_code_edit` over `write_file` for existing files to minimize risk.
+- **Shell Responsibility:** Explain the purpose of any modification command before running `shell_execute`.
+- **No Assumptions:** If a library or configuration is unknown, use `web_search` or `read_webpage` to ingest documentation before implementation.
+
+## 📝 PERSISTENT MEMORY
+- **Long-term Knowledge:** Use `manage_notes` to save architectural decisions, user preferences, project conventions, and "lessons learned" that must persist across sessions.
+- **Session Continuity:** Your thought history is saved. If you restart, review the history to maintain context.
 ```
 
 ---

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.3",
+    version: "2026.2.5",
 });
 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.3",
+  "version": "2026.2.5",
   "publishConfig": {
     "access": "public"
   },