@gotza02/sequential-thinking 2026.2.9 → 2026.2.11

package/dist/graph.js

@@ -103,6 +103,14 @@ export class ProjectKnowledgeGraph {
                         }
                     }
                 }
+                // 4. Import Equals: import x = require('...')
+                else if (ts.isImportEqualsDeclaration(node)) {
+                    if (ts.isExternalModuleReference(node.moduleReference)) {
+                        if (ts.isStringLiteral(node.moduleReference.expression)) {
+                            imports.push(node.moduleReference.expression.text);
+                        }
+                    }
+                }
                 ts.forEachChild(node, visit);
             };
             visit(sourceFile);
@@ -121,13 +129,13 @@ export class ProjectKnowledgeGraph {
             // Basic Regex for generic symbols and imports
             if (ext === '.py') {
                 // Python: import x, from x import y, def func, class Cls
-                const importMatches = content.matchAll(/^(?:import|from)\s+([a-zA-Z0-9_.]+)/gm);
+                const importMatches = content.matchAll(/^\s*(?:import|from)\s+([a-zA-Z0-9_.]+)/gm);
                 for (const match of importMatches)
                     imports.push(match[1]);
-                const funcMatches = content.matchAll(/^def\s+([a-zA-Z0-9_]+)/gm);
+                const funcMatches = content.matchAll(/^\s*def\s+([a-zA-Z0-9_]+)/gm);
                 for (const match of funcMatches)
                     symbols.push(`def:${match[1]}`);
-                const classMatches = content.matchAll(/^class\s+([a-zA-Z0-9_]+)/gm);
+                const classMatches = content.matchAll(/^\s*class\s+([a-zA-Z0-9_]+)/gm);
                 for (const match of classMatches)
                     symbols.push(`class:${match[1]}`);
             }
@@ -136,7 +144,7 @@ export class ProjectKnowledgeGraph {
                 const importMatches = content.matchAll(/import\s+"([^"]+)"/g);
                 for (const match of importMatches)
                     imports.push(match[1]);
-                const funcMatches = content.matchAll(/^func\s+([a-zA-Z0-9_]+)/gm);
+                const funcMatches = content.matchAll(/^\s*func\s+([a-zA-Z0-9_]+)/gm);
                 for (const match of funcMatches)
                     symbols.push(`func:${match[1]}`);
             }
@@ -176,7 +184,7 @@ export class ProjectKnowledgeGraph {
             return absolutePath;
         }
         // 2. Try appending extensions
-        const extensions = ['.ts', '.js', '.tsx', '.jsx', '.json', '/index.ts', '/index.js'];
+        const extensions = ['.ts', '.js', '.tsx', '.jsx', '.json', '.py', '.go', '.rs', '.java', '.c', '.cpp', '.h', '/index.ts', '/index.js'];
         for (const ext of extensions) {
             const p = absolutePath + ext;
             if (this.nodes.has(p)) {

package/dist/graph.test.js

@@ -76,4 +76,57 @@ describe('ProjectKnowledgeGraph', () => {
         const relationships = graph.getRelationships('/app/index.js');
         expect(relationships?.imports).toContain('Button.jsx');
     });
+    it('should handle circular dependencies', async () => {
+        const contentA = `import { b } from './b'; export const a = 1;`;
+        const contentB = `import { a } from './a'; export const b = 2;`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false },
+            { name: 'b.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            if (filePath.endsWith('b.ts'))
+                return contentB;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        const relB = graph.getRelationships('/app/b.ts');
+        expect(relA?.imports).toContain('b.ts');
+        expect(relA?.importedBy).toContain('b.ts');
+        expect(relB?.imports).toContain('a.ts');
+        expect(relB?.importedBy).toContain('a.ts');
+    });
+    it('should gracefully handle missing imports', async () => {
+        const contentA = `import { ghost } from './ghost';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        // ghost.ts doesn't exist, so imports should be empty (filtered out)
+        expect(relA?.imports).toHaveLength(0);
+    });
+    it('should ignore directory traversal attempts outside root', async () => {
+        // If we pretend root is /app, and we try to import ../outside
+        const contentA = `import { secret } from '../secret';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        // Should be empty because '../secret' is not in the scanned file list (nodes)
+        expect(relA?.imports).toHaveLength(0);
+    });
 });

