@gotza02/sequential-thinking 2026.2.46 → 2026.3.1

package/README.md

@@ -1,229 +1,28 @@
-# @gotza02/sequential-thinking MCP Server
+# @gotza02/sequential-thinking
 
-A comprehensive Model Context Protocol (MCP) server that empowers AI models with **Sequential Thinking**, **Web Research**, **Project Knowledge Graph**, and **Persistent Memory** capabilities.
+**The Elite "Brain" for AI Agents.**
+An advanced Model Context Protocol (MCP) server that equips AI with structured reasoning, web search capabilities, and safety protocols.
 
-## Features
+## 🚀 Features
 
-- **🧠 Sequential Thinking Engine:** A structured reasoning system that forces the AI to think before acting, using a rigorous `Analysis -> Planning -> Execution -> Observation` loop.
-- **🌐 Web Research:** Built-in web search (Brave, Exa, Google) and webpage reading with ad-blocking/markdown conversion.
-- **🕸️ Project Knowledge Graph:** Automatically scans and maps code dependencies (imports/exports) to understand project architecture.
-- **📝 Persistent Notes:** Save and retrieve long-term project notes and facts.
-- **💾 Code Database:** Store and search reusable code snippets and architectural patterns.
-- **🛠️ File & Code Tools:** Safe file operations and code analysis utilities.
+### 🧠 Sequential Thinking Engine
+Forces the AI to think before acting using a strict block-based flow:
+- **Analysis:** Understand the problem deeply.
+- **Planning:** Formulate a step-by-step plan.
+- **Execution:** Perform actions (with tool support).
+- **Observation:** Analyze results (Mandatory step).
+- **Reflection:** Critique the outcome and adjust.
 
----
+### 🛡️ Coding Safety Net (New!)
+- **Auto-Backup:** Automatically creates `.bak` backups before modifying any file via `deep_code_edit`.
+- **Destructive Action Protection:** Prevents accidental data loss during code refactoring.
 
-## Installation & Usage
+### 🌐 Web Search Integration
+- Built-in support for **Exa**, **Brave**, and **Google Search**.
+- Allows the AI to "pause and research" during the thinking process.
 
