@gotza02/sequential-thinking 2026.1.16

package/README.md

@@ -0,0 +1,132 @@
+# Sequential Thinking MCP Server
+
+An MCP server implementation that provides a tool for dynamic and reflective problem-solving through a structured thinking process (Tree of Thoughts, Self-Reflexion).
+
+## Features
+
+- **Sequential Analysis**: Break down complex problems into manageable linear steps.
+- **Iterative Reasoning**: Think step-by-step in a structured manner, refining insights in loops.
+- **Tree of Thoughts**: Generate and evaluate multiple options, exploring Conservative, Balanced, and Aggressive strategies.
+- **Self-Critique**: Actively check for risks, biases, and potential errors in the thinking process.
+- **Branch Merging**: Synthesize and combine insights from multiple divergent reasoning paths.
+- **Hypothesis Testing**: Formulate specific hypotheses and verify them against evidence or logic.
+- **Option Evaluation**: Score and weigh different options (`evaluation`) to make informed decisions.
+- **Self-Reflexion**: Review and correct previous thoughts (`reflexion`) to improve accuracy.
+- **Dynamic Adjustment**: Adjust the total number of thoughts dynamically as understanding deepens.
+
+## Tool
+
+### sequentialthinking
+
+Facilitates a detailed, step-by-step thinking process for problem-solving and analysis.
+
+**(See inputs above)**
+
+### web_search
+
+Search the web using Brave or Exa APIs.
+
+**Inputs:**
+- `query` (string): The search query.
+- `provider` (enum, optional): 'brave', 'exa', or 'google'.
+
+**Configuration:**
+Requires `BRAVE_API_KEY` or `EXA_API_KEY` environment variables.
+
+### fetch
+
+Perform an HTTP request.
+
+**Inputs:**
+- `url` (string): URL to fetch.
+- `method` (string, optional): HTTP method (GET, POST, etc.).
+- `headers` (object, optional): Request headers.
+- `body` (string, optional): Request body.
+
+### shell_execute
+
+Execute a shell command. **Use with caution.**
+
+**Inputs:**
+- `command` (string): The command to run.
+
+### read_file / write_file
+
+Manage files on the local system.
+
+**Inputs:**
+- `path` (string): File path.
+- `content` (string, for write_file): Content to write.
+
+### build_project_graph
+
+Scan directory and build dependency graph.
+
+**Inputs:**
+- `path` (string, optional): Root directory to scan.
+
+### get_file_relationships
+
+Get imports and references for a specific file.
+
+**Inputs:**
+- `filePath` (string): Path to the file.
+
+### get_project_graph_summary
+
+Get overview of project structure and most referenced files.
+
+## Usage
+
+The Sequential Thinking tool is designed for:
+- 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
+- Tasks that need to maintain context over multiple steps
+- Situations where irrelevant information needs to be filtered out
+
+## Configuration
+
+### Usage with Claude Desktop
+
+Add this to your `claude_desktop_config.json`:
+
+#### npx
+
+```json
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-sequential-thinking"
+      ]
+    }
+  }
+}
+```
+
+### Usage with VS Code
+
+For quick installation, click one of the installation buttons below...
+
+[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPM-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=sequentialthinking&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-sequential-thinking%22%5D%7D)
+
+## Building
+
+```bash
+npm install
+npm run build
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## License
+
+This MCP server is licensed under the MIT License.

package/dist/graph.js

@@ -0,0 +1,120 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class ProjectKnowledgeGraph {
+    nodes = new Map();
+    rootDir = '';
+    constructor() { }
+    async build(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.nodes.clear();
+        const files = await this.getAllFiles(this.rootDir);
+        // Step 1: Initialize nodes
+        for (const file of files) {
+            this.nodes.set(file, {
+                path: file,
+                imports: [],
+                importedBy: []
+            });
+        }
+        // Step 2: Parse imports and build edges
+        for (const file of files) {
+            await this.parseFile(file);
+        }
+        return {
+            nodeCount: this.nodes.size,
+            totalFiles: files.length
+        };
+    }
+    async getAllFiles(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            const res = path.resolve(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist')
+                    continue;
+                files.push(...await this.getAllFiles(res));
+            }
+            else {
+                if (/\.(ts|js|tsx|jsx|json)$/.test(entry.name)) {
+                    files.push(res);
+                }
+            }
+        }
+        return files;
+    }
+    async parseFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const importRegex = /import\s+(?:[\w\s{},*]+from\s+)?['"]([^'"]+)['"]/g;
+            const dynamicImportRegex = /import\(['"]([^'"]+)['"]\)/g;
+            const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+            const allMatches = [
+                ...content.matchAll(importRegex),
+                ...content.matchAll(dynamicImportRegex),
+                ...content.matchAll(requireRegex)
+            ];
+            const currentNode = this.nodes.get(filePath);
+            if (!currentNode)
+                return;
+            for (const match of allMatches) {
+                const importPath = match[1];
+                if (importPath.startsWith('.')) {
+                    const resolvedPath = await this.resolvePath(path.dirname(filePath), importPath);
+                    if (resolvedPath && this.nodes.has(resolvedPath)) {
+                        currentNode.imports.push(resolvedPath);
+                        this.nodes.get(resolvedPath)?.importedBy.push(filePath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error parsing file ${filePath}:`, error);
+        }
+    }
+    async resolvePath(dir, relativePath) {
+        const extensions = ['', '.ts', '.js', '.tsx', '.jsx', '.json', '/index.ts', '/index.js'];
+        const absolutePath = path.resolve(dir, relativePath);
+        for (const ext of extensions) {
+            const p = absolutePath + ext;
+            if (this.nodes.has(p)) {
+                return p;
+            }
+        }
+        return null;
+    }
+    getRelationships(filePath) {
+        const absolutePath = path.resolve(this.rootDir, filePath);
+        // Try to match exact or with extensions
+        let node = this.nodes.get(absolutePath);
+        if (!node) {
+            // Fallback search
+            for (const [key, value] of this.nodes.entries()) {
+                if (key.endsWith(filePath)) {
+                    node = value;
+                    break;
+                }
+            }
+        }
+        if (!node)
+            return null;
+        return {
+            path: node.path,
+            imports: node.imports.map(p => path.relative(this.rootDir, p)),
+            importedBy: node.importedBy.map(p => path.relative(this.rootDir, p))
+        };
+    }
+    getSummary() {
+        return {
+            root: this.rootDir,
+            fileCount: this.nodes.size,
+            mostReferencedFiles: [...this.nodes.values()]
+                .sort((a, b) => b.importedBy.length - a.importedBy.length)
+                .slice(0, 5)
+                .map(n => ({
+                file: path.relative(this.rootDir, n.path),
+                referencedBy: n.importedBy.length
+            }))
+        };
+    }
+}

