@gotza02/sequential-thinking 2026.2.9 → 2026.2.10

package/README.md

@@ -201,4 +201,4 @@ You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP
 ---
 
 ## License
-MIT - พัฒนาโดย @gotza02
+MIT - พัฒนาโดย @gotza02/sequential-thinking

package/dist/codestore.js

@@ -1,9 +1,11 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { AsyncMutex } from './utils.js';
 export class CodeDatabase {
     filePath;
     db = { snippets: [], patterns: {} };
     loaded = false;
+    mutex = new AsyncMutex();
     constructor(storagePath = 'code_database.json') {
         this.filePath = path.resolve(storagePath);
     }
@@ -23,35 +25,45 @@ export class CodeDatabase {
         await fs.writeFile(this.filePath, JSON.stringify(this.db, null, 2), 'utf-8');
     }
     async addSnippet(snippet) {
-        await this.load();
-        const newSnippet = {
-            ...snippet,
-            id: Math.random().toString(36).substring(2, 9),
-            updatedAt: new Date().toISOString()
-        };
-        this.db.snippets.push(newSnippet);
-        await this.save();
-        return newSnippet;
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const newSnippet = {
+                ...snippet,
+                id: Math.random().toString(36).substring(2, 9),
+                updatedAt: new Date().toISOString()
+            };
+            this.db.snippets.push(newSnippet);
+            await this.save();
+            return newSnippet;
+        });
     }
     async searchSnippets(query) {
-        await this.load();
-        const q = query.toLowerCase();
-        return this.db.snippets.filter(s => s.title.toLowerCase().includes(q) ||
-            s.description.toLowerCase().includes(q) ||
-            s.tags.some(t => t.toLowerCase().includes(q)) ||
-            s.code.toLowerCase().includes(q));
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const q = query.toLowerCase();
+            return this.db.snippets.filter(s => s.title.toLowerCase().includes(q) ||
+                s.description.toLowerCase().includes(q) ||
+                s.tags.some(t => t.toLowerCase().includes(q)) ||
+                s.code.toLowerCase().includes(q));
+        });
     }
     async learnPattern(name, description) {
-        await this.load();
-        this.db.patterns[name] = description;
-        await this.save();
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            this.db.patterns[name] = description;
+            await this.save();
+        });
     }
     async getPattern(name) {
-        await this.load();
-        return this.db.patterns[name] || null;
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return this.db.patterns[name] || null;
+        });
     }
     async listAllPatterns() {
-        await this.load();
-        return this.db.patterns;
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return this.db.patterns;
+        });
     }
 }

package/dist/codestore.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { CodeDatabase } from './codestore.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('CodeDatabase', () => {
+    let db;
+    const testPath = 'test_code_db.json';
+    let mockStore = '{"snippets": [], "patterns": {}}';
+    beforeEach(() => {
+        mockStore = '{"snippets": [], "patterns": {}}';
+        fs.readFile.mockImplementation(async () => mockStore);
+        fs.writeFile.mockImplementation(async (path, data) => {
+            mockStore = data;
+        });
+        db = new CodeDatabase(testPath);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should add a code snippet', async () => {
+        const snippet = await db.addSnippet({
+            title: "Quick Sort",
+            language: "typescript",
+            code: "function sort() {}",
+            description: "A sorting algorithm",
+            tags: ["algo"]
+        });
+        expect(snippet.id).toBeDefined();
+        expect(snippet.title).toBe("Quick Sort");
+        const stored = JSON.parse(mockStore);
+        expect(stored.snippets).toHaveLength(1);
+    });
+    it('should search snippets', async () => {
+        await db.addSnippet({
+            title: "React Hook",
+            language: "ts",
+            code: "const useX = () => {}",
+            description: "Custom hook",
+            tags: ["react"]
+        });
+        await db.addSnippet({
+            title: "Python Script",
+            language: "py",
+            code: "print('hello')",
+            description: "Hello world",
+            tags: ["python"]
+        });
+        const results = await db.searchSnippets("hook");
+        expect(results).toHaveLength(1);
+        expect(results[0].title).toBe("React Hook");
+    });
+    it('should learn and retrieve patterns', async () => {
+        await db.learnPattern("Repository Pattern", "Separate data access from business logic.");
+        const pattern = await db.getPattern("Repository Pattern");
+        expect(pattern).toContain("Separate data access");
+        const all = await db.listAllPatterns();
+        expect(all["Repository Pattern"]).toBeDefined();
+    });
+});

package/dist/filesystem.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import { validatePath } from './utils.js';
+import * as path from 'path';
+describe('FileSystem Security', () => {
+    // Mock process.cwd to be a known fixed path
+    const mockCwd = '/app/project';
+    // We need to spy on process.cwd and path.resolve behavior if we want to be strict,
+    // but validatePath uses path.resolve(requestedPath).
+    // Let's just mock path.resolve to behave as expected, or trust the real path module 
+    // but ensure we set up the cwd check correctly.
+    // The easiest way is to mock process.cwd().
+    const originalCwd = process.cwd;
+    beforeEach(() => {
+        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should allow paths within the project root', () => {
+        const p = validatePath('src/index.ts');
+        expect(p).toBe(path.resolve(mockCwd, 'src/index.ts'));
+    });
+    it('should allow explicit ./ paths', () => {
+        const p = validatePath('./package.json');
+        expect(p).toBe(path.resolve(mockCwd, 'package.json'));
+    });
+    it('should block traversal to parent directory', () => {
+        expect(() => {
+            validatePath('../outside.txt');
+        }).toThrow(/Access denied/);
+    });
+    it('should block multiple level traversal', () => {
+        expect(() => {
+            validatePath('src/../../etc/passwd');
+        }).toThrow(/Access denied/);
+    });
+    it('should block absolute paths outside root', () => {
+        // path.resolve('/etc/passwd') returns '/etc/passwd' on linux-like
+        // path.resolve('C:/Windows') on windows...
+        // We rely on path.resolve behavior.
+        // If system is linux-like:
+        if (path.sep === '/') {
+            expect(() => {
+                validatePath('/etc/passwd');
+            }).toThrow(/Access denied/);
+        }
+    });
+});

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);
     }
@@ -24,64 +26,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);
+    });
+});