@gotza02/sequential-thinking 2026.2.20 → 2026.2.22

package/dist/tools/human.d.ts

@@ -0,0 +1,65 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Human-in-the-Loop interaction record
+ */
+interface HumanInteraction {
+    id: string;
+    timestamp: string;
+    questionType: 'confirmation' | 'choice' | 'input' | 'review';
+    urgency: 'low' | 'medium' | 'high' | 'critical';
+    question: string;
+    context?: string;
+    options?: string[];
+    defaultOption?: string;
+    status: 'pending' | 'answered' | 'timeout' | 'skipped';
+    response?: string;
+    respondedAt?: string;
+}
+/**
+ * Human-in-the-Loop Manager
+ * Manages interactions between AI and human operators
+ */
+export declare class HumanInteractionManager {
+    private interactions;
+    private pendingCallbacks;
+    constructor();
+    /**
+     * Generate unique interaction ID
+     */
+    private generateId;
+    /**
+     * Create a new human interaction request
+     */
+    createInteraction(params: {
+        questionType: 'confirmation' | 'choice' | 'input' | 'review';
+        urgency: 'low' | 'medium' | 'high' | 'critical';
+        question: string;
+        context?: string;
+        options?: string[];
+        defaultOption?: string;
+        timeoutMs?: number;
+    }): Promise<HumanInteraction>;
+    /**
+     * Record a response to an interaction
+     */
+    recordResponse(id: string, response: string): HumanInteraction | null;
+    /**
+     * Get all pending interactions
+     */
+    getPendingInteractions(): HumanInteraction[];
+    /**
+     * Get interaction history
+     */
+    getHistory(limit?: number): HumanInteraction[];
+    /**
+     * Clear old interactions (older than specified hours)
+     */
+    clearOldInteractions(hoursOld?: number): number;
+    /**
+     * Format interaction for display
+     */
+    formatInteraction(interaction: HumanInteraction): string;
+}
+export declare function getHumanManager(): HumanInteractionManager;
+export declare function registerHumanTools(server: McpServer): void;
+export {};

package/dist/tools/human.js