package/dist/integration.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// We need to import the register functions to get the callbacks, 
+// but we can just use the classes directly for this integration logic test.
+// Actually, testing the *interaction* via the tool layer is better.
+import { registerThinkingTools } from './tools/thinking.js';
+import { registerGraphTools } from './tools/graph.js';
+import { registerNoteTools } from './tools/notes.js';
+describe('Integration Workflow', () => {
+    let toolCallbacks = {};
+    const mockServer = {
+        tool: (name, desc, schema, cb) => {
+            toolCallbacks[name] = cb;
+        }
+    };
+    // Mocks
+    const mockThinking = { processThought: vi.fn(), clearHistory: vi.fn() };
+    const mockGraph = { build: vi.fn(), getRelationships: vi.fn() };
+    const mockNotes = { addNote: vi.fn() };
+    beforeEach(() => {
+        toolCallbacks = {};
+        registerThinkingTools(mockServer, mockThinking);
+        registerGraphTools(mockServer, mockGraph);
+        registerNoteTools(mockServer, mockNotes);
+        vi.clearAllMocks();
+    });
+    it('should support a full analysis workflow', async () => {
+        // Step 1: Start Thinking
+        mockThinking.processThought.mockResolvedValue({
+            content: [{ type: "text", text: "Thought processed" }]
+        });
+        await toolCallbacks['sequentialthinking']({
+            thought: "Analyze architecture",
+            thoughtNumber: 1,
+            totalThoughts: 5,
+            nextThoughtNeeded: true,
+            thoughtType: 'analysis'
+        });
+        expect(mockThinking.processThought).toHaveBeenCalledWith(expect.objectContaining({
+            thought: "Analyze architecture"
+        }));
+        // Step 2: Build Graph
+        mockGraph.build.mockResolvedValue({ nodeCount: 10, totalFiles: 20 });
+        await toolCallbacks['build_project_graph']({ path: '.' });
+        expect(mockGraph.build).toHaveBeenCalled();
+        // Step 3: Get Relationships
+        mockGraph.getRelationships.mockReturnValue({ imports: ['utils.ts'] });
+        const relResult = await toolCallbacks['get_file_relationships']({ filePath: 'src/index.ts' });
+        expect(JSON.parse(relResult.content[0].text).imports).toContain('utils.ts');
+        // Step 4: Add Note
+        mockNotes.addNote.mockResolvedValue({ id: '123', title: 'Arch Note' });
+        await toolCallbacks['manage_notes']({
+            action: 'add',
+            title: 'Architecture Review',
+            content: 'Found circular deps'
+        });
+        expect(mockNotes.addNote).toHaveBeenCalledWith('Architecture Review', 'Found circular deps', undefined, undefined, undefined);
+    });
+});

package/dist/lib.js

