@gotza02/sequential-thinking 2026.2.2 → 2026.2.3

package/README.md

@@ -1,90 +1,113 @@
 # Sequential Thinking MCP Server (Extended Edition) 🧠✨
 
-**MCP Server ที่ช่วยให้ AI "คิดก่อนทำ" อย่างเป็นระบบ พร้อมความสามารถในการค้นหาเว็บ, วิเคราะห์โค้ด และจดจำข้อมูลระยะยาว**
+**MCP Server ที่ยกระดับ AI ให้เป็นวิศวกรซอฟต์แวร์อัจฉริยะ ด้วยระบบ Deepest Thinking และการวิเคราะห์ Codebase เชิงลึก**
 
-โปรเจกต์นี้คือส่วนขยายของ Sequential Thinking ที่เพิ่มเครื่องมือสำคัญเพื่อให้ AI ทำงานเป็น "Autonomous Agent" ได้อย่างสมบูรณ์แบบ ทั้งการวางแผน (Planning), การหาข้อมูล (Research), และการลงมือทำ (Execution)
+โปรเจกต์นี้คือส่วนขยายขั้นสูงของ Sequential Thinking ที่รวมเอาความสามารถในการวางแผนที่เป็นระบบ, การหาข้อมูลทั่วโลก (Web Search), การสร้างแผนผังความสัมพันธ์ของโค้ด (Dependency Graph) และการจัดการหน่วยความจำระยะยาวเข้าด้วยกัน เพื่อให้ AI สามารถทำงานที่ซับซ้อนได้อย่างอิสระและแม่นยำ
 
 ---
 
-## 🔑 Environment Variables (การตั้งค่าตัวแปร)
+## 🌟 จุดเด่นของเวอร์ชัน Extended
+
+1.  **Deepest Thinking Protocol**: บังคับให้ AI วิเคราะห์ปัญหาแบบเป็นลำดับขั้นตอน (Step-by-step) พร้อมการแตกกิ่งความคิด (Branching) และการทบทวนตัวเอง (Reflexion) เพื่อหาทางเลือกที่ดีที่สุด
+2.  **Codebase Intelligence**: ระบบ `ProjectKnowledgeGraph` ที่ใช้ TypeScript Compiler API จริงๆ ในการสแกนความสัมพันธ์ระหว่างไฟล์และ Exported Symbols
+3.  **Deep Coding Workflow**: เครื่องมือใหม่สำหรับการแก้ไขโค้ดที่ต้องผ่านการวิเคราะห์บริบท (Context Document) และการวางแผนที่ผ่านการตรวจสอบเหตุผลแล้วเท่านั้น
+4.  **Optimized Web Extraction**: ระบบอ่านเว็บที่ตัดโฆษณาและส่วนที่ไม่จำเป็นออก (Readability) แปลงเป็น Markdown เพื่อประหยัด Token และให้ข้อมูลที่สะอาดที่สุด
+
+---
 
-นี่คือตัวแปรทั้งหมดที่ระบบรองรับ คุณสามารถเลือกตั้งค่าได้ตามฟีเจอร์ที่ต้องการใช้งาน:
+## 🔑 Environment Variables (การตั้งค่าตัวแปร)
 
-### 1. Web Search APIs (เลือกอย่างน้อย 1 อย่างเพื่อใช้ `web_search`)
 | Variable Name | Description | Required? |
 |--------------|-------------|-----------|
 | `BRAVE_API_KEY` | สำหรับค้นหาผ่าน Brave Search | ❌ (Optional) |