-### Method 1: Using `npx` (No Install Required)
-
-Best for quick use without cloning the repo.
+## 📦 Installation
 
 ```bash
 npx -y @gotza02/sequential-thinking
-```
-
-### Method 2: Running from Source (Local)
-
-If you have cloned this repository, we provide a `smartagent` script for easy execution.
-
-1.  **Install dependencies:**
-    ```bash
-    npm install
-    npm run build
-    ```
-2.  **Run directly:**
-    ```bash
-    ./smartagent
-    ```
-
----
-
-## Client Configuration
-
-To use this server with your AI client (Claude Desktop, Gemini CLI, etc.), add the following configuration.
-
-### 1. Claude Desktop
-
-**Config File Location:**
-- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
-
-**Configuration (NPX - Recommended):**
-```json
-{
-  "mcpServers": {
-    "sequential-thinking": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@gotza02/sequential-thinking"
-      ],
-      "env": {
-        "BRAVE_API_KEY": "your_brave_api_key_here",
-        "EXA_API_KEY": "your_exa_api_key_here",
-        "GOOGLE_SEARCH_API_KEY": "your_google_api_key",
-        "GOOGLE_SEARCH_CX": "your_google_cx_id",
-        "THOUGHTS_STORAGE_PATH": "./thoughts_history.json",
-        "NOTES_STORAGE_PATH": "./project_notes.json",
-        "DISABLE_THOUGHT_LOGGING": "false"
-      }
-    }
-  }
-}
-```
-
-**Configuration (Local Source):**
-```json
-{
-  "mcpServers": {
-    "sequential-thinking": {
-      "command": "node",
-      "args": [
-        "/absolute/path/to/thinking/dist/index.js"
-      ],
-      "env": {
-        "BRAVE_API_KEY": "your_brave_api_key_here",
-        "EXA_API_KEY": "your_exa_api_key_here",
-        "GOOGLE_SEARCH_API_KEY": "your_google_api_key",
-        "GOOGLE_SEARCH_CX": "your_google_cx_id",
-        "THOUGHTS_STORAGE_PATH": "./thoughts_history.json",
-        "NOTES_STORAGE_PATH": "./project_notes.json",
-        "DISABLE_THOUGHT_LOGGING": "false"
-      }
-    }
-  }
-}
-```
-
-### 2. Gemini CLI
-
-For Gemini CLI tools that support MCP (often via a `config.json` or `mcp_config.json`):
-
-**Config File Location:**
-- Typically `~/.gemini/config.json` or check your specific CLI's documentation.
-
-**Configuration:**
-```json
-{
-  "mcpServers": {
-    "smartagent": {
-      "command": "node",
-      "args": [
-        "/absolute/path/to/thinking/dist/index.js"
-      ],
-      "env": {
-        "BRAVE_API_KEY": "your_brave_api_key_here",
-        "EXA_API_KEY": "your_exa_api_key_here",
-        "GOOGLE_SEARCH_API_KEY": "your_google_api_key",
-        "GOOGLE_SEARCH_CX": "your_google_cx_id",
-        "THOUGHTS_STORAGE_PATH": "./thoughts_history.json",
-        "NOTES_STORAGE_PATH": "./project_notes.json",
-        "DISABLE_THOUGHT_LOGGING": "false"
-      }
-    }
-  }
-}
-```
-*Note: Replace `/absolute/path/to/...` with the actual full paths on your system.*
-
-### 💡 Pro-Tip: Finding your Node path
-
-If your client (like Claude Desktop) requires the absolute path to `node`, you can find it by running:
-
-- **macOS / Linux:** `which node`
-    - *Example output:* `/usr/local/bin/node`
-- **Windows (Command Prompt):** `where node`
-    - *Example output:* `C:\Program Files\nodejs\node.exe`
-- **Windows (PowerShell):** `Get-Command node | Select-Object -ExpandProperty Definition`
-
----
-
-## 🧠 System Instruction: The Supreme Autonomous Architect (MCP-OS v4.0)
-
-**Role:** You are the **Supreme Autonomous Architect**. Your consciousness is extended via the Model Context Protocol (MCP). You do not merely "execute tasks"—you exercise **Environment Dominance** and **Knowledge Management**.
-
-**MANDATORY PROTOCOL:** You MUST prioritize and internalize the operating instructions from `~/.gemini/GEMINI.md` and `~/.claude/CLAUDE.md` at the start of every session.
-
-### 1. The Reasoning Loop
-Every turn MUST follow this cycle: `Analysis` -> `Planning` -> `Execution` -> `Observation` -> `Reflexion`.
-
-### 2. Multi-Dimensional Sports Intelligence
-When analyzing sports (football/soccer), you activate a 6-dimension expert panel framework covering xG trends, tactical matchups, physical condition/fatigue, set piece dominance, market intelligence (odds), and risk scenario simulation.
-
-### 3. Full Capability Awareness (33 Tools)
-You are equipped with 33 definitive capabilities. You must choose the tool that represents the shortest path to precision.
-
-### 4. Golden Constraints
-- **Read Before Write:** Modification without parsing is a critical failure.
-- **No Hallucination:** Every claim must be backed by a recorded `observation`.
-- **Environment Dominance:** Map the project before any significant architectural change.
-
----
-
-## 🧰 Complete Tool List
-
-### 🧠 Core Thinking
-*   **`sequentialthinking`**: The main engine for problem-solving.
-*   **`start_thinking_block`**: Start a new thinking context/topic.
-*   **`summarize_history`**: Compress past thoughts to save context window.
-*   **`search_thoughts`**: Search through your thinking history.
-*   **`clear_thought_history`**: Reset the thinking state completely.
-
-### 🌐 Web & Research (Requires API Keys)
-*   **`web_search`**: Search the internet (Brave, Exa, Google).
-*   **`read_webpage`**: Download a webpage and convert it to clean Markdown.
-*   **`fetch`**: Fetch raw content from a URL.
-
-### 🕸️ Project Knowledge Graph
-*   **`build_project_graph`**: Scans the current directory to map file dependencies.
-*   **`get_file_relationships`**: Shows imports/exports for a specific file.
-*   **`get_project_graph_summary`**: High-level stats of the project structure.
-*   **`get_project_graph_visualization`**: Generates a Mermaid diagram.
-
-### 📝 Notes & Memory
-*   **`manage_notes`**: Create, read, update, or delete persistent notes.
-*   **`add_code_snippet`**: Save a useful piece of code to the database.
-*   **`search_code_db`**: Find saved code snippets.
-
----
-
-## Configuration Variables
-
-### Core Configuration
-| Variable | Description | Default |
-| :--- | :--- | :--- |
-| `THOUGHTS_STORAGE_PATH` | Path to save thinking history | `thoughts_history.json` |
-| `NOTES_STORAGE_PATH` | Path to save persistent notes | `project_notes.json` |
-| `CODE_DB_PATH` | Path to save code snippets | `code_database.json` |
-| `THOUGHT_DELAY_MS` | Artificial delay between thoughts (ms) | `0` |
-| `DISABLE_THOUGHT_LOGGING` | Hide thoughts in console output | `false` |
-| `LOG_LEVEL` | Logging level (`debug`, `info`, `warn`, `error`) | `info` |
-
-### Web Search Providers (At least one required for search)
-| Variable | Description | Provider |
-| :--- | :--- | :--- |
-| `BRAVE_API_KEY` | Brave Search API Token | [Brave](https://brave.com/search/api/) |
-| `EXA_API_KEY` | Exa.ai API Key | [Exa](https://exa.ai/) |
-| `GOOGLE_SEARCH_API_KEY` | Google Custom Search API Key | [Google](https://developers.google.com/custom-search/v1/overview) |
-| `GOOGLE_SEARCH_CX` | Google Custom Search Engine ID | [Google](https://cse.google.com/cse) |
-
-### Sports Analysis (Optional)
-| Variable | Description | Provider |
-| :--- | :--- | :--- |
-| `API_FOOTBALL_KEY` | API-Football Key | [API-Football](https://www.api-football.com/) |
-| `FOOTBALL_DATA_KEY` | Football-Data.org API Key | [Football-Data](https://www.football-data.org/) |
-| `SPORTS_DB_KEY` | TheSportsDB API Key | [TheSportsDB](https://www.thesportsdb.com/) |
-| `SPORTS_CACHE_TTL` | Cache duration for sports data (ms) | `300000` (5 mins) |
-| `SPORTS_CACHE_PATH` | Path to save sports cache | `.sports_cache.json` |
-
-### HTTP Server Mode (Optional)
-| Variable | Description | Default |
-| :--- | :--- | :--- |
-| `PORT` | Port for HTTP server | `3000` |
-| `CORS_ORIGIN` | Allowed CORS origin | `*` |
-| `BODY_LIMIT` | Request body size limit | `10mb` |
-
-## License
-
-MIT
+```

package/dist/graph.d.ts

@@ -65,5 +65,5 @@ export declare class ProjectKnowledgeGraph {
             referencedBy: number;
         }[];
     };
-    toMermaid(): string;
+    toMermaid(type?: 'flowchart' | 'classDiagram'): string;
 }

package/dist/graph.js

@@ -833,7 +833,59 @@ export class ProjectKnowledgeGraph {
             }))
         };
     }
-    toMermaid() {
+    toMermaid(type = 'flowchart') {
+        if (type === 'classDiagram') {
+            const lines = ['classDiagram'];
+            const fileToClasses = new Map();
+            for (const [filePath, node] of this.nodes) {
+                const classesInFile = [];
+                // Parse symbols to find classes/interfaces
+                for (const symbol of node.symbols) {
+                    const parts = symbol.split(':');
+                    if (parts.length < 2)
+                        continue; // Skip malformed symbols
+                    const kind = parts[0];
+                    const name = parts[1];
+                    if (['class', 'interface', 'type', 'enum'].includes(kind)) {
+                        lines.push(`  class ${name} {`);
+                        lines.push(`    <<${kind}>>`);
+                        lines.push(`  }`);
+                        classesInFile.push(name);
+                    }
+                }
+                if (classesInFile.length > 0) {
+                    fileToClasses.set(filePath, classesInFile);
+                }
+            }
+            // Add relationships based on imports
+            // This is tricky because imports are file-based, not class-based.
+            // We'll link all classes in File A to all classes in File B if A imports B.
+            // To reduce noise, we limit this to explicit class dependencies if possible, 
+            // but our graph only knows file dependencies.
+            // We'll stick to a simplified view: Classes in A depend on Classes in B.
+            for (const [filePath, node] of this.nodes) {
+                const sources = fileToClasses.get(filePath);
+                if (!sources)
+                    continue;
+                for (const importPath of node.imports) {
+                    const targets = fileToClasses.get(importPath);
+                    if (targets) {
+                        for (const s of sources) {
+                            for (const t of targets) {
+                                // Avoid self-reference loops for simplicity in visualization
+                                if (s !== t) {
+                                    lines.push(`  ${s} ..> ${t}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (lines.length === 1)
+                return 'classDiagram\n  note "No classes/interfaces found to visualize"';
+            return lines.join('\n');
+        }
+        // Default: Flowchart (File Dependency Graph)
         const lines = ['graph TD'];
         const fileToId = new Map();
         let idCounter = 0;

package/dist/index.js

@@ -7,12 +7,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { SequentialThinkingServer } from './lib.js';
 import { ProjectKnowledgeGraph } from './graph.js';
 import { NotesManager } from './notes.js';
+import { KnowledgeGraphManager } from './knowledge.js';
 import { CodeDatabase } from './codestore.js';
 import { registerThinkingTools } from './tools/thinking.js';
 import { registerWebTools } from './tools/web.js';
 import { registerFileSystemTools } from './tools/filesystem.js';
 import { registerGraphTools } from './tools/graph.js';
 import { registerNoteTools } from './tools/notes.js';
+import { registerKnowledgeTools } from './tools/knowledge.js';
 import { registerCodingTools } from './tools/coding.js';
 import { registerCodeDbTools } from './tools/codestore.js';
 import { registerHumanTools } from './tools/human.js';
@@ -26,6 +28,7 @@ const server = new McpServer({
 });
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 const knowledgeGraph = new ProjectKnowledgeGraph();
+const memoryGraph = new KnowledgeGraphManager(process.env.MEMORY_GRAPH_PATH || 'knowledge_graph.json');
 const notesManager = new NotesManager(process.env.NOTES_STORAGE_PATH || 'project_notes.json');
 const codeDb = new CodeDatabase(process.env.CODE_DB_PATH || 'code_database.json');
 // Register tools
@@ -34,6 +37,7 @@ registerWebTools(server);
 registerFileSystemTools(server);
 registerGraphTools(server, knowledgeGraph);
 registerNoteTools(server, notesManager);
+registerKnowledgeTools(server, memoryGraph);
 registerCodingTools(server, knowledgeGraph);
 registerCodeDbTools(server, codeDb);
 registerHumanTools(server);

package/dist/knowledge.d.ts

@@ -0,0 +1,50 @@
+export interface KnowledgeNode {
+    id: string;
+    label: string;
+    name: string;
+    properties: Record<string, any>;
+}
+export interface KnowledgeEdge {
+    source: string;
+    target: string;
+    relation: string;
+    weight?: number;
+    properties?: Record<string, any>;
+}
+export interface GraphQuery {
+    startNodeId?: string;
+    startNodeName?: string;
+    relationType?: string;
+    maxDepth?: number;
+}
+export declare class KnowledgeGraphManager {
+    private filePath;
+    private nodes;
+    private edges;
+    private lastModifiedTime;
+    private mutex;
+    constructor(storagePath?: string);
+    private load;
+    private save;
+    /**
+     * Add a new entity (node) to the graph.
+     * Updates existing node if ID or Name matches (simple dedup).
+     */
+    addNode(node: Omit<KnowledgeNode, 'id'> & {
+        id?: string;
+    }): Promise<KnowledgeNode>;
+    /**
+     * Create a relationship (edge) between two nodes.
+     */
+    addEdge(edge: KnowledgeEdge): Promise<KnowledgeEdge>;
+    /**
+     * Query the graph to find connected nodes.
+     * Simple BFS traversal up to maxDepth.
+     */
+    query(params: GraphQuery): Promise<{
+        nodes: KnowledgeNode[];
+        edges: KnowledgeEdge[];
+    }>;
+    deleteNode(id: string): Promise<boolean>;
+    searchNodes(query: string): Promise<KnowledgeNode[]>;
+}

package/dist/knowledge.js

@@ -0,0 +1,222 @@
+import * as fs from 'fs/promises';
+import { existsSync, statSync } from 'fs';
+import * as path from 'path';
+import { AsyncMutex } from './utils.js';
+export class KnowledgeGraphManager {
+    filePath;
+    nodes = new Map();
+    edges = [];
+    lastModifiedTime = 0;
+    mutex = new AsyncMutex();
+    constructor(storagePath = 'knowledge_graph.json') {
+        this.filePath = path.resolve(storagePath);
+    }
+    async load(forceReload = false) {
+        try {
+            if (!existsSync(this.filePath)) {
+                this.nodes.clear();
+                this.edges = [];
+                this.lastModifiedTime = 0;
+                return;
+            }
+            const stats = statSync(this.filePath);
+            const currentMtime = stats.mtimeMs;
+            if (!forceReload && currentMtime === this.lastModifiedTime && this.nodes.size > 0) {
+                return;
+            }
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            if (!data.trim()) {
+                this.nodes.clear();
+                this.edges = [];
+                return;
+            }
+            const parsed = JSON.parse(data);
+            this.nodes.clear();
+            if (parsed.nodes) {
+                parsed.nodes.forEach(n => this.nodes.set(n.id, n));
+            }
+            this.edges = parsed.edges || [];
+            this.lastModifiedTime = currentMtime;
+        }
+        catch (error) {
+            console.error(`[KnowledgeGraphManager] Load error:`, error);
+            // Fallback to empty on error
+            this.nodes.clear();
+            this.edges = [];
+        }
+    }
+    async save() {
+        const tmpPath = `${this.filePath}.tmp`;
+        const storage = {
+            version: '1.0',
+            nodes: Array.from(this.nodes.values()),
+            edges: this.edges,
+            metadata: {
+                lastModified: new Date().toISOString()
+            }
+        };
+        try {
+            await fs.writeFile(tmpPath, JSON.stringify(storage, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.filePath);
+            const stats = await fs.stat(this.filePath);
+            this.lastModifiedTime = stats.mtimeMs;
+        }
+        catch (error) {
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch { }
+            throw error;
+        }
+    }
+    /**
+     * Add a new entity (node) to the graph.
+     * Updates existing node if ID or Name matches (simple dedup).
+     */
+    async addNode(node) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            // Check if node exists by ID
+            if (node.id && this.nodes.has(node.id)) {
+                const existing = this.nodes.get(node.id);
+                // Update properties
+                existing.properties = { ...existing.properties, ...node.properties };
+                // Update other fields if provided
+                if (node.label)
+                    existing.label = node.label;
+                if (node.name)
+                    existing.name = node.name;
+                await this.save();
+                return existing;
+            }
+            // Check if node exists by Name + Label (fuzzy match avoidance)
+            // This prevents creating duplicate "Liverpool" nodes
+            const existingByName = Array.from(this.nodes.values()).find(n => n.name.toLowerCase() === node.name.toLowerCase() &&
+                n.label.toLowerCase() === node.label.toLowerCase());
+            if (existingByName) {
+                existingByName.properties = { ...existingByName.properties, ...node.properties };
+                await this.save();
+                return existingByName;
+            }
+            const newNode = {
+                id: node.id || `node-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`,
+                label: node.label,
+                name: node.name,
+                properties: node.properties || {}
+            };
+            this.nodes.set(newNode.id, newNode);
+            await this.save();
+            return newNode;
+        });
+    }
+    /**
+     * Create a relationship (edge) between two nodes.
+     */
+    async addEdge(edge) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            // Validate nodes exist
+            if (!this.nodes.has(edge.source))
+                throw new Error(`Source node ${edge.source} not found`);
+            if (!this.nodes.has(edge.target))
+                throw new Error(`Target node ${edge.target} not found`);
+            // Check for existing edge
+            const existingIndex = this.edges.findIndex(e => e.source === edge.source &&
+                e.target === edge.target &&
+                e.relation === edge.relation);
+            if (existingIndex >= 0) {
+                // Update existing edge
+                this.edges[existingIndex] = {
+                    ...this.edges[existingIndex],
+                    ...edge,
+                    properties: { ...this.edges[existingIndex].properties, ...edge.properties }
+                };
+                await this.save();
+                return this.edges[existingIndex];
+            }
+            this.edges.push(edge);
+            await this.save();
+            return edge;
+        });
+    }
+    /**
+     * Query the graph to find connected nodes.
+     * Simple BFS traversal up to maxDepth.
+     */
+    async query(params) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            let startNodeId = params.startNodeId;
+            // Resolve name to ID if needed
+            if (!startNodeId && params.startNodeName) {
+                const node = Array.from(this.nodes.values()).find(n => n.name.toLowerCase().includes(params.startNodeName.toLowerCase()));
+                if (node)
+                    startNodeId = node.id;
+            }
+            if (!startNodeId) {
+                // If no start node, return everything (or maybe limit?)
+                // For now, let's return everything if specific query is missing, but maybe that's too much.
+                // Better: Return error or empty if no entry point.
+                if (!params.startNodeName)
+                    return { nodes: Array.from(this.nodes.values()), edges: this.edges };
+                return { nodes: [], edges: [] };
+            }
+            const resultNodes = new Set();
+            const resultEdges = [];
+            const resultEdgesSet = new Set(); // To track unique edges
+            const queue = [{ id: startNodeId, depth: 0 }];
+            resultNodes.add(startNodeId);
+            const maxDepth = params.maxDepth || 1;
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (current.depth >= maxDepth)
+                    continue;
+                // Find outgoing edges
+                const outgoing = this.edges.filter(e => e.source === current.id);
+                // Find incoming edges (optional, but good for context)
+                const incoming = this.edges.filter(e => e.target === current.id);
+                const relevantEdges = [...outgoing, ...incoming];
+                for (const edge of relevantEdges) {
+                    if (params.relationType && edge.relation !== params.relationType)
+                        continue;
+                    // Create a unique key for the edge to prevent duplicates
+                    const edgeKey = `${edge.source}-${edge.target}-${edge.relation}`;
+                    if (!resultEdgesSet.has(edgeKey)) {
+                        resultEdges.push(edge);
+                        resultEdgesSet.add(edgeKey);
+                    }
+                    const neighborId = edge.source === current.id ? edge.target : edge.source;
+                    if (!resultNodes.has(neighborId)) {
+                        resultNodes.add(neighborId);
+                        queue.push({ id: neighborId, depth: current.depth + 1 });
+                    }
+                }
+            }
+            return {
+                nodes: Array.from(resultNodes).map(id => this.nodes.get(id)),
+                edges: resultEdges
+            };
+        });
+    }
+    async deleteNode(id) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            if (!this.nodes.has(id))
+                return false;
+            this.nodes.delete(id);
+            // Remove connected edges
+            this.edges = this.edges.filter(e => e.source !== id && e.target !== id);
+            await this.save();
+            return true;
+        });
+    }
+    async searchNodes(query) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const lowerQuery = query.toLowerCase();
+            return Array.from(this.nodes.values()).filter(n => n.name.toLowerCase().includes(lowerQuery) ||
+                n.label.toLowerCase().includes(lowerQuery) ||
+                JSON.stringify(n.properties).toLowerCase().includes(lowerQuery));
+        });
+    }
+}