@@ -9,6 +9,7 @@ export class SequentialThinkingServer {
     storagePath;
     delayMs;
     isSaving = false;
+    hasPendingSave = false;
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -33,8 +34,7 @@ export class SequentialThinkingServer {
     }
     async saveHistory() {
         if (this.isSaving) {
-            // Simple retry if already saving
-            setTimeout(() => this.saveHistory(), 100);
+            this.hasPendingSave = true;
             return;
         }
         this.isSaving = true;
@@ -49,6 +49,10 @@ export class SequentialThinkingServer {
         }
         finally {
             this.isSaving = false;
+            if (this.hasPendingSave) {
+                this.hasPendingSave = false;
+                this.saveHistory();
+            }
         }
     }
     async clearHistory() {
@@ -70,9 +74,30 @@ export class SequentialThinkingServer {
         // Remove the range and insert summary
         const removedCount = endIndex - startIndex + 1;
         this.thoughtHistory.splice(startIndex - 1, removedCount, summaryThought);
-        // Renumber subsequent thoughts
+        // Renumber subsequent thoughts and update references
+        const shiftAmount = removedCount - 1;
         for (let i = startIndex; i < this.thoughtHistory.length; i++) {
-            this.thoughtHistory[i].thoughtNumber -= (removedCount - 1);
+            const t = this.thoughtHistory[i];
+            // Update own number
+            t.thoughtNumber -= shiftAmount;
+            // Update references (branchFromThought)
+            if (t.branchFromThought) {
+                if (t.branchFromThought > endIndex) {
+                    t.branchFromThought -= shiftAmount;
+                }
+                else if (t.branchFromThought >= startIndex) {
+                    t.branchFromThought = startIndex; // Point to summary
+                }
+            }
+            // Update references (revisesThought)
+            if (t.revisesThought) {
+                if (t.revisesThought > endIndex) {
+                    t.revisesThought -= shiftAmount;
+                }
+                else if (t.revisesThought >= startIndex) {
+                    t.revisesThought = startIndex; // Point to summary
+                }
+            }
         }
         // Rebuild branches (simplification: clear and let it rebuild if needed, or just clear)
         this.branches = {};

package/dist/notes.js

@@ -1,9 +1,11 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { AsyncMutex } from './utils.js';
 export class NotesManager {
     filePath;
     notes = [];
     loaded = false;
+    mutex = new AsyncMutex();
     constructor(storagePath = 'project_notes.json') {
         this.filePath = path.resolve(storagePath);
     }
@@ -15,8 +17,25 @@ export class NotesManager {
             this.notes = JSON.parse(data);
         }
         catch (error) {
-            // If file doesn't exist, start with empty array
-            this.notes = [];
+            // Case 1: File doesn't exist (Normal first run)
+            if (error.code === 'ENOENT') {
+                this.notes = [];
+            }
+            // 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}`);
+                }
+                catch (backupError) {
+                    console.error(`[NotesManager] Critical: Failed to backup corrupted notes file: ${backupError}`);
+                }
+                // Initialize empty to allow system to recover
+                this.notes = [];
+            }
         }
         this.loaded = true;
     }
@@ -24,64 +43,74 @@ export class NotesManager {
         await fs.writeFile(this.filePath, JSON.stringify(this.notes, null, 2), 'utf-8');
     }
     async addNote(title, content, tags = [], priority = 'medium', expiresAt) {
-        await this.load();
-        const note = {
-            id: Date.now().toString(36) + Math.random().toString(36).substring(2, 7),
-            title,
-            content,
-            tags,
-            priority,
-            expiresAt,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString()
-        };
-        this.notes.push(note);
-        await this.save();
-        return note;
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const note = {
+                id: Date.now().toString(36) + Math.random().toString(36).substring(2, 7),
+                title,
+                content,
+                tags,
+                priority,
+                expiresAt,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            this.notes.push(note);
+            await this.save();
+            return note;
+        });
     }
     async listNotes(tag, includeExpired = false) {
-        await this.load();
-        const now = new Date();
-        let activeNotes = this.notes;
-        if (!includeExpired) {
-            activeNotes = this.notes.filter(n => !n.expiresAt || new Date(n.expiresAt) > now);
-        }
-        if (tag) {
-            return activeNotes.filter(n => n.tags.includes(tag));
-        }
-        return activeNotes.sort((a, b) => {
-            const priorityMap = { 'critical': 4, 'high': 3, 'medium': 2, 'low': 1 };
-            return (priorityMap[b.priority] || 0) - (priorityMap[a.priority] || 0);
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const now = new Date();
+            let activeNotes = this.notes;
+            if (!includeExpired) {
+                activeNotes = this.notes.filter(n => !n.expiresAt || new Date(n.expiresAt) > now);
+            }
+            if (tag) {
+                return activeNotes.filter(n => n.tags.includes(tag));
+            }
+            return activeNotes.sort((a, b) => {
+                const priorityMap = { 'critical': 4, 'high': 3, 'medium': 2, 'low': 1 };
+                return (priorityMap[b.priority] || 0) - (priorityMap[a.priority] || 0);
+            });
         });
     }
     async searchNotes(query) {
-        await this.load();
-        const lowerQuery = query.toLowerCase();
-        return this.notes.filter(n => n.title.toLowerCase().includes(lowerQuery) ||
-            n.content.toLowerCase().includes(lowerQuery) ||
-            n.tags.some(t => t.toLowerCase().includes(lowerQuery)));
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const lowerQuery = query.toLowerCase();
+            return this.notes.filter(n => n.title.toLowerCase().includes(lowerQuery) ||
+                n.content.toLowerCase().includes(lowerQuery) ||
+                n.tags.some(t => t.toLowerCase().includes(lowerQuery)));
+        });
     }
     async deleteNote(id) {
-        await this.load();
-        const initialLength = this.notes.length;
-        this.notes = this.notes.filter(n => n.id !== id);
-        if (this.notes.length !== initialLength) {
-            await this.save();
-            return true;
-        }
-        return false;
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const initialLength = this.notes.length;
+            this.notes = this.notes.filter(n => n.id !== id);
+            if (this.notes.length !== initialLength) {
+                await this.save();
+                return true;
+            }
+            return false;
+        });
     }
     async updateNote(id, updates) {
-        await this.load();
-        const index = this.notes.findIndex(n => n.id === id);
-        if (index === -1)
-            return null;
-        this.notes[index] = {
-            ...this.notes[index],
-            ...updates,
-            updatedAt: new Date().toISOString()
-        };
-        await this.save();
-        return this.notes[index];
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const index = this.notes.findIndex(n => n.id === id);
+            if (index === -1)
+                return null;
+            this.notes[index] = {
+                ...this.notes[index],
+                ...updates,
+                updatedAt: new Date().toISOString()
+            };
+            await this.save();
+            return this.notes[index];
+        });
     }
 }

