@gotza02/sequential-thinking 2026.1.25 → 2026.1.27

package/README.md

@@ -49,6 +49,9 @@ The core engine for structured problem-solving. It forces a step-by-step analysi
 
 **Best Practice:** Use this for ANY non-trivial task. Don't just answer; think first.
 
+#### `clear_thought_history`
+Clears the stored thinking history. Use this to start fresh or free up context.
+
 ### 🌐 External Knowledge
 
 #### `web_search`
@@ -70,6 +73,12 @@ Performs a direct HTTP request to a URL. Useful for getting raw HTML, JSON, or t
 - `headers`: JSON object for headers (e.g., `{"Authorization": "Bearer..."}`).
 - `body`: Request body for POST/PUT.
 
+#### `read_webpage`
+Reads a webpage and converts it to clean Markdown, removing ads and navigation. Great for reading articles or documentation to save tokens.
+
+**Inputs:**
+- `url` (string, required): The URL to read.
+
 ### 🏗 Codebase Intelligence
 
 #### `build_project_graph`
@@ -90,6 +99,13 @@ Zoom in on a specific file to see its context.
 - `imports`: What this file needs.
 - `importedBy`: Who relies on this file.
 
+#### `search_code`
+Searches for a text pattern across all code files in the project. Useful for finding usage examples or specific logic.
+
+**Inputs:**
+- `pattern` (string, required): Text to search for.
+- `path` (string, optional): Root directory (defaults to `.`).
+
 ### 🛠 System Operations
 
 #### `read_file`
@@ -148,6 +164,11 @@ The Sequential Thinking tool is designed for:
 
 ## Configuration
 
+### Environment Variables
+- `THOUGHT_DELAY_MS`: (Optional) Milliseconds to wait before processing each thought. Default: `0`.
+- `DISABLE_THOUGHT_LOGGING`: (Optional) Set to `true` to hide colored logs.
+- `THOUGHTS_STORAGE_PATH`: (Optional) Path to history file. Default: `thoughts_history.json`.
+
 ### Usage with Claude Desktop
 
 Add this to your `claude_desktop_config.json`. You can configure API keys directly here:
@@ -193,6 +214,17 @@ npm run build
 npm test
 ```
 
+## Recent Updates (v2026.1.27)
+- **New Tools**:
+  - `read_webpage`: Convert webpages to Markdown for efficient reading.
+  - `search_code`: Recursive text search in code files.
+  - `clear_thought_history`: Reset the thinking process.
+
+## Recent Updates (v2026.1.26)
+
+- **Rate Limiting**:
+  - Added `THOUGHT_DELAY_MS` environment variable to introduce a delay between thought steps. This helps prevent request flooding and rate limit issues.
+
 ## Recent Updates (v2026.1.24)
 
 - **Bug Fixes**:

package/dist/index.js

@@ -7,12 +7,16 @@ import * as fs from 'fs/promises';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { ProjectKnowledgeGraph } from './graph.js';
+import * as path from 'path';
+import { JSDOM } from 'jsdom';
+import { Readability } from '@mozilla/readability';
+import TurndownService from 'turndown';
 const execAsync = promisify(exec);
 const server = new McpServer({
     name: "sequential-thinking-server",
     version: "2026.1.18",
 });
-const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json');
+const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 const knowledgeGraph = new ProjectKnowledgeGraph();
 // --- Sequential Thinking Tool ---
 server.tool("sequentialthinking", `A detailed tool for dynamic and reflective problem-solving through thoughts.
@@ -314,6 +318,82 @@ async function runServer() {
     await server.connect(transport);
     console.error("Sequential Thinking MCP Server (Extended) running on stdio");
 }
+// --- New Tools v2026.1.27 ---
+// 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 fetch(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
+        };
+    }
+});
+// 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 {
+        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(path.resolve(searchPath || '.'));
+        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
+        };
+    }
+});
+// 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." }]
+    };
+});
 runServer().catch((error) => {
     console.error("Fatal error running server:", error);
     process.exit(1);

package/dist/lib.js

@@ -7,9 +7,11 @@ export class SequentialThinkingServer {
     branches = {};
     disableThoughtLogging;
     storagePath;
-    constructor(storagePath = 'thoughts_history.json') {
+    delayMs;
+    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() {
@@ -36,6 +38,11 @@ export class SequentialThinkingServer {
             console.error(`Error saving history to ${this.storagePath}:`, error);
         }
     }
+    async clearHistory() {
+        this.thoughtHistory = [];
+        this.branches = {};
+        await this.saveHistory();
+    }
     addToMemory(input) {
         if (input.thoughtNumber > input.totalThoughts) {
             input.totalThoughts = input.thoughtNumber;
@@ -97,6 +104,9 @@ export class SequentialThinkingServer {
     }
     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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.1.25",
+  "version": "2026.1.27",
   "publishConfig": {
     "access": "public"
   },
@@ -29,12 +29,17 @@
   },
   "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",