@gotza02/sequential-thinking 2026.3.10 → 2026.3.11

package/dist/core/ContextManager.d.ts

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

package/dist/core/ContextManager.js

@@ -0,0 +1,62 @@
+export class ContextManager {
+    summaryCache = new Map();
+    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 activeBlock = history.filter(t => t.blockId === safeCurrentBlockId);
+        const summaries = await this.compressOldBlocks(oldBlocks);
+        // Format active block detailed
+        const activeContext = activeBlock.map(t => `[${t.thoughtType?.toUpperCase() || 'INFO'}] #${t.thoughtNumber}: ${t.thought}`).join('\n');
+        return `
+=== PROJECT HISTORY (SUMMARIZED) ===
+${summaries}
+
+=== 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
+            if (!blockId)
+                continue;
+            const cached = this.summaryCache.get(blockId);
+            if (cached && cached.count === thoughts.length) {
+                result += `[Block: ${blockId}] Summary: ${cached.summary}\n`;
+            }
+            else {
+                if (thoughts.length > 2) {
+                    const 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`;
+                }
+            }
+        }
+        return result;
+    }
+    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);
+        });
+        return map;
+    }
+    async generateSummary(thoughts) {
+        // Mock implementation
+        const decisions = thoughts.filter(t => t.thoughtType === 'planning' || t.thoughtType === 'selection').length;
+        const executions = thoughts.filter(t => t.thoughtType === 'execution').length;
+        const topic = thoughts[0]?.thought.substring(0, 30) || 'Unknown';
+        return `Topic: "${topic}...". Processed ${thoughts.length} steps (${decisions} plans, ${executions} actions). Outcome: Handed off or completed.`;
+    }
+}

package/dist/lib.d.ts

@@ -38,6 +38,7 @@ export declare class SequentialThinkingServer {
     private saveMutex;
     private consecutiveStallCount;
     private confidenceScore;
+    private contextManager;
     constructor(storagePath?: string, delayMs?: number);
     private loadHistory;
     private attemptRecovery;

package/dist/lib.js

@@ -3,6 +3,7 @@ import * as fs from 'fs/promises';
 import { existsSync, readFileSync } from 'fs';
 import * as path from 'path';
 import { AsyncMutex } from './utils.js';
+import { ContextManager } from './core/ContextManager.js';
 export class SequentialThinkingServer {
     thoughtHistory = [];
     blocks = [];
@@ -15,6 +16,7 @@ export class SequentialThinkingServer {
     saveMutex = new AsyncMutex();
     consecutiveStallCount = 0; // Track consecutive stalls/loops
     confidenceScore = 100; // Meta-Cognition Score (0-100)
+    contextManager = new ContextManager();
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -439,9 +441,9 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             let feedbackExtension = "";
             // --- 🔄 FEATURE 0: Smart Branching Reward (Reset Confidence on Pivot) ---
             if (input.branchFromThought) {
-                if (this.confidenceScore < 90) {
-                    this.confidenceScore = 90;
-                    feedbackExtension += `\n🌿 BRANCH DETECTED: Confidence restored to 90. Good decision to pivot.`;
+                if (this.confidenceScore < 75) {
+                    this.confidenceScore = 75;
+                    feedbackExtension += `\n🌿 BRANCH DETECTED: Confidence restored to 75. Good decision to pivot.`;
                 }
             }
             // --- 🧠 FEATURE 1: Semantic Thought Recall ---
@@ -681,6 +683,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             // D. Generate Contextual Output
             const currentBlock = this.blocks.find(b => b.id === input.blockId);
             const mermaid = this.generateMermaid();
+            const optimizedContext = await this.contextManager.getOptimizedContext(this.thoughtHistory, input.blockId || null);
             if (feedbackExtension)
                 warnings.push(feedbackExtension);
             return {
@@ -694,6 +697,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                             blockContext: currentBlock
                                 ? `Block '${currentBlock.topic.substring(0, 30)}' has ${currentBlock.thoughts.length} thoughts.`
                                 : 'No active block',
+                            optimizedContext,
                             branches: Object.keys(this.branches),
                             thoughtHistoryLength: this.thoughtHistory.length,
                             feedback: warnings.length > 0 ? warnings : "Flow Healthy ✅",

package/package.json

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