@gotza02/sequential-thinking 2026.1.22 → 2026.1.24

package/README.md

@@ -103,7 +103,7 @@ The Sequential Thinking tool is designed for:
 
 ### Usage with Claude Desktop
 
-Add this to your `claude_desktop_config.json`:
+Add this to your `claude_desktop_config.json`. You can configure API keys directly here:
 
 #### npx
 
@@ -115,7 +115,13 @@ Add this to your `claude_desktop_config.json`:
       "args": [
         "-y",
         "@gotza02/sequential-thinking"
-      ]
+      ],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_BRAVE_API_KEY",
+        "EXA_API_KEY": "YOUR_EXA_API_KEY",
+        "GOOGLE_SEARCH_API_KEY": "YOUR_GOOGLE_SEARCH_API_KEY",
+        "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_SEARCH_CX"
+      }
     }
   }
 }
@@ -140,6 +146,11 @@ npm run build
 npm test
 ```
 
+## Recent Updates (v2026.1.24)
+
+- **Bug Fixes**:
+  - Fixed `get_file_relationships` to correctly resolve absolute imports and imports from project root (e.g., `src/utils`), ensuring the dependency graph is complete for projects using path aliases or absolute paths.
+
 ## Recent Updates (v2026.1.22)
 
 - **Environment Variables**:

package/dist/graph.js

@@ -79,15 +79,19 @@ export class ProjectKnowledgeGraph {
             if (!currentNode)
                 return;
             for (const importPath of imports) {
+                let resolvedPath = null;
                 if (importPath.startsWith('.')) {
-                    const resolvedPath = await this.resolvePath(path.dirname(filePath), 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);
-                        }
+                    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);
                     }
                 }
             }

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/package.json

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