@gotza02/sequential-thinking 2026.2.19 → 2026.2.21

package/dist/server.test.js

@@ -1,127 +0,0 @@
-import { describe, it, expect, beforeEach, afterAll } from 'vitest';
-import { SequentialThinkingServer } from './lib.js';
-import * as fs from 'fs';
-describe('SequentialThinkingServer', () => {
-    let server;
-    const testStoragePath = 'test_thoughts.json';
-    beforeEach(() => {
-        if (fs.existsSync(testStoragePath)) {
-            fs.unlinkSync(testStoragePath);
-        }
-        server = new SequentialThinkingServer(testStoragePath);
-    });
-    afterAll(() => {
-        if (fs.existsSync(testStoragePath)) {
-            fs.unlinkSync(testStoragePath);
-        }
-    });
-    it('should process a basic linear thought', async () => {
-        const input = {
-            thought: "First step",
-            thoughtNumber: 1,
-            totalThoughts: 3,
-            nextThoughtNeeded: true,
-            thoughtType: 'analysis'
-        };
-        const result = await server.processThought(input);
-        expect(result.isError).toBeUndefined();
-        const content = JSON.parse(result.content[0].text);
-        expect(content.thoughtNumber).toBe(1);
-        expect(content.thoughtHistoryLength).toBe(1);
-    });
-    it('should handle branching correctly', async () => {
-        // Initial thought
-        await server.processThought({
-            thought: "Root thought",
-            thoughtNumber: 1,
-            totalThoughts: 3,
-            nextThoughtNeeded: true
-        });
-        // Branch 1
-        const branch1Input = {
-            thought: "Alternative A",
-            thoughtNumber: 2,
-            totalThoughts: 3,
-            nextThoughtNeeded: true,
-            branchFromThought: 1,
-            branchId: "branch-A",
-            thoughtType: 'generation'
-        };
-        const result1 = await server.processThought(branch1Input);
-        const content1 = JSON.parse(result1.content[0].text);
-        expect(content1.branches).toContain("1-branch-A");
-        // Branch 2
-        const branch2Input = {
-            thought: "Alternative B",
-            thoughtNumber: 2,
-            totalThoughts: 3,
-            nextThoughtNeeded: true,
-            branchFromThought: 1,
-            branchId: "branch-B",
-            thoughtType: 'generation'
-        };
-        const result2 = await server.processThought(branch2Input);
-        const content2 = JSON.parse(result2.content[0].text);
-        expect(content2.branches).toContain("1-branch-B");
-        expect(content2.branches.length).toBe(2);
-    });
-    it('should handle evaluation with scores', async () => {
-        const input = {
-            thought: "Evaluating option X",
-            thoughtNumber: 3,
-            totalThoughts: 5,
-            nextThoughtNeeded: true,
-            thoughtType: 'evaluation',
-            score: 8,
-            options: ['Option X', 'Option Y']
-        };
-        const result = await server.processThought(input);
-        expect(result.isError).toBeUndefined();
-        // Since we don't return the score in the simple JSON response (only in logs or history),
-        // we mainly check that it doesn't crash and processes correctly.
-        // If we exposed history in the response, we could check that too.
-    });
-    it('should adjust totalThoughts if thoughtNumber exceeds it', async () => {
-        const input = {
-            thought: "Unexpected long process",
-            thoughtNumber: 6,
-            totalThoughts: 5,
-            nextThoughtNeeded: true
-        };
-        const result = await server.processThought(input);
-        const content = JSON.parse(result.content[0].text);
-        expect(content.totalThoughts).toBe(6);
-    });
-    it('should clear thought history', async () => {
-        await server.processThought({
-            thought: "To be forgotten",
-            thoughtNumber: 1,
-            totalThoughts: 1,
-            nextThoughtNeeded: false
-        });
-        await server.clearHistory();
-        // Since we can't easily peek into private state, we'll process a new thought
-        // and check if thoughtHistoryLength is 1 (meaning it started over or is just this one)
-        const result = await server.processThought({
-            thought: "Fresh start",
-            thoughtNumber: 1,
-            totalThoughts: 1,
-            nextThoughtNeeded: false
-        });
-        const content = JSON.parse(result.content[0].text);
-        expect(content.thoughtHistoryLength).toBe(1);
-    });
-    it('should summarize history correctly', async () => {
-        // Add 3 thoughts
-        await server.processThought({ thought: "T1", thoughtNumber: 1, totalThoughts: 3, nextThoughtNeeded: true });
-        await server.processThought({ thought: "T2", thoughtNumber: 2, totalThoughts: 3, nextThoughtNeeded: true });
-        await server.processThought({ thought: "T3", thoughtNumber: 3, totalThoughts: 3, nextThoughtNeeded: false });
-        const result = await server.archiveHistory(1, 2, "Summary of T1 and T2");
-        expect(result.newHistoryLength).toBe(2); // Summary + T3
-        expect(result.summaryInsertedAt).toBe(1);
-    });
-    it('should throw error when summarizing invalid range', async () => {
-        await server.processThought({ thought: "T1", thoughtNumber: 1, totalThoughts: 1, nextThoughtNeeded: false });
-        await expect(server.archiveHistory(1, 5, "Invalid")).rejects.toThrow();
-    });
-});