-| `EXA_API_KEY` | สำหรับค้นหาผ่าน Exa.ai (แนะนำสำหรับงาน Deep Research) | ❌ (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` |
+| `THOUGHT_DELAY_MS` | เวลาหน่วงระหว่างคิด (เพื่อความสมจริงและการจัดการ Rate Limit) | `0` |
+
+---
+
+## 🛠️ รายการเครื่องมือ (Tools Capability)
 
-### 2. Storage & Memory (การจัดเก็บข้อมูล)
-| Variable Name | Description | Default Value |
-|--------------|-------------|---------------|
-| `THOUGHTS_STORAGE_PATH` | ไฟล์เก็บประวัติการคิด (Thinking History) | `thoughts_history.json` |
-| `NOTES_STORAGE_PATH` | ไฟล์เก็บความจำระยะยาว (Long-term Notes) | `project_notes.json` |
+### 🧠 1. Cognitive & Deepest Thinking
+*   **`sequentialthinking`**: (ปรับปรุงใหม่!) บังคับใช้หลักการ **Deepest Thinking** รองรับการทำ Analysis, Reflexion, Evaluation และ Selection ในทุกการแก้ปัญหา
+*   **`summarize_history`**: สรุปประวัติความคิดที่ยาวเหยียดเพื่อประหยัดพื้นที่บริบท
+*   **`clear_thought_history`**: ล้างสมองเพื่อเริ่มงานชิ้นใหม่
 
-### 3. System Behavior (พฤติกรรมระบบ)
-| Variable Name | Description | Default Value |
-|--------------|-------------|---------------|
-| `THOUGHT_DELAY_MS` | เวลาหน่วงระหว่างความคิด (ms) เพื่อกัน Rate Limit | `0` |
-| `DISABLE_THOUGHT_LOGGING`| ปิดการแสดงผล Log สีสวยงามใน Console (`true`/`false`) | `false` |
+### 💻 2. Deep Coding & Codebase Context
+*   **`deep_code_analyze`**: 🌟 **(ใหม่)** สร้าง Codebase Context Document รวบรวมเนื้อหาไฟล์, Symbols และความสัมพันธ์ (Import/Export) เพื่อให้ AI "เรียนรู้" ก่อนแก้โค้ด
+*   **`deep_code_edit`**: 🌟 **(ใหม่)** แก้ไขโค้ดแบบ Surgical Edit โดยต้องระบุ `reasoning` (เหตุผลเชิงลึก) ที่ผ่านการคิดวิเคราะห์มาแล้ว
+*   **`build_project_graph`**: สแกนโปรเจกต์เพื่อสร้างแผนผังความสัมพันธ์ทั้งหมด
+*   **`get_file_relationships`**: ตรวจสอบว่าไฟล์เป้าหมายกระทบกับส่วนไหนของระบบบ้าง
+*   **`search_code`**: ค้นหา Code Pattern ทั้งโปรเจกต์แบบชาญฉลาด
+
+### 🌐 3. External Research
+*   **`web_search`**: ค้นหาข้อมูลล่าสุดจากโลกภายนอก (Brave/Exa/Google)
+*   **`read_webpage`**: อ่านเนื้อหาเว็บแปลงเป็น Markdown ที่สะอาดและเข้าใจง่าย
+*   **`fetch`**: ดึงข้อมูล Raw จาก API ต่างๆ
+
+### 📁 4. System & Persistence
+*   **`read_file` / `write_file` / `edit_file`**: จัดการไฟล์ในระบบ
+*   **`shell_execute`**: รันคำสั่ง Terminal (เช่น Build, Test, Deploy)
+*   **`manage_notes`**: จัดการหน่วยความจำระยะยาวข้ามเซสชัน
 
 ---
 
-## 🚀 Installation & Usage (การติดตั้งและใช้งาน)
+## 🔄 The "Deep Coding" Workflow (ขั้นตอนการทำงานที่แนะนำ)
 
-สามารถติดตั้งผ่าน npm ได้โดยตรง:
+เพื่อให้ AI ทำงานได้อย่างเทพที่สุด แนะนำให้ใช้ลำดับการทำงานดังนี้:
 
-```bash
-npm install @gotza02/sequential-thinking
-```
+1.  **Map the Codebase**: รัน `build_project_graph` เพื่อให้ AI เข้าใจโครงสร้างโปรเจกต์ทั้งหมด
+2.  **Deep Analysis**: ใช้ `deep_code_analyze` กับไฟล์ที่เกี่ยวข้อง เพื่อสร้างบริบทและความเข้าใจ symbols ที่ใช้งาน
+3.  **Strategic Planning**: ใช้ `sequentialthinking` เพื่อวางแผนแบบ Deepest Thinking (แตกกิ่งความคิด, ทดสอบสมมติฐาน)
+4.  **Precision Edit**: ลงมือแก้ไขด้วย `deep_code_edit` หรือ `edit_file` พร้อมระบุเหตุผลที่วิเคราะห์มาแล้ว
+5.  **Verify**: ใช้ `shell_execute` รันคำสั่ง Test หรือ Lint เพื่อตรวจสอบความถูกต้อง
 
-รองรับทั้ง **Gemini CLI** และ **Claude Desktop**
+---
 
-### Option A: ใช้งานผ่าน npx (แนะนำสำหรับผู้ใช้ทั่วไป)
-*ไม่ต้องโหลดโค้ด แค่แก้ Config แล้วใช้งานได้เลย*
+## 🚀 การติดตั้ง (Installation)
 
-#### 1. สำหรับ Gemini CLI
-แก้ไขไฟล์ `~/.gemini/settings.json` (หรือ `config.json`):
+คุณสามารถเลือกติดตั้งได้ 2 รูปแบบตามความสะดวกดังนี้:
 
-```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_KEY",
-        "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_CX",
-        "THOUGHTS_STORAGE_PATH": "thoughts_history.json",
-        "NOTES_STORAGE_PATH": "project_notes.json",
-        "THOUGHT_DELAY_MS": "1000",
-        "DISABLE_THOUGHT_LOGGING": "false"
-      }
-    }
-  }
-}
+### 1. แบบคำสั่งเดียวจบ (One-Command Setup)
+สำหรับท่านที่ต้องการความรวดเร็วในการติดตั้งและ Build ลงเครื่อง:
+```bash
+git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-thinking && npm install && npm run build
 ```
 
