@gotza02/sequential-thinking 1.0.0

package/dist/lib.js

@@ -0,0 +1,189 @@
+import chalk from 'chalk';
+import * as fs from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
+import * as path from 'path';
+export class SequentialThinkingServer {
+    thoughtHistory = [];
+    branches = {};
+    disableThoughtLogging;
+    storagePath;
+    delayMs;
+    isSaving = false;
+    constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
+        this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
+        this.storagePath = path.resolve(storagePath);
+        this.delayMs = delayMs;
+        this.loadHistory();
+    }
+    loadHistory() {
+        try {
+            if (existsSync(this.storagePath)) {
+                const data = readFileSync(this.storagePath, 'utf-8');
+                const history = JSON.parse(data);
+                if (Array.isArray(history)) {
+                    this.thoughtHistory = []; // Reset to avoid duplicates
+                    this.branches = {};
+                    history.forEach(thought => this.addToMemory(thought));
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error loading history from ${this.storagePath}:`, error);
+        }
+    }
+    async saveHistory() {
+        if (this.isSaving) {
+            // Simple retry if already saving
+            setTimeout(() => this.saveHistory(), 100);
+            return;
+        }
+        this.isSaving = true;
+        try {
+            // Atomic write: write to tmp then rename
+            const tmpPath = `${this.storagePath}.tmp`;
+            await fs.writeFile(tmpPath, JSON.stringify(this.thoughtHistory, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.storagePath);
+        }
+        catch (error) {
+            console.error(`Error saving history to ${this.storagePath}:`, error);
+        }
+        finally {
+            this.isSaving = false;
+        }
+    }
+    async clearHistory() {
+        this.thoughtHistory = [];
+        this.branches = {};
+        await this.saveHistory();
+    }
+    async archiveHistory(startIndex, endIndex, summary) {
+        if (startIndex < 1 || endIndex > this.thoughtHistory.length || startIndex > endIndex) {
+            throw new Error(`Invalid range: ${startIndex} to ${endIndex}. History length is ${this.thoughtHistory.length}.`);
+        }
+        const summaryThought = {
+            thought: `SUMMARY [${startIndex}-${endIndex}]: ${summary}`,
+            thoughtNumber: startIndex,
+            totalThoughts: this.thoughtHistory[this.thoughtHistory.length - 1].totalThoughts - (endIndex - startIndex),
+            nextThoughtNeeded: true,
+            thoughtType: 'analysis'
+        };
+        // Remove the range and insert summary
+        const removedCount = endIndex - startIndex + 1;
+        this.thoughtHistory.splice(startIndex - 1, removedCount, summaryThought);
+        // Renumber subsequent thoughts
+        for (let i = startIndex; i < this.thoughtHistory.length; i++) {
+            this.thoughtHistory[i].thoughtNumber -= (removedCount - 1);
+        }
+        // Rebuild branches (simplification: clear and let it rebuild if needed, or just clear)
+        this.branches = {};
+        this.thoughtHistory.forEach(t => {
+            if (t.branchFromThought && t.branchId) {
+                const branchKey = `${t.branchFromThought}-${t.branchId}`;
+                if (!this.branches[branchKey])
+                    this.branches[branchKey] = [];
+                this.branches[branchKey].push(t);
+            }
+        });
+        await this.saveHistory();
+        return {
+            newHistoryLength: this.thoughtHistory.length,
+            summaryInsertedAt: startIndex
+        };
+    }
+    addToMemory(input) {
+        if (input.thoughtNumber > input.totalThoughts) {
+            input.totalThoughts = input.thoughtNumber;
+        }
+        this.thoughtHistory.push(input);
+        if (input.branchFromThought && input.branchId) {
+            const branchKey = `${input.branchFromThought}-${input.branchId}`;
+            if (!this.branches[branchKey]) {
+                this.branches[branchKey] = [];
+            }
+            this.branches[branchKey].push(input);
+        }
+    }
+    formatThought(thoughtData) {
+        const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId, thoughtType, score, options, selectedOption } = thoughtData;
+        let prefix = '';
+        let context = '';
+        if (thoughtType === 'reflexion' || isRevision) {
+            prefix = chalk.yellow('🔄 Reflexion');
+            if (revisesThought)
+                context += ` (revising thought ${revisesThought})`;
+        }
+        else if (thoughtType === 'generation') {
+            prefix = chalk.magenta('💡 Generation');
+        }
+        else if (thoughtType === 'evaluation') {
+            prefix = chalk.cyan('⚖️ Evaluation');
+            if (score)
+                context += ` (Score: ${score})`;
+        }
+        else if (thoughtType === 'selection') {
+            prefix = chalk.green('✅ Selection');
+            if (selectedOption)
+                context += ` (Selected: ${selectedOption})`;
+        }
+        else if (branchFromThought) {
+            prefix = chalk.green('🌿 Branch');
+            context = ` (from thought ${branchFromThought}, ID: ${branchId})`;
+        }
+        else {
+            prefix = chalk.blue('💭 Thought');
+            context = '';
+        }
+        const header = `${prefix} ${thoughtNumber}/${totalThoughts}${context}`;
+        const borderLength = Math.max(header.length, thought.length) + 4;
+        const border = '─'.repeat(borderLength);
+        let extraContent = '';
+        if (options && options.length > 0) {
+            extraContent += `
+│ Options:
+` + options.map(o => `│ - ${o}`).join('\n');
+        }
+        return `
+┌${border}┐
+│ ${header} │
+├${border}┤
+│ ${thought.padEnd(borderLength - 2)} │${extraContent}
+└${border}┘`;
+    }
+    async processThought(input) {
+        try {
+            if (this.delayMs > 0) {
+                await new Promise(resolve => setTimeout(resolve, this.delayMs));
+            }
+            this.addToMemory(input);
+            await this.saveHistory();
+            if (!this.disableThoughtLogging) {
+                const formattedThought = this.formatThought(input);
+                console.error(formattedThought);
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            thoughtNumber: input.thoughtNumber,
+                            totalThoughts: input.totalThoughts,
+                            nextThoughtNeeded: input.nextThoughtNeeded,
+                            branches: Object.keys(this.branches),
+                            thoughtHistoryLength: this.thoughtHistory.length
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            status: 'failed'
+                        }, null, 2)
+                    }],
+                isError: true
+            };
+        }
+    }
+}

package/dist/notes.js

@@ -0,0 +1,77 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class NotesManager {
+    filePath;
+    notes = [];
+    loaded = false;
+    constructor(storagePath = 'project_notes.json') {
+        this.filePath = path.resolve(storagePath);
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            this.notes = JSON.parse(data);
+        }
+        catch (error) {
+            // If file doesn't exist, start with empty array
+            this.notes = [];
+        }
+        this.loaded = true;
+    }
+    async save() {
+        await fs.writeFile(this.filePath, JSON.stringify(this.notes, null, 2), 'utf-8');
+    }
+    async addNote(title, content, tags = []) {
+        await this.load();
+        const note = {
+            id: Date.now().toString(36) + Math.random().toString(36).substring(2, 7),
+            title,
+            content,
+            tags,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        this.notes.push(note);
+        await this.save();
+        return note;
+    }
+    async listNotes(tag) {
+        await this.load();
+        if (tag) {
+            return this.notes.filter(n => n.tags.includes(tag));
+        }
+        return this.notes;
+    }
+    async searchNotes(query) {
+        await this.load();
+        const lowerQuery = query.toLowerCase();
+        return this.notes.filter(n => n.title.toLowerCase().includes(lowerQuery) ||
+            n.content.toLowerCase().includes(lowerQuery) ||
+            n.tags.some(t => t.toLowerCase().includes(lowerQuery)));
+    }
+    async deleteNote(id) {
+        await this.load();
+        const initialLength = this.notes.length;
+        this.notes = this.notes.filter(n => n.id !== id);
+        if (this.notes.length !== initialLength) {
+            await this.save();
+            return true;
+        }
+        return false;
+    }
+    async updateNote(id, updates) {
+        await this.load();
+        const index = this.notes.findIndex(n => n.id === id);
+        if (index === -1)
+            return null;
+        this.notes[index] = {
+            ...this.notes[index],
+            ...updates,
+            updatedAt: new Date().toISOString()
+        };
+        await this.save();
+        return this.notes[index];
+    }
+}

package/dist/repro_search.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+async function searchCodeLogic(pattern, searchPath = '.') {
+    try {
+        const resolvedPath = path.resolve(searchPath);
+        const stat = await fs.stat(resolvedPath);
+        if (stat.isFile()) {
+            const content = await fs.readFile(resolvedPath, 'utf-8');
+            if (content.includes(pattern)) {
+                return {
+                    content: [{ type: "text", text: `Found "${pattern}" in:\n${resolvedPath}` }]
+                };
+            }
+            else {
+                return {
+                    content: [{ type: "text", text: `No matches found for "${pattern}"` }]
+                };
+            }
+        }
+        async function searchDir(dir) {
+            const results = [];
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (['node_modules', '.git', 'dist', 'coverage', '.gemini'].includes(entry.name))
+                        continue;
+                    results.push(...await searchDir(fullPath));
+                }
+                else if (new RegExp('\\.(ts|js|json|md|txt|html|css|py|java|c|cpp|h|rs|go)$').test(entry.name)) {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    if (content.includes(pattern)) {
+                        results.push(fullPath);
+                    }
+                }
+            }
+            return results;
+        }
+        const matches = await searchDir(resolvedPath);
+        const joinedMatches = matches.join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: matches.length > 0 ? `Found "${pattern}" in:\n${joinedMatches}` : `No matches found for "${pattern}"`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Search Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+}
+describe('search_code tool', () => {
+    const testDir = path.join(__dirname, 'test_search_env');
+    beforeEach(async () => {
+        await fs.mkdir(testDir, { recursive: true });
+        await fs.writeFile(path.join(testDir, 'target.ts'), 'function myFunction() { return "found me"; }');
+        await fs.writeFile(path.join(testDir, 'other.ts'), 'const x = 10;');
+        await fs.mkdir(path.join(testDir, 'nested'), { recursive: true });
+        await fs.writeFile(path.join(testDir, 'nested', 'deep.ts'), 'export const secret = "found me too";');
+        await fs.mkdir(path.join(testDir, 'node_modules'), { recursive: true });
+        await fs.writeFile(path.join(testDir, 'node_modules', 'ignored.ts'), 'found me');
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    // ... (previous tests)
+    it('should handle single file path', async () => {
+        // This test will FAIL with current implementation (simulated here with the fix applied? No, I need to test failure first)
+        // Wait, I updated searchCodeLogic above with the FIX. 
+        // So this test checks if the FIX works.
+        const result = await searchCodeLogic('found me', path.join(testDir, 'target.ts'));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain('target.ts');
+    });
+});

package/dist/server.test.js

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

package/dist/tools/filesystem.js

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { execAsync } from "../utils.js";
+export function registerFileSystemTools(server) {
+    // 3. shell_execute
+    server.tool("shell_execute", "Execute a shell command. Use with caution.", {
+        command: z.string().describe("The bash command to execute")
+    }, async ({ command }) => {
+        try {
+            const { stdout, stderr } = await execAsync(command);
+            return {
+                content: [{
+                        type: "text",
+                        text: `STDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Shell Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 4. read_file
+    server.tool("read_file", "Read the contents of a file.", {
+        path: z.string().describe("Path to the file")
+    }, async ({ path }) => {
+        try {
+            const content = await fs.readFile(path, 'utf-8');
+            return {
+                content: [{ type: "text", text: content }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Read Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 5. write_file
+    server.tool("write_file", "Write content to a file (overwrites existing).", {
+        path: z.string().describe("Path to the file"),
+        content: z.string().describe("Content to write")
+    }, async ({ path, content }) => {
+        try {
+            await fs.writeFile(path, content, 'utf-8');
+            return {
+                content: [{ type: "text", text: `Successfully wrote to ${path}` }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Write Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 10. search_code
+    server.tool("search_code", "Search for a text pattern in project files (excludes node_modules, etc.).", {
+        pattern: z.string().describe("The text to search for"),
+        path: z.string().optional().default('.').describe("Root directory to search")
+    }, async ({ pattern, path: searchPath }) => {
+        try {
+            const resolvedPath = path.resolve(searchPath || '.');
+            const stats = await fs.stat(resolvedPath);
+            if (stats.isFile()) {
+                const content = await fs.readFile(resolvedPath, 'utf-8');
+                const matches = content.includes(pattern) ? [resolvedPath] : [];
+                return {
+                    content: [{
+                            type: "text",
+                            text: matches.length > 0 ? `Found "${pattern}" in:\n${matches.join('\n')}` : `No matches found for "${pattern}"`
+                        }]
+                };
+            }
+            async function searchDir(dir) {
+                const results = [];
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (['node_modules', '.git', 'dist', 'coverage', '.gemini'].includes(entry.name))
+                            continue;
+                        results.push(...await searchDir(fullPath));
+                    }
+                    else if (/\.(ts|js|json|md|txt|html|css|py|java|c|cpp|h|rs|go)$/.test(entry.name)) {
+                        const content = await fs.readFile(fullPath, 'utf-8');
+                        if (content.includes(pattern)) {
+                            results.push(fullPath);
+                        }
+                    }
+                }
+                return results;
+            }
+            const matches = await searchDir(resolvedPath);
+            return {
+                content: [{
+                        type: "text",
+                        text: matches.length > 0 ? `Found "${pattern}" in:\n${matches.join('\n')}` : `No matches found for "${pattern}"`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Search Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 13. edit_file
+    server.tool("edit_file", "Replace a specific string in a file with a new string. Use this for surgical edits to avoid overwriting the whole file.", {
+        path: z.string().describe("Path to the file"),
+        oldText: z.string().describe("The exact text segment to replace"),
+        newText: z.string().describe("The new text to insert"),
+        allowMultiple: z.boolean().optional().default(false).describe("Allow replacing multiple occurrences (default: false)")
+    }, async ({ path, oldText, newText, allowMultiple }) => {
+        try {
+            const content = await fs.readFile(path, 'utf-8');
+            // Check occurrences
+            // Escape special regex characters in oldText to treat it as literal string
+            const escapeRegExp = (string) => string.replace(/[.*+?^${}()|[\\]/g, '\\$&');
+            const regex = new RegExp(escapeRegExp(oldText), 'g');
+            const matchCount = (content.match(regex) || []).length;
+            if (matchCount === 0) {
+                return {
+                    content: [{ type: "text", text: "Error: 'oldText' not found in the file. Please ensure exact matching (including whitespace/indentation)." }],
+                    isError: true
+                };
+            }
+            if (matchCount > 1 && !allowMultiple) {
+                return {
+                    content: [{ type: "text", text: `Error: Found ${matchCount} occurrences of 'oldText'. Set 'allowMultiple' to true if you intend to replace all, or provide more unique context in 'oldText'.` }],
+                    isError: true
+                };
+            }
+            const newContent = content.replace(allowMultiple ? regex : oldText, newText);
+            await fs.writeFile(path, newContent, 'utf-8');
+            return {
+                content: [{ type: "text", text: `Successfully replaced ${allowMultiple ? matchCount : 1} occurrence(s) in ${path}` }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Edit Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/graph.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+export function registerGraphTools(server, knowledgeGraph) {
+    // 6. build_project_graph
+    server.tool("build_project_graph", "Scan the directory and build a dependency graph of the project (Analyzing imports/exports).", {
+        path: z.string().optional().default('.').describe("Root directory path to scan (default: current dir)")
+    }, async ({ path }) => {
+        try {
+            const result = await knowledgeGraph.build(path || '.');
+            return {
+                content: [{ type: "text", text: `Graph built successfully.\nNodes: ${result.nodeCount}\nTotal Scanned Files: ${result.totalFiles}` }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Graph Build Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 7. get_file_relationships
+    server.tool("get_file_relationships", "Get dependencies and references for a specific file from the built graph.", {
+        filePath: z.string().describe("Path to the file (e.g., 'src/index.ts')")
+    }, async ({ filePath }) => {
+        try {
+            const rel = knowledgeGraph.getRelationships(filePath);
+            if (!rel) {
+                return {
+                    content: [{ type: "text", text: `File not found in graph: ${filePath}. (Did you run 'build_project_graph'?)` }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(rel, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 8. get_project_graph_summary
+    server.tool("get_project_graph_summary", "Get a summary of the project structure (most referenced files, total count).", {}, async () => {
+        try {
+            const summary = knowledgeGraph.getSummary();
+            return {
+                content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 14. get_project_graph_visualization
+    server.tool("get_project_graph_visualization", "Get a Mermaid Diagram string representing the project's dependency graph. You can render this string in a Markdown viewer that supports Mermaid.", {}, async () => {
+        try {
+            const diagram = knowledgeGraph.toMermaid();
+            if (diagram.trim() === 'graph TD') {
+                return {
+                    content: [{ type: "text", text: "Graph is empty. Please run 'build_project_graph' first." }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: "text", text: diagram }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}