@gotza02/sequential-thinking 10000.0.0 → 10000.0.2

package/dist/graph.test.js

@@ -0,0 +1,150 @@
+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();
+        // Default mocks for stat and writeFile
+        fs.stat.mockResolvedValue({
+            isDirectory: () => true,
+            mtimeMs: 1000
+        });
+        fs.writeFile.mockResolvedValue(undefined);
+    });
+    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('graph_cache.json'))
+                return '{}'; // Mock empty cache
+            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.includes('graph_cache.json'))
+                return '{}';
+            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.includes('graph_cache.json'))
+                return '{}';
+            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');
+    });
+    it('should handle circular dependencies', async () => {
+        const contentA = `import { b } from './b'; export const a = 1;`;
+        const contentB = `import { a } from './a'; export const b = 2;`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false },
+            { name: 'b.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            if (filePath.endsWith('b.ts'))
+                return contentB;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        const relB = graph.getRelationships('/app/b.ts');
+        expect(relA?.imports).toContain('b.ts');
+        expect(relA?.importedBy).toContain('b.ts');
+        expect(relB?.imports).toContain('a.ts');
+        expect(relB?.importedBy).toContain('a.ts');
+    });
+    it('should gracefully handle missing imports', async () => {
+        const contentA = `import { ghost } from './ghost';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        // ghost.ts doesn't exist, so imports should be empty (filtered out)
+        expect(relA?.imports).toHaveLength(0);
+    });
+    it('should ignore directory traversal attempts outside root', async () => {
+        // If we pretend root is /app, and we try to import ../outside
+        const contentA = `import { secret } from '../secret';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        // Should be empty because '../secret' is not in the scanned file list (nodes)
+        expect(relA?.imports).toHaveLength(0);
+    });
+});

package/dist/graph_extra.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/graph_extra.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+describe('ProjectKnowledgeGraph - Extra Coverage', () => {
+    let tempDir;
+    let graph;
+    beforeEach(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-extra-test-'));
+        graph = new ProjectKnowledgeGraph();
+    });
+    afterEach(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    it('should parse Python files correctly', async () => {
+        const pyFile = path.join(tempDir, 'script.py');
+        const content = `
+import os
+import sys, time
+from .local_mod import func
+from package.module import Class
+
+class MyClass:
+    pass
+
+def my_func():
+    pass
+`;
+        await fs.writeFile(pyFile, content);
+        await fs.writeFile(path.join(tempDir, 'local_mod.py'), 'def func(): pass');
+        await graph.build(tempDir);
+        const rel = graph.getRelationships('script.py');
+        expect(rel?.symbols).toContain('class:MyClass');
+        expect(rel?.symbols).toContain('def:my_func');
+        expect(rel?.imports).toContain('os');
+        expect(rel?.imports).toContain('sys');
+        expect(rel?.imports).toContain('local_mod.py');
+    });
+    it('should parse Go files correctly', async () => {
+        const goFile = path.join(tempDir, 'main.go');
+        const content = `
+package main
+import "fmt"
+import (
+    "os"
+    "net/http"
+)
+
+type MyStruct struct {}
+type MyInterface interface {}
+
+func main() {}
+`;
+        await fs.writeFile(goFile, content);
+        await graph.build(tempDir);
+        const rel = graph.getRelationships('main.go');
+        expect(rel?.symbols).toContain('type:MyStruct');
+        expect(rel?.symbols).toContain('type:MyInterface');
+        expect(rel?.symbols).toContain('func:main');
+        expect(rel?.imports).toContain('fmt');
+        expect(rel?.imports).toContain('os');
+        expect(rel?.imports).toContain('net/http');
+    });
+    it('should handle broken relative imports gracefully', async () => {
+        const tsFile = path.join(tempDir, 'index.ts');
+        await fs.writeFile(tsFile, "import { x } from './non_existent';");
+        await graph.build(tempDir);
+        const rel = graph.getRelationships('index.ts');
+        // Should not contain the broken path since it's relative but missing
+        expect(rel?.imports).not.toContain('./non_existent');
+    });
+    it('should generate Mermaid visualization', async () => {
+        await fs.writeFile(path.join(tempDir, 'a.ts'), "import './b';");
+        await fs.writeFile(path.join(tempDir, 'b.ts'), "export const b = 1;");
+        await graph.build(tempDir);
+        const mermaid = graph.toMermaid();
+        expect(mermaid).toContain('graph TD');
+        expect(mermaid).toContain('["a.ts"]');
+        expect(mermaid).toContain('["b.ts"]');
+        expect(mermaid).toContain('-->');
+    });
+    it('should provide deep context', async () => {
+        await fs.writeFile(path.join(tempDir, 'util.ts'), "export const u = 1;");
+        await fs.writeFile(path.join(tempDir, 'main.ts'), "import {u} from './util'; export const m = 2;");
+        await fs.writeFile(path.join(tempDir, 'app.ts'), "import {m} from './main';");
+        await graph.build(tempDir);
+        const context = graph.getDeepContext('main.ts');
+        expect(context?.targetFile.path).toBe('main.ts');
+        expect(context?.dependencies[0].path).toBe('util.ts');
+        expect(context?.dependents[0].path).toBe('app.ts');
+    });
+});

