@gotza02/sequential-thinking 2026.2.12 → 2026.2.14

package/README.md

@@ -1,246 +1,76 @@
-# Sequential Thinking MCP Server (Extended Edition) 🧠✨
+# Sequential Thinking MCP (Extended) 🧠
 
-**MCP Server ที่ยกระดับ AI ให้เป็นวิศวกรซอฟต์แวร์อัจฉริยะ ด้วยระบบ Deepest Thinking, การวิเคราะห์ Codebase เชิงลึก และฐานข้อมูลความรู้ (Code Database)**
+Advanced MCP Server enabling AI to act as a Software Engineer with Deep Thinking, Codebase Graph Analysis, and Persistent Memory.
 
-> **🛡️ Battle-Tested:** ผ่านการทดสอบ **Chaos Engineering** และ **Stress Testing** รองรับโหลดหนักและกู้คืนตัวเองจากความเสียหายได้ (Auto-Repair)
+## ✨ Key Features
+- **Deep Thinking:** Step-by-step reasoning with auto-correction (Loop Breaker).
+- **Code Intelligence:** Dependency graph mapping (`build_project_graph`) & surgical code editing.
+- **Memory:** Long-term project notes, reusable code database, and thought history.
+- **Research:** Integrated Web search (Brave/Exa) & webpage reading.
 
