@gotza02/sequential-thinking 1.0.0

package/README.md

@@ -0,0 +1,262 @@
+# Sequential Thinking MCP Server
+
+MCP Server นี้ถูกออกแบบมาเพื่อช่วยให้ AI สามารถคิดวิเคราะห์แก้ปัญหาได้อย่างเป็นระบบ (Sequential Thinking) ผ่านกระบวนการคิดแบบทีละขั้นตอน (Step-by-step), การแตกแขนงความคิด (Tree of Thoughts) และการทบทวนตัวเอง (Self-Reflexion)
+
+## ฟีเจอร์หลัก (Features)
+
+- **การวิเคราะห์ตามลำดับ (Sequential Analysis)**: ย่อยปัญหาที่ซับซ้อนให้เป็นขั้นตอนย่อยๆ ที่จัดการได้ง่าย
+- **การให้เหตุผลแบบวนซ้ำ (Iterative Reasoning)**: คิดทีละขั้นตอนอย่างมีโครงสร้าง และปรับปรุงผลลัพธ์ผ่านการวนรอบ
+- **แตกแขนงความคิด (Tree of Thoughts)**: สร้างและประเมินทางเลือกหลายๆ ทาง (เช่น กลยุทธ์แบบระมัดระวัง, แบบสมดุล, หรือแบบกล้าเสี่ยง)
+- **การวิจารณ์ตัวเอง (Self-Critique)**: ตรวจสอบความเสี่ยง ข้อผิดพลาด และอคติในกระบวนการคิดอย่างสม่ำเสมอ
+- **รวมความคิด (Branch Merging)**: สังเคราะห์และรวบรวมข้อมูลเชิงลึกจากเส้นทางการคิดที่แตกต่างกัน
+- **การทดสอบสมมติฐาน (Hypothesis Testing)**: ตั้งสมมติฐานและตรวจสอบความถูกต้องด้วยหลักฐานหรือตรรกะ
+- **ประเมินทางเลือก (Option Evaluation)**: ให้คะแนนและชั่งน้ำหนักทางเลือกต่างๆ (`evaluation`) เพื่อช่วยตัดสินใจ
+- **ทบทวนตัวเอง (Self-Reflexion)**: ย้อนกลับไปแก้ไขความคิดก่อนหน้า (`reflexion`) เพื่อปรับปรุงความแม่นยำ
+- **ปรับเปลี่ยนแบบไดนามิก (Dynamic Adjustment)**: ปรับจำนวนขั้นตอนการคิดเพิ่มหรือลดได้ตามความเหมาะสมของสถานการณ์
+
+## คำแนะนำระบบสำหรับ AI (System Instruction)
+
+เมื่อเชื่อมต่อกับ Server นี้ AI ควรปฏิบัติตามแนวทางต่อไปนี้เพื่อให้แก้ปัญหาได้ดีที่สุด:
+
+1.  **การคิดแบบวนซ้ำ (Iterative Thinking)**: ใช้เครื่องมือ `sequentialthinking` สำหรับงานที่ซับซ้อน **อย่า** พยายามตอบทันที ให้แตกปัญหาเป็นขั้นตอน ตั้งสมมติฐาน และประเมินผล
+2.  **สำรวจบริบท (Context Discovery)**: ก่อนแก้ไขโค้ด ให้ใช้ `build_project_graph` ตามด้วย `get_project_graph_summary` เพื่อเข้าใจโครงสร้างโปรเจกต์เสมอ และใช้ `get_file_relationships` เพื่อดูความสัมพันธ์ของไฟล์
+3.  **ตรวจสอบข้อเท็จจริง (Fact Verification)**: ใช้ `web_search` เพื่อตรวจสอบข้อมูลล่าสุด, เวอร์ชั่นของ Library หรือเอกสาร และใช้ `fetch` เพื่อดึงข้อมูลดิบเมื่อจำเป็น
+4.  **รันคำสั่ง (Local Execution)**: ใช้ `shell_execute` เพื่อรัน Test, Linter หรือ Build เพื่อตรวจสอบความถูกต้องของการแก้ไข อ่านไฟล์ด้วย `read_file` ก่อนเขียนทับเสมอ
+5.  **ความต่อเนื่อง (Persistence)**: กระบวนการคิดจะถูกบันทึกอัตโนมัติ หากทำงานค้างไว้ สามารถย้อนกลับมาดูไฟล์ `thoughts_history.json` ได้
+
+## คู่มือการใช้งานเครื่องมือ (Detailed Tool Guide)
+
+### 🧠 เครื่องมือช่วยคิด (Cognitive Tools)
+
+#### `sequentialthinking`
+หัวใจหลักสำหรับการแก้ปัญหาอย่างมีโครงสร้าง บังคับให้คิดวิเคราะห์ทีละขั้นตอนก่อนจะสรุปผล
+
+**Inputs:**
+- `thought` (string, required): เนื้อหาของความคิดในขั้นตอนนี้
+- `thoughtNumber` (integer, required): ลำดับขั้นตอนปัจจุบัน (เริ่มที่ 1)
+- `totalThoughts` (integer, required): จำนวนขั้นตอนที่คาดว่าจะใช้ (ปรับเปลี่ยนได้ตลอด)
+- `nextThoughtNeeded` (boolean, required): `true` ถ้าต้องคิดต่อ, `false` เมื่อได้คำตอบสุดท้ายแล้ว
+- `thoughtType` (enum): ประเภทของความคิด:
+  - `analysis`: วิเคราะห์แยกแยะปัญหา
+  - `generation`: ระดมสมองหาทางออก
+  - `evaluation`: ประเมินทางเลือก (ใช้คู่กับ `score`)
+  - `reflexion`: ทบทวนความคิดก่อนหน้า (ใช้คู่กับ `isRevision`)
+  - `selection`: เลือกเส้นทางที่จะไปต่อ
+- `isRevision` (boolean): `true` ถ้ากำลังแก้ไขข้อผิดพลาดก่อนหน้า
+- `revisesThought` (integer): ระบุหมายเลขขั้นตอนที่กำลังแก้ไข
+- `branchFromThought` (integer): หมายเลขขั้นตอนแม่ ถ้าต้องการแตกกิ่งความคิดใหม่
+- `branchId` (string): ชื่อระบุของกิ่งความคิดนั้น (Branch ID)
+
+**ข้อแนะนำ:** ใช้เครื่องมือนี้กับงานทุกอย่างที่ไม่ใช่คำถามพื้นฐาน อย่าเพิ่งรีบตอบ ให้คิดก่อน
+
+#### `clear_thought_history`
+ล้างประวัติการคิดทั้งหมด ใช้เมื่อต้องการเริ่มงานใหม่หรือเคลียร์ Context
+
+#### `summarize_history`
+ย่อรวมความคิดหลายๆ ขั้นตอนให้เป็นสรุปเดียว จำเป็นมากสำหรับการคิดที่ยาวนาน เพื่อประหยัด Token
+
+**Inputs:**
+- `startIndex` (integer): จุดเริ่มต้นที่จะสรุป
+- `endIndex` (integer): จุดสิ้นสุดที่จะสรุป
+- `summary` (string): ข้อความสรุป
+
+### 🌐 ความรู้ภายนอก (External Knowledge)
+
+#### `web_search`
+ค้นหาข้อมูลแบบ Real-time จากอินเทอร์เน็ต
+
+**Inputs:**
+- `query` (string, required): คำค้นหา
+- `provider` (enum, optional):
+  - `brave`: ค้นหาเว็บทั่วไป (ต้องมี `BRAVE_API_KEY`)
+  - `exa`: ค้นหาเชิงลึกด้วย AI (ต้องมี `EXA_API_KEY`)
+  - `google`: Google Custom Search (ต้องมี `GOOGLE_SEARCH_API_KEY` & `GOOGLE_SEARCH_CX`)
+
+#### `fetch`
+ดึงข้อมูล HTTP Request จาก URL โดยตรง มีประโยชน์มากสำหรับดึง HTML, JSON หรือ Text จากแหล่งข้อมูลที่เจอผ่าน Search
+
+**Inputs:**
+- `url` (string, required): URL เป้าหมาย
+- `method`: `GET` (default), `POST`, `PUT`, `DELETE`
+- `headers`: JSON Object สำหรับ Headers
+- `body`: Request Body สำหรับ POST/PUT
+
+#### `read_webpage`
+อ่านหน้าเว็บและแปลงเป็น Markdown ที่สะอาด (ตัดโฆษณาและเมนูออก) เหมาะสำหรับอ่านบทความหรือ Document เพื่อประหยัด Token
+
+**Inputs:**
+- `url` (string, required): URL ที่จะอ่าน
+
+### 🏗 ความฉลาดด้านโค้ด (Codebase Intelligence)
+
+#### `build_project_graph`
+**รันคำสั่งนี้เป็นอันดับแรก** เมื่อเริ่มโปรเจกต์ใหม่ มันจะสแกนโฟลเดอร์และสร้างแผนผังความสัมพันธ์ (Dependency Graph) โดยใช้ TypeScript AST Analysis รวมถึงดึงข้อมูล **Exported Symbols** (Functions, Classes, Variables) ออกมาด้วย
+
+**Inputs:**
+- `path` (string, optional): โฟลเดอร์ราก (Default คือ `.`)
+
+#### `get_project_graph_summary`
+ดูภาพรวมโครงสร้างโปรเจกต์และไฟล์ที่ถูกอ้างอิงถึงบ่อยที่สุด
+
+#### `get_project_graph_visualization`
+สร้าง Mermaid Diagram String แสดงความสัมพันธ์ของไฟล์ในโปรเจกต์ สามารถนำไปแสดงผลใน Markdown Viewer ได้
+
+### 🛠 การจัดการระบบ (System Operations)
+
+#### `read_file`
+อ่านเนื้อหาไฟล์ **ควรอ่านไฟล์ก่อนแก้ไขเสมอ**
+
+**Inputs:**
+- `path` (string, required): Path ของไฟล์
+
+#### `write_file`
+สร้างหรือเขียนทับไฟล์
+
+**Inputs:**
+- `path` (string, required): Path ของไฟล์
+- `content` (string, required): เนื้อหาที่จะเขียน
+
+#### `edit_file`
+แก้ไขข้อความบางส่วนในไฟล์ (Search & Replace) เหมาะสำหรับการแก้ไขจุดเล็กๆ โดยไม่ต้องเขียนทับทั้งไฟล์
+
+**Inputs:**
+- `path` (string, required): Path ของไฟล์
+- `oldText` (string, required): ข้อความเดิมที่ต้องการเปลี่ยน (ต้องตรงเป๊ะ)
+- `newText` (string, required): ข้อความใหม่
+- `allowMultiple` (boolean, optional): อนุญาตให้เปลี่ยนหลายจุดพร้อมกัน (Default: false)
+
+#### `manage_notes`
+จัดการความจำระยะยาว (Long-term Memory) / บันทึกช่วยจำ ใช้เก็บข้อมูลสำคัญ กฎ หรือสิ่งที่เรียนรู้เพื่อให้จำได้ข้าม Session
+
+**Inputs:**
+- `action` (enum, required): 'add', 'list', 'search', 'update', 'delete'
+- `title` (string): หัวข้อ
+- `content` (string): เนื้อหา
+- `tags` (array): แท็กจัดหมวดหมู่
+- `searchQuery` (string): คำค้นหา (สำหรับ action: search)
+- `noteId` (string): ID ของโน้ต (สำหรับ update/delete)
+
+#### `shell_execute`
+รันคำสั่ง Shell (เช่น `npm test`, `npm run build`, `ls`)
+**คำเตือน:** ใช้ด้วยความระมัดระวัง หลีกเลี่ยงคำสั่งที่ลบข้อมูลหรือเปิดเผยความลับ
+
+## การตั้งค่าและการใช้งาน (Installation & Usage)
+
+### 1. การใช้งานกับ Gemini CLI (Usage with Gemini CLI)
+
+แก้ไขไฟล์ `~/.gemini/settings.json` (หรือ `config.json`):
+
+#### แบบใช้ npx (ไม่ต้องติดตั้ง)
+
+```json
+{
+  "mcpServers": {
+    "smartagent": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@gotza02/sequential-thinking"
+      ],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_BRAVE_API_KEY",
+        "EXA_API_KEY": "YOUR_EXA_API_KEY"
+      }
+    }
+  }
+}
+```
+
+#### แบบติดตั้ง Local (Node.js)
+
+1. Clone Repository นี้มา
+2. รัน `npm install` และ `npm run build`
+3. ตั้งค่าใน `settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "smartagent": {
+      "command": "node",
+      "args": [
+        "/path/to/your/MCP3/dist/index.js"
+      ],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_BRAVE_API_KEY",
+        "THOUGHTS_STORAGE_PATH": "thoughts_history.json",
+        "NOTES_STORAGE_PATH": "project_notes.json"
+      }
+    }
+  }
+}
+```
+
+### 2. การใช้งานกับ Claude Desktop (Usage with Claude Desktop)
+
+แก้ไขไฟล์ `claude_desktop_config.json`:
+
+#### แบบใช้ npx (ไม่ต้องติดตั้ง)
+
+```json
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@gotza02/sequential-thinking"
+      ],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_BRAVE_API_KEY"
+      }
+    }
+  }
+}
+```
+
+#### แบบติดตั้ง Local (Node.js)
+
+```json
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/MCP3/dist/index.js"
+      ],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_BRAVE_API_KEY",
+        "THOUGHTS_STORAGE_PATH": "/absolute/path/to/thoughts_history.json",
+        "NOTES_STORAGE_PATH": "/absolute/path/to/project_notes.json"
+      }
+    }
+  }
+}
+```
+
+## การ Build และ Test
+
+```bash
+npm install
+npm run build
+```
+
+```bash
+npm test
+```
+
+## ประวัติการอัปเดต (Recent Updates)
+
+### v1.0.0 (Major Release)
+- **First Stable Release**: เปิดตัวเวอร์ชั่นเสถียร 1.0.0 พร้อมเอกสารภาษาไทยสมบูรณ์
+- **Features Complete**: รวมฟีเจอร์ Sequential Thinking, Web Search, File System, Graph Analysis และ Memory ไว้ครบถ้วน
+
+### v2026.2.0 (Refactoring)
+- **Refactoring**: ปรับโครงสร้างโค้ดครั้งใหญ่ แยกการทำงานเป็นโมดูล (`src/tools/`) เพื่อให้อ่านง่ายและรองรับการขยายตัวในอนาคต
+
+### v2026.1.31
+- **New Tools**:
+  - `manage_notes`: ระบบความจำระยะยาวสำหรับเก็บข้อมูลข้าม Session
+
+## License
+
+MIT License