@@ -0,0 +1,305 @@
+import { z } from "zod";
+/**
+ * Human-in-the-Loop Manager
+ * Manages interactions between AI and human operators
+ */
+export class HumanInteractionManager {
+    interactions = new Map();
+    pendingCallbacks = new Map();
+    constructor() { }
+    /**
+     * Generate unique interaction ID
+     */
+    generateId() {
+        return `hitl_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Create a new human interaction request
+     */
+    async createInteraction(params) {
+        const id = this.generateId();
+        const interaction = {
+            id,
+            timestamp: new Date().toISOString(),
+            questionType: params.questionType,
+            urgency: params.urgency,
+            question: params.question,
+            context: params.context,
+            options: params.options,
+            defaultOption: params.defaultOption,
+            status: 'pending'
+        };
+        this.interactions.set(id, interaction);
+        return interaction;
+    }
+    /**
+     * Record a response to an interaction
+     */
+    recordResponse(id, response) {
+        const interaction = this.interactions.get(id);
+        if (!interaction)
+            return null;
+        interaction.status = 'answered';
+        interaction.response = response;
+        interaction.respondedAt = new Date().toISOString();
+        // Resolve any pending callback
+        const callback = this.pendingCallbacks.get(id);
+        if (callback) {
+            clearTimeout(callback.timeout);
+            callback.resolve(response);
+            this.pendingCallbacks.delete(id);
+        }
+        return interaction;
+    }
+    /**
+     * Get all pending interactions
+     */
+    getPendingInteractions() {
+        return Array.from(this.interactions.values())
+            .filter(i => i.status === 'pending')
+            .sort((a, b) => {
+            // Sort by urgency then by timestamp
+            const urgencyOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+            const urgencyDiff = urgencyOrder[a.urgency] - urgencyOrder[b.urgency];
+            if (urgencyDiff !== 0)
+                return urgencyDiff;
+            return new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime();
+        });
+    }
+    /**
+     * Get interaction history
+     */
+    getHistory(limit = 50) {
+        return Array.from(this.interactions.values())
+            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+            .slice(0, limit);
+    }
+    /**
+     * Clear old interactions (older than specified hours)
+     */
+    clearOldInteractions(hoursOld = 24) {
+        const cutoff = Date.now() - (hoursOld * 60 * 60 * 1000);
+        let cleared = 0;
+        for (const [id, interaction] of this.interactions) {
+            if (new Date(interaction.timestamp).getTime() < cutoff) {
+                this.interactions.delete(id);
+                cleared++;
+            }
+        }
+        return cleared;
+    }
+    /**
+     * Format interaction for display
+     */
+    formatInteraction(interaction) {
+        const urgencyEmoji = {
+            critical: '🚨',
+            high: '⚠️',
+            medium: '📋',
+            low: 'ℹ️'
+        };
+        const typeLabel = {
+            confirmation: 'ยืนยัน (Yes/No)',
+            choice: 'เลือกตัวเลือก',
+            input: 'ต้องการข้อมูล',
+            review: 'ตรวจสอบ/อนุมัติ'
+        };
+        let output = `\n${'═'.repeat(60)}\n`;
+        output += `${urgencyEmoji[interaction.urgency]} HUMAN INPUT REQUIRED [${interaction.urgency.toUpperCase()}]\n`;
+        output += `${'─'.repeat(60)}\n`;
+        output += `📌 Type: ${typeLabel[interaction.questionType]}\n`;
+        output += `🆔 ID: ${interaction.id}\n`;
+        output += `⏰ Time: ${interaction.timestamp}\n`;
+        output += `${'─'.repeat(60)}\n`;
+        output += `❓ Question:\n   ${interaction.question}\n`;
+        if (interaction.context) {
+            output += `\n📝 Context:\n   ${interaction.context}\n`;
+        }
+        if (interaction.options && interaction.options.length > 0) {
+            output += `\n📋 Options:\n`;
+            interaction.options.forEach((opt, i) => {
+                const isDefault = opt === interaction.defaultOption;
+                output += `   ${i + 1}. ${opt}${isDefault ? ' (default)' : ''}\n`;
+            });
+        }
+        if (interaction.defaultOption && interaction.questionType === 'confirmation') {
+            output += `\n   Default: ${interaction.defaultOption}\n`;
+        }
+        output += `${'═'.repeat(60)}\n`;
+        output += `💡 To respond, use: respond_to_human tool with id="${interaction.id}"\n`;
+        return output;
+    }
+}
+// Singleton instance for the manager
+let humanManager = null;
+export function getHumanManager() {
+    if (!humanManager) {
+        humanManager = new HumanInteractionManager();
+    }
+    return humanManager;
+}
+export function registerHumanTools(server) {
+    const manager = getHumanManager();
+    // --- ask_human Tool ---
+    server.tool("ask_human", `Request human input or decision during AI operation. Use this tool when:
+- A destructive or irreversible action needs confirmation (e.g., "Delete database?")
+- Multiple valid approaches exist and human preference is needed
+- Critical decisions that could have significant impact
+- Clarification is needed on ambiguous requirements
+- Review/approval is required before proceeding
+
+This transforms the AI from "guessing" to "collaborative" mode.
+
+Question Types:
+- confirmation: Yes/No questions (e.g., "Proceed with deletion?")
+- choice: Select from predefined options (e.g., "Which framework?")
+- input: Free-form text input needed (e.g., "What should the function be named?")
+- review: Present work for human review/approval
+
+Urgency Levels:
+- critical: Immediate response required, blocks all operations
+- high: Important decision, should respond soon
+- medium: Normal priority question
+- low: Nice to have input, can proceed with default if no response`, {
+        question: z.string().describe("The question to ask the human"),
+        questionType: z.enum(['confirmation', 'choice', 'input', 'review'])
+            .default('input')
+            .describe("Type of question being asked"),
+        urgency: z.enum(['low', 'medium', 'high', 'critical'])
+            .default('medium')
+            .describe("Urgency level of the question"),
+        context: z.string().optional()
+            .describe("Additional context explaining why this input is needed"),
+        options: z.array(z.string()).optional()
+            .describe("Available options for 'choice' type questions"),
+        defaultOption: z.string().optional()
+            .describe("Default option if human doesn't respond (for non-critical)")
+    }, async ({ question, questionType, urgency, context, options, defaultOption }) => {
+        // Validate options for choice type
+        if (questionType === 'choice' && (!options || options.length < 2)) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Error: 'choice' question type requires at least 2 options"
+                    }],
+                isError: true
+            };
+        }
+        const interaction = await manager.createInteraction({
+            questionType,
+            urgency,
+            question,
+            context,
+            options,
+            defaultOption
+        });
+        const formatted = manager.formatInteraction(interaction);
+        return {
+            content: [{
+                    type: "text",
+                    text: formatted + `\n\n⏳ Status: WAITING FOR HUMAN RESPONSE\n\nThe AI should pause this line of action until a response is received via 'respond_to_human' or 'get_pending_questions'.`
+                }]
+        };
+    });
+    // --- respond_to_human Tool ---
+    server.tool("respond_to_human", "Provide a response to a pending human-in-the-loop question. Use this after receiving human input.", {
+        interactionId: z.string().describe("The interaction ID from ask_human"),
+        response: z.string().describe("The human's response to the question")
+    }, async ({ interactionId, response }) => {
+        const interaction = manager.recordResponse(interactionId, response);
+        if (!interaction) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: No pending interaction found with ID "${interactionId}"`
+                    }],
+                isError: true
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `✅ Response recorded for interaction ${interactionId}\n\n` +
+                        `Question: ${interaction.question}\n` +
+                        `Response: ${response}\n` +
+                        `Responded at: ${interaction.respondedAt}\n\n` +
+                        `The AI can now proceed based on this human decision.`
+                }]
+        };
+    });
+    // --- get_pending_questions Tool ---
+    server.tool("get_pending_questions", "Get all pending human-in-the-loop questions that need responses.", {}, async () => {
+        const pending = manager.getPendingInteractions();
+        if (pending.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "✅ No pending questions. All human interactions have been addressed."
+                    }]
+            };
+        }
+        let output = `📋 PENDING HUMAN INTERACTIONS (${pending.length})\n`;
+        output += `${'═'.repeat(60)}\n\n`;
+        for (const interaction of pending) {
+            output += manager.formatInteraction(interaction);
+            output += '\n';
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: output
+                }]
+        };
+    });
+    // --- get_interaction_history Tool ---
+    server.tool("get_interaction_history", "Get the history of human-AI interactions for context and learning.", {
+        limit: z.number().int().min(1).max(100).default(20)
+            .describe("Maximum number of interactions to return")
+    }, async ({ limit }) => {
+        const history = manager.getHistory(limit);
+        if (history.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "No interaction history found."
+                    }]
+            };
+        }
+        let output = `📜 INTERACTION HISTORY (${history.length} most recent)\n`;
+        output += `${'═'.repeat(60)}\n\n`;
+        for (const interaction of history) {
+            const statusEmoji = {
+                pending: '⏳',
+                answered: '✅',
+                timeout: '⏱️',
+                skipped: '⏭️'
+            };
+            output += `${statusEmoji[interaction.status]} [${interaction.id}]\n`;
+            output += `   Type: ${interaction.questionType} | Urgency: ${interaction.urgency}\n`;
+            output += `   Q: ${interaction.question.substring(0, 80)}${interaction.question.length > 80 ? '...' : ''}\n`;
+            if (interaction.response) {
+                output += `   A: ${interaction.response.substring(0, 80)}${interaction.response.length > 80 ? '...' : ''}\n`;
+            }
+            output += `   Time: ${interaction.timestamp}\n\n`;
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: output
+                }]
+        };
+    });
+    // --- clear_old_interactions Tool ---
+    server.tool("clear_old_interactions", "Clear old interaction history to free up memory.", {
+        hoursOld: z.number().int().min(1).default(24)
+            .describe("Clear interactions older than this many hours")
+    }, async ({ hoursOld }) => {
+        const cleared = manager.clearOldInteractions(hoursOld);
+        return {
+            content: [{
+                    type: "text",
+                    text: `🗑️ Cleared ${cleared} interactions older than ${hoursOld} hours.`
+                }]
+        };
+    });
+}