package/dist/stress.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { SequentialThinkingServer } from './lib.js';
-import { ProjectKnowledgeGraph } from './graph.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-// Mock fs for graph test
-vi.mock('fs/promises', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        readdir: vi.fn(),
-        readFile: vi.fn(),
-        writeFile: vi.fn(),
-        rename: vi.fn(),
-        unlink: vi.fn()
-    };
-});
-// Mock existsSync and readFileSync from 'fs' (non-promise) for SequentialThinkingServer
-vi.mock('fs', async () => {
-    return {
-        existsSync: () => false,
-        readFileSync: () => '[]',
-        unlinkSync: () => { }
-    };
-});
-describe('Stress Testing', () => {
-    it('should handle 1000 sequential thoughts', async () => {
-        // We use a real instance but mocked fs
-        const server = new SequentialThinkingServer('stress_thoughts.json');
-        const startTime = Date.now();
-        for (let i = 1; i <= 1000; i++) {
-            await server.processThought({
-                thought: `Thought ${i}`,
-                thoughtNumber: i,
-                totalThoughts: 1000,
-                nextThoughtNeeded: i < 1000
-            });
-        }
-        const duration = Date.now() - startTime;
-        console.log(`Processed 1000 thoughts in ${duration}ms`);
-        expect(duration).toBeLessThan(10000); // Should be fast enough (< 10s)
-    });
-    it('should handle large graph construction', async () => {
-        const graph = new ProjectKnowledgeGraph();
-        // Mock 1000 files
-        const files = Array.from({ length: 1000 }, (_, i) => `file${i}.ts`);
-        // Mock readdir to return these files (recursively? no, just flat for stress test)
-        // logic in getAllFiles is recursive. We need to mock it to return all at once or handle recursion.
-        // Actually, ProjectKnowledgeGraph.getAllFiles calls readdir.
-        // Let's mock readdir to return files for root, and then nothing for subdirs.
-        fs.readdir.mockImplementation(async (dir) => {
-            if (dir === path.resolve('.')) {
-                return files.map(f => ({
-                    name: f,
-                    isDirectory: () => false
-                }));
-            }
-            return [];
-        });
-        fs.readFile.mockResolvedValue("import { x } from './file0';");
-        const startTime = Date.now();
-        const result = await graph.build('.');
-        const duration = Date.now() - startTime;
-        console.log(`Built graph of ${result.totalFiles} files in ${duration}ms`);
-        expect(result.totalFiles).toBe(1000);
-        expect(duration).toBeLessThan(5000);
-    });
-});

package/dist/utils.test.js

@@ -1,40 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { validatePath } from './utils.js';
-import * as path from 'path';
-describe('Utils: validatePath', () => {
-    // Mock process.cwd to be a known fixed path
-    const mockCwd = '/app/project';
-    beforeEach(() => {
-        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should allow paths within the project root', () => {
-        const p = validatePath('src/index.ts');
-        expect(p).toBe(path.resolve(mockCwd, 'src/index.ts'));
-    });
-    it('should allow explicit ./ paths', () => {
-        const p = validatePath('./package.json');
-        expect(p).toBe(path.resolve(mockCwd, 'package.json'));
-    });
-    it('should block traversal to parent directory', () => {
-        expect(() => {
-            validatePath('../outside.txt');
-        }).toThrow(/Access denied/);
-    });
-    it('should block multiple level traversal', () => {
-        expect(() => {
-            validatePath('src/../../etc/passwd');
-        }).toThrow(/Access denied/);
-    });
-    it('should block absolute paths outside root', () => {
-        // Only run this check if we can reliably simulate absolute paths
-        // For now, let's assume standard unix paths for the test logic
-        if (path.sep === '/') {
-            expect(() => {
-                validatePath('/etc/passwd');
-            }).toThrow(/Access denied/);
-        }
-    });
-});