package/dist/notes.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { NotesManager } from './notes.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('NotesManager', () => {
+    let manager;
+    const testPath = 'test_notes.json';
+    let mockStore = '[]';
+    beforeEach(() => {
+        mockStore = '[]';
+        fs.readFile.mockImplementation(async () => mockStore);
+        fs.writeFile.mockImplementation(async (path, data) => {
+            mockStore = data;
+        });
+        manager = new NotesManager(testPath);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should add a note correctly', async () => {
+        const note = await manager.addNote("Test Title", "Test Content", ["tag1"]);
+        expect(note.title).toBe("Test Title");
+        expect(note.tags).toContain("tag1");
+        expect(JSON.parse(mockStore)).toHaveLength(1);
+    });
+    it('should list notes with sorting by priority', async () => {
+        await manager.addNote("Low Prio", "Content", [], "low");
+        await manager.addNote("High Prio", "Content", [], "high");
+        const notes = await manager.listNotes();
+        expect(notes[0].priority).toBe('high');
+        expect(notes[1].priority).toBe('low');
+    });
+    it('should filter notes by tag', async () => {
+        await manager.addNote("Note 1", "Content", ["react"]);
+        await manager.addNote("Note 2", "Content", ["vue"]);
+        const reactNotes = await manager.listNotes('react');
+        expect(reactNotes).toHaveLength(1);
+        expect(reactNotes[0].title).toBe("Note 1");
+    });
+    it('should search notes by query', async () => {
+        await manager.addNote("Deploy Script", "Run npm build", ["devops"]);
+        await manager.addNote("Meeting Notes", "Discuss API", ["meeting"]);
+        const results = await manager.searchNotes("build");
+        expect(results).toHaveLength(1);
+        expect(results[0].title).toBe("Deploy Script");
+    });
+    it('should update a note', async () => {
+        const note = await manager.addNote("Original", "Content");
+        const updated = await manager.updateNote(note.id, { title: "Updated" });
+        expect(updated?.title).toBe("Updated");
+        expect(updated?.content).toBe("Content"); // Should remain
+        const list = await manager.listNotes();
+        expect(list[0].title).toBe("Updated");
+    });
+    it('should delete a note', async () => {
+        const note = await manager.addNote("To Delete", "Content");
+        const success = await manager.deleteNote(note.id);
+        expect(success).toBe(true);
+        const list = await manager.listNotes();
+        expect(list).toHaveLength(0);
+    });
+    it('should hide expired notes by default', async () => {
+        // Expired yesterday
+        const yesterday = new Date();
+        yesterday.setDate(yesterday.getDate() - 1);
+        await manager.addNote("Expired", "Content", [], "medium", yesterday.toISOString());
+        await manager.addNote("Active", "Content");
+        const list = await manager.listNotes();
+        expect(list).toHaveLength(1);
+        expect(list[0].title).toBe("Active");
+        const all = await manager.listNotes(undefined, true);
+        expect(all).toHaveLength(2);
+    });
+});