package/dist/tools/notes.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { NotesManager } from '../notes.js';
+export declare function registerNoteTools(server: McpServer, notesManager: NotesManager): void;

package/dist/tools/thinking.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SequentialThinkingServer } from '../lib.js';
+export declare function registerThinkingTools(server: McpServer, thinkingServer: SequentialThinkingServer): void;

package/dist/tools/thinking.js

@@ -1,71 +1,94 @@
 import { z } from "zod";
 export function registerThinkingTools(server, thinkingServer) {
-    // --- Sequential Thinking Tool ---
-    server.tool("sequentialthinking", `A specialized tool for Deepest Thinking, providing dynamic and reflective problem-solving.
-This tool mandates a rigorous analysis process that adapts and evolves as understanding deepens.
-Use this tool ALWAYS for complex queries to ensure the most thorough and accurate solution.
+    // --- Sequential Thinking Tool (Opus 4.5 Interleaved Mode) ---
+    server.tool("sequentialthinking", `CORE THINKING ENGINE (OPUS-4.5 INTERLEAVED MODE).
+Use this tool to structure your reasoning, plan actions, and analyze results.
+The system is now BLOCK-BASED to handle complex, multi-stage tasks.
 
-Deepest Thinking Requirements:
-- Mandatory Analysis: Break down problems into atomic requirements before generating solutions.
-- Mandatory Reflexion: Critique your own thoughts regularly to identify biases or errors.
-- Mandatory Branching: Explore alternative hypotheses (Conservative/Balanced/Aggressive) for critical decisions.
-- Dynamic Depth: Adjust total_thoughts as new complexities are discovered.
-- Correctness focus: Repeat the process until a verified, satisfactory answer is reached.
+═══════════════════════════════════════════════════════════════
+THOUGHT TYPES (NEW)
+═══════════════════════════════════════════════════════════════
+- 'analysis'    : Understand the problem / Break down requirements
+- 'planning'    : Formulate a plan / Decide next steps BEFORE executing
+- 'execution'   : Explicitly state what tool you are about to call
+- 'observation' : Record the OUTPUT of a tool call (MANDATORY after execution)
+- 'hypothesis'  : Form a new hypothesis based on observations
+- 'reflexion'   : Critique your progress / Check for errors / Self-review
+- 'solution'    : Final answer / Task completion
 
-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
+Legacy types (still supported):
+- 'generation'  : Generate multiple options
+- 'evaluation'  : Evaluate options with scoring
+- 'selection'   : Select the best option
 
-Key features:
-- Tree of Thoughts: Generate and evaluate multiple options.
-- Self-Critique: Check for risks, biases, and errors in thinking.
-- Hypothesis Testing: Formulate and verify hypotheses based on Chain of Thought.
-- Branch Merging: Combine insights from multiple divergent paths.
+═══════════════════════════════════════════════════════════════
+INTERLEAVED WORKFLOW RULE (CRITICAL)
+═══════════════════════════════════════════════════════════════
+The correct flow is:
 
-Troubleshooting & Stuck States:
-- If you realize you are stuck in a loop or a bug persists after 2 attempts:
-  1. Do NOT continue linear thoughts.
-  2. Create a NEW BRANCH ('branchFromThought') from a point before the error.
-  3. Explicitly state "Stuck detected, branching to explore Approach B".
-  4. Change your fundamental assumptions or implementation strategy completely.
+  Analysis -> Planning -> Execution -> [Call Tool] -> Observation -> Analysis -> ...
 
-Parameters explained:
-- thought: Your current thinking step (analysis, revision, question, hypothesis).
-- nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end.
-- thoughtNumber: Current number in sequence.
-- totalThoughts: Current estimate of thoughts needed (can be adjusted).
-- isRevision: True if this thought revises previous thinking.
-- revisesThought: Which thought number is being reconsidered.
-- branchFromThought: The branching point thought number.
-- branchId: Identifier for the current branch.
-- 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.
+1. BEFORE calling any tool, use 'execution' type to declare your intent
+2. AFTER a tool returns, use 'observation' type to record and analyze the result
+3. The system will WARN you if you skip the observation step
 
-You MUST:
-1. Use thoughtType: 'analysis' for the first steps to map requirements.
-2. Use thoughtType: 'reflexion' frequently to validate logic.
-3. Use thoughtType: 'evaluation' and 'selection' when choosing between branches.
-4. Only set nextThoughtNeeded to false when the solution is definitive and fully verified.`, {
+Example flow:
+  T1: analysis    - "I need to read the config file to understand the structure"
+  T2: planning    - "I will use read_file tool on config.json"
+  T3: execution   - "Calling read_file on ./config.json" [relatedToolCall: "read_file"]
+  [Tool Call: read_file]
+  T4: observation - "The config has 3 sections: auth, database, logging" [toolResult: "..."]
+  T5: analysis    - "Now I need to modify the database section"
+  ...
+
+═══════════════════════════════════════════════════════════════
+BLOCKS (Context Grouping)
+═══════════════════════════════════════════════════════════════
+Thoughts are grouped into 'blocks' by topic. When switching topics:
+- Start a new block with a new blockId (e.g., 'debug-auth', 'implement-api')
+- This prevents false-positive loop detection when changing context
+- Old blocks are auto-archived to save memory
+
+═══════════════════════════════════════════════════════════════
+SMART WARNINGS
+═══════════════════════════════════════════════════════════════
+The system will warn you when:
+- STALLING: Too many thinking steps without execution
+- LOOP: Repeating the same action
+- MISSING OBSERVATION: Skipping result analysis after tool call
+- NO PLANNING: Executing without a planning step
+- NO VERIFICATION: Ending without testing/checking
+
+═══════════════════════════════════════════════════════════════
+TROUBLESHOOTING
+═══════════════════════════════════════════════════════════════
+If stuck in a loop:
+1. Do NOT continue linear thoughts
+2. Create a NEW BRANCH ('branchFromThought') from before the error
+3. State "Stuck detected, branching to explore Approach B"
+4. Change your assumptions completely`, {
         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)"),
+        thoughtType: z.enum([
+            'analysis', 'planning', 'execution', 'observation',
+            'hypothesis', 'reflexion', 'solution',
+            'generation', 'evaluation', 'selection'
+        ]).describe("The structural role of this thought (see THOUGHT TYPES above)"),
+        thoughtNumber: z.number().int().min(1).describe("Current thought number (e.g., 1, 2, 3)"),
+        totalThoughts: z.number().int().min(1).describe("Estimated total thoughts needed (can be adjusted)"),
+        nextThoughtNeeded: z.boolean().describe("True if more thinking/action is needed"),
+        // New Interleaved Fields
+        blockId: z.string().optional().describe("ID for the current topic block (e.g., 'auth-debug', 'api-research'). Keep same ID to stay in context."),
+        relatedToolCall: z.string().optional().describe("If type='execution', specify the tool name here (e.g., 'read_file', 'edit_file')"),
+        toolResult: z.string().optional().describe("If type='observation', summarize the key findings from the tool output here"),
+        // Legacy Fields (backwards compatible)
         isRevision: z.boolean().optional().describe("Whether this revises previous thinking"),
-        revisesThought: z.number().int().min(1).optional().describe("Which thought is being reconsidered"),
+        revisesThought: z.number().int().min(1).optional().describe("Which thought number 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")
+        branchId: z.string().optional().describe("Branch identifier (e.g., 'approach-b', 'alternative')"),
+        needsMoreThoughts: z.boolean().optional().describe("If more thoughts are needed beyond totalThoughts"),
+        score: z.number().min(1).max(10).optional().describe("Score for evaluation type (1-10)"),
+        options: z.array(z.string()).optional().describe("List of options for generation type"),
+        selectedOption: z.string().optional().describe("The option selected for selection type")
     }, async (args) => {
         const result = await thinkingServer.processThought(args);
         return {
@@ -73,15 +96,15 @@ You MUST:
             isError: result.isError
         };
     });