package/dist/verify_cache.test.js

@@ -1,27 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ProjectKnowledgeGraph } from './graph.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-describe('Graph Caching Verification', () => {
-    it('should use cache on second run', async () => {
-        const graph = new ProjectKnowledgeGraph();
-        const root = process.cwd();
-        // Cleanup existing cache
-        const cachePath = path.join(root, '.gemini_graph_cache.json');
-        try {
-            await fs.unlink(cachePath);
-        }
-        catch (e) { }
-        console.log('--- Run 1 (Fresh) ---');
-        const res1 = await graph.build(root);
-        console.log('Result 1:', res1);
-        expect(res1.parsedFiles).toBeGreaterThan(0);
-        expect(res1.cachedFiles).toBe(0);
-        console.log('--- Run 2 (Cached) ---');
-        const res2 = await graph.build(root);
-        console.log('Result 2:', res2);
-        expect(res2.parsedFiles).toBe(0);
-        expect(res2.cachedFiles).toBeGreaterThan(0);
-        expect(res2.nodeCount).toBe(res1.nodeCount);
-    });
-});

package/dist/verify_edit.test.js

@@ -1,66 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-// Replicating the logic from src/index.ts for testing
-async function editFileLogic(path, oldText, newText, allowMultiple = false) {
-    try {
-        const content = await fs.readFile(path, 'utf-8');
-        const escapeRegExp = (string) => string.replace(/[.*+?^${}()|[\\]/g, '\\$&');
-        const regex = new RegExp(escapeRegExp(oldText), 'g');
-        const matchCount = (content.match(regex) || []).length;
-        if (matchCount === 0) {
-            return { error: "Error: 'oldText' not found" };
-        }
-        if (matchCount > 1 && !allowMultiple) {
-            return { error: `Error: Found ${matchCount} occurrences` };
-        }
-        const newContent = content.replace(allowMultiple ? regex : oldText, newText);
-        await fs.writeFile(path, newContent, 'utf-8');
-        return { success: true };
-    }
-    catch (error) {
-        return { error: String(error) };
-    }
-}
-describe('edit_file logic', () => {
-    const testFile = path.join(__dirname, 'test_edit.txt');
-    beforeEach(async () => {
-        await fs.writeFile(testFile, 'Line 1\nTarget\nLine 3\nTarget again');
-    });
-    afterEach(async () => {
-        try {
-            await fs.unlink(testFile);
-        }
-        catch { }
-    });
-    it('should replace single occurrence', async () => {
-        await fs.writeFile(testFile, 'Line 1\nUnique\nLine 3');
-        const result = await editFileLogic(testFile, 'Unique', 'Replaced');
-        expect(result.error).toBeUndefined();
-        const content = await fs.readFile(testFile, 'utf-8');
-        expect(content).toContain('Line 1\nReplaced\nLine 3');
-    });
-    it('should fail if text not found', async () => {
-        const result = await editFileLogic(testFile, 'Missing', 'New');
-        expect(result.error).toContain("not found");
-    });
-    it('should fail if multiple found and allowMultiple=false', async () => {
-        const result = await editFileLogic(testFile, 'Target', 'New');
-        expect(result.error).toContain("Found 2 occurrences");
-    });
-    it('should replace multiple if allowMultiple=true', async () => {
-        const result = await editFileLogic(testFile, 'Target', 'New', true);
-        expect(result.error).toBeUndefined();
-        const content = await fs.readFile(testFile, 'utf-8');
-        expect(content).toBe('Line 1\nNew\nLine 3\nNew again');
-    });
-    it('should handle special regex characters in text', async () => {
-        await fs.writeFile(testFile, 'func(a, b) { return a+b; }');
-        const oldText = 'func(a, b) { return a+b; }';
-        const newText = 'replacement';
-        const result = await editFileLogic(testFile, oldText, newText);
-        expect(result.error).toBeUndefined();
-        const content = await fs.readFile(testFile, 'utf-8');
-        expect(content).toBe('replacement');
-    });
-});

package/dist/verify_notes.test.js

@@ -1,36 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { NotesManager } from './notes.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-describe('Notes Manager', () => {
-    const testFile = path.join(__dirname, 'test_notes.json');
-    let manager;
-    beforeEach(async () => {
-        manager = new NotesManager(testFile);
-    });
-    afterEach(async () => {
-        try {
-            await fs.unlink(testFile);
-        }
-        catch { }
-    });
-    it('should add and list notes', async () => {
-        await manager.addNote("My Note", "Content", ["tag1"]);
-        const notes = await manager.listNotes();
-        expect(notes.length).toBe(1);
-        expect(notes[0].title).toBe("My Note");
-    });
-    it('should search notes', async () => {
-        await manager.addNote("React Tips", "Use hooks", ["react"]);
-        await manager.addNote("Vue Tips", "Use composition", ["vue"]);
-        const results = await manager.searchNotes("hooks");
-        expect(results.length).toBe(1);
-        expect(results[0].title).toBe("React Tips");
-    });
-    it('should delete note', async () => {
-        const note = await manager.addNote("To Delete", "...");
-        await manager.deleteNote(note.id);
-        const notes = await manager.listNotes();
-        expect(notes.length).toBe(0);
-    });
-});