package/dist/graph_repro.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/graph_repro.test.js

@@ -0,0 +1,50 @@
+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();
+        // Default mock for stat
+        fs.stat.mockResolvedValue({
+            isDirectory: () => true,
+            mtimeMs: Date.now()
+        });
+    });
+    it('should resolve absolute imports from project root', async () => {
+        // Scenario: /app/src/feature/a.ts imports 'src/shared/b.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 '';
+        });
+        // Mock stat for specific files
+        fs.stat.mockImplementation(async (filePath) => {
+            if (filePath === rootDir)
+                return { isDirectory: () => true, mtimeMs: 100 };
+            return { isDirectory: () => false, mtimeMs: 100 };
+        });
+        await graph.build(rootDir);
+        const relationships = graph.getRelationships(indexFile);
+        // We expect 'src/utils.ts' to be in imports.
+        expect(relationships?.imports).toContain('src/utils.ts');
+    });
+});

package/dist/human.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/human.test.js

@@ -0,0 +1,221 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HumanInteractionManager, getHumanManager } from './tools/human.js';
+describe('Human-in-the-Loop Manager', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new HumanInteractionManager();
+    });
+    describe('createInteraction', () => {
+        it('should create a confirmation interaction', async () => {
+            const interaction = await manager.createInteraction({
+                questionType: 'confirmation',
+                urgency: 'high',
+                question: 'ต้องการลบ Database จริงหรือไม่?',
+                context: 'Database มี 1000 records',
+                defaultOption: 'No'
+            });
+            expect(interaction.id).toMatch(/^hitl_\d+_[a-z0-9]+$/);
+            expect(interaction.questionType).toBe('confirmation');
+            expect(interaction.urgency).toBe('high');
+            expect(interaction.question).toBe('ต้องการลบ Database จริงหรือไม่?');
+            expect(interaction.status).toBe('pending');
+            expect(interaction.defaultOption).toBe('No');
+        });
+        it('should create a choice interaction with options', async () => {
+            const interaction = await manager.createInteraction({
+                questionType: 'choice',
+                urgency: 'medium',
+                question: 'เลือก Framework ที่ต้องการใช้',
+                options: ['React', 'Vue', 'Angular', 'Svelte']
+            });
+            expect(interaction.questionType).toBe('choice');
+            expect(interaction.options).toEqual(['React', 'Vue', 'Angular', 'Svelte']);
+        });
+        it('should create an input interaction', async () => {
+            const interaction = await manager.createInteraction({
+                questionType: 'input',
+                urgency: 'low',
+                question: 'ต้องการตั้งชื่อ function ว่าอะไร?'
+            });
+            expect(interaction.questionType).toBe('input');
+            expect(interaction.urgency).toBe('low');
+        });
+        it('should create a review interaction', async () => {
+            const interaction = await manager.createInteraction({
+                questionType: 'review',
+                urgency: 'critical',
+                question: 'กรุณาตรวจสอบ PR นี้ก่อน merge',
+                context: 'PR #123: Refactor authentication module'
+            });
+            expect(interaction.questionType).toBe('review');
+            expect(interaction.urgency).toBe('critical');
+        });
+    });
+    describe('recordResponse', () => {
+        it('should record response for existing interaction', async () => {
+            const interaction = await manager.createInteraction({
+                questionType: 'confirmation',
+                urgency: 'high',
+                question: 'Proceed?'
+            });
+            const updated = manager.recordResponse(interaction.id, 'Yes');
+            expect(updated).not.toBeNull();
+            expect(updated?.status).toBe('answered');
+            expect(updated?.response).toBe('Yes');
+            expect(updated?.respondedAt).toBeDefined();
+        });
+        it('should return null for non-existent interaction', () => {
+            const result = manager.recordResponse('invalid_id', 'response');
+            expect(result).toBeNull();
+        });
+    });
+    describe('getPendingInteractions', () => {
+        it('should return only pending interactions', async () => {
+            const i1 = await manager.createInteraction({
+                questionType: 'confirmation',
+                urgency: 'low',
+                question: 'Question 1'
+            });
+            const i2 = await manager.createInteraction({
+                questionType: 'input',
+                urgency: 'high',
+                question: 'Question 2'
+            });
+            // Answer first one
+            manager.recordResponse(i1.id, 'Yes');
+            const pending = manager.getPendingInteractions();
+            expect(pending.length).toBe(1);
+            expect(pending[0].id).toBe(i2.id);
+        });
+        it('should sort by urgency (critical first)', async () => {
+            await manager.createInteraction({
+                questionType: 'input',
+                urgency: 'low',
+                question: 'Low priority'
+            });
+            await manager.createInteraction({
+                questionType: 'confirmation',
+                urgency: 'critical',
+                question: 'Critical priority'
+            });
+            await manager.createInteraction({
+                questionType: 'choice',
+                urgency: 'medium',
+                question: 'Medium priority',
+                options: ['A', 'B']
+            });
+            const pending = manager.getPendingInteractions();
+            expect(pending[0].urgency).toBe('critical');
+            expect(pending[1].urgency).toBe('medium');
+            expect(pending[2].urgency).toBe('low');
+        });
+    });
+    describe('getHistory', () => {
+        it('should return all interactions sorted by time (newest first)', async () => {
+            await manager.createInteraction({
+                questionType: 'input',
+                urgency: 'low',
+                question: 'First'
+            });
+            await new Promise(resolve => setTimeout(resolve, 10));
+            await manager.createInteraction({
+                questionType: 'input',
+                urgency: 'low',
+                question: 'Second'
+            });
+            const history = manager.getHistory();
+            expect(history.length).toBe(2);
+            expect(history[0].question).toBe('Second');
+            expect(history[1].question).toBe('First');
+        });
+        it('should respect limit parameter', async () => {
+            for (let i = 0; i < 5; i++) {
+                await manager.createInteraction({
+                    questionType: 'input',
+                    urgency: 'low',
+                    question: `Question ${i}`
+                });
+            }
+            const history = manager.getHistory(3);
+            expect(history.length).toBe(3);
+        });
+    });
+    describe('formatInteraction', () => {
+        it('should format interaction with all details', async () => {
+            const interaction = await manager.createInteraction({
+                questionType: 'choice',
+                urgency: 'high',
+                question: 'Which option?',
+                context: 'This is important',
+                options: ['Option A', 'Option B'],
+                defaultOption: 'Option A'
+            });
+            const formatted = manager.formatInteraction(interaction);
+            expect(formatted).toContain('HUMAN INPUT REQUIRED');
+            expect(formatted).toContain('HIGH');
+            expect(formatted).toContain('Which option?');
+            expect(formatted).toContain('This is important');
+            expect(formatted).toContain('Option A');
+            expect(formatted).toContain('Option B');
+            expect(formatted).toContain('(default)');
+            expect(formatted).toContain(interaction.id);
+        });
+    });
+    describe('clearOldInteractions', () => {
+        it('should clear interactions older than specified hours', async () => {
+            // Create interaction with old timestamp (manually set)
+            const interaction = await manager.createInteraction({
+                questionType: 'input',
+                urgency: 'low',
+                question: 'Old question'
+            });
+            // Since we can't easily mock time, just verify the method doesn't crash
+            const cleared = manager.clearOldInteractions(0); // Clear everything older than 0 hours
+            // The interaction we just created should still be there (it's not old enough)
+            // This is more of a smoke test
+            expect(typeof cleared).toBe('number');
+        });
+    });
+    describe('Collaborative Workflow', () => {
+        it('should support full collaborative workflow', async () => {
+            // Step 1: AI asks for confirmation before destructive action
+            const deleteConfirm = await manager.createInteraction({
+                questionType: 'confirmation',
+                urgency: 'critical',
+                question: 'กำลังจะลบ production database ทั้งหมด ต้องการดำเนินการต่อหรือไม่?',
+                context: 'Database: prod-db-001, Size: 500GB, Records: 10M',
+                defaultOption: 'No'
+            });
+            expect(deleteConfirm.status).toBe('pending');
+            // Step 2: Human responds "No"
+            manager.recordResponse(deleteConfirm.id, 'No');
+            // Step 3: AI asks for alternative approach
+            const alternative = await manager.createInteraction({
+                questionType: 'choice',
+                urgency: 'medium',
+                question: 'ต้องการดำเนินการอย่างไรแทน?',
+                options: [
+                    'Backup แล้วค่อยลบ',
+                    'ลบเฉพาะ records ที่เก่ากว่า 1 ปี',
+                    'ยกเลิกทั้งหมด'
+                ]
+            });
+            // Step 4: Human selects option
+            manager.recordResponse(alternative.id, 'Backup แล้วค่อยลบ');
+            // Verify workflow
+            const history = manager.getHistory();
+            expect(history.length).toBe(2);
+            const answered = history.filter(i => i.status === 'answered');
+            expect(answered.length).toBe(2);
+            expect(answered.find(i => i.id === deleteConfirm.id)?.response).toBe('No');
+            expect(answered.find(i => i.id === alternative.id)?.response).toBe('Backup แล้วค่อยลบ');
+        });
+    });
+});
+describe('getHumanManager singleton', () => {
+    it('should return the same instance', () => {
+        const manager1 = getHumanManager();
+        const manager2 = getHumanManager();
+        expect(manager1).toBe(manager2);
+    });
+});