-#### 2. สำหรับ Claude Desktop
-แก้ไขไฟล์ `claude_desktop_config.json`:
+### 2. แบบทีละขั้นตอน (Step-by-Step Guide)
+เหมาะสำหรับการปรับแต่งหรือการติดตั้งบนสภาพแวดล้อมที่จำกัด:
+
+1.  **Clone Repository**: ดาวน์โหลดโค้ดมายังเครื่องของคุณ
+    ```bash
+    git clone https://github.com/gotza02/sequential-thinking.git
+    cd sequential-thinking
+    ```
+2.  **Install Dependencies**: ติดตั้ง Library ที่จำเป็นทั้งหมด
+    ```bash
+    npm install
+    ```
+3.  **Build Project**: ทำการ Compile TypeScript ให้เป็น JavaScript
+    ```bash
+    npm run build
+    ```
+4.  **Configuration**: เปิดไฟล์ตั้งค่า AI Client ของคุณ (เช่น `~/.gemini/settings.json`) แล้วเพิ่มการตั้งค่า MCP Server โดยอ้างอิง Path ไปยังโฟลเดอร์ที่ Build เสร็จแล้ว
+
+---
+
+## ⚙️ การตั้งค่าใน AI Client (Configuration Examples)
 
 ```json
 {
   "mcpServers": {
-    "sequential-thinking": {
+    "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_KEY",
-        "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_CX",
-        "THOUGHTS_STORAGE_PATH": "thoughts_history.json",
-        "NOTES_STORAGE_PATH": "project_notes.json",
+        "BRAVE_API_KEY": "YOUR_KEY",
+        "EXA_API_KEY": "YOUR_KEY",
         "THOUGHT_DELAY_MS": "1000"
       }
     }
@@ -94,144 +117,30 @@ npm install @gotza02/sequential-thinking
 
 ---
 
-### Option B: ใช้งานแบบ Local Source (สำหรับนักพัฒนา)
-*สำหรับคนที่ต้องการแก้ไขโค้ด หรือรันจากเครื่องตัวเอง*
-
-1. **Clone & Build:**
-   ```bash
-   git clone <repo_url>
-   cd sequential-thinking
-   npm install
-   npm run build
-   ```
-
-2. **ตั้งค่า Config (ตัวอย่างสำหรับ Gemini CLI):**
-   *เปลี่ยน Path ให้ตรงกับที่อยู่ไฟล์ในเครื่องคุณ*
-
-   ```json
-   {
-     "mcpServers": {
-       "smartagent": {
-         "command": "node",
-         "args": ["/Users/username/projects/sequential-thinking/dist/index.js"],
-         "env": {
-            "BRAVE_API_KEY": "YOUR_BRAVE_KEY",
-            "EXA_API_KEY": "YOUR_EXA_KEY",
-            "GOOGLE_SEARCH_API_KEY": "YOUR_GOOGLE_KEY",
-            "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_CX",
-            "THOUGHTS_STORAGE_PATH": "thoughts_history.json",
-            "NOTES_STORAGE_PATH": "project_notes.json",
-            "THOUGHT_DELAY_MS": "1000",
-            "DISABLE_THOUGHT_LOGGING": "false"
-         }
-       }
-     }
-   }
-   ```
-
----
-
-## 🛠️ Tools Capability (ความสามารถเครื่องมือ)
-
-### 🧠 1. Cognitive Tools (สมองและการคิด)
-*   **`sequentialthinking`**: เครื่องมือหลัก! ช่วยแตกปัญหาใหญ่เป็นขั้นตอนย่อย (Step-by-step), แตกกิ่งความคิด (Branching), และทบทวนตัวเอง (Reflexion)
-*   **`summarize_history`**: ย่อสรุปประวัติการคิดที่ยาวเหยียดให้สั้นลง
-*   **`clear_thought_history`**: ล้างสมอง เริ่มต้นคิดเรื่องใหม่
-
-### 🌐 2. Web Capabilities (การเข้าถึงอินเทอร์เน็ต)
-*   **`web_search`**: ค้นหาข้อมูลล่าสุด (รองรับ Brave, Exa, Google)
-*   **`read_webpage`**: อ่านเนื้อหาในเว็บแบบ Markdown (ตัดโฆษณาออกให้อัตโนมัติ)
-*   **`fetch`**: ดึงข้อมูล Raw JSON/HTML จาก API
-
-### 🏗️ 3. Codebase Intelligence (ความเข้าใจโค้ด)
-*   **`build_project_graph`**: สแกนโปรเจกต์เพื่อสร้างแผนผังความสัมพันธ์ (Dependency Graph)
-*   **`get_file_relationships`**: ดูว่าไฟล์นี้ถูกใครเรียกใช้บ้าง (ป้องกันการแก้แล้วพัง)
-*   **`search_code`**: ค้นหาโค้ดทั้งโปรเจกต์แบบฉลาด
-
-### 📝 4. Long-term Memory (ความจำระยะยาว)
-*   **`manage_notes`**: บันทึก/อ่าน/แก้ไข ข้อความที่ต้องการให้ AI จำได้ข้าม Session (เช่น กฎของโปรเจกต์, ความชอบของผู้ใช้)
-
-### 💻 5. System Operations (จัดการระบบ)
-*   **`read_file`**: อ่านไฟล์ (ต้องทำก่อนแก้ไฟล์เสมอ)
-*   **`edit_file`**: แก้ไขไฟล์เฉพาะจุด (Search & Replace) ปลอดภัยกว่าเขียนทับ
-*   **`write_file`**: สร้างไฟล์ใหม่ หรือเขียนทับทั้งไฟล์
-*   **`shell_execute`**: รันคำสั่ง Terminal (เช่น `npm test`, `git status`)
-
----
-
-## 🤖 Recommended System Instruction (คำสั่งระบบที่แนะนำ)
-
-เพื่อประสิทธิภาพสูงสุด ให้ Copy ข้อความด้านล่างนี้ไปใส่ใน **System Prompt** ของ AI Agent ที่คุณใช้งาน:
+## 🤖 Recommended System Instruction
 
 ```bash
