@gotza02/sequential-thinking 2026.3.11 → 2026.3.12

package/dist/core/ContextManager.d.ts

@@ -1,9 +1,12 @@
 import { ThoughtData } from '../lib.js';
 export declare class ContextManager {
     private summaryCache;
+    private readonly STOP_WORDS;
     constructor();
     getOptimizedContext(history: ThoughtData[], currentBlockId: string | null): Promise<string>;
-    private compressOldBlocks;
-    private groupByBlock;
+    private getBlockSummaries;
+    private selectRelevantBlocks;
+    private extractKeywords;
+    private calculateOverlap;
     private generateSummary;
 }

package/dist/core/ContextManager.js

@@ -1,56 +1,137 @@
 export class ContextManager {
     summaryCache = new Map();
+    STOP_WORDS = new Set([
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by',
+        'is', 'are', 'was', 'were', 'be', 'been', 'being',
+        'have', 'has', 'had', 'do', 'does', 'did',
+        'it', 'this', 'that', 'these', 'those',
+        'i', 'you', 'he', 'she', 'we', 'they',
+        'from', 'as', 'what', 'which', 'when', 'where', 'how', 'why'
+    ]);
     constructor() { }
     async getOptimizedContext(history, currentBlockId) {
-        // If no current block, treat everything as old or just show all?
-        // If null, we might be in setup mode. Let's assume empty current block.
         const safeCurrentBlockId = currentBlockId || '';
-        const oldBlocks = history.filter(t => t.blockId !== safeCurrentBlockId);
+        const oldBlocksThoughts = history.filter(t => t.blockId !== safeCurrentBlockId);
         const activeBlock = history.filter(t => t.blockId === safeCurrentBlockId);
-        const summaries = await this.compressOldBlocks(oldBlocks);
+        // 1. Get all summaries (with caching)
+        const allSummaries = await this.getBlockSummaries(oldBlocksThoughts);
+        // 2. Select relevant summaries (Smart Context)
+        // Query = Active block content + Current Topic (if any)
+        const currentTopic = activeBlock.length > 0 ? activeBlock[0].thought.substring(0, 50) : '';
+        const queryText = currentTopic + " " + activeBlock.map(t => t.thought).join(' ');
+        const selectedSummaries = this.selectRelevantBlocks(allSummaries, queryText);
+        // 3. Format Output
+        let summariesText = "";
+        if (selectedSummaries.length === 0 && allSummaries.length > 0) {
+            // Fallback: If no relevant found (rare), show last 2
+            const recent = allSummaries.sort((a, b) => b.lastUpdated - a.lastUpdated).slice(0, 2);
+            summariesText = recent.map(s => `[Block: ${s.blockId}] Summary: ${s.summary}`).join('\n');
+        }
+        else {
+            summariesText = selectedSummaries.map(s => `[Block: ${s.blockId}] Summary: ${s.summary}`).join('\n');
+        }
         // Format active block detailed
         const activeContext = activeBlock.map(t => `[${t.thoughtType?.toUpperCase() || 'INFO'}] #${t.thoughtNumber}: ${t.thought}`).join('\n');
         return `
-=== PROJECT HISTORY (SUMMARIZED) ===
-${summaries}
+=== PROJECT HISTORY (SMART CONTEXT) ===
+${summariesText}
 
 === CURRENT FOCUS (DETAILED: ${safeCurrentBlockId || 'GLOBAL'}) ===
 ${activeContext}
 `;
     }
-    async compressOldBlocks(logs) {
-        const groups = this.groupByBlock(logs);
-        let result = '';
-        for (const [blockId, thoughts] of groups) {
-            // Skip blocks with undefined or empty blockId if they sneak in
+    async getBlockSummaries(logs) {
+        // 1. Group by block (maintaining order)
+        const groups = new Map();
+        logs.forEach((log, index) => {
+            const bid = log.blockId || 'default';
+            if (!groups.has(bid)) {
+                groups.set(bid, { thoughts: [], maxIndex: -1 });
+            }
+            const group = groups.get(bid);
+            group.thoughts.push(log);
+            group.maxIndex = index; // Always updates to the latest index encountered
+        });
+        const results = [];
+        for (const [blockId, data] of groups) {
             if (!blockId)
                 continue;
+            const { thoughts, maxIndex } = data;
+            let summary = "";
             const cached = this.summaryCache.get(blockId);
             if (cached && cached.count === thoughts.length) {
-                result += `[Block: ${blockId}] Summary: ${cached.summary}\n`;
+                summary = cached.summary;
             }
             else {
                 if (thoughts.length > 2) {
-                    const summary = await this.generateSummary(thoughts);
+                    summary = await this.generateSummary(thoughts);
                     this.summaryCache.set(blockId, { summary, count: thoughts.length });
-                    result += `[Block: ${blockId}] Summary: ${summary}\n`;
                 }
                 else {
-                    result += `[Block: ${blockId}] ${thoughts.map(t => t.thought).join(' -> ')}\n`;
+                    summary = thoughts.map(t => t.thought).join(' -> ');
                 }
             }
+            // Extract topic from first thought or blockId
+            const topic = thoughts[0]?.thought.substring(0, 50) || blockId;
+            results.push({
+                blockId,
+                summary,
+                topic,
+                lastUpdated: maxIndex // Use the array index as the source of truth for recency
+            });
         }
-        return result;
+        return results;
     }
-    groupByBlock(logs) {
-        const map = new Map();
-        logs.forEach(log => {
-            const bid = log.blockId || 'default';
-            const items = map.get(bid) || [];
-            items.push(log);
-            map.set(bid, items);
+    selectRelevantBlocks(candidates, query) {
+        if (candidates.length === 0)
+            return [];
+        const queryKeywords = this.extractKeywords(query);
+        const scored = candidates.map(block => {
+            const blockKeywords = this.extractKeywords(block.topic + " " + block.summary);
+            const score = this.calculateOverlap(queryKeywords, blockKeywords);
+            return { block, score };
+        });
+        // Sort by score descending, then recency
+        scored.sort((a, b) => {
+            if (a.score !== b.score)
+                return b.score - a.score;
+            return b.block.lastUpdated - a.block.lastUpdated;
         });
-        return map;
+        // Always include the immediate previous block (for continuity)
+        // Find the block with the highest lastUpdated
+        const lastBlock = candidates.reduce((prev, current) => (prev.lastUpdated > current.lastUpdated) ? prev : current);
+        const selected = new Set();
+        selected.add(lastBlock); // Always add last block
+        // Add Top N relevant blocks
+        for (const item of scored) {
+            if (selected.size >= 4)
+                break; // Max 4 blocks context
+            if (item.score > 0) { // Only if there is some relevance
+                selected.add(item.block);
+            }
+        }
+        // Return sorted by recency (oldest to newest) for logical flow
+        return Array.from(selected).sort((a, b) => a.lastUpdated - b.lastUpdated);
+    }
+    extractKeywords(text) {
+        const tokens = text.toLowerCase()
+            .replace(/[^a-z0-9\s]/g, '') // Remove symbols
+            .split(/\s+/);
+        const keywords = new Set();
+        for (const t of tokens) {
+            if (t.length > 2 && !this.STOP_WORDS.has(t)) {
+                keywords.add(t);
+            }
+        }
+        return keywords;
+    }
+    calculateOverlap(setA, setB) {
+        let intersection = 0;
+        for (const elem of setA) {
+            if (setB.has(elem))
+                intersection++;
+        }
+        return intersection;
     }
     async generateSummary(thoughts) {
         // Mock implementation

package/dist/core/RuleManager.d.ts

@@ -0,0 +1,10 @@
+export declare class RuleManager {
+    private rules;
+    private storagePath;
+    constructor(storagePath?: string);
+    private loadRules;
+    private saveRules;
+    addRule(trigger: string, warning: string): Promise<void>;
+    checkRules(execution: string): string[];
+    getRulesSummary(): string;
+}

package/dist/core/RuleManager.js

@@ -0,0 +1,62 @@
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import * as path from 'path';
+export class RuleManager {
+    rules = [];
+    storagePath;
+    constructor(storagePath = 'learned_rules.json') {
+        this.storagePath = path.resolve(storagePath);
+        this.loadRules();
+    }
+    async loadRules() {
+        try {
+            if (existsSync(this.storagePath)) {
+                const data = await fs.readFile(this.storagePath, 'utf-8');
+                this.rules = JSON.parse(data);
+            }
+        }
+        catch (error) {
+            console.error('[RuleManager] Error loading rules:', error);
+        }
+    }
+    async saveRules() {
+        try {
+            await fs.writeFile(this.storagePath, JSON.stringify(this.rules, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('[RuleManager] Error saving rules:', error);
+        }
+    }
+    async addRule(trigger, warning) {
+        const existing = this.rules.find(r => r.trigger === trigger);
+        if (existing) {
+            existing.failCount++;
+            existing.warning = warning; // Update with latest context
+        }
+        else {
+            this.rules.push({
+                trigger,
+                warning,
+                createdAt: new Date().toISOString(),
+                failCount: 1
+            });
+        }
+        await this.saveRules();
+    }
+    checkRules(execution) {
+        const warnings = [];
+        const lowerExec = execution.toLowerCase();
+        for (const rule of this.rules) {
+            // Simple keyword check or exact match
+            if (lowerExec.includes(rule.trigger.toLowerCase())) {
+                warnings.push(`🛡️ IMMUNE SYSTEM WARNING: This action previously failed. Lesson: "${rule.warning}"`);
+            }
+        }
+        return warnings;
+    }
+    getRulesSummary() {
+        if (this.rules.length === 0)
+            return "No rules learned yet.";
+        return this.rules.map(r => `- [${r.trigger}] ${r.warning}`).join('\n');
+    }
+}

package/dist/dashboard/server.d.ts

@@ -0,0 +1,2 @@
+import * as http from 'http';
+export declare function startDashboard(port: number, historyPath: string): Promise<http.Server>;

package/dist/dashboard/server.js

@@ -0,0 +1,67 @@
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function startDashboard(port, historyPath) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            // Handle CORS
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET');
+            if (req.url === '/') {
+                // Serve index.html
+                const indexPath = path.join(__dirname, 'index.html');
+                fs.readFile(indexPath, (err, data) => {
+                    if (err) {
+                        res.writeHead(500);
+                        res.end('Error loading dashboard');
+                        return;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(data);
+                });
+            }
+            else if (req.url === '/api/history') {
+                // Serve thoughts_history.json
+                fs.readFile(historyPath, (err, data) => {
+                    if (err) {
+                        // Try .tmp if main file is locked/missing (rare fallback)
+                        fs.readFile(historyPath + '.tmp', (err2, data2) => {
+                            if (err2) {
+                                res.writeHead(500);
+                                res.end(JSON.stringify({ error: 'History not found' }));
+                                return;
+                            }
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(data2);
+                        });
+                        return;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(data);
+                });
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+        server.on('error', (e) => {
+            if (e.code === 'EADDRINUSE') {
+                console.error(`[Dashboard] Port ${port} is busy. Trying ${port + 1}...`);
+                // Recursive retry
+                startDashboard(port + 1, historyPath).then(resolve).catch(reject);
+            }
+            else {
+                console.error('[Dashboard] Server error:', e);
+                reject(e);
+            }
+        });
+        server.listen(port, () => {
+            console.error(`[Dashboard] 📊 Dashboard running at http://localhost:${port}`);
+            resolve(server);
+        });
+    });
+}

package/dist/index.js

@@ -19,6 +19,7 @@ import { registerCodingTools } from './tools/coding.js';
 import { registerCodeDbTools } from './tools/codestore.js';
 import { registerHumanTools } from './tools/human.js';
 import { registerSportsTools } from './tools/sports.js';
+import { startDashboard } from './dashboard/server.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -27,6 +28,11 @@ const server = new McpServer({
     version: pkg.version,
 });
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
+// Start Dashboard
+const historyPath = process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json';
+startDashboard(3001, historyPath).catch(err => {
+    console.error("[Dashboard] Failed to start:", err);
+});
 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');

package/dist/lib.d.ts

@@ -39,6 +39,7 @@ export declare class SequentialThinkingServer {
     private consecutiveStallCount;
     private confidenceScore;
     private contextManager;
+    private ruleManager;
     constructor(storagePath?: string, delayMs?: number);
     private loadHistory;
     private attemptRecovery;
@@ -71,5 +72,6 @@ export declare class SequentialThinkingServer {
         thoughtCount: number;
     }[];
     getHistoryLength(): number;
+    private learnFromFailures;
 }
 export {};

package/dist/lib.js

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from 'fs';
 import * as path from 'path';
 import { AsyncMutex } from './utils.js';
 import { ContextManager } from './core/ContextManager.js';
+import { RuleManager } from './core/RuleManager.js';
 export class SequentialThinkingServer {
     thoughtHistory = [];
     blocks = [];
@@ -17,6 +18,7 @@ export class SequentialThinkingServer {
     consecutiveStallCount = 0; // Track consecutive stalls/loops
     confidenceScore = 100; // Meta-Cognition Score (0-100)
     contextManager = new ContextManager();
+    ruleManager = new RuleManager();
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -523,6 +525,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                 const oldBlock = this.blocks.find(b => b.id === this.currentBlockId);
                 if (oldBlock) {
                     oldBlock.status = 'completed';
+                    await this.learnFromFailures(oldBlock.id);
                     // Auto-Summary Trigger
                     if (oldBlock.thoughts.length > 5) {
                         warnings.push(`📜 CONTEXT MANAGEMENT: Previous block '${oldBlock.topic.substring(0, 30)}...' was long. Please use 'summarize_history' to compress it.`);
@@ -560,10 +563,16 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                 }
             }
             // Rule 2: Repeating Action Detection
-            if (input.thoughtType === 'execution' &&
-                recentInBlock.some(t => t.thoughtType === 'execution' && t.thought === input.thought)) {
-                warnings.push(`🛑 LOOP DETECTED: You are attempting to execute the exact same action again. You MUST change your strategy or create a branch with a different approach.`);
-                isStallingOrLooping = true;
+            if (input.thoughtType === 'execution') {
+                // Check Immune System Rules
+                const ruleWarnings = this.ruleManager.checkRules(input.thought);
+                ruleWarnings.forEach(w => warnings.push(w));
+                if (ruleWarnings.length > 0)
+                    this.confidenceScore -= 10;
+                if (recentInBlock.some(t => t.thoughtType === 'execution' && t.thought === input.thought)) {
+                    warnings.push(`🛑 LOOP DETECTED: You are attempting to execute the exact same action again. You MUST change your strategy or create a branch with a different approach.`);
+                    isStallingOrLooping = true;
+                }
             }
             // Rule 3: Missing Observation
             if (lastThought &&
@@ -646,6 +655,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                         .filter(t => t.thoughtType === 'execution')
                         .map(t => t.thought);
                     const activeBlock = this.blocks.find(b => b.id === input.blockId);
+                    await this.learnFromFailures(input.blockId || "");
                     await this.saveSolution(activeBlock?.topic || 'Untitled', input.thought, solutionSteps);
                 }
             }
@@ -662,7 +672,10 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             // --- 📊 Update Confidence Score ---
             if (warnings.length > 0)
                 this.confidenceScore -= (5 * warnings.length);
-            if (input.thoughtType === 'observation') {
+            if (input.thoughtType === 'reflexion') {
+                this.confidenceScore = Math.min(100, this.confidenceScore + 10);
+            }
+            else if (input.thoughtType === 'observation') {
                 const isError = input.toolResult?.toLowerCase().includes('error');
                 if (isError)
                     this.confidenceScore -= 10;
@@ -805,4 +818,18 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
     getHistoryLength() {
         return this.thoughtHistory.length;
     }
+    async learnFromFailures(blockId) {
+        const blockThoughts = this.thoughtHistory.filter(t => t.blockId === blockId);
+        for (let i = 0; i < blockThoughts.length - 1; i++) {
+            const current = blockThoughts[i];
+            const next = blockThoughts[i + 1];
+            if (current.thoughtType === 'execution' && next.thoughtType === 'observation') {
+                const res = next.toolResult?.toLowerCase() || "";
+                // Failure keywords
+                if (res.includes("error") || res.includes("fail") || res.includes("exception") || res.includes("enoent")) {
+                    await this.ruleManager.addRule(current.thought, res.substring(0, 100).replace(/\n/g, ' '));
+                }
+            }
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.3.11",
+  "version": "2026.3.12",
   "publishConfig": {
     "access": "public"
   },