@gotza02/sequential-thinking 2026.2.2 → 2026.2.4

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,45 @@ 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"
-         }
-       }
-     }
-   }
-   ```
+## 🤖 Recommended System Instruction (The Ultimate Deep Engineer)
 
----
-
-## 🛠️ 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 ที่คุณใช้งาน:
-
-```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.
+ให้ Copy ข้อความด้านล่างนี้ไปใส่ใน **System Prompt** ของ AI Agent เพื่อประสิทธิภาพสูงสุด:
 
-## 🧠 PRIME DIRECTIVE: Sequential Thinking
+```markdown
+# 🤖 System Instruction: Ultimate Deep Engineer (Sequential Thinking Extended)
 
-**Rule #1: NEVER answer complex queries immediately.**
-You MUST use the `sequentialthinking` tool to structure your reasoning process.
+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.
 
-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.
+## 🧠 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.
 
-**Constraints:**
--   Do not output code until you have a clear plan.
--   If you are unsure, generate a hypothesis and verify it.
+## 🏗 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.
 
-## 🏗 Codebase Intelligence Protocol
+## 💻 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.
 
-**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.
+## 🛡 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.
 
-**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.
+## 📝 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.
 ```
 
 ---
 
-## 📦 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.4",
 });
 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.4",
   "publishConfig": {
     "access": "public"
   },