@gotza02/sequential-thinking 1.0.0

package/dist/tools/notes.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export function registerNoteTools(server, notesManager) {
+    // 15. manage_notes
+    server.tool("manage_notes", "Manage long-term memory/notes. Use this to save important information, rules, or learnings that should persist across sessions.", {
+        action: z.enum(['add', 'list', 'search', 'update', 'delete']).describe("Action to perform"),
+        title: z.string().optional().describe("Title of the note (for add/update)"),
+        content: z.string().optional().describe("Content of the note (for add/update)"),
+        tags: z.array(z.string()).optional().describe("Tags for categorization (for add/update)"),
+        searchQuery: z.string().optional().describe("Query to search notes (for search)"),
+        noteId: z.string().optional().describe("ID of the note (for update/delete)")
+    }, async ({ action, title, content, tags, searchQuery, noteId }) => {
+        try {
+            switch (action) {
+                case 'add':
+                    if (!title || !content) {
+                        return { content: [{ type: "text", text: "Error: 'title' and 'content' are required for add action." }], isError: true };
+                    }
+                    const newNote = await notesManager.addNote(title, content, tags);
+                    return { content: [{ type: "text", text: `Note added successfully.\nID: ${newNote.id}` }] };
+                case 'list':
+                    const notes = await notesManager.listNotes();
+                    return { content: [{ type: "text", text: JSON.stringify(notes, null, 2) }] };
+                case 'search':
+                    if (!searchQuery) {
+                        return { content: [{ type: "text", text: "Error: 'searchQuery' is required for search action." }], isError: true };
+                    }
+                    const searchResults = await notesManager.searchNotes(searchQuery);
+                    return { content: [{ type: "text", text: searchResults.length > 0 ? JSON.stringify(searchResults, null, 2) : "No matching notes found." }] };
+                case 'update':
+                    if (!noteId) {
+                        return { content: [{ type: "text", text: "Error: 'noteId' is required for update action." }], isError: true };
+                    }
+                    const updatedNote = await notesManager.updateNote(noteId, { title, content, tags });
+                    if (!updatedNote) {
+                        return { content: [{ type: "text", text: `Error: Note with ID ${noteId} not found.` }], isError: true };
+                    }
+                    return { content: [{ type: "text", text: `Note updated successfully.` }] };
+                case 'delete':
+                    if (!noteId) {
+                        return { content: [{ type: "text", text: "Error: 'noteId' is required for delete action." }], isError: true };
+                    }
+                    const deleted = await notesManager.deleteNote(noteId);
+                    return { content: [{ type: "text", text: deleted ? "Note deleted successfully." : `Error: Note with ID ${noteId} not found.` }], isError: !deleted };
+                default:
+                    return { content: [{ type: "text", text: `Error: Unknown action '${action}'` }], isError: true };
+            }
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Notes Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/thinking.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+export function registerThinkingTools(server, thinkingServer) {
+    // --- Sequential Thinking Tool ---
+    server.tool("sequentialthinking", `A detailed tool for dynamic and reflective problem-solving through thoughts.
+This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+Each thought can build on, question, or revise previous insights as understanding deepens.
+
+When to use this tool:
+- Breaking down complex problems into steps
+- Planning and design with room for revision
+- Analysis that might need course correction
+- Problems where the full scope might not be clear initially
+- Problems that require a multi-step solution
+- Tasks that need to maintain context over multiple steps
+- Situations where irrelevant information needs to be filtered out
+
+Key features:
+- You can adjust total_thoughts up or down as you progress
+- You can question or revise previous thoughts
+- You can add more thoughts even after reaching what seemed like the end
+- You can express uncertainty and explore alternative approaches
+- Not every thought needs to build linearly - you can branch or backtrack
+- Iterative Reasoning: Think step-by-step in a structured manner
+- Tree of Thoughts: Generate and evaluate multiple options (Conservative/Balanced/Aggressive)
+- Self-Critique: Check for risks, biases, and errors in thinking
+- Branch Merging: Combine insights from multiple divergent paths
+- Hypothesis Testing: Formulate and verify hypotheses
+- Generates a solution hypothesis
+- Verifies the hypothesis based on the Chain of Thought steps
+- Repeats the process until satisfied
+- Provides a correct answer
+
+Parameters explained:
+- thought: Your current thinking step, which can include:
+  * Regular analytical steps
+  * Revisions of previous thoughts
+  * Questions about previous decisions
+  * Realizations about needing more analysis
+  * Changes in approach
+  * Hypothesis generation
+  * Hypothesis verification
+- nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end
+- thoughtNumber: Current number in sequence (can go beyond initial total if needed)
+- totalThoughts: Current estimate of thoughts needed (can be adjusted up/down)
+- isRevision: A boolean indicating if this thought revises previous thinking
+- revisesThought: If is_revision is true, which thought number is being reconsidered
+- branchFromThought: If branching, which thought number is the branching point
+- branchId: Identifier for the current branch (if any)
+- needsMoreThoughts: If reaching end but realizing more thoughts needed
+- thoughtType: The type of thought (analysis, generation, evaluation, reflexion, selection)
+- score: Score for evaluation (1-10)
+- options: List of options generated
+- selectedOption: The option selected
+
+You should:
+1. Start with an initial estimate of needed thoughts, but be ready to adjust
+2. Feel free to question or revise previous thoughts
+3. Don't hesitate to add more thoughts if needed, even at the "end"
+4. Express uncertainty when present
+5. Mark thoughts that revise previous thinking or branch into new paths
+6. Ignore information that is irrelevant to the current step
+7. Generate a solution hypothesis when appropriate
+8. Verify the hypothesis based on the Chain of Thought steps
+9. Repeat the process until satisfied with the solution
+10. Provide a single, ideally correct answer as the final output
+11. Only set nextThoughtNeeded to false when truly done and a satisfactory answer is reached`, {
+        thought: z.string().describe("Your current thinking step"),
+        nextThoughtNeeded: z.boolean().describe("Whether another thought step is needed"),
+        thoughtNumber: z.number().int().min(1).describe("Current thought number (numeric value, e.g., 1, 2, 3)"),
+        totalThoughts: z.number().int().min(1).describe("Estimated total thoughts needed (numeric value, e.g., 5, 10)"),
+        isRevision: z.boolean().optional().describe("Whether this revises previous thinking"),
+        revisesThought: z.number().int().min(1).optional().describe("Which thought is being reconsidered"),
+        branchFromThought: z.number().int().min(1).optional().describe("Branching point thought number"),
+        branchId: z.string().optional().describe("Branch identifier"),
+        needsMoreThoughts: z.boolean().optional().describe("If more thoughts are needed"),
+        thoughtType: z.enum(['analysis', 'generation', 'evaluation', 'reflexion', 'selection']).optional().describe("The type of thought"),
+        score: z.number().min(1).max(10).optional().describe("Score for evaluation (1-10)"),
+        options: z.array(z.string()).optional().describe("List of options generated"),
+        selectedOption: z.string().optional().describe("The option selected")
+    }, async (args) => {
+        const result = await thinkingServer.processThought(args);
+        return {
+            content: result.content,
+            isError: result.isError
+        };
+    });
+    // 11. clear_thought_history
+    server.tool("clear_thought_history", "Clear the sequential thinking history.", {}, async () => {
+        await thinkingServer.clearHistory();
+        return {
+            content: [{ type: "text", text: "Thought history cleared." }]
+        };
+    });
+    // 12. summarize_history
+    server.tool("summarize_history", "Compress multiple thoughts into a single summary thought to save space/context.", {
+        startIndex: z.number().int().min(1).describe("The starting thought number to summarize"),
+        endIndex: z.number().int().min(1).describe("The ending thought number to summarize"),
+        summary: z.string().describe("The summary text that replaces the range")
+    }, async ({ startIndex, endIndex, summary }) => {
+        try {
+            const result = await thinkingServer.archiveHistory(startIndex, endIndex, summary);
+            return {
+                content: [{ type: "text", text: `Successfully summarized thoughts ${startIndex}-${endIndex}. New history length: ${result.newHistoryLength}` }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Archive Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/web.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { fetchWithRetry } from "../utils.js";
+import { JSDOM } from 'jsdom';
+import { Readability } from '@mozilla/readability';
+import TurndownService from 'turndown';
+export function registerWebTools(server) {
+    // 1. web_search
+    server.tool("web_search", "Search the web using Brave or Exa APIs (requires API keys in environment variables: BRAVE_API_KEY or EXA_API_KEY).", {
+        query: z.string().min(1).describe("The search query"),
+        provider: z.enum(['brave', 'exa', 'google']).optional().describe("Preferred search provider")
+    }, async ({ query, provider }) => {
+        try {
+            // Priority: User Preference > Brave > Exa > Google
+            let selectedProvider = provider;
+            if (!selectedProvider) {
+                if (process.env.BRAVE_API_KEY)
+                    selectedProvider = 'brave';
+                else if (process.env.EXA_API_KEY)
+                    selectedProvider = 'exa';
+                else if (process.env.GOOGLE_SEARCH_API_KEY)
+                    selectedProvider = 'google';
+                else
+                    return { content: [{ type: "text", text: "Error: No search provider configured. Please set BRAVE_API_KEY, EXA_API_KEY, or GOOGLE_SEARCH_API_KEY." }], isError: true };
+            }
+            if (selectedProvider === 'brave') {
+                if (!process.env.BRAVE_API_KEY)
+                    throw new Error("BRAVE_API_KEY not found");
+                const response = await fetchWithRetry(`https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=5`, {
+                    headers: { 'X-Subscription-Token': process.env.BRAVE_API_KEY }
+                });
+                if (!response.ok)
+                    throw new Error(`Brave API error: ${response.statusText}`);
+                const data = await response.json();
+                return { content: [{ type: "text", text: JSON.stringify(data.web?.results || data, null, 2) }] };
+            }
+            if (selectedProvider === 'exa') {
+                if (!process.env.EXA_API_KEY)
+                    throw new Error("EXA_API_KEY not found");
+                const response = await fetchWithRetry('https://api.exa.ai/search', {
+                    method: 'POST',
+                    headers: {
+                        'x-api-key': process.env.EXA_API_KEY,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ query, numResults: 5 })
+                });
+                if (!response.ok)
+                    throw new Error(`Exa API error: ${response.statusText}`);
+                const data = await response.json();
+                return { content: [{ type: "text", text: JSON.stringify(data.results || data, null, 2) }] };
+            }
+            if (selectedProvider === 'google') {
+                if (!process.env.GOOGLE_SEARCH_API_KEY)
+                    throw new Error("GOOGLE_SEARCH_API_KEY not found");
+                if (!process.env.GOOGLE_SEARCH_CX)
+                    throw new Error("GOOGLE_SEARCH_CX (Search Engine ID) not found");
+                const response = await fetchWithRetry(`https://www.googleapis.com/customsearch/v1?key=${process.env.GOOGLE_SEARCH_API_KEY}&cx=${process.env.GOOGLE_SEARCH_CX}&q=${encodeURIComponent(query)}&num=5`);
+                if (!response.ok)
+                    throw new Error(`Google API error: ${response.statusText}`);
+                const data = await response.json();
+                // Extract relevant fields to keep output clean
+                const results = data.items?.map((item) => ({
+                    title: item.title,
+                    link: item.link,
+                    snippet: item.snippet
+                })) || [];
+                return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+            }
+            return { content: [{ type: "text", text: "Error: Unsupported or unconfigured provider." }], isError: true };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Search Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 2. fetch
+    server.tool("fetch", "Perform an HTTP request to a specific URL.", {
+        url: z.string().url().describe("The URL to fetch"),
+        method: z.enum(['GET', 'POST', 'PUT', 'DELETE']).optional().default('GET').describe("HTTP Method"),
+        headers: z.record(z.string(), z.string()).optional().describe("HTTP Headers"),
+        body: z.string().optional().describe("Request body (for POST/PUT)")
+    }, async ({ url, method, headers, body }) => {
+        try {
+            const response = await fetchWithRetry(url, {
+                method,
+                headers: headers || {},
+                body: body
+            });
+            const text = await response.text();
+            return {
+                content: [{
+                        type: "text",
+                        text: `Status: ${response.status}\n\n${text.substring(0, 10000)}${text.length > 10000 ? '\n...(truncated)' : ''}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Fetch Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // 9. read_webpage
+    server.tool("read_webpage", "Read a webpage and convert it to clean Markdown (removes ads, navs, etc.).", {
+        url: z.string().url().describe("The URL to read")
+    }, async ({ url }) => {
+        try {
+            const response = await fetchWithRetry(url);
+            const html = await response.text();
+            const doc = new JSDOM(html, { url });
+            const reader = new Readability(doc.window.document);
+            const article = reader.parse();
+            if (!article)
+                throw new Error("Could not parse article content");
+            const turndownService = new TurndownService();
+            const markdown = turndownService.turndown(article.content || "");
+            return {
+                content: [{
+                        type: "text",
+                        text: `Title: ${article.title}\n\n${markdown}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Read Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/utils.js

@@ -0,0 +1,35 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+export const execAsync = promisify(exec);
+export const DEFAULT_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+export async function fetchWithRetry(url, options = {}, retries = 3, backoff = 1000) {
+    const fetchOptions = {
+        ...options,
+        headers: { ...DEFAULT_HEADERS, ...options.headers }
+    };
+    try {
+        const response = await fetch(url, fetchOptions);
+        if (response.status === 429 && retries > 0) {
+            const retryAfter = response.headers.get('Retry-After');
+            const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : backoff;
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+            return fetchWithRetry(url, options, retries - 1, backoff * 2);
+        }
+        if (!response.ok && retries > 0 && response.status >= 500) {
+            await new Promise(resolve => setTimeout(resolve, backoff));
+            return fetchWithRetry(url, options, retries - 1, backoff * 2);
+        }
+        return response;
+    }
+    catch (error) {
+        if (retries > 0) {
+            await new Promise(resolve => setTimeout(resolve, backoff));
+            return fetchWithRetry(url, options, retries - 1, backoff * 2);
+        }
+        throw error;
+    }
+}

package/dist/verify_edit.test.js

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,25 @@
+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/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@gotza02/sequential-thinking",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "MCP server for sequential thinking and problem solving (Extended with Web Search & Graph)",
+  "license": "MIT",
+  "mcpName": "sequential-thinking-extended",
+  "author": "Anthropic, PBC (https://anthropic.com)",
+  "homepage": "https://modelcontextprotocol.io",
+  "bugs": "https://github.com/modelcontextprotocol/servers/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modelcontextprotocol/servers.git"
+  },
+  "type": "module",
+  "bin": {
+    "mcp-server-sequential-thinking": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "test": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "@mozilla/readability": "^0.6.0",
+    "chalk": "^5.3.0",
+    "jsdom": "^27.4.0",
+    "turndown": "^7.2.2",
+    "typescript": "^5.3.3",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/jsdom": "^27.0.0",
+    "@types/node": "^22",
+    "@types/turndown": "^5.0.6",
+    "@types/yargs": "^17.0.32",
+    "@vitest/coverage-v8": "^2.1.8",
+    "shx": "^0.3.4",
+    "vitest": "^2.1.8"
+  }
+}