-    // 11. clear_thought_history
-    server.tool("clear_thought_history", "Clear the sequential thinking history.", {}, async () => {
+    // --- Clear Thought History ---
+    server.tool("clear_thought_history", "Clear the sequential thinking history. Use this to start fresh when changing to a completely different task.", {}, async () => {
         await thinkingServer.clearHistory();
         return {
-            content: [{ type: "text", text: "Thought history cleared." }]
+            content: [{ type: "text", text: "Thought history cleared. All blocks reset." }]
         };
     });
-    // 12. summarize_history
-    server.tool("summarize_history", "Compress multiple thoughts into a single summary thought to save space/context.", {
+    // --- Summarize History ---
+    server.tool("summarize_history", "Compress multiple thoughts into a single summary thought to save space/context. Useful for long-running tasks.", {
         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")
@@ -99,9 +122,9 @@ You MUST:
             };
         }
     });
-    // 13. search_thoughts
-    server.tool("search_thoughts", "Search through the thinking history to recall specific details or past decisions.", {
-        query: z.string().describe("The search term or keyword to look for")
+    // --- Search Thoughts ---
+    server.tool("search_thoughts", "Search through the thinking history to recall specific details, past decisions, or tool results.", {
+        query: z.string().describe("The search term or keyword to look for (searches thought content, types, blocks, and tool calls)")
     }, async ({ query }) => {
         try {
             const results = await thinkingServer.searchHistory(query);
@@ -121,4 +144,53 @@ You MUST:
             };
         }
     });
+    // --- Start New Block ---
+    server.tool("start_thinking_block", "Explicitly start a new thinking block for a new topic/context. Use this when switching between distinct tasks to prevent false loop detection.", {
+        blockId: z.string().describe("Unique ID for the new block (e.g., 'debug-auth', 'implement-feature-x')"),
+        topic: z.string().describe("Short description of what this block is about")
+    }, async ({ blockId, topic }) => {
+        try {
+            thinkingServer.startNewBlock(blockId, topic);
+            return {
+                content: [{
+                        type: "text",
+                        text: `New thinking block started.\nBlock ID: ${blockId}\nTopic: ${topic}\n\nPrevious block has been archived. You can now think about "${topic}" without interference from previous context.`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    // --- Get Blocks Summary ---
+    server.tool("get_thinking_blocks", "Get a summary of all thinking blocks to understand your thinking history across different topics.", {}, async () => {
+        try {
+            const blocks = thinkingServer.getBlocksSummary();
+            const currentBlock = thinkingServer.getCurrentBlock();
+            if (blocks.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No thinking blocks found. Start thinking to create your first block." }]
+                };
+            }
+            let output = `Thinking Blocks Summary (${blocks.length} blocks):\n\n`;
+            for (const block of blocks) {
+                const isCurrent = currentBlock && block.id === currentBlock.id;
+                output += `${isCurrent ? '>>> ' : '    '}[${block.status.toUpperCase()}] ${block.id}\n`;
+                output += `        Topic: ${block.topic}\n`;
+                output += `        Thoughts: ${block.thoughtCount}\n\n`;
+            }
+            return {
+                content: [{ type: "text", text: output }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
 }

package/dist/tools/web.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerWebTools(server: McpServer): void;

package/dist/utils.d.ts

@@ -0,0 +1,32 @@
+export declare function execAsync(command: string, options?: {
+    timeout?: number;
+    maxBuffer?: number;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare class AsyncMutex {
+    private mutex;
+    lock(): Promise<() => void>;
+    dispatch<T>(fn: (() => T | PromiseLike<T>)): Promise<T>;
+}
+export declare function validatePath(requestedPath: string): string;
+export declare function validatePublicUrl(urlString: string): Promise<void>;
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare class Logger {
+    private level;
+    constructor();
+    private shouldLog;
+    debug(msg: string, ...args: any[]): void;
+    info(msg: string, ...args: any[]): void;
+    warn(msg: string, ...args: any[]): void;
+    error(msg: string, ...args: any[]): void;
+}
+export declare const logger: Logger;
+export declare const DEFAULT_HEADERS: {
+    'User-Agent': string;
+    Accept: string;
+    'Accept-Language': string;
+};
+export declare function fetchWithRetry(url: string, options?: any, retries?: number, backoff?: number): Promise<Response>;
+export {};