package/dist/verify_viz.test.js

@@ -1,25 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { ProjectKnowledgeGraph } from './graph.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-describe('Graph Visualization', () => {
-    const testDir = path.join(__dirname, 'test_viz_env');
-    const graph = new ProjectKnowledgeGraph();
-    beforeEach(async () => {
-        await fs.mkdir(testDir, { recursive: true });
-        await fs.writeFile(path.join(testDir, 'a.ts'), 'import { b } from "./b";');
-        await fs.writeFile(path.join(testDir, 'b.ts'), 'export const b = 1;');
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    it('should generate mermaid diagram', async () => {
-        await graph.build(testDir);
-        const mermaid = graph.toMermaid();
-        console.log("Generated Mermaid:", mermaid);
-        expect(mermaid).toContain('graph TD');
-        expect(mermaid).toMatch(/N\d+\["a\.ts"\]/);
-        expect(mermaid).toMatch(/N\d+\["b\.ts"\]/);
-        expect(mermaid).toContain('-->');
-    });
-});

package/dist/web_fallback.test.js

@@ -1,103 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { registerWebTools } from './tools/web.js';
-import * as utils from './utils.js';
-// Mock utils
-vi.mock('./utils.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        fetchWithRetry: vi.fn(),
-    };
-});
-describe('web_search fallback', () => {
-    let mockToolCallback;
-    const mockServer = {
-        tool: vi.fn((name, desc, schema, callback) => {
-            if (name === 'web_search') {
-                mockToolCallback = callback;
-            }
-        })
-    };
-    const originalEnv = process.env;
-    beforeEach(() => {
-        process.env = { ...originalEnv };
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    it('should use Brave if configured and no provider specified', async () => {
-        process.env.BRAVE_API_KEY = 'test-brave-key';
-        delete process.env.EXA_API_KEY;
-        delete process.env.GOOGLE_SEARCH_API_KEY;
-        registerWebTools(mockServer);
-        const mockResponse = {
-            ok: true,
-            json: async () => ({ web: { results: ['brave result'] } })
-        };
-        utils.fetchWithRetry.mockResolvedValue(mockResponse);
-        const result = await mockToolCallback({ query: 'test' });
-        expect(utils.fetchWithRetry).toHaveBeenCalledWith(expect.stringContaining('api.search.brave.com'), expect.anything());
-        expect(result.isError).toBeUndefined();
-        expect(JSON.parse(result.content[0].text)).toEqual(['brave result']);
-    });
-    it('should fallback to Exa if Brave fails', async () => {
-        process.env.BRAVE_API_KEY = 'test-brave-key';
-        process.env.EXA_API_KEY = 'test-exa-key';
-        registerWebTools(mockServer);
-        // First call (Brave) fails
-        utils.fetchWithRetry
-            .mockResolvedValueOnce({ ok: false, statusText: 'Brave Error', status: 500 })
-            // Second call (Exa) succeeds
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ results: ['exa result'] })
-        });
-        const result = await mockToolCallback({ query: 'test' });
-        expect(utils.fetchWithRetry).toHaveBeenCalledTimes(2);
-        // 1. Brave
-        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(1, expect.stringContaining('api.search.brave.com'), expect.anything());
-        // 2. Exa
-        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(2, expect.stringContaining('api.exa.ai'), expect.anything());
-        expect(result.isError).toBeUndefined();
-        expect(JSON.parse(result.content[0].text)).toEqual(['exa result']);
-    });
-    it('should respect requested provider and verify its availability', async () => {
-        process.env.BRAVE_API_KEY = 'test-brave-key';
-        // Exa not configured
-        delete process.env.EXA_API_KEY;
-        registerWebTools(mockServer);
-        const result = await mockToolCallback({ query: 'test', provider: 'exa' });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("Requested provider 'exa' is not configured");
-    });
-    it('should try requested provider first, then fallback', async () => {
-        process.env.BRAVE_API_KEY = 'test-brave-key';
-        process.env.EXA_API_KEY = 'test-exa-key';
-        registerWebTools(mockServer);
-        // Request Exa
-        // Mock Exa fail, Brave success
-        utils.fetchWithRetry
-            .mockResolvedValueOnce({ ok: false, statusText: 'Exa Error', status: 500 })
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ web: { results: ['brave result'] } })
-        });
-        const result = await mockToolCallback({ query: 'test', provider: 'exa' });
-        expect(utils.fetchWithRetry).toHaveBeenCalledTimes(2);
-        // 1. Exa (requested)
-        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(1, expect.stringContaining('api.exa.ai'), expect.anything());
-        // 2. Brave (fallback)
-        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(2, expect.stringContaining('api.search.brave.com'), expect.anything());
-        expect(result.isError).toBeUndefined();
-    });
-    it('should return error if all fail', async () => {
-        process.env.BRAVE_API_KEY = 'test-brave-key';
-        registerWebTools(mockServer);
-        utils.fetchWithRetry.mockResolvedValue({ ok: false, statusText: 'Some Error', status: 500 });
-        const result = await mockToolCallback({ query: 'test' });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("All search providers failed");
-        expect(result.content[0].text).toContain("Brave API error");
-    });
-});