package/dist/graph.js

@@ -0,0 +1,214 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import ts from 'typescript';
+export class ProjectKnowledgeGraph {
+    nodes = new Map();
+    rootDir = '';
+    constructor() { }
+    async build(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.nodes.clear();
+        const files = await this.getAllFiles(this.rootDir);
+        // Step 1: Initialize nodes
+        for (const file of files) {
+            this.nodes.set(file, {
+                path: file,
+                imports: [],
+                importedBy: [],
+                symbols: []
+            });
+        }
+        // Step 2: Parse imports and build edges
+        for (const file of files) {
+            await this.parseFile(file);
+        }
+        return {
+            nodeCount: this.nodes.size,
+            totalFiles: files.length
+        };
+    }
+    async getAllFiles(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const files = [];
+        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')
+                    continue;
+                files.push(...await this.getAllFiles(res));
+            }
+            else {
+                if (/\.(ts|js|tsx|jsx|json)$/.test(entry.name)) {
+                    files.push(res);
+                }
+            }
+        }
+        return files;
+    }
+    async parseFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+            const imports = [];
+            const symbols = [];
+            const visit = (node) => {
+                // --- Symbols (Exports) ---
+                if (ts.isFunctionDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`function:${node.name.text}`);
+                }
+                else if (ts.isClassDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`class:${node.name.text}`);
+                }
+                else if (ts.isVariableStatement(node)) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported) {
+                        node.declarationList.declarations.forEach(d => {
+                            if (ts.isIdentifier(d.name))
+                                symbols.push(`var:${d.name.text}`);
+                        });
+                    }
+                }
+                // --- Imports ---
+                if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+                    if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                        imports.push(node.moduleSpecifier.text);
+                    }
+                }
+                // 2. Dynamic imports: import('...')
+                else if (ts.isCallExpression(node)) {
+                    if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
+                        const arg = node.arguments[0];
+                        if (ts.isStringLiteral(arg)) {
+                            imports.push(arg.text);
+                        }
+                    }
+                    // 3. CommonJS: require('...')
+                    else if (ts.isIdentifier(node.expression) && node.expression.text === 'require' && node.arguments.length > 0) {
+                        const arg = node.arguments[0];
+                        if (ts.isStringLiteral(arg)) {
+                            imports.push(arg.text);
+                        }
+                    }
+                }
+                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);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error parsing file ${filePath}:`, error);
+        }
+    }
+    async resolvePath(dir, relativePath) {
+        const absolutePath = path.resolve(dir, relativePath);
+        // 1. Try exact match
+        if (this.nodes.has(absolutePath)) {
+            return absolutePath;
+        }
+        // 2. Try appending extensions
+        const extensions = ['.ts', '.js', '.tsx', '.jsx', '.json', '/index.ts', '/index.js'];
+        for (const ext of extensions) {
+            const p = absolutePath + ext;
+            if (this.nodes.has(p)) {
+                return p;
+            }
+        }
+        // 3. Try handling .js -> .ts mapping (ESM style imports)
+        if (absolutePath.endsWith('.js')) {
+            const tsPath = absolutePath.replace(/\.js$/, '.ts');
+            if (this.nodes.has(tsPath))
+                return tsPath;
+            const tsxPath = absolutePath.replace(/\.js$/, '.tsx');
+            if (this.nodes.has(tsxPath))
+                return tsxPath;
+            const jsxPath = absolutePath.replace(/\.js$/, '.jsx');
+            if (this.nodes.has(jsxPath))
+                return jsxPath;
+        }
+        return null;
+    }
+    getRelationships(filePath) {
+        const absolutePath = path.resolve(this.rootDir, filePath);
+        // Try to match exact or with extensions
+        let node = this.nodes.get(absolutePath);
+        if (!node) {
+            // Fallback search
+            for (const [key, value] of this.nodes.entries()) {
+                if (key.endsWith(filePath)) {
+                    node = value;
+                    break;
+                }
+            }
+        }
+        if (!node)
+            return null;
+        return {
+            path: node.path,
+            imports: node.imports.map(p => path.relative(this.rootDir, p)),
+            importedBy: node.importedBy.map(p => path.relative(this.rootDir, p)),
+            symbols: node.symbols
+        };
+    }
+    getSummary() {
+        return {
+            root: this.rootDir,
+            fileCount: this.nodes.size,
+            mostReferencedFiles: [...this.nodes.values()]
+                .sort((a, b) => b.importedBy.length - a.importedBy.length)
+                .slice(0, 5)
+                .map(n => ({
+                file: path.relative(this.rootDir, n.path),
+                referencedBy: n.importedBy.length
+            }))
+        };
+    }
+    toMermaid() {
+        const lines = ['graph TD'];
+        const fileToId = new Map();
+        let idCounter = 0;
+        // Assign IDs
+        for (const [filePath, _] of this.nodes) {
+            const relative = path.relative(this.rootDir, filePath);
+            const id = `N${idCounter++}`;
+            fileToId.set(filePath, id);
+            // Escape quotes in label
+            const label = relative.replace(/"/g, "'");
+            lines.push(`  ${id}["${label}"]`);
+        }
+        // Add Edges
+        for (const [filePath, node] of this.nodes) {
+            const sourceId = fileToId.get(filePath);
+            for (const importPath of node.imports) {
+                const targetId = fileToId.get(importPath);
+                if (sourceId && targetId) {
+                    lines.push(`  ${sourceId} --> ${targetId}`);
+                }
+            }
+        }
+        return lines.join('\\n');
+    }
+}

package/dist/graph.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('ProjectKnowledgeGraph', () => {
+    let graph;
+    beforeEach(() => {
+        graph = new ProjectKnowledgeGraph();
+        vi.resetAllMocks();
+    });
+    it('should ignore imports in comments', async () => {
+        const mockFiles = ['/app/index.ts', '/app/utils.ts', '/app/oldUtils.ts'];
+        const mockContentIndex = `
+            import { something } from './utils';
+            // import { oldThing } from './oldUtils';
+            /* import { other } from './other' */
+        `;
+        const mockContentUtils = 'export const something = 1;';
+        fs.readdir.mockResolvedValue([
+            { name: 'index.ts', isDirectory: () => false },
+            { name: 'utils.ts', isDirectory: () => false },
+            { name: 'oldUtils.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (path) => {
+            if (path.includes('index.ts'))
+                return mockContentIndex;
+            return '';
+        });
+        // Mock resolvePath behavior indirectly by mocking existing files check in graph.build logic
+        // But since graph.ts uses fs.readdir recursively, we need to mock that structure.
+        // For simplicity in this unit test, we'll mock 'getAllFiles' if it were public, 
+        // but since it's private, we have to mock fs structure carefully or rely on the implementation.
+        // Let's rely on the fact that build calls getAllFiles which calls readdir.
+        // We need to ensure 'utils.ts' and 'oldUtils.ts' resolution is tested.
+        // Actually, since we mock readFile, the file existence check in resolvePath uses "this.nodes.has".
+        // "this.nodes" is populated by getAllFiles.
+        // So we need getAllFiles to return both index.ts and utils.ts.
+        // And NOT oldUtils.ts so we can see if it tries to resolve it?
+        // Actually, if it tries to resolve 'oldUtils', it might fail if not in nodes.
+        // But the bug is that it SHOULD NOT even try to resolve 'oldUtils' because it's commented out.
+        await graph.build('/app');
+        const relationships = graph.getRelationships('/app/index.ts');
+        expect(relationships?.imports).toContain('utils.ts');
+        expect(relationships?.imports).not.toContain('oldUtils.ts');
+    });
+    it('should resolve .js imports to .ts files', async () => {
+        const mockContentIndex = `import { something } from './lib.js';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'index.ts', isDirectory: () => false },
+            { name: 'lib.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('index.ts'))
+                return mockContentIndex;
+            return '';
+        });
+        await graph.build('/app');
+        const relationships = graph.getRelationships('/app/index.ts');
+        // The output of getRelationships.imports is relative paths.
+        // If imports ./lib.js, and we have lib.ts, it should resolve to /app/lib.ts
+        // And path.relative('/app', '/app/lib.ts') is 'lib.ts'
+        expect(relationships?.imports).toContain('lib.ts');
+    });
+    it('should resolve .js imports to .jsx files', async () => {
+        const mockContentIndex = `import { Button } from './Button.js';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'index.js', isDirectory: () => false },
+            { name: 'Button.jsx', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('index.js'))
+                return mockContentIndex;
+            return '';
+        });
+        await graph.build('/app');
+        const relationships = graph.getRelationships('/app/index.js');
+        expect(relationships?.imports).toContain('Button.jsx');
+    });
+});

package/dist/graph_repro.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('ProjectKnowledgeGraph Reproduction', () => {
+    let graph;
+    beforeEach(() => {
+        graph = new ProjectKnowledgeGraph();
+        vi.resetAllMocks();
+    });
+    it('should resolve absolute imports from project root', async () => {
+        // Scenario: /app/src/feature/a.ts imports 'src/shared/b.ts'
+        const mockContentA = `import { b } from 'src/shared/b';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'src', isDirectory: () => true },
+            { name: 'feature', isDirectory: () => true },
+            { name: 'shared', isDirectory: () => true },
+            { name: 'a.ts', isDirectory: () => false },
+            { name: 'b.ts', isDirectory: () => false }
+        ]);
+        // Mock getAllFiles behavior by manually setting up the file system structure conceptually
+        // Since getAllFiles is recursive and hard to mock perfectly with just readdir,
+        // we'll focus on the result of getAllFiles which populates the graph.
+        // Wait, the test uses the REAL getAllFiles, so we must mock readdir correctly.
+        // Let's simplify: Flat structure for test.
+        // Root: /app
+        // Files: /app/a.ts, /app/b.ts
+        // a.ts content: "import ... from 'b'" (no dot)
+        // OR
+        // a.ts content: "import ... from 'app/b'" (if root is /)
+        // Let's try the 'src/...' pattern which is common.
+        // Root: /root
+        // File: /root/src/index.ts -> imports 'src/utils'
+        // File: /root/src/utils.ts
+        const rootDir = '/root';
+        const indexFile = '/root/src/index.ts';
+        const utilsFile = '/root/src/utils.ts';
+        // Mock readdir to simulate:
+        // /root -> [src]
+        // /root/src -> [index.ts, utils.ts]
+        fs.readdir.mockImplementation(async (dir) => {
+            if (dir === '/root')
+                return [{ name: 'src', isDirectory: () => true }];
+            if (dir === '/root/src')
+                return [
+                    { name: 'index.ts', isDirectory: () => false },
+                    { name: 'utils.ts', isDirectory: () => false }
+                ];
+            return [];
+        });
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath === indexFile)
+                return `import { u } from 'src/utils';`;
+            return '';
+        });
+        await graph.build(rootDir);
+        const relationships = graph.getRelationships(indexFile);
+        // We expect 'src/utils.ts' to be in imports.
+        // Note: graph.getRelationships returns relative paths.
+        // relative('/root', '/root/src/utils.ts') -> 'src/utils.ts'
+        expect(relationships?.imports).toContain('src/utils.ts');
+    });
+});

package/dist/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SequentialThinkingServer } from './lib.js';
+import { ProjectKnowledgeGraph } from './graph.js';
+import { NotesManager } from './notes.js';
+import { registerThinkingTools } from './tools/thinking.js';
+import { registerWebTools } from './tools/web.js';
+import { registerFileSystemTools } from './tools/filesystem.js';
+import { registerGraphTools } from './tools/graph.js';
+import { registerNoteTools } from './tools/notes.js';
+const server = new McpServer({
+    name: "sequential-thinking-server",
+    version: "2026.1.18",
+});
+const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
+const knowledgeGraph = new ProjectKnowledgeGraph();
+const notesManager = new NotesManager(process.env.NOTES_STORAGE_PATH || 'project_notes.json');
+// Register tools
+registerThinkingTools(server, thinkingServer);
+registerWebTools(server);
+registerFileSystemTools(server);
+registerGraphTools(server, knowledgeGraph);
+registerNoteTools(server, notesManager);
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Sequential Thinking MCP Server (Extended) running on stdio");
+}
+runServer().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});