package/dist/index.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { SequentialThinkingServer } from './lib.js';
+import * as fs from 'fs/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { ProjectKnowledgeGraph } from './graph.js';
+const execAsync = promisify(exec);
+const server = new McpServer({
+    name: "sequential-thinking-server",
+    version: "0.2.0",
+});
+const thinkingServer = new SequentialThinkingServer();
+const knowledgeGraph = new ProjectKnowledgeGraph();
+// --- 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 = thinkingServer.processThought(args);
+    return {
+        content: result.content,
+        isError: result.isError
+    };
+});
+// --- New Tools ---
+// 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().describe("The search query"),
+    provider: z.enum(['brave', 'exa', 'google']).optional().describe("Preferred search provider")
+}, async ({ query, provider }) => {
+    try {
+        // Priority: User Preference > Brave > Exa
+        let selectedProvider = provider;
+        if (!selectedProvider) {
+            if (process.env.BRAVE_API_KEY)
+                selectedProvider = 'brave';
+            else if (process.env.EXA_API_KEY)
+                selectedProvider = 'exa';
+            else
+                return { content: [{ type: "text", text: "Error: No search provider configured. Please set BRAVE_API_KEY or EXA_API_KEY." }], isError: true };
+        }
+        if (selectedProvider === 'brave') {
+            if (!process.env.BRAVE_API_KEY)
+                throw new Error("BRAVE_API_KEY not found");
+            const response = await fetch(`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 fetch('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) }] };
+        }
+        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 fetch(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
+        };
+    }
+});
+// 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
+        };
+    }
+});
+// --- Project Knowledge Graph Tools ---
+// 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
+        };
+    }
+});
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Sequential Thinking MCP Server (Extended) running on stdio");
+}
+runServer().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

package/dist/lib.js

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+export class SequentialThinkingServer {
+    thoughtHistory = [];
+    branches = {};
+    disableThoughtLogging;
+    constructor() {
+        this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
+    }
+    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}┘`;
+    }
+    processThought(input) {
+        try {
+            if (input.thoughtNumber > input.totalThoughts) {
+                input.totalThoughts = input.thoughtNumber;
+            }
+            this.thoughtHistory.push(input);
+            if (input.branchFromThought && input.branchId) {
+                if (!this.branches[input.branchId]) {
+                    this.branches[input.branchId] = [];
+                }
+                this.branches[input.branchId].push(input);
+            }
+            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/server.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SequentialThinkingServer } from './lib.js';
+describe('SequentialThinkingServer', () => {
+    let server;
+    beforeEach(() => {
+        server = new SequentialThinkingServer();
+    });
+    it('should process a basic linear thought', () => {
+        const input = {
+            thought: "First step",
+            thoughtNumber: 1,
+            totalThoughts: 3,
+            nextThoughtNeeded: true,
+            thoughtType: 'analysis'
+        };
+        const result = 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', () => {
+        // Initial thought
+        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 = server.processThought(branch1Input);
+        const content1 = JSON.parse(result1.content[0].text);
+        expect(content1.branches).toContain("branch-A");
+        // Branch 2
+        const branch2Input = {
+            thought: "Alternative B",
+            thoughtNumber: 2,
+            totalThoughts: 3,
+            nextThoughtNeeded: true,
+            branchFromThought: 1,
+            branchId: "branch-B",
+            thoughtType: 'generation'
+        };
+        const result2 = server.processThought(branch2Input);
+        const content2 = JSON.parse(result2.content[0].text);
+        expect(content2.branches).toContain("branch-B");
+        expect(content2.branches.length).toBe(2);
+    });
+    it('should handle evaluation with scores', () => {
+        const input = {
+            thought: "Evaluating option X",
+            thoughtNumber: 3,
+            totalThoughts: 5,
+            nextThoughtNeeded: true,
+            thoughtType: 'evaluation',
+            score: 8,
+            options: ['Option X', 'Option Y']
+        };
+        const result = 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', () => {
+        const input = {
+            thought: "Unexpected long process",
+            thoughtNumber: 6,
+            totalThoughts: 5,
+            nextThoughtNeeded: true
+        };
+        const result = server.processThought(input);
+        const content = JSON.parse(result.content[0].text);
+        expect(content.totalThoughts).toBe(6);
+    });
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@gotza02/sequential-thinking",
+  "version": "2026.01.16",
+  "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": "https://github.com/modelcontextprotocol/servers.git"
+  },
+  "type": "module",
+  "bin": {
+    "mcp-server-sequential-thinking": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "test": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "chalk": "^5.3.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "@types/yargs": "^17.0.32",
+    "@vitest/coverage-v8": "^2.1.8",
+    "shx": "^0.3.4",
+    "typescript": "^5.3.3",
+    "vitest": "^2.1.8"
+  }
+}