package/dist/registration.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from 'vitest';
+import { registerThinkingTools } from './tools/thinking.js';
+import { registerGraphTools } from './tools/graph.js';
+import { registerNoteTools } from './tools/notes.js';
+import { registerWebTools } from './tools/web.js';
+import { registerFileSystemTools } from './tools/filesystem.js';
+import { registerCodingTools } from './tools/coding.js';
+import { registerCodeDbTools } from './tools/codestore.js';
+describe('Tool Registration', () => {
+    it('should register all tools without duplicates', () => {
+        const registeredTools = new Set();
+        const mockServer = {
+            tool: (name, desc, schema, cb) => {
+                if (registeredTools.has(name)) {
+                    throw new Error(`Duplicate tool name: ${name}`);
+                }
+                registeredTools.add(name);
+            }
+        };
+        // Mock dependencies
+        const mockThinking = { processThought: vi.fn(), clearHistory: vi.fn(), archiveHistory: vi.fn() };
+        const mockGraph = { build: vi.fn(), getRelationships: vi.fn(), getSummary: vi.fn(), toMermaid: vi.fn() };
+        const mockNotes = {};
+        const mockCodeDb = {};
+        registerThinkingTools(mockServer, mockThinking);
+        registerGraphTools(mockServer, mockGraph);
+        registerNoteTools(mockServer, mockNotes);
+        registerWebTools(mockServer);
+        registerFileSystemTools(mockServer);
+        registerCodingTools(mockServer, mockGraph);
+        registerCodeDbTools(mockServer, mockCodeDb);
+        expect(registeredTools.has('sequentialthinking')).toBe(true);
+        expect(registeredTools.has('build_project_graph')).toBe(true);
+        expect(registeredTools.has('read_file')).toBe(true);
+        expect(registeredTools.has('web_search')).toBe(true);
+        // ... and so on
+        console.log('Registered tools:', Array.from(registeredTools).join(', '));
+    });
+});

package/dist/repro_dollar.js

@@ -0,0 +1,30 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerFileSystemTools } from './tools/filesystem.js';
+// Mock server
+const server = new McpServer({ name: "test", version: "1" });
+// Mock tool registration to capture the handler
+let editHandler;
+server.tool = (name, desc, schema, handler) => {
+    if (name === 'edit_file')
+        editHandler = handler;
+    return undefined;
+};
+registerFileSystemTools(server);
+async function test() {
+    console.log("Testing edit_file with dollar signs...");
+    const result = await editHandler({
+        path: 'test_dollar.txt',
+        oldText: 'OLD',
+        newText: '$100' // This usually becomes empty or weird if interpreted as regex replacement
+    });
+    const fs = await import('fs/promises');
+    const content = await fs.readFile('test_dollar.txt', 'utf-8');
+    console.log("File content:", content.trim());
+    if (content.trim() === 'Price: $100') {
+        console.log("PASS: $ preserved");
+    }
+    else {
+        console.log("FAIL: $ corrupted");
+    }
+}
+test();