-โปรเจกต์นี้คือส่วนขยายขั้นสูงของ Sequential Thinking ที่รวมเอาความสามารถในการวางแผนที่เป็นระบบ, การหาข้อมูลทั่วโลก (Web Search), การสร้างแผนผังความสัมพันธ์ของโค้ด (Dependency Graph), การจัดการหน่วยความจำระยะยาว และ **ฐานข้อมูลความรู้โค้ด (Code Database)** เข้าด้วยกัน เพื่อให้ AI สามารถทำงานที่ซับซ้อนได้อย่างอิสระและแม่นยำ
-
----
-
-## 🌟 จุดเด่นของเวอร์ชัน Extended
-
-1.  **Deepest Thinking Protocol**: บังคับให้ AI วิเคราะห์ปัญหาแบบเป็นลำดับขั้นตอน (Step-by-step) พร้อมการแตกกิ่งความคิด (Branching) และการทบทวนตัวเอง (Reflexion) เพื่อหาทางเลือกที่ดีที่สุด
-2.  **Codebase Intelligence**: ระบบ `ProjectKnowledgeGraph` ที่ใช้ TypeScript Compiler API และ Regex (สำหรับ Python/Go) ในการสแกนความสัมพันธ์ระหว่างไฟล์และ Exported Symbols
-3.  **Code Database (CodeStore)**: ระบบจัดเก็บ Snippets และ Architectural Patterns ลงในไฟล์ JSON ถาวร ช่วยให้ AI "จดจำ" วิธีแก้ปัญหาและนำกลับมาใช้ใหม่ได้
-4.  **Deep Coding Workflow**: เครื่องมือใหม่สำหรับการแก้ไขโค้ดที่ต้องผ่านการวิเคราะห์บริบท (Context Document) และการวางแผนที่ผ่านการตรวจสอบเหตุผลแล้วเท่านั้น
-5.  **Smart Notes**: ระบบบันทึกที่มี **Priority Level** และ **Expiration Date** ช่วยจัดลำดับความสำคัญของงานได้ดียิ่งขึ้น พร้อมฟีเจอร์ **Auto-Repair** กู้คืนไฟล์อัตโนมัติหากข้อมูลเสียหาย
-
----
-
-## 🔑 Environment Variables (การตั้งค่าตัวแปร)
-
-| Variable Name | Description | Required? |
-|--------------|-------------|-----------|
-| `BRAVE_API_KEY` | สำหรับค้นหาผ่าน Brave Search | ❌ (Optional) |
-| `EXA_API_KEY` | สำหรับค้นหาผ่าน Exa.ai (แนะนำมากสำหรับงาน Deep Research) | ❌ (Optional) |
-| `GOOGLE_SEARCH_API_KEY` | Google Custom Search API Key | ❌ (Optional) |
-| `GOOGLE_SEARCH_CX` | Google Custom Search Engine ID (CX) | ❌ (Optional) |
-| `THOUGHTS_STORAGE_PATH` | ไฟล์เก็บประวัติความคิดเพื่อใช้ต่อเนื่อง | `thoughts_history.json` |
-| `NOTES_STORAGE_PATH` | ไฟล์เก็บความจำระยะยาว (กฎโปรเจกต์, ความชอบ) | `project_notes.json` |
-| `CODE_DB_PATH` | ไฟล์เก็บฐานข้อมูลความรู้โค้ด (Snippets/Patterns) | `code_database.json` |
-| `THOUGHT_DELAY_MS` | เวลาหน่วงระหว่างคิด (เพื่อความสมจริงและการจัดการ Rate Limit) | `0` |
-| `LOG_LEVEL` | ระดับการแสดงผล Log (debug, info, warn, error) | `info` |
-
----
-
-## 🛠️ รายการเครื่องมือ (Tools Capability)
-
-### 🧠 1. Cognitive & Deepest Thinking
-*   **`sequentialthinking`**: (ปรับปรุงใหม่!) บังคับใช้หลักการ **Deepest Thinking** รองรับการทำ Analysis, Reflexion, Evaluation และ Selection ในทุกการแก้ปัญหา
-*   **`summarize_history`**: สรุปประวัติความคิดที่ยาวเหยียดเพื่อประหยัดพื้นที่บริบท
-*   **`clear_thought_history`**: ล้างสมองเพื่อเริ่มงานชิ้นใหม่
-
-### 💻 2. Deep Coding & Codebase Context
-*   **`deep_code_analyze`**: 🌟 **(ใหม่)** สร้าง Codebase Context Document รวบรวมเนื้อหาไฟล์, Symbols และความสัมพันธ์ (Import/Export) เพื่อให้ AI "เรียนรู้" ก่อนแก้โค้ด
-*   **`deep_code_edit`**: 🌟 **(ใหม่)** แก้ไขโค้ดแบบ Surgical Edit โดยต้องระบุ `reasoning` (เหตุผลเชิงลึก) ที่ผ่านการคิดวิเคราะห์มาแล้ว
-*   **`build_project_graph`**: สแกนโปรเจกต์เพื่อสร้างแผนผังความสัมพันธ์ทั้งหมด (รองรับ TS, JS, PY, GO)
-*   **`get_file_relationships`**: ตรวจสอบว่าไฟล์เป้าหมายกระทบกับส่วนไหนของระบบบ้าง
-*   **`search_code`**: ค้นหา Code Pattern ทั้งโปรเจกต์แบบชาญฉลาด
-
-### 📚 3. Knowledge & Memory (CodeStore)
-*   **`add_code_snippet`**: 🌟 **(ใหม่)** บันทึก Snippet โค้ดที่ใช้งานบ่อยลงฐานข้อมูล
-*   **`search_code_db`**: 🌟 **(ใหม่)** ค้นหาความรู้เดิมจากฐานข้อมูล (ช่วยลดเวลาในการเริ่มงานใหม่)
-*   **`learn_architecture_pattern`**: 🌟 **(ใหม่)** บันทึกรูปแบบโครงสร้างของระบบ
-*   **`manage_notes`**: (ปรับปรุงใหม่!) จัดการบันทึกพร้อมระบุ **Priority** และ **Expiration**
-
-### 🌐 4. External Research
-*   **`web_search`**: ค้นหาข้อมูลล่าสุดจากโลกภายนอก (Brave/Exa/Google)
-*   **`read_webpage`**: อ่านเนื้อหาเว็บแปลงเป็น Markdown ที่สะอาดและเข้าใจง่าย
-*   **`fetch`**: ดึงข้อมูล Raw จาก API ต่างๆ
-
-### 📁 5. System & Persistence
-*   **`read_file` / `write_file` / `edit_file`**: จัดการไฟล์ในระบบ
-*   **`shell_execute`**: รันคำสั่ง Terminal (มีระบบป้องกันคำสั่งอันตราย เช่น `rm -rf /`)
-
----
-
-
-
-## 🚀 การติดตั้ง (Installation)
-
-
-
-คุณสามารถเลือกติดตั้งได้ 3 รูปแบบตามความสะดวกดังนี้:
-
-
-
-### 1. แบบ npx (ไม่ต้องติดตั้งลงเครื่องถาวร)
-
-วิธีที่ง่ายที่สุดและแนะนำสำหรับ AI Client ส่วนใหญ่:
+## 🚀 Quick Setup
 