package/dist/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// We need to import the register functions to get the callbacks, 
+// but we can just use the classes directly for this integration logic test.
+// Actually, testing the *interaction* via the tool layer is better.
+import { registerThinkingTools } from './tools/thinking.js';
+import { registerGraphTools } from './tools/graph.js';
+import { registerNoteTools } from './tools/notes.js';
+describe('Integration Workflow', () => {
+    let toolCallbacks = {};
+    const mockServer = {
+        tool: (name, desc, schema, cb) => {
+            toolCallbacks[name] = cb;
+        }
+    };
+    // Mocks
+    const mockThinking = { processThought: vi.fn(), clearHistory: vi.fn() };
+    const mockGraph = { build: vi.fn(), getRelationships: vi.fn() };
+    const mockNotes = { addNote: vi.fn() };
+    beforeEach(() => {
+        toolCallbacks = {};
+        registerThinkingTools(mockServer, mockThinking);
+        registerGraphTools(mockServer, mockGraph);
+        registerNoteTools(mockServer, mockNotes);
+        vi.clearAllMocks();
+    });
+    it('should support a full analysis workflow', async () => {
+        // Step 1: Start Thinking
+        mockThinking.processThought.mockResolvedValue({
+            content: [{ type: "text", text: "Thought processed" }]
+        });
+        await toolCallbacks['sequentialthinking']({
+            thought: "Analyze architecture",
+            thoughtNumber: 1,
+            totalThoughts: 5,
+            nextThoughtNeeded: true,
+            thoughtType: 'analysis'
+        });
+        expect(mockThinking.processThought).toHaveBeenCalledWith(expect.objectContaining({
+            thought: "Analyze architecture"
+        }));
+        // Step 2: Build Graph
+        mockGraph.build.mockResolvedValue({ nodeCount: 10, totalFiles: 20 });
+        await toolCallbacks['build_project_graph']({ path: '.' });
+        expect(mockGraph.build).toHaveBeenCalled();
+        // Step 3: Get Relationships
+        mockGraph.getRelationships.mockReturnValue({ imports: ['utils.ts'] });
+        const relResult = await toolCallbacks['get_file_relationships']({ filePath: 'src/index.ts' });
+        expect(JSON.parse(relResult.content[0].text).imports).toContain('utils.ts');
+        // Step 4: Add Note
+        mockNotes.addNote.mockResolvedValue({ id: '123', title: 'Arch Note' });
+        await toolCallbacks['manage_notes']({
+            action: 'add',
+            title: 'Architecture Review',
+            content: 'Found circular deps'
+        });
+        expect(mockNotes.addNote).toHaveBeenCalledWith('Architecture Review', 'Found circular deps', undefined, undefined, undefined);
+    });
+});

package/dist/knowledge.test.d.ts

@@ -0,0 +1 @@
+export {};