-# 🤖 System Instruction: Enhanced Sequential Engineer
-
-You are an advanced AI Software Engineer enhanced with the **Sequential Thinking MCP Server**. Your goal is to solve complex problems autonomously, accurately, and safely.
-
-## 🧠 PRIME DIRECTIVE: Sequential Thinking
-
-**Rule #1: NEVER answer complex queries immediately.**
-You MUST use the `sequentialthinking` tool to structure your reasoning process.
-
-1.  **Analyze:** Break the user's request into atomic requirements.
-2.  **Plan:** Formulate a step-by-step plan.
-3.  **Execute:** Carry out the plan, one step at a time.
-4.  **Reflect:** Critique your own work. If a step fails, use `isRevision: true` to correct your course.
+# 🤖 System Instruction: Enhanced Deep Engineer
 
-**Constraints:**
--   Do not output code until you have a clear plan.
--   If you are unsure, generate a hypothesis and verify it.
+You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP (Extended).
 
-## 🏗 Codebase Intelligence Protocol
+## 🧠 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.
 
-**On Start:**
-1.  **Map the Territory:** Run `build_project_graph` immediately to understand the project structure.
-2.  **Summarize:** Run `get_project_graph_summary` to identify key files.
+## 🏗 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.
 
-**Before Editing:**
-1.  **Context Check:** Run `get_file_relationships` to see what depends on the file you are changing.
-2.  **Read First:** ALWAYS run `read_file` to get the *current* content. Never rely on memory or assumptions.
-
-## 🛠 File Operations Protocol
-
--   **Small Changes:** Use `edit_file` for surgical replacements. This minimizes the risk of context loss or accidental deletions.
--   **New/Large Files:** Use `write_file`.
--   **Verification:** After editing, ALWAYS verify the syntax or logic (e.g., run `npm run build` or `npm test` using `shell_execute`).
-
-## 🌐 External Knowledge Protocol
-
--   **Unknown Libs:** If you see a library you don't know, use `web_search` to find its docs.
--   **Reading:** Use `read_webpage` to ingest documentation efficiently (markdown format).
--   **Errors:** If you hit a cryptic error, search for it.
-
-## 📝 Memory & Persistence
-
--   **Long-Term:** Use `manage_notes` to save architectural decisions, user preferences, or "lessons learned" that should survive this session.
--   **Session:** Your thought process is automatically saved. If you crash or restart, review `thoughts_history.json`.
-
-## 🔄 The Golden Workflow
-
-1.  **Discovery:** `build_project_graph` -> `sequentialthinking` (Plan)
-2.  **Research:** `web_search` -> `read_webpage`
-3.  **Implementation:** `read_file` -> `sequentialthinking` (Refine) -> `edit_file`
-4.  **Verification:** `shell_execute` (Test/Build)
-5.  **Completion:** Final answer with summary of changes.
+## 🛠 PRECISION IMPLEMENTATION
+- PREFER 'deep_code_edit' for logical changes.
+- ALWAYS verify changes using 'shell_execute' (npm test, build, etc.).
 ```
 
 ---
 
-## 📦 Development
-
-```bash
-# Install dependencies
-npm install
-
-# Build the project
-npm run build
-
-# Run tests
-npm test
-```
-
 ## License
-MIT
+MIT - พัฒนาโดย @gotza02

package/dist/graph.js

@@ -173,6 +173,49 @@ export class ProjectKnowledgeGraph {
             symbols: node.symbols
         };
     }
+    getDeepContext(filePath) {
+        const absolutePath = path.resolve(this.rootDir, filePath);
+        let node = this.nodes.get(absolutePath);
+        if (!node) {
+            for (const [key, value] of this.nodes.entries()) {
+                if (key.endsWith(filePath)) {
+                    node = value;
+                    break;
+                }
+            }
+        }
+        if (!node)
+            return null;
+        const context = {
+            targetFile: {
+                path: path.relative(this.rootDir, node.path),
+                symbols: node.symbols
+            },
+            dependencies: [],
+            dependents: []
+        };
+        // Get symbols and paths for what this file imports
+        for (const imp of node.imports) {
+            const impNode = this.nodes.get(imp);
+            if (impNode) {
+                context.dependencies.push({
+                    path: path.relative(this.rootDir, impNode.path),
+                    symbols: impNode.symbols
+                });
+            }
+        }
+        // Get symbols and paths for what imports this file
+        for (const dep of node.importedBy) {
+            const depNode = this.nodes.get(dep);
+            if (depNode) {
+                context.dependents.push({
+                    path: path.relative(this.rootDir, depNode.path),
+                    symbols: depNode.symbols
+                });
+            }
+        }
+        return context;
+    }
     getSummary() {
         return {
             root: this.rootDir,

package/dist/index.js

@@ -9,9 +9,10 @@ import { registerWebTools } from './tools/web.js';
 import { registerFileSystemTools } from './tools/filesystem.js';
 import { registerGraphTools } from './tools/graph.js';
 import { registerNoteTools } from './tools/notes.js';
+import { registerCodingTools } from './tools/coding.js';
 const server = new McpServer({
     name: "sequential-thinking-server",
-    version: "2026.1.18",
+    version: "2026.2.3",
 });
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 const knowledgeGraph = new ProjectKnowledgeGraph();
@@ -22,6 +23,7 @@ registerWebTools(server);
 registerFileSystemTools(server);
 registerGraphTools(server, knowledgeGraph);
 registerNoteTools(server, notesManager);
+registerCodingTools(server, knowledgeGraph);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/coding.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export function registerCodingTools(server, graph) {
+    // 14. deep_code_analyze
+    server.tool("deep_code_analyze", "Generates a 'Codebase Context Document' for a specific file or task. This tool learns from the codebase structure and symbols to provide deep insights before coding.", {
+        filePath: z.string().describe("The file path to analyze as the center of context"),
+        taskDescription: z.string().optional().describe("Optional description of what you intend to do")
+    }, async ({ filePath, taskDescription }) => {
+        try {
+            const context = graph.getDeepContext(filePath);
+            if (!context) {
+                return { content: [{ type: "text", text: `Error: File '${filePath}' not found in graph. Run 'build_project_graph' first.` }], isError: true };
+            }
+            const fileContent = await fs.readFile(path.resolve(filePath), 'utf-8');
+            let doc = `--- CODEBASE CONTEXT DOCUMENT: ${filePath} ---\n\n`;
+            if (taskDescription) {
+                doc += `TASK: ${taskDescription}\n\n`;
+            }
+            doc += `FILE CONTENT:\n\`\`\`\n${fileContent}\n\`\`\`\n\n`;
+            doc += `EXPORTED SYMBOLS:\n${context.targetFile.symbols.join(', ')}\n\n`;
+            doc += `DEPENDENCIES (Used by this file):\n`;
+            context.dependencies.forEach(d => {
+                doc += `- ${d.path} (Symbols: ${d.symbols.join(', ')})\n`;
+            });
+            doc += `\nDEPENDENTS (Files that use this file):\n`;
+            context.dependents.forEach(d => {
+                doc += `- ${d.path} (Symbols: ${d.symbols.join(', ')})\n`;
+            });
+            doc += `\n--- END OF CONTEXT ---`;
+            return {
+                content: [{ type: "text", text: doc }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Analysis Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+        }
+    });
+    // 15. deep_code_edit
+    server.tool("deep_code_edit", "Apply a surgical code edit based on a 'Deepest Thinking' plan. Use this tool AFTER analyzing the codebase and formulating a thought sequence.", {
+        path: z.string().describe("Path to the file to edit"),
+        oldText: z.string().describe("The exact text to replace"),
+        newText: z.string().describe("The new code to insert"),
+        reasoning: z.string().describe("The 'Deepest Thinking' reasoning behind this change")
+    }, async ({ path: filePath, oldText, newText, reasoning }) => {
+        try {
+            const absolutePath = path.resolve(filePath);
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            if (!content.includes(oldText)) {
+                return { content: [{ type: "text", text: "Error: Target text not found. Ensure exact match including whitespace." }], isError: true };
+            }
+            const newContent = content.replace(oldText, newText);
+            await fs.writeFile(absolutePath, newContent, 'utf-8');
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully applied edit to ${filePath}.\nReasoning verified: ${reasoning}`
+                    }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Edit Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/thinking.js

@@ -1,9 +1,16 @@
 import { z } from "zod";
 export function registerThinkingTools(server, thinkingServer) {
     // --- Sequential Thinking Tool ---
-    server.tool("sequentialthinking", `A detailed tool for dynamic and reflective problem-solving through thoughts.
-This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
-Each thought can build on, question, or revise previous insights as understanding deepens.
+    server.tool("sequentialthinking", `A specialized tool for Deepest Thinking, providing dynamic and reflective problem-solving.
+This tool mandates a rigorous analysis process that adapts and evolves as understanding deepens.
+Use this tool ALWAYS for complex queries to ensure the most thorough and accurate solution.
+
+Deepest Thinking Requirements:
+- Mandatory Analysis: Break down problems into atomic requirements before generating solutions.
+- Mandatory Reflexion: Critique your own thoughts regularly to identify biases or errors.
+- Mandatory Branching: Explore alternative hypotheses (Conservative/Balanced/Aggressive) for critical decisions.
+- Dynamic Depth: Adjust total_thoughts as new complexities are discovered.
+- Correctness focus: Repeat the process until a verified, satisfactory answer is reached.
 
 When to use this tool:
 - Breaking down complex problems into steps
@@ -15,55 +22,30 @@ When to use this tool:
 - Situations where irrelevant information needs to be filtered out
 
 Key features:
-- You can adjust total_thoughts up or down as you progress
-- You can question or revise previous thoughts
-- You can add more thoughts even after reaching what seemed like the end
-- You can express uncertainty and explore alternative approaches
-- Not every thought needs to build linearly - you can branch or backtrack
-- Iterative Reasoning: Think step-by-step in a structured manner
-- Tree of Thoughts: Generate and evaluate multiple options (Conservative/Balanced/Aggressive)
-- Self-Critique: Check for risks, biases, and errors in thinking
-- Branch Merging: Combine insights from multiple divergent paths
-- Hypothesis Testing: Formulate and verify hypotheses
-- Generates a solution hypothesis
-- Verifies the hypothesis based on the Chain of Thought steps
-- Repeats the process until satisfied
-- Provides a correct answer
+- Tree of Thoughts: Generate and evaluate multiple options.
+- Self-Critique: Check for risks, biases, and errors in thinking.
+- Hypothesis Testing: Formulate and verify hypotheses based on Chain of Thought.
+- Branch Merging: Combine insights from multiple divergent paths.
 
 Parameters explained:
-- thought: Your current thinking step, which can include:
-  * Regular analytical steps
-  * Revisions of previous thoughts
-  * Questions about previous decisions
-  * Realizations about needing more analysis
-  * Changes in approach
-  * Hypothesis generation
-  * Hypothesis verification
-- nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end
-- thoughtNumber: Current number in sequence (can go beyond initial total if needed)
-- totalThoughts: Current estimate of thoughts needed (can be adjusted up/down)
-- isRevision: A boolean indicating if this thought revises previous thinking
-- revisesThought: If is_revision is true, which thought number is being reconsidered
-- branchFromThought: If branching, which thought number is the branching point
-- branchId: Identifier for the current branch (if any)
-- needsMoreThoughts: If reaching end but realizing more thoughts needed
-- thoughtType: The type of thought (analysis, generation, evaluation, reflexion, selection)
-- score: Score for evaluation (1-10)
-- options: List of options generated
-- selectedOption: The option selected
+- thought: Your current thinking step (analysis, revision, question, hypothesis).
+- nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end.
+- thoughtNumber: Current number in sequence.
+- totalThoughts: Current estimate of thoughts needed (can be adjusted).
+- isRevision: True if this thought revises previous thinking.
+- revisesThought: Which thought number is being reconsidered.
+- branchFromThought: The branching point thought number.
+- branchId: Identifier for the current branch.
+- thoughtType: The type of thought (analysis, generation, evaluation, reflexion, selection).
+- score: Score for evaluation (1-10).
+- options: List of options generated.
+- selectedOption: The option selected.
 
-You should:
-1. Start with an initial estimate of needed thoughts, but be ready to adjust
-2. Feel free to question or revise previous thoughts
-3. Don't hesitate to add more thoughts if needed, even at the "end"
-4. Express uncertainty when present
-5. Mark thoughts that revise previous thinking or branch into new paths
-6. Ignore information that is irrelevant to the current step
-7. Generate a solution hypothesis when appropriate
-8. Verify the hypothesis based on the Chain of Thought steps
-9. Repeat the process until satisfied with the solution
-10. Provide a single, ideally correct answer as the final output
-11. Only set nextThoughtNeeded to false when truly done and a satisfactory answer is reached`, {
+You MUST:
+1. Use thoughtType: 'analysis' for the first steps to map requirements.
+2. Use thoughtType: 'reflexion' frequently to validate logic.
+3. Use thoughtType: 'evaluation' and 'selection' when choosing between branches.
+4. Only set nextThoughtNeeded to false when the solution is definitive and fully verified.`, {
         thought: z.string().describe("Your current thinking step"),
         nextThoughtNeeded: z.boolean().describe("Whether another thought step is needed"),
         thoughtNumber: z.number().int().min(1).describe("Current thought number (numeric value, e.g., 1, 2, 3)"),

package/package.json

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