+### 1. Installation
+**Option A: Run Temporarily (Recommended for testing)**
 ```bash
-
 npx -y @gotza02/sequential-thinking
-
 ```
 
-
-
-### 2. แบบ npm (ติดตั้งลงเครื่อง)
-
-เหมาะสำหรับผู้ที่ต้องการความเสถียรหรือใช้งานในสภาพแวดล้อมที่ไม่มีอินเทอร์เน็ตตลอดเวลา:
-
-
-
-*   **Global Installation (แนะนำ):**
-
-    ```bash
-
-npm install -g @gotza02/sequential-thinking
-
-    ```
-
-*   **Local Installation (ในโปรเจกต์):
-
-    ```bash
-
-npm install @gotza02/sequential-thinking
-
-    ```
-
-
-
-### 3. แบบจาก Source Code (Developer)
-
+**Option B: Install Globally**
 ```bash
-
-git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-thinking && npm install && npm run build
-
-```
-
-
-
----
-
-
-
-## 🔍 วิธีค้นหา Path ที่ถูกต้อง (Path Discovery)
-
-
-
-หากคุณติดตั้งผ่าน `npm` และต้องการทราบว่าไฟล์ `index.js` อยู่ที่ไหนเพื่อนำไปใส่ใน AI Client:
-
-
-
-*   **กรณีติดตั้ง Global:**
-
-    ```bash
-
-# สำหรับ Linux/Android (Termux)
-
-echo "$(npm config get prefix)/lib/node_modules/@gotza02/sequential-thinking/dist/index.js"
-
-
-
-# สำหรับ Windows (PowerShell)
-
-echo "$env:APPDATA\npm\node_modules\@gotza02\sequential-thinking\dist\index.js"
-
-    ```
-
-*   **กรณีติดตั้ง Local:**
-
-    ```bash
-
-echo "$(pwd)/node_modules/@gotza02/sequential-thinking/dist/index.js"
-
-    ```
-
-
-
----
-
-
-
-## ⚙️ การตั้งค่าใน AI Client (Configuration Examples)
-
-
-
-### 1. การใช้ npx (ง่ายที่สุด)
-
-เหมาะสำหรับ **Gemini CLI** หรือ **Claude Desktop** ที่เชื่อมต่ออินเทอร์เน็ตได้:
-
-```json
-
-{
-
-  "command": "npx",
-
-  "args": ["-y", "@gotza02/sequential-thinking"]
-
-}
-
+npm install -g @gotza02/sequential-thinking
 ```
 
+### 2. Configuration (Gemini/Claude)
+Add this to your MCP settings (`~/.gemini/settings.json` or `claude_desktop_config.json`).
 
-
-### 2. การใช้ npm/Node (เสถียรกว่า)
-
-ต้องระบุ Path ที่หาได้จากขั้นตอน **Path Discovery** ด้านบน:
-
+**For npx usage:**
 ```json
-
 {
-
-  "command": "node",
-
-  "args": ["/ทาง/ไป/ยัง/node_modules/@gotza02/sequential-thinking/dist/index.js"]
-
+  "mcpServers": {
+    "smartagent": {
+      "command": "npx",
+      "args": ["-y", "@gotza02/sequential-thinking"],
+      "env": { "THOUGHTS_STORAGE_PATH": "thoughts.json" }
+    }
+  }
 }
-
 ```
 