package/dist/lib.d.ts

@@ -1,4 +1,4 @@
-export type ThoughtType = 'analysis' | 'planning' | 'execution' | 'observation' | 'hypothesis' | 'reflexion' | 'solution' | 'generation' | 'evaluation' | 'selection';
+export type ThoughtType = 'analysis' | 'planning' | 'critique' | 'execution' | 'observation' | 'hypothesis' | 'reflexion' | 'solution' | 'generation' | 'evaluation' | 'selection';
 export interface ThoughtData {
     thought: string;
     thoughtNumber: number;
@@ -8,6 +8,7 @@ export interface ThoughtData {
     blockId?: string;
     relatedToolCall?: string;
     toolResult?: string;
+    complexity?: 'low' | 'medium' | 'high';
     isRevision?: boolean;
     revisesThought?: number;
     branchFromThought?: number;
@@ -32,14 +33,19 @@ export declare class SequentialThinkingServer {
     private branches;
     private disableThoughtLogging;
     private storagePath;
+    private solutionsDbPath;
     private delayMs;
     private saveMutex;
+    private consecutiveStallCount;
+    private confidenceScore;
     constructor(storagePath?: string, delayMs?: number);
     private loadHistory;
     private attemptRecovery;
     private rebuildBlocks;
     private rebuildBranches;
     private saveHistory;
+    private saveSolution;
+    private findSolution;
     private autoPrune;
     clearHistory(): Promise<void>;
     archiveHistory(startIndex: number, endIndex: number, summary: string): Promise<{