package/dist/repro_dollar_simple.js

@@ -0,0 +1,22 @@
+async function test() {
+    console.log("Testing edit_file logic...");
+    // Simulate the logic in filesystem.ts
+    const content = "Price: OLD";
+    const oldText = "OLD";
+    const newText = "$&"; // Should be "$&" literally, but replace will make it "OLD"
+    // Logic from tool
+    // If allowMultiple is false, it passes string directly
+    const buggedResult = content.replace(oldText, newText);
+    console.log(`Original: "${content}"`);
+    console.log(`Old: "${oldText}"`);
+    console.log(`New: "${newText}"`);
+    console.log(`Result: "${buggedResult}"`);
+    if (buggedResult === "Price: OLD") {
+        console.log("FAIL: $& was interpreted as the matched string");
+    }
+    else if (buggedResult === "Price: $&") {
+        console.log("PASS: $& was preserved literally");
+    }
+}
+test();
+export {};

package/dist/repro_history.js

@@ -0,0 +1,41 @@
+import { SequentialThinkingServer } from './lib.js';
+import * as fs from 'fs/promises';
+async function test() {
+    const server = new SequentialThinkingServer('test_history_bug.json');
+    await server.clearHistory();
+    // Create thoughts: 1, 2, 3, 4
+    await server.processThought({ thought: "1", thoughtNumber: 1, totalThoughts: 4, nextThoughtNeeded: true });
+    await server.processThought({ thought: "2", thoughtNumber: 2, totalThoughts: 4, nextThoughtNeeded: true });
+    await server.processThought({ thought: "3", thoughtNumber: 3, totalThoughts: 4, nextThoughtNeeded: true });
+    // Thought 4 branches from 3
+    await server.processThought({
+        thought: "4",
+        thoughtNumber: 4,
+        totalThoughts: 4,
+        nextThoughtNeeded: false,
+        branchFromThought: 3,
+        branchId: "test"
+    });
+    // Verify initial state
+    // History: [1, 2, 3, 4(from 3)]
+    // Summarize 2-3
+    await server.archiveHistory(2, 3, "Summary of 2 and 3");
+    // Expected History: [1, Summary(2), 4(3)]
+    // Thought 4 should now contain "branchFromThought: 2" (pointing to summary)
+    // Or if it broke, it might still say 3 (which is itself!) or not be updated.
+    // Read file manually to check JSON content
+    const data = JSON.parse(await fs.readFile('test_history_bug.json', 'utf-8'));
+    const lastThought = data[data.length - 1];
+    console.log("Last Thought:", lastThought);
+    if (lastThought.branchFromThought === 3) {
+        console.log("FAIL: branchFromThought was NOT updated. It points to 3 (which is now itself).");
+    }
+    else if (lastThought.branchFromThought === 2) {
+        console.log("PASS: branchFromThought was updated to point to Summary.");
+    }
+    else {
+        console.log(`FAIL: branchFromThought is ${lastThought.branchFromThought} (Unknown state)`);
+    }
+    await fs.unlink('test_history_bug.json');
+}
+test();

package/dist/repro_path.js

@@ -0,0 +1,17 @@
+import * as path from 'path';
+async function test() {
+    console.log("Testing path traversal vulnerability...");
+    const cwd = process.cwd();
+    const maliciousPath = '/etc/passwd'; // Or any file outside cwd
+    const resolved = path.resolve(maliciousPath);
+    console.log(`CWD: ${cwd}`);
+    console.log(`Input: ${maliciousPath}`);
+    console.log(`Resolved: ${resolved}`);
+    if (!resolved.startsWith(cwd)) {
+        console.log("FAIL: Path is outside CWD and would be allowed by current logic.");
+    }
+    else {
+        console.log("PASS: Path is inside CWD.");
+    }
+}
+test();

package/dist/repro_ts_req.js

@@ -0,0 +1,3 @@
+import { createRequire as _createRequire } from "module";
+const __require = _createRequire(import.meta.url);
+const fs = __require("fs");