package/dist/web_read.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { registerWebTools } from './tools/web.js';
-import * as utils from './utils.js';
-vi.mock('./utils.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        fetchWithRetry: vi.fn(),
-        validatePublicUrl: vi.fn(),
-    };
-});
-describe('read_webpage tool', () => {
-    let mockToolCallback;
-    const mockServer = {
-        tool: vi.fn((name, desc, schema, callback) => {
-            if (name === 'read_webpage') {
-                mockToolCallback = callback;
-            }
-        })
-    };
-    beforeEach(() => {
-        vi.clearAllMocks();
-        registerWebTools(mockServer);
-    });
-    it('should convert HTML to Markdown', async () => {
-        const mockHtml = `
-            <html>
-                <head><title>Test Article</title></head>
-                <body>
-                    <h1>Main Header</h1>
-                    <p>Paragraph <b>bold</b>.</p>
-                </body>
-            </html>
-        `;
-        utils.fetchWithRetry.mockResolvedValue({
-            ok: true,
-            text: async () => mockHtml
-        });
-        utils.validatePublicUrl.mockResolvedValue(undefined);
-        const result = await mockToolCallback({ url: 'https://example.com' });
-        expect(result.isError).toBeUndefined();
-        const content = result.content[0].text;
-        expect(content).toContain("Title: Test Article");
-        expect(content).toContain("Main Header");
-        expect(content).toContain("**bold**"); // Markdown bold
-    });
-    it('should handle private URL validation error', async () => {
-        utils.validatePublicUrl.mockRejectedValue(new Error("Access denied: Private IP"));
-        const result = await mockToolCallback({ url: 'http://localhost' });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("Access denied");
-    });
-    it('should handle fetch errors', async () => {
-        utils.validatePublicUrl.mockResolvedValue(undefined);
-        utils.fetchWithRetry.mockRejectedValue(new Error("Network Error"));
-        const result = await mockToolCallback({ url: 'https://example.com' });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("Network Error");
-    });
-});