@gotza02/sequential-thinking 2026.1.17 → 2026.1.18

package/README.md

@@ -127,6 +127,13 @@ npm run build
 npm test
 ```
 
+## Recent Updates (v2026.1.18)
+
+- **Bug Fixes**:
+  - Fixed an issue where commented-out imports were incorrectly parsed by the graph analyzer.
+  - Resolved a branching logic issue where branch IDs could collide.
+  - Fixed version mismatch between package.json and server instance.
+
 ## License
 
 This MCP server is licensed under the MIT License.

package/dist/graph.js

@@ -45,7 +45,12 @@ export class ProjectKnowledgeGraph {
     }
     async parseFile(filePath) {
         try {
-            const content = await fs.readFile(filePath, 'utf-8');
+            let content = await fs.readFile(filePath, 'utf-8');
+            // Remove comments before parsing imports
+            // 1. Remove block comments /* ... */
+            content = content.replace(/\/\*[\s\S]*?\*\//g, '');
+            // 2. Remove line comments // ...
+            content = content.replace(/\/\/.*$/gm, '');
             const importRegex = /import\s+(?:[\w\s{},*]+from\s+)?['"]([^'"]+)['"]/g;
             const dynamicImportRegex = /import\(['"]([^'"]+)['"]\)/g;
             const requireRegex = /require\(['"]([^'"]+)['"]\)/g;

package/dist/graph.test.js

@@ -0,0 +1,46 @@
+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');
+    });
+});

package/dist/index.js

@@ -10,7 +10,7 @@ import { ProjectKnowledgeGraph } from './graph.js';
 const execAsync = promisify(exec);
 const server = new McpServer({
     name: "sequential-thinking-server",
-    version: "0.2.0",
+    version: "2026.1.18",
 });
 const thinkingServer = new SequentialThinkingServer();
 const knowledgeGraph = new ProjectKnowledgeGraph();

package/dist/lib.js

@@ -59,10 +59,11 @@ export class SequentialThinkingServer {
             }
             this.thoughtHistory.push(input);
             if (input.branchFromThought && input.branchId) {
-                if (!this.branches[input.branchId]) {
-                    this.branches[input.branchId] = [];
+                const branchKey = `${input.branchFromThought}-${input.branchId}`;
+                if (!this.branches[branchKey]) {
+                    this.branches[branchKey] = [];
                 }
-                this.branches[input.branchId].push(input);
+                this.branches[branchKey].push(input);
             }
             if (!this.disableThoughtLogging) {
                 const formattedThought = this.formatThought(input);

package/dist/server.test.js

@@ -39,7 +39,7 @@ describe('SequentialThinkingServer', () => {
         };
         const result1 = server.processThought(branch1Input);
         const content1 = JSON.parse(result1.content[0].text);
-        expect(content1.branches).toContain("branch-A");
+        expect(content1.branches).toContain("1-branch-A");
         // Branch 2
         const branch2Input = {
             thought: "Alternative B",
@@ -52,7 +52,7 @@ describe('SequentialThinkingServer', () => {
         };
         const result2 = server.processThought(branch2Input);
         const content2 = JSON.parse(result2.content[0].text);
-        expect(content2.branches).toContain("branch-B");
+        expect(content2.branches).toContain("1-branch-B");
         expect(content2.branches.length).toBe(2);
     });
     it('should handle evaluation with scores', () => {

package/package.json

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