@gotza02/sequential-thinking 2026.2.30 → 2026.2.32

package/dist/lib.js

@@ -63,53 +63,104 @@ export class SequentialThinkingServer {
         }
     }
     attemptRecovery(data) {
-        const lastBrace = data.lastIndexOf('}');
-        if (lastBrace !== -1) {
+        // Try incremental approach: find the longest valid JSON prefix
+        let braceCount = 0;
+        let lastValidIndex = -1;
+        for (let i = 0; i < data.length; i++) {
+            const char = data[i];
+            if (char === '{') {
+                braceCount++;
+            }
+            else if (char === '}') {
+                braceCount--;
+                // When brace count returns to 0, we have a complete object
+                if (braceCount === 0) {
+                    lastValidIndex = i;
+                }
+            }
+        }
+        if (lastValidIndex !== -1) {
             try {
-                const recoveredData = data.substring(0, lastBrace + 1).trim();
-                const attemptedJson = recoveredData.endsWith(']') ? recoveredData : recoveredData + ']';
-                const history = JSON.parse(attemptedJson);
-                if (Array.isArray(history)) {
-                    history.forEach(thought => this.addToMemory(thought));
+                const recoveredData = data.substring(0, lastValidIndex + 1).trim();
+                const parsed = JSON.parse(recoveredData);
+                // Handle new format with version
+                if (parsed.version && parsed.blocks) {
+                    this.blocks = parsed.blocks;
+                    this.thoughtHistory = parsed.thoughtHistory || [];
+                    if (this.blocks.length > 0) {
+                        const activeBlock = this.blocks.find(b => b.status === 'active');
+                        this.currentBlockId = activeBlock?.id || this.blocks[this.blocks.length - 1].id;
+                    }
+                    this.rebuildBranches();
+                    console.log(`Successfully recovered ${this.thoughtHistory.length} thoughts from new format.`);
+                    return;
+                }
+                // Handle legacy array format
+                if (Array.isArray(parsed)) {
+                    parsed.forEach(thought => this.addToMemory(thought));
                     this.rebuildBlocks();
-                    console.log(`Successfully recovered ${history.length} thoughts.`);
+                    console.log(`Successfully recovered ${parsed.length} thoughts from legacy format.`);
                 }
             }
             catch (recoveryError) {
                 console.error('Recovery failed, starting with empty history.');
             }
         }
+        else {
+            console.error('No valid JSON structure found for recovery.');
+        }
     }
     rebuildBlocks() {
+        // Map existing blocks to preserve their metadata
         const oldBlocksMap = new Map();
         for (const b of this.blocks) {
-            oldBlocksMap.set(b.id, b);
+            oldBlocksMap.set(b.id, { ...b });
         }
-        this.blocks = [];
-        const blockMap = new Map();
+        // Map thoughts by blockId from thoughtHistory
+        const thoughtsByBlock = new Map();
         for (const t of this.thoughtHistory) {
             const bid = t.blockId || 'default';
-            if (!blockMap.has(bid)) {
-                const oldBlock = oldBlocksMap.get(bid);
-                const newBlock = {
-                    id: bid,
-                    topic: oldBlock ? oldBlock.topic : t.thought.substring(0, 50),
-                    status: oldBlock ? oldBlock.status : 'active',
-                    thoughts: [],
-                    createdAt: oldBlock ? oldBlock.createdAt : new Date().toISOString(),
-                    updatedAt: new Date().toISOString()
-                };
-                blockMap.set(bid, newBlock);
-                this.blocks.push(newBlock);
+            if (!thoughtsByBlock.has(bid)) {
+                thoughtsByBlock.set(bid, []);
             }
-            blockMap.get(bid).thoughts.push(t);
+            thoughtsByBlock.get(bid).push(t);
         }
-        if (this.blocks.length > 0) {
-            // Ensure currentBlockId points to a valid block or the last one
-            if (!this.blocks.find(b => b.id === this.currentBlockId)) {
-                this.currentBlockId = this.blocks[this.blocks.length - 1].id;
+        // Merge old blocks with new thoughts
+        const mergedBlocks = [];
+        const mergedBlockIds = new Set();
+        // First, update existing blocks with their thoughts
+        for (const [bid, thoughts] of thoughtsByBlock) {
+            const oldBlock = oldBlocksMap.get(bid);
+            // Merge old thoughts with new thoughts (avoid duplicates by thoughtNumber)
+            const oldThoughts = oldBlock?.thoughts || [];
+            const oldThoughtNumbers = new Set(oldThoughts.map(t => t.thoughtNumber));
+            const newThoughts = thoughts.filter(t => !oldThoughtNumbers.has(t.thoughtNumber));
+            const mergedThoughts = [...oldThoughts, ...newThoughts];
+            const mergedBlock = {
+                id: bid,
+                topic: oldBlock?.topic || thoughts[0]?.thought.substring(0, 50) || 'Untitled',
+                status: oldBlock?.status || 'active',
+                thoughts: mergedThoughts,
+                createdAt: oldBlock?.createdAt || new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            mergedBlocks.push(mergedBlock);
+            mergedBlockIds.add(bid);
+        }
+        // Then, preserve blocks that have no thoughts in current thoughtHistory
+        for (const [bid, oldBlock] of oldBlocksMap) {
+            if (!mergedBlockIds.has(bid)) {
+                mergedBlocks.push(oldBlock);
             }
         }
+        this.blocks = mergedBlocks;
+        // Ensure currentBlockId points to a valid block
+        if (this.blocks.length > 0) {
+            const activeBlock = this.blocks.find(b => b.status === 'active');
+            this.currentBlockId = activeBlock?.id ||
+                (this.blocks.find(b => b.id === this.currentBlockId)?.id) ||
+                this.blocks[this.blocks.length - 1].id;
+        }
         else {
             this.currentBlockId = null;
         }
@@ -409,6 +460,11 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                 recentInBlock.every(t => t.thoughtType === input.thoughtType)) {
                 warnings.push(`⚠️ TYPE LOOP: You've used '${input.thoughtType}' for 4 consecutive steps. Consider using a different thought type to progress.`);
             }
+            // Rule 7: Struggle Detection (Rule of 3)
+            const executionCount = blockThoughts.filter(t => t.thoughtType === 'execution').length;
+            if (executionCount >= 3 && input.thoughtType === 'execution') {
+                warnings.push(`🛑 STRUGGLE DETECTED: You have executed 3+ commands in this block without reaching a solution. If you are fixing a bug and it's not working, STOP. Do not try a 4th time linearly. Use 'branchFromThought' to try a completely different approach.`);
+            }
             // C. Update State
             this.addToMemory(input);
             await this.saveHistory();

package/dist/notes.d.ts

@@ -12,14 +12,51 @@ export interface Note {
 export declare class NotesManager {
     private filePath;
     private notes;
-    private loaded;
+    private lastModifiedTime;
     private mutex;
     constructor(storagePath?: string);
+    /**
+     * Load notes from disk with automatic reload detection.
+     * Uses mtime to detect if file has been modified externally.
+     */
     private load;
+    /**
+     * Attempt to recover notes from corrupted JSON using incremental parsing.
+     * Similar to the approach in lib.ts but adapted for notes format.
+     */
+    private attemptRecovery;
+    /**
+     * Backup corrupted file with timestamp
+     */
+    private backupCorruptedFile;
+    /**
+     * Atomic save using write-to-temp + rename pattern.
+     * This ensures either the old file or new file exists, never a partial write.
+     */
     private save;
+    /**
+     * Reload notes from disk (useful for external changes)
+     */
+    reload(): Promise<void>;
     addNote(title: string, content: string, tags?: string[], priority?: Priority, expiresAt?: string): Promise<Note>;
     listNotes(tag?: string, includeExpired?: boolean): Promise<Note[]>;
     searchNotes(query: string): Promise<Note[]>;
     deleteNote(id: string): Promise<boolean>;
-    updateNote(id: string, updates: Partial<Pick<Note, 'title' | 'content' | 'tags'>>): Promise<Note | null>;
+    updateNote(id: string, updates: Partial<Pick<Note, 'title' | 'content' | 'tags' | 'priority' | 'expiresAt'>>): Promise<Note | null>;
+    /**
+     * Get a single note by ID
+     */
+    getNote(id: string): Promise<Note | null>;
+    /**
+     * Clear all notes (use with caution!)
+     */
+    clearAll(): Promise<void>;
+    /**
+     * Export notes as JSON string
+     */
+    export(): Promise<string>;
+    /**
+     * Import notes from JSON string
+     */
+    import(jsonData: string, merge?: boolean): Promise<number>;
 }

package/dist/notes.js

@@ -1,52 +1,185 @@
 import * as fs from 'fs/promises';
+import { existsSync, statSync } from 'fs';
 import * as path from 'path';
 import { AsyncMutex } from './utils.js';
 export class NotesManager {
     filePath;
     notes = [];
-    loaded = false;
+    lastModifiedTime = 0; // mtime for reload detection
     mutex = new AsyncMutex();
     constructor(storagePath = 'project_notes.json') {
         this.filePath = path.resolve(storagePath);
     }
-    async load() {
-        if (this.loaded)
-            return;
+    /**
+     * Load notes from disk with automatic reload detection.
+     * Uses mtime to detect if file has been modified externally.
+     */
+    async load(forceReload = false) {
         try {
+            // Check if file exists and get its mtime
+            if (!existsSync(this.filePath)) {
+                this.notes = [];
+                this.lastModifiedTime = 0;
+                return;
+            }
+            const stats = statSync(this.filePath);
+            const currentMtime = stats.mtimeMs;
+            // Skip reload if file hasn't been modified (unless forced)
+            if (!forceReload && currentMtime === this.lastModifiedTime && this.notes.length > 0) {
+                return;
+            }
             const data = await fs.readFile(this.filePath, 'utf-8');
-            this.notes = JSON.parse(data);
+            if (!data.trim()) {
+                this.notes = [];
+                this.lastModifiedTime = currentMtime;
+                return;
+            }
+            try {
+                const parsed = JSON.parse(data);
+                // New format with version
+                if (parsed.version && parsed.notes) {
+                    this.notes = parsed.notes || [];
+                }
+                // Legacy format (direct array)
+                else if (Array.isArray(parsed)) {
+                    this.notes = parsed;
+                }
+                // Invalid format
+                else {
+                    throw new Error('Invalid storage format');
+                }
+                this.lastModifiedTime = currentMtime;
+            }
+            catch (parseError) {
+                console.error(`[NotesManager] Parse error, attempting recovery:`, parseError);
+                this.attemptRecovery(data);
+                this.lastModifiedTime = currentMtime;
+            }
         }
         catch (error) {
-            // Case 1: File doesn't exist (Normal first run)
             if (error.code === 'ENOENT') {
                 this.notes = [];
+                this.lastModifiedTime = 0;
             }
-            // Case 2: Corrupted JSON or other read errors
             else {
-                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-                const backupPath = `${this.filePath}.bak.${timestamp}`;
-                try {
-                    // Try to backup the corrupted file
-                    await fs.rename(this.filePath, backupPath);
-                    console.error(`[NotesManager] Error reading notes file. Corrupted file backed up to: ${backupPath}`);
+                console.error(`[NotesManager] Load error:`, error);
+                this.notes = [];
+                this.lastModifiedTime = 0;
+            }
+        }
+    }
+    /**
+     * Attempt to recover notes from corrupted JSON using incremental parsing.
+     * Similar to the approach in lib.ts but adapted for notes format.
+     */
+    attemptRecovery(data) {
+        let braceCount = 0;
+        let lastValidIndex = -1;
+        for (let i = 0; i < data.length; i++) {
+            const char = data[i];
+            if (char === '{') {
+                braceCount++;
+            }
+            else if (char === '}') {
+                braceCount--;
+                if (braceCount === 0) {
+                    lastValidIndex = i;
                 }
-                catch (backupError) {
-                    console.error(`[NotesManager] Critical: Failed to backup corrupted notes file: ${backupError}`);
+            }
+        }
+        if (lastValidIndex !== -1) {
+            try {
+                const recoveredData = data.substring(0, lastValidIndex + 1).trim();
+                const parsed = JSON.parse(recoveredData);
+                // Try to extract notes from recovered data
+                if (parsed.version && parsed.notes) {
+                    this.notes = parsed.notes;
+                    console.log(`[NotesManager] Recovered ${this.notes.length} notes from new format.`);
+                }
+                else if (Array.isArray(parsed)) {
+                    this.notes = parsed;
+                    console.log(`[NotesManager] Recovered ${this.notes.length} notes from legacy format.`);
+                }
+                else if (parsed.notes && Array.isArray(parsed.notes)) {
+                    this.notes = parsed.notes;
+                    console.log(`[NotesManager] Recovered ${this.notes.length} notes.`);
                 }
-                // Initialize empty to allow system to recover
+                else {
+                    this.notes = [];
+                }
+                // Backup the corrupted file
+                this.backupCorruptedFile(data);
+            }
+            catch (recoveryError) {
+                console.error('[NotesManager] Recovery failed:', recoveryError);
                 this.notes = [];
+                this.backupCorruptedFile(data);
             }
         }
-        this.loaded = true;
+        else {
+            console.error('[NotesManager] No valid JSON structure found.');
+            this.notes = [];
+        }
     }
+    /**
+     * Backup corrupted file with timestamp
+     */
+    async backupCorruptedFile(corruptedData) {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupPath = `${this.filePath}.corrupted.${timestamp}`;
+            await fs.writeFile(backupPath, corruptedData, 'utf-8');
+            console.error(`[NotesManager] Corrupted data backed up to: ${backupPath}`);
+        }
+        catch (backupError) {
+            console.error('[NotesManager] Failed to backup corrupted file:', backupError);
+        }
+    }
+    /**
+     * Atomic save using write-to-temp + rename pattern.
+     * This ensures either the old file or new file exists, never a partial write.
+     */
     async save() {
-        await fs.writeFile(this.filePath, JSON.stringify(this.notes, null, 2), 'utf-8');
+        const tmpPath = `${this.filePath}.tmp`;
+        // Prepare storage format with version
+        const storage = {
+            version: '2.0',
+            notes: this.notes,
+            metadata: {
+                lastModified: new Date().toISOString()
+            }
+        };
+        try {
+            // Step 1: Write to temporary file
+            await fs.writeFile(tmpPath, JSON.stringify(storage, null, 2), 'utf-8');
+            // Step 2: Atomic rename (overwrites target if exists)
+            await fs.rename(tmpPath, this.filePath);
+            // Step 3: Update our mtime cache
+            const stats = await fs.stat(this.filePath);
+            this.lastModifiedTime = stats.mtimeMs;
+        }
+        catch (error) {
+            // Clean up temp file if something went wrong
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch { }
+            throw error;
+        }
+    }
+    /**
+     * Reload notes from disk (useful for external changes)
+     */
+    async reload() {
+        return this.mutex.dispatch(async () => {
+            await this.load(true);
+        });
     }
     async addNote(title, content, tags = [], priority = 'medium', expiresAt) {
         return this.mutex.dispatch(async () => {
             await this.load();
             const note = {
-                id: Date.now().toString(36) + Math.random().toString(36).substring(2, 7),
+                id: `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 9)}`,
                 title,
                 content,
                 tags,
@@ -64,15 +197,23 @@ export class NotesManager {
         return this.mutex.dispatch(async () => {
             await this.load();
             const now = new Date();
-            let activeNotes = this.notes;
+            let filteredNotes = this.notes;
+            // Filter expired notes
             if (!includeExpired) {
-                activeNotes = this.notes.filter(n => !n.expiresAt || new Date(n.expiresAt) > now);
+                filteredNotes = filteredNotes.filter(n => !n.expiresAt || new Date(n.expiresAt) > now);
             }
+            // Filter by tag
             if (tag) {
-                return activeNotes.filter(n => n.tags.includes(tag));
+                filteredNotes = filteredNotes.filter(n => n.tags.includes(tag));
             }
-            return activeNotes.sort((a, b) => {
-                const priorityMap = { 'critical': 4, 'high': 3, 'medium': 2, 'low': 1 };
+            // Sort by priority (highest first)
+            return filteredNotes.sort((a, b) => {
+                const priorityMap = {
+                    critical: 4,
+                    high: 3,
+                    medium: 2,
+                    low: 1
+                };
                 return (priorityMap[b.priority] || 0) - (priorityMap[a.priority] || 0);
             });
         });
@@ -113,4 +254,72 @@ export class NotesManager {
             return this.notes[index];
         });
     }
+    /**
+     * Get a single note by ID
+     */
+    async getNote(id) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return this.notes.find(n => n.id === id) || null;
+        });
+    }
+    /**
+     * Clear all notes (use with caution!)
+     */
+    async clearAll() {
+        return this.mutex.dispatch(async () => {
+            this.notes = [];
+            await this.save();
+        });
+    }
+    /**
+     * Export notes as JSON string
+     */
+    async export() {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return JSON.stringify({
+                version: '2.0',
+                notes: this.notes,
+                exportedAt: new Date().toISOString()
+            }, null, 2);
+        });
+    }
+    /**
+     * Import notes from JSON string
+     */
+    async import(jsonData, merge = false) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            try {
+                const parsed = JSON.parse(jsonData);
+                let importedNotes = [];
+                if (parsed.version && parsed.notes) {
+                    importedNotes = parsed.notes;
+                }
+                else if (Array.isArray(parsed)) {
+                    importedNotes = parsed;
+                }
+                if (merge) {
+                    // Merge: avoid duplicates by ID
+                    const existingIds = new Set(this.notes.map(n => n.id));
+                    for (const note of importedNotes) {
+                        if (!existingIds.has(note.id)) {
+                            this.notes.push(note);
+                            existingIds.add(note.id);
+                        }
+                    }
+                }
+                else {
+                    // Replace all
+                    this.notes = importedNotes;
+                }
+                await this.save();
+                return this.notes.length;
+            }
+            catch (error) {
+                throw new Error(`Failed to import notes: ${error}`);
+            }
+        });
+    }
 }

package/dist/system_test.js

@@ -36,7 +36,7 @@ async function testSystem() {
     console.log("2. Searching for 'Deepest'...");
     const results = await codeDb.searchSnippets("Deepest");
     console.log(`Found ${results.length} result(s):`);
-    results.forEach(r => console.log(`- ${r.title} (${r.language})`));
+    results.forEach(r => console.log(`- ${r.snippet.title} (${r.snippet.language})`));
     console.log("\n✅ Test Complete!");
     // Cleanup
     try {

package/dist/tools/codestore.js

@@ -32,7 +32,7 @@ export function registerCodeDbTools(server, db) {
             if (results.length > 0) {
                 output += `SNIPPETS FOUND:\n`;
                 results.forEach(s => {
-                    output += `ID: ${s.id} | ${s.title} (${s.language})\nDesc: ${s.description}\nCode:\n\`\`\`\n${s.code}\n\`\`\`\n\n`;
+                    output += `ID: ${s.snippet.id} | ${s.snippet.title} (${s.snippet.language})\nDesc: ${s.snippet.description}\nCode:\n\`\`\`\n${s.snippet.code}\n\`\`\`\n\n`;
                 });
             }
             const matchedPatterns = Object.entries(patterns).filter(([k, v]) => k.toLowerCase().includes(query.toLowerCase()) || v.toLowerCase().includes(query.toLowerCase()));