-
-
-#### ตัวอย่างไฟล์ Config (Gemini CLI: `~/.gemini/settings.json`)
+**For npm usage:**
+*(Find path with: `npm root -g`)*
 ```json
 {
   "mcpServers": {
     "smartagent": {
-      "command": "npx",
-      "args": ["-y", "@gotza02/sequential-thinking"],
-      "env": {
-        "BRAVE_API_KEY": "YOUR_BRAVE_KEY",
-        "EXA_API_KEY": "YOUR_EXA_KEY",
-        "GOOGLE_SEARCH_API_KEY": "YOUR_GOOGLE_API_KEY",
-        "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_SEARCH_ENGINE_ID",
-        "THOUGHTS_STORAGE_PATH": "thoughts_history.json",
-        "NOTES_STORAGE_PATH": "project_notes.json",
-        "CODE_DB_PATH": "code_database.json"
-      }
+      "command": "node",
+      "args": ["/PATH/TO/node_modules/@gotza02/sequential-thinking/dist/index.js"]
     }
   }
 }
 ```
 
-> **Note:** สำหรับ Google Search คุณจำเป็นต้องมีทั้ง **API Key** และ **Search Engine ID (CX)** ซึ่งสามารถสร้างได้จาก [Google Custom Search Engine](https://programmablesearchengine.google.com/)
-
----
-
-## 🛠️ ติดตั้งคำสั่งระบบ (System Instruction Setup)
-
-คุณสามารถติดตั้งคำสั่งระบบ **Ultimate Deep Engineer** ให้กับ Gemini และ Claude ได้โดยอัตโนมัติด้วย Script นี้:
-
-```bash
-chmod +x install-ultimate-engineer.sh && ./install-ultimate-engineer.sh
-```
+## 🔑 Environment Variables
+| Variable | Description |
+|----------|-------------|
+| `THOUGHTS_STORAGE_PATH` | Path to save thought history (Required) |
+| `NOTES_STORAGE_PATH` | Path to save project notes |
+| `CODE_DB_PATH` | Path to save code snippets |
+| `BRAVE_API_KEY` | Optional: For Brave Search |
+| `EXA_API_KEY` | Optional: For Exa.ai Search |
+
+## 🛠️ Tools Summary
+- **Thinking:** `sequentialthinking`, `summarize_history`, `clear_thought_history`
+- **Code:** `build_project_graph`, `deep_code_analyze`, `deep_code_edit`, `search_code`
+- **Memory:** `add_code_snippet`, `search_code_db`, `manage_notes`
+- **Web:** `web_search`, `read_webpage`, `fetch`
+- **System:** `read_file`, `write_file`, `edit_file`, `shell_execute`
 
 ---
 
 ## 🤖 Recommended System Instruction (The Ultimate Deep Engineer)
 
-ให้ Copy ข้อความด้านล่างนี้ไปใส่ใน **System Prompt** ของ AI Agent เพื่อประสิทธิภาพสูงสุด:
+Copy this into your AI's System Prompt to enable the Loop Breaker and Deep Thinking protocols:
 
 ```markdown
 # 🤖 System Instruction: Ultimate Deep Engineer (Sequential Thinking Extended)
@@ -252,20 +82,41 @@ You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP
 - **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'`.
-- **Loop Breaker:** If a bug persists after 2 attempts or reasoning loops, MUST create a new branch (`branchFromThought`) to change strategy completely.
+- **Loop Breaker (Auto-Correction):**
+  - **Self-Monitoring:** If you detect yourself repeating a failed strategy or stuck in a loop -> **STOP**.
+  - **Mandatory Branching:** You MUST create a new branch (`branchFromThought`) to explore a *radically different* approach.
+  - **Explicit Statement:** State "Stuck detected. Branching to Strategy B..." before proceeding.
 - **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.
+## 🛠️ TOOL USAGE TRIGGERS (Context-Action Mapping)
+**You MUST follow these explicit triggers:**
+
+1.  **Unknown/New Project Context:**
+    - **Trigger:** Start of session or new task.
+    - **Action:** `build_project_graph` -> `read_file` (README/config).
+    - **Goal:** Map the territory before moving.
+
+2.  **Coding/Refactoring Tasks:**
+    - **Trigger:** Request to write or edit code.
+    - **Action:** `deep_code_analyze` (on target files) -> `sequentialthinking` (Plan) -> `deep_code_edit` or `edit_file`.
+    - **Constraint:** NEVER edit code without reading the file and its related context first.
+
+3.  **Debugging/Error Fixing:**
+    - **Trigger:** User reports a bug or error.
+    - **Action:** `read_file` (logs/code) OR `diagnose_error_screenshot` -> `sequentialthinking` (Hypothesis) -> `codebase_investigator` (Verification).
+    - **Constraint:** Do not guess. Evidence first.
+
+4.  **Unknown Libraries/Docs:**
+    - **Trigger:** Need to use a specific library/tool you are unsure about.
+    - **Action:** `web_search` -> `read_webpage` or `get_code_context_exa`.
+    - **Constraint:** Do not hallucinate APIs.
 
 ## 💻 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.
+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.
@@ -278,7 +129,5 @@ You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP
 - **Session Continuity:** Your thought history is saved. If you restart, review the history to maintain context.
 ```
 
----
-
 ## License
-MIT - พัฒนาโดย @gotza02/sequential-thinking
+MIT - Developed by @gotza02/sequential-thinking

package/dist/graph.js

@@ -18,9 +18,11 @@ export class ProjectKnowledgeGraph {
                 symbols: []
             });
         }
-        // Step 2: Parse imports and build edges
-        for (const file of files) {
-            await this.parseFile(file);
+        // Step 2: Parse imports and build edges in parallel with concurrency limit
+        const CONCURRENCY_LIMIT = 20;
+        for (let i = 0; i < files.length; i += CONCURRENCY_LIMIT) {
+            const chunk = files.slice(i, i + CONCURRENCY_LIMIT);
+            await Promise.all(chunk.map(file => this.parseFile(file)));
         }
         return {
             nodeCount: this.nodes.size,
@@ -126,27 +128,52 @@ export class ProjectKnowledgeGraph {
             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(/^\s*(?:import|from)\s+([a-zA-Z0-9_.]+)/gm);
-                for (const match of importMatches)
+                // 1. Python Imports
+                // Handle: import os, sys
+                const simpleImportMatches = content.matchAll(/^\s*import\s+([^#\n]+)/gm);
+                for (const match of simpleImportMatches) {
+                    match[1].split(',').forEach(s => {
+                        const clean = s.trim().split(/\s+/)[0]; // Handle 'import x as y'
+                        if (clean)
+                            imports.push(clean);
+                    });
+                }
+                // Handle: from .module import func OR from package.module import func
+                const fromImportMatches = content.matchAll(/^\s*from\s+([.a-zA-Z0-9_]+)\s+import/gm);
+                for (const match of fromImportMatches)
                     imports.push(match[1]);
-                const funcMatches = content.matchAll(/^\s*def\s+([a-zA-Z0-9_]+)/gm);
-                for (const match of funcMatches)
+                // 2. Python Symbols (Only top-level defs/classes to avoid nested methods)
+                const topLevelFuncMatches = content.matchAll(/^def\s+([a-zA-Z0-9_]+)/gm);
+                for (const match of topLevelFuncMatches)
                     symbols.push(`def:${match[1]}`);
-                const classMatches = content.matchAll(/^\s*class\s+([a-zA-Z0-9_]+)/gm);
-                for (const match of classMatches)
+                const topLevelClassMatches = content.matchAll(/^class\s+([a-zA-Z0-9_]+)/gm);
+                for (const match of topLevelClassMatches)
                     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)
+                // 1. Go Imports
+                // Single line: import "fmt"
+                const singleImportMatches = content.matchAll(/import\s+"([^"]+)"/g);
+                for (const match of singleImportMatches)
                     imports.push(match[1]);
-                const funcMatches = content.matchAll(/^\s*func\s+([a-zA-Z0-9_]+)/gm);
+                // Block: import ( "fmt"; "os" )
+                const blockImportMatches = content.matchAll(/import\s+\(([\s\S]*?)\)/g);
+                for (const match of blockImportMatches) {
+                    const block = match[1];
+                    const innerMatches = block.matchAll(/"([^"]+)"/g);
+                    for (const im of innerMatches)
+                        imports.push(im[1]);
+                }
+                // 2. Go Symbols
+                // Functions: func Name(...)
+                const funcMatches = content.matchAll(/^func\s+([a-zA-Z0-9_]+)/gm);
                 for (const match of funcMatches)
                     symbols.push(`func:${match[1]}`);
+                // Types: type Name struct/interface
+                const typeMatches = content.matchAll(/^type\s+([a-zA-Z0-9_]+)\s+(?:struct|interface)/gm);
+                for (const match of typeMatches)
+                    symbols.push(`type:${match[1]}`);
             }
             await this.finalizeFileNodes(filePath, imports, symbols);
         }
@@ -175,6 +202,12 @@ export class ProjectKnowledgeGraph {
                     this.nodes.get(resolvedPath)?.importedBy.push(filePath);
                 }
             }
+            else {
+                // If we can't resolve to a local file, keep the original import string as an external dependency
+                if (!currentNode.imports.includes(importPath)) {
+                    currentNode.imports.push(importPath);
+                }
+            }
         }
     }
     async resolvePath(dir, relativePath) {
@@ -222,7 +255,12 @@ export class ProjectKnowledgeGraph {
             return null;
         return {
             path: node.path,
-            imports: node.imports.map(p => path.relative(this.rootDir, p)),
+            imports: node.imports.map(p => {
+                if (path.isAbsolute(p)) {
+                    return path.relative(this.rootDir, p);
+                }
+                return p; // Return as is for external libraries
+            }),
             importedBy: node.importedBy.map(p => path.relative(this.rootDir, p)),
             symbols: node.symbols
         };

package/dist/lib.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import * as fs from 'fs/promises';
 import { existsSync, readFileSync } from 'fs';
 import * as path from 'path';
+import { AsyncMutex } from './utils.js';
 export class SequentialThinkingServer {
     thoughtHistory = [];
     branches = {};
@@ -10,6 +11,7 @@ export class SequentialThinkingServer {
     delayMs;
     isSaving = false;
     hasPendingSave = false;
+    saveMutex = new AsyncMutex();
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -20,11 +22,40 @@ export class SequentialThinkingServer {
         try {
             if (existsSync(this.storagePath)) {
                 const data = readFileSync(this.storagePath, 'utf-8');
-                const history = JSON.parse(data);
-                if (Array.isArray(history)) {
-                    this.thoughtHistory = []; // Reset to avoid duplicates
-                    this.branches = {};
-                    history.forEach(thought => this.addToMemory(thought));
+                if (!data.trim())
+                    return; // Empty file is fine
+                try {
+                    const history = JSON.parse(data);
+                    if (Array.isArray(history)) {
+                        this.thoughtHistory = [];
+                        this.branches = {};
+                        history.forEach(thought => {
+                            if (thought && typeof thought === 'object' && 'thought' in thought) {
+                                this.addToMemory(thought);
+                            }
+                        });
+                    }
+                }
+                catch (parseError) {
+                    console.error(`Error parsing history from ${this.storagePath}, attempting recovery:`, parseError);
+                    // Basic Recovery: Try to fix truncated JSON by finding the last complete object
+                    // This is a simple heuristic: find the last '}' that closes a thought object
+                    const lastBrace = data.lastIndexOf('}');
+                    if (lastBrace !== -1) {
+                        try {
+                            const recoveredData = data.substring(0, lastBrace + 1).trim();
+                            // If it's part of an array, we might need to add ']'
+                            const attemptedJson = recoveredData.endsWith(']') ? recoveredData : recoveredData + ']';
+                            const history = JSON.parse(attemptedJson);
+                            if (Array.isArray(history)) {
+                                history.forEach(thought => this.addToMemory(thought));
+                                console.log(`Successfully recovered ${history.length} thoughts.`);
+                            }
+                        }
+                        catch (recoveryError) {
+                            console.error('Recovery failed, starting with empty history.');
+                        }
+                    }
                 }
             }
         }
@@ -33,27 +64,17 @@ export class SequentialThinkingServer {
         }
     }
     async saveHistory() {
-        if (this.isSaving) {
-            this.hasPendingSave = true;
-            return;
-        }
-        this.isSaving = true;
-        try {
-            // Atomic write: write to tmp then rename
-            const tmpPath = `${this.storagePath}.tmp`;
-            await fs.writeFile(tmpPath, JSON.stringify(this.thoughtHistory, null, 2), 'utf-8');
-            await fs.rename(tmpPath, this.storagePath);
-        }
-        catch (error) {
-            console.error(`Error saving history to ${this.storagePath}:`, error);
-        }
-        finally {
-            this.isSaving = false;
-            if (this.hasPendingSave) {
-                this.hasPendingSave = false;
-                this.saveHistory();
+        // Use mutex to ensure only one file operation happens at a time
+        await this.saveMutex.dispatch(async () => {
+            try {
+                const tmpPath = `${this.storagePath}.tmp`;
+                await fs.writeFile(tmpPath, JSON.stringify(this.thoughtHistory, null, 2), 'utf-8');
+                await fs.rename(tmpPath, this.storagePath);
             }
-        }
+            catch (error) {
+                console.error(`Error saving history to ${this.storagePath}:`, error);
+            }
+        });
     }
     async clearHistory() {
         this.thoughtHistory = [];
@@ -74,13 +95,18 @@ export class SequentialThinkingServer {
         // Remove the range and insert summary
         const removedCount = endIndex - startIndex + 1;
         this.thoughtHistory.splice(startIndex - 1, removedCount, summaryThought);
-        // Renumber subsequent thoughts and update references
+        // Update all thoughts to reflect the new total and renumber subsequent ones
+        const newTotal = this.thoughtHistory.length;
         const shiftAmount = removedCount - 1;
-        for (let i = startIndex; i < this.thoughtHistory.length; i++) {
+        for (let i = 0; i < this.thoughtHistory.length; i++) {
             const t = this.thoughtHistory[i];
-            // Update own number
-            t.thoughtNumber -= shiftAmount;
-            // Update references (branchFromThought)
+            // 1. Update total thoughts for everyone
+            t.totalThoughts = newTotal;
+            // 2. Renumber thoughts that came after the summarized range
+            if (i >= startIndex) {
+                t.thoughtNumber -= shiftAmount;
+            }
+            // 3. Update references for all thoughts
             if (t.branchFromThought) {
                 if (t.branchFromThought > endIndex) {
                     t.branchFromThought -= shiftAmount;
@@ -89,7 +115,6 @@ export class SequentialThinkingServer {
                     t.branchFromThought = startIndex; // Point to summary
                 }
             }
-            // Update references (revisesThought)
             if (t.revisesThought) {
                 if (t.revisesThought > endIndex) {
                     t.revisesThought -= shiftAmount;

package/dist/tools/web.js

@@ -136,7 +136,41 @@ export function registerWebTools(server) {
             const article = reader.parse();
             if (!article)
                 throw new Error("Could not parse article content");
-            const turndownService = new TurndownService();
+            const turndownService = new TurndownService({
+                headingStyle: 'atx',
+                codeBlockStyle: 'fenced'
+            });
+            // Custom Rule for GitHub Flavored Markdown Tables
+            turndownService.addRule('tables', {
+                filter: ['table'],
+                replacement: function (content, node) {
+                    const rows = [];
+                    const table = node;
+                    const trs = Array.from(table.querySelectorAll('tr'));
+                    trs.forEach((tr, index) => {
+                        const cols = [];
+                        const tds = Array.from(tr.querySelectorAll('th, td'));
+                        tds.forEach(td => {
+                            // Clean content: remove newlines and pipe characters
+                            cols.push(td.textContent?.replace(/[\n\r]/g, ' ').replace(/\|/g, '\\|').trim() || "");
+                        });
+                        if (cols.length > 0) {
+                            rows.push(`| ${cols.join(' | ')} |`);
+                            // Add separator after header
+                            if (index === 0 || tr.querySelector('th')) {
+                                rows.push(`| ${cols.map(() => '---').join(' | ')} |`);
+                            }
+                        }
+                    });
+                    // Filter out duplicate separator lines if any
+                    const uniqueRows = rows.filter((row, i) => {
+                        if (row.includes('---') && rows[i - 1]?.includes('---'))
+                            return false;
+                        return true;
+                    });
+                    return '\n\n' + uniqueRows.join('\n') + '\n\n';
+                }
+            });
             let markdown = turndownService.turndown(article.content || "");
             if (markdown.length > 20000) {
                 markdown = markdown.substring(0, 20000) + "\n...(truncated)";

package/dist/utils.js

@@ -52,13 +52,10 @@ export function validatePath(requestedPath) {
     return absolutePath;
 }
 function isPrivateIP(ip) {
-    // IPv4 ranges
-    // 127.0.0.0/8
-    // 10.0.0.0/8
-    // 172.16.0.0/12
-    // 192.168.0.0/16
-    // 0.0.0.0/8
-    const parts = ip.split('.').map(Number);
+    // Remove brackets if present (IPv6 literals in hostnames)
+    const cleanIp = ip.replace(/^\[|\]$/g, '');
+    // IPv4 check
+    const parts = cleanIp.split('.').map(Number);
     if (parts.length === 4) {
         if (parts[0] === 127)
             return true;
@@ -72,13 +69,19 @@ function isPrivateIP(ip) {
             return true;
         return false;
     }
-    // IPv6 checks (simple check for loopback/link-local)
-    if (ip === '::1' || ip === '::')
+    // IPv6 check
+    // Normalize: remove leading/trailing colons and convert to lowercase
+    const normalized = cleanIp.toLowerCase();
+    // Loopback: ::1, 0:0:0:0:0:0:0:1
+    if (normalized === '::1' || normalized === '::' || normalized.replace(/:0/g, ':').replace(/^0+/, '') === '::1')
         return true;
-    if (ip.startsWith('fc') || ip.startsWith('fd'))
+    // Private/Link-local ranges
+    if (normalized.startsWith('fc') || normalized.startsWith('fd'))
         return true; // Unique Local
-    if (ip.startsWith('fe80'))
+    if (normalized.startsWith('fe80'))
         return true; // Link Local
+    if (normalized.startsWith('::ffff:7f') || normalized.startsWith('::ffff:10.') || normalized.startsWith('::ffff:192.168.'))
+        return true; // IPv4-mapped private
     return false;
 }
 export async function validatePublicUrl(urlString) {
@@ -86,7 +89,11 @@ export async function validatePublicUrl(urlString) {
     if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
         throw new Error('Invalid protocol. Only http and https are allowed.');
     }
-    // Attempt to resolve hostname
+    // 1. Direct check for IP literals in hostname
+    if (isPrivateIP(parsed.hostname)) {
+        throw new Error(`Access denied: Host '${parsed.hostname}' is a private IP`);
+    }
+    // 2. Resolve and check all resulting IPs
     try {
         const addresses = await dns.lookup(parsed.hostname, { all: true });
         for (const addr of addresses) {
@@ -100,7 +107,7 @@ export async function validatePublicUrl(urlString) {
         if (error instanceof Error && error.message.startsWith('Access denied')) {
             throw error;
         }
-        // Ignore DNS errors here, let fetch handle them (or fail safely)
+        // Ignore other DNS errors, let fetch handle them
     }
 }
 class Logger {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.2.12",
+  "version": "2026.2.14",
   "publishConfig": {
     "access": "public"
   },