@vybestack/llxprt-code-core 0.1.18 → 0.1.19-alpha

package/dist/src/integration-tests/todo-system.test.js

@@ -3,608 +3,44 @@
  * Copyright 2025 Vybestack LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * Comprehensive behavioral tests for the todo system
- * @requirement REQ-007: All behavioral test scenarios
- */
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { TodoWrite } from '../tools/todo-write.js';
-import { TodoRead } from '../tools/todo-read.js';
-import { TodoStore } from '../tools/todo-store.js';
-import { TodoReminderService } from '../services/todo-reminder-service.js';
-import { ComplexityAnalyzer } from '../services/complexity-analyzer.js';
-describe('Todo System Integration Tests', () => {
-    const testSessionId = 'test-session-123';
-    const testAgentId = 'test-agent-456';
-    const todoDir = path.join(os.homedir(), '.llxprt', 'todos');
-    beforeEach(async () => {
-        // Clean up any existing test files
-        await cleanupTestFiles();
-    });
-    afterEach(async () => {
-        // Clean up test files after each test
-        await cleanupTestFiles();
-    });
-    async function cleanupTestFiles() {
-        try {
-            await fs.rm(todoDir, { recursive: true, force: true });
-        }
-        catch (_error) {
-            // Ignore errors if directory doesn't exist
-        }
-    }
-    /**
-     * @requirement REQ-007: Todo Persistence
-     * @scenario Create todos in session and read back in new request
-     * @given Todos are written to storage
-     * @when Reading todos in a new tool instance
-     * @then The same todos are retrieved
-     */
-    describe('Todo Persistence', () => {
-        test('should persist todos across tool instances', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const testTodos = [
-                {
-                    id: '1',
-                    content: 'Implement authentication',
-                    status: 'pending',
-                    priority: 'high',
-                },
-                {
-                    id: '2',
-                    content: 'Write unit tests',
-                    status: 'in_progress',
-                    priority: 'medium',
-                },
-                {
-                    id: '3',
-                    content: 'Deploy to production',
-                    status: 'pending',
-                    priority: 'low',
-                },
-            ];
-            // Act - Write todos
-            const writeResult = await todoWrite.execute({ todos: testTodos }, new AbortController().signal);
-            // Assert write was successful
-            const metadata = writeResult.metadata;
-            expect(metadata?.statistics?.total).toBe(3);
-            // Act - Read todos with new instance
-            const todoRead = new TodoRead();
-            todoRead.context = context;
-            const readResult = await todoRead.execute({}, new AbortController().signal);
-            // Assert - Verify persistence
-            expect(readResult.llmContent).toContain('Implement authentication');
-            expect(readResult.llmContent).toContain('Write unit tests');
-            expect(readResult.llmContent).toContain('Deploy to production');
-        });
-        test('should handle empty todo list on first read', async () => {
-            // Arrange
-            const context = { sessionId: 'new-session-789' };
-            const todoRead = new TodoRead();
-            todoRead.context = context;
-            // Act
-            const result = await todoRead.execute({}, new AbortController().signal);
-            // Assert
-            expect(result.llmContent).toContain('No todos found');
-        });
-        test('should persist todos with special characters', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const specialTodos = [
-                {
-                    id: '1',
-                    content: 'Fix "quotes" & <brackets>',
-                    status: 'pending',
-                    priority: 'high',
-                },
-                {
-                    id: '2',
-                    content: 'Handle\nnewlines\tand\ttabs',
-                    status: 'pending',
-                    priority: 'medium',
-                },
-            ];
-            // Act
-            await todoWrite.execute({ todos: specialTodos }, new AbortController().signal);
-            // Read back
-            const store = new TodoStore(testSessionId);
-            const retrievedTodos = await store.readTodos();
-            // Assert
-            expect(retrievedTodos).toHaveLength(2);
-            expect(retrievedTodos[0].content).toBe('Fix "quotes" & <brackets>');
-            expect(retrievedTodos[1].content).toBe('Handle\nnewlines\tand\ttabs');
-        });
-    });
-    /**
-     * @requirement REQ-003/004: Reminder Injection
-     * @scenario Write todos and verify reminder generation
-     * @given TodoWrite operation is performed
-     * @when State changes occur
-     * @then Appropriate reminders are generated
-     */
-    describe('Reminder Injection', () => {
-        test('should generate reminder when todos are added', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const newTodos = [
-                { id: '1', content: 'New task', status: 'pending', priority: 'high' },
-            ];
-            // Act
-            const result = await todoWrite.execute({ todos: newTodos }, new AbortController().signal);
-            // Assert
-            expect(result.metadata?.stateChanged).toBe(true);
-            expect(result.metadata?.todosAdded).toBe(1);
-            expect(result.llmContent).toContain('<system-reminder>');
-            expect(result.llmContent).toContain('Your todo list has changed');
-        });
-        test('should generate reminder when todo status changes', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            // First write
-            const initialTodos = [
-                { id: '1', content: 'Task 1', status: 'pending', priority: 'high' },
-            ];
-            await todoWrite.execute({ todos: initialTodos }, new AbortController().signal);
-            // Update status
-            const updatedTodos = [
-                { id: '1', content: 'Task 1', status: 'in_progress', priority: 'high' },
-            ];
-            // Act
-            const result = await todoWrite.execute({ todos: updatedTodos }, new AbortController().signal);
-            // Assert
-            expect(result.metadata?.stateChanged).toBe(true);
-            expect(result.metadata?.statusChanged).toBe(1);
-            expect(result.llmContent).toContain('<system-reminder>');
-        });
-        test('should not generate reminder when no changes occur', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const todos = [
-                { id: '1', content: 'Task 1', status: 'pending', priority: 'high' },
-            ];
-            // First write
-            await todoWrite.execute({ todos }, new AbortController().signal);
-            // Write same todos again
-            const result = await todoWrite.execute({ todos }, new AbortController().signal);
-            // Assert
-            expect(result.metadata?.stateChanged).toBe(false);
-            expect(result.llmContent).not.toContain('<system-reminder>');
-        });
-        test('should generate empty todo reminder for complex task', () => {
-            // Arrange
-            const reminderService = new TodoReminderService();
-            // Act
-            const reminder = reminderService.getReminderForEmptyTodos(true);
-            // Assert
-            expect(reminder).toContain('<system-reminder>');
-            expect(reminder).toContain('todo list is currently empty');
-            expect(reminder).toContain('DO NOT mention this to the user');
-        });
-    });
-    /**
-     * @requirement REQ-005: Complexity Detection
-     * @scenario Test various message patterns for complexity
-     * @given Different user message patterns
-     * @when Complexity analysis is performed
-     * @then Correct complexity scores and suggestions are generated
-     */
-    describe('Complexity Detection', () => {
-        let analyzer;
-        beforeEach(() => {
-            analyzer = new ComplexityAnalyzer();
-        });
-        test('should detect numbered list as complex task', () => {
-            // Arrange
-            const message = `Please help me with the following:
-        1. Set up authentication system
-        2. Create user dashboard
-        3. Implement payment processing
-        4. Deploy to production`;
-            // Act
-            const result = analyzer.analyzeComplexity(message);
-            // Assert
-            expect(result.isComplex).toBe(true);
-            expect(result.detectedTasks).toHaveLength(4);
-            expect(result.detectedTasks[0]).toBe('Set up authentication system');
-            expect(result.shouldSuggestTodos).toBe(true);
-            expect(result.suggestionReminder).toContain('multiple tasks');
-        });
-        test('should detect bullet points as complex task', () => {
-            // Arrange
-            const message = `I need to:
-        - Configure database
-        - Set up API endpoints
-        - Add error handling
-        - Write documentation`;
-            // Act
-            const result = analyzer.analyzeComplexity(message);
-            // Assert
-            expect(result.isComplex).toBe(true);
-            expect(result.detectedTasks).toHaveLength(4);
-            expect(result.shouldSuggestTodos).toBe(true);
-        });
-        test('should detect sequential indicators', () => {
-            // Arrange
-            const message = 'First, set up the database. Then configure the API. After that, add authentication. Finally, deploy the app.';
-            // Act
-            const result = analyzer.analyzeComplexity(message);
-            // Assert
-            expect(result.isComplex).toBe(true);
-            expect(result.sequentialIndicators).toContain('first');
-            expect(result.sequentialIndicators).toContain('then');
-            expect(result.sequentialIndicators).toContain('after that');
-            expect(result.sequentialIndicators).toContain('finally');
-        });
-        test('should not detect simple request as complex', () => {
-            // Arrange
-            const message = 'What is the capital of France?';
-            // Act
-            const result = analyzer.analyzeComplexity(message);
-            // Assert
-            expect(result.isComplex).toBe(false);
-            expect(result.detectedTasks).toHaveLength(0);
-            expect(result.shouldSuggestTodos).toBe(false);
-            expect(result.suggestionReminder).toBeUndefined();
-        });
-        test('should detect multiple questions as complex', () => {
-            // Arrange
-            const message = 'How do I set up authentication? What database should I use? Where should I deploy this?';
-            // Act
-            const result = analyzer.analyzeComplexity(message);
-            // Assert
-            expect(result.questionCount).toBe(3);
-            expect(result.isComplex).toBe(true);
-        });
-        test('should handle comma-separated task lists', () => {
-            // Arrange
-            const message = 'I need to add authentication, create tests, and deploy to production.';
-            // Act
-            const result = analyzer.analyzeComplexity(message);
-            // Assert
-            expect(result.detectedTasks).toHaveLength(3);
-            expect(result.detectedTasks).toContain('add authentication');
-            expect(result.detectedTasks).toContain('create tests');
-            expect(result.detectedTasks).toContain('deploy to production');
-        });
-        test('should track analysis statistics', () => {
-            // Arrange
-            analyzer.reset(); // Clear history
-            // Act - Perform multiple analyses
-            const result1 = analyzer.analyzeComplexity('Simple question?');
-            const result2 = analyzer.analyzeComplexity('1. Task one\n2. Task two\n3. Task three');
-            const result3 = analyzer.analyzeComplexity('I need to implement authentication, write tests, deploy to production, and update documentation');
-            const stats = analyzer.getAnalysisStats();
-            // Assert
-            expect(stats.totalAnalyses).toBe(3);
-            // Check actual complexity detection results
-            expect(result1.isComplex).toBe(false);
-            expect(result2.isComplex).toBe(true);
-            expect(result3.isComplex).toBe(true); // Should detect comma-separated tasks
-            expect(stats.complexRequestCount).toBe(2);
-            expect(stats.suggestionsGenerated).toBeGreaterThanOrEqual(1);
-            expect(stats.averageComplexityScore).toBeGreaterThan(0);
-        });
-    });
-    /**
-     * @requirement REQ-002: Multi-Agent Isolation
-     * @scenario Create todos in main session and subagent
-     * @given Different sessionId and agentId combinations
-     * @when Todos are created in different contexts
-     * @then Each context has isolated todo lists
-     */
-    describe('Multi-Agent Isolation', () => {
-        test('should isolate todos between main session and subagent', async () => {
-            // Arrange
-            const mainContext = { sessionId: testSessionId };
-            const subagentContext = {
-                sessionId: testSessionId,
-                agentId: testAgentId,
-            };
-            const mainWrite = new TodoWrite();
-            mainWrite.context = mainContext;
-            const subagentWrite = new TodoWrite();
-            subagentWrite.context = subagentContext;
-            const mainTodos = [
-                { id: '1', content: 'Main task', status: 'pending', priority: 'high' },
-            ];
-            const subagentTodos = [
-                {
-                    id: '1',
-                    content: 'Subagent task',
-                    status: 'pending',
-                    priority: 'medium',
-                },
-            ];
-            // Act - Write to both contexts
-            await mainWrite.execute({ todos: mainTodos }, new AbortController().signal);
-            await subagentWrite.execute({ todos: subagentTodos }, new AbortController().signal);
-            // Read from both contexts
-            const mainRead = new TodoRead();
-            mainRead.context = mainContext;
-            const mainResult = await mainRead.execute({}, new AbortController().signal);
-            const subagentRead = new TodoRead();
-            subagentRead.context = subagentContext;
-            const subagentResult = await subagentRead.execute({}, new AbortController().signal);
-            // Assert - Verify isolation
-            expect(mainResult.llmContent).toContain('Main task');
-            expect(mainResult.llmContent).not.toContain('Subagent task');
-            expect(subagentResult.llmContent).toContain('Subagent task');
-            expect(subagentResult.llmContent).not.toContain('Main task');
-        });
-        test('should use different file paths for different contexts', () => {
-            // Arrange
-            const mainStore = new TodoStore(testSessionId);
-            const subagentStore = new TodoStore(testSessionId, testAgentId);
-            // Act - Get file paths using private method (via reflection for testing)
-            const mainPath = mainStore.getFilePath();
-            const subagentPath = subagentStore.getFilePath();
-            // Assert
-            expect(mainPath).not.toBe(subagentPath);
-            expect(mainPath).toContain(testSessionId);
-            expect(subagentPath).toContain(testSessionId);
-            expect(subagentPath).toContain(testAgentId);
-        });
-        test('should handle multiple subagents independently', async () => {
-            // Arrange
-            const agent1Context = {
-                sessionId: testSessionId,
-                agentId: 'agent-1',
-            };
-            const agent2Context = {
-                sessionId: testSessionId,
-                agentId: 'agent-2',
-            };
-            const agent1Write = new TodoWrite();
-            agent1Write.context = agent1Context;
-            const agent2Write = new TodoWrite();
-            agent2Write.context = agent2Context;
-            // Act
-            await agent1Write.execute({
-                todos: [
-                    {
-                        id: '1',
-                        content: 'Agent 1 task',
-                        status: 'pending',
-                        priority: 'high',
-                    },
-                ],
-            }, new AbortController().signal);
-            await agent2Write.execute({
-                todos: [
-                    {
-                        id: '1',
-                        content: 'Agent 2 task',
-                        status: 'pending',
-                        priority: 'low',
-                    },
-                ],
-            }, new AbortController().signal);
-            // Read from both agents
-            const store1 = new TodoStore(testSessionId, 'agent-1');
-            const store2 = new TodoStore(testSessionId, 'agent-2');
-            const todos1 = await store1.readTodos();
-            const todos2 = await store2.readTodos();
-            // Assert
-            expect(todos1).toHaveLength(1);
-            expect(todos1[0].content).toBe('Agent 1 task');
-            expect(todos2).toHaveLength(1);
-            expect(todos2[0].content).toBe('Agent 2 task');
-        });
-    });
-    /**
-     * @requirement REQ-007: Error Handling
-     * @scenario Test various error conditions
-     * @given Malformed data or system failures
-     * @when Operations are performed
-     * @then Errors are handled gracefully
-     */
-    describe('Error Handling', () => {
-        test('should handle malformed todo data gracefully', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const malformedTodos = [
-                { id: '1', content: '', status: 'pending', priority: 'high' }, // Empty content
-            ];
-            // Act & Assert
-            await expect(todoWrite.execute({ todos: malformedTodos }, new AbortController().signal)).rejects.toThrow('Validation error');
-        });
-        test('should handle missing required fields', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const incompleteTodos = [
-                { id: '1', content: 'Task' }, // Missing status and priority
-            ];
-            // Act & Assert
-            await expect(todoWrite.execute({ todos: incompleteTodos }, new AbortController().signal)).rejects.toThrow('Validation error');
-        });
-        test('should handle invalid status values', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const invalidTodos = [
-                { id: '1', content: 'Task', status: 'invalid', priority: 'high' },
-            ];
-            // Act & Assert
-            await expect(todoWrite.execute({ todos: invalidTodos }, new AbortController().signal)).rejects.toThrow('Validation error');
-        });
-        test('should recover from corrupted storage file', async () => {
-            // Arrange
-            const store = new TodoStore(testSessionId);
-            const filePath = store.getFilePath();
-            // Create corrupted file
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-            await fs.writeFile(filePath, 'invalid json content', 'utf-8');
-            // Act & Assert - Should throw when reading corrupted data
-            await expect(store.readTodos()).rejects.toThrow();
-        });
-        test('should handle filesystem permission errors gracefully', async () => {
-            // This test would require mocking fs operations to simulate permission errors
-            // Skipping actual implementation as it would require complex mocking
-            expect(true).toBe(true);
-        });
-        test('should validate todo ID uniqueness', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const duplicateIdTodos = [
-                { id: '1', content: 'Task 1', status: 'pending', priority: 'high' },
-                { id: '1', content: 'Task 2', status: 'pending', priority: 'medium' }, // Duplicate ID
-            ];
-            // Act - This should succeed as the schema doesn't enforce uniqueness
-            const result = await todoWrite.execute({ todos: duplicateIdTodos }, new AbortController().signal);
-            // Assert - The write should succeed but we should have 2 todos
-            const metadata = result.metadata;
-            expect(metadata?.statistics?.total).toBe(2);
-        });
-        test('should handle empty message in complexity analyzer', () => {
-            // Arrange
-            const analyzer = new ComplexityAnalyzer();
-            // Act
-            const result = analyzer.analyzeComplexity('');
-            // Assert
-            expect(result.isComplex).toBe(false);
-            expect(result.complexityScore).toBe(0);
-            expect(result.detectedTasks).toHaveLength(0);
-        });
-    });
-    /**
-     * Additional behavioral tests for comprehensive coverage
-     */
-    describe('Advanced Scenarios', () => {
-        test('should calculate correct statistics after multiple operations', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            // Act - Multiple writes with different states
-            const todos1 = [
-                { id: '1', content: 'Task 1', status: 'pending', priority: 'high' },
-                { id: '2', content: 'Task 2', status: 'pending', priority: 'medium' },
-            ];
-            await todoWrite.execute({ todos: todos1 }, new AbortController().signal);
-            const todos2 = [
-                { id: '1', content: 'Task 1', status: 'in_progress', priority: 'high' },
-                { id: '2', content: 'Task 2', status: 'completed', priority: 'medium' },
-                { id: '3', content: 'Task 3', status: 'pending', priority: 'low' },
-            ];
-            const result = await todoWrite.execute({ todos: todos2 }, new AbortController().signal);
-            // Assert
-            const metadata = result.metadata;
-            expect(metadata?.statistics).toEqual({
-                total: 3,
-                inProgress: 1,
-                pending: 1,
-                completed: 1,
-                highPriority: 1,
-                mediumPriority: 1,
-                lowPriority: 1,
-            });
-        });
-        test('should determine correct next action based on priorities', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            const todos = [
-                {
-                    id: '1',
-                    content: 'Low priority',
-                    status: 'pending',
-                    priority: 'low',
-                },
-                {
-                    id: '2',
-                    content: 'High priority',
-                    status: 'pending',
-                    priority: 'high',
-                },
-                {
-                    id: '3',
-                    content: 'Medium priority',
-                    status: 'pending',
-                    priority: 'medium',
-                },
-            ];
-            // Act
-            const result = await todoWrite.execute({ todos }, new AbortController().signal);
-            // Assert - Should suggest starting with high priority
-            expect(result.llmContent).toContain('Start with: High priority');
-        });
-        test('should handle large todo lists efficiently', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const todoWrite = new TodoWrite();
-            todoWrite.context = context;
-            // Create 100 todos
-            const largeTodoList = Array.from({ length: 100 }, (_, i) => ({
-                id: `task-${i}`,
-                content: `Task ${i}`,
-                status: i % 3 === 0 ? 'completed' : i % 3 === 1 ? 'in_progress' : 'pending',
-                priority: i % 3 === 0 ? 'high' : i % 3 === 1 ? 'medium' : 'low',
-            }));
-            // Act
-            const startTime = Date.now();
-            const result = await todoWrite.execute({ todos: largeTodoList }, new AbortController().signal);
-            const duration = Date.now() - startTime;
-            // Assert
-            const metadata = result.metadata;
-            expect(metadata?.statistics?.total).toBe(100);
-            expect(duration).toBeLessThan(1000); // Should complete within 1 second
-        });
-        test('should handle concurrent access to same session', async () => {
-            // Arrange
-            const context = { sessionId: testSessionId };
-            const write1 = new TodoWrite();
-            write1.context = context;
-            const write2 = new TodoWrite();
-            write2.context = context;
-            const todos1 = [
-                {
-                    id: '1',
-                    content: 'From write 1',
-                    status: 'pending',
-                    priority: 'high',
-                },
-            ];
-            const todos2 = [
-                {
-                    id: '2',
-                    content: 'From write 2',
-                    status: 'pending',
-                    priority: 'medium',
-                },
-            ];
-            // Act - Sequential writes to avoid race condition in test
-            // In real usage, file locking would handle this
-            await write1.execute({ todos: todos1 }, new AbortController().signal);
-            await write2.execute({ todos: todos2 }, new AbortController().signal);
-            // Read final state
-            const store = new TodoStore(testSessionId);
-            const finalTodos = await store.readTodos();
-            // Assert - Last write should win
-            expect(finalTodos).toHaveLength(1);
-            expect(finalTodos[0].content).toBe('From write 2');
-        });
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ToolCallTrackerService } from '../services/tool-call-tracker-service.js';
+import { TodoContextTracker } from '../services/todo-context-tracker.js';
+describe('Todo Integration Test', () => {
+    const sessionId = 'test-session';
+    const todoId = 'test-todo';
+    beforeEach(() => {
+        // Reset the context tracker
+        const contextTracker = TodoContextTracker.forSession(sessionId);
+        contextTracker.setActiveTodo(null);
+    });
+    afterEach(() => {
+        // Clear the context tracker
+        const contextTracker = TodoContextTracker.forSession(sessionId);
+        contextTracker.clearActiveTodo();
+        // Clear any executing tool calls for this session
+        ToolCallTrackerService.clearToolCallsForSession(sessionId);
+    });
+    it('should track tool calls associated with active todo', async () => {
+        // Set up the context tracker with an active todo
+        const contextTracker = TodoContextTracker.forSession(sessionId);
+        contextTracker.setActiveTodo(todoId);
+        // Start tracking a tool call
+        const toolCallId = ToolCallTrackerService.startTrackingToolCall(sessionId, 'test_tool', { param: 'value' });
+        // Verify we got a tool call ID
+        expect(toolCallId).toBeTruthy();
+        // Get all tool calls for the todo
+        const allCalls = ToolCallTrackerService.getAllToolCalls(sessionId, todoId);
+        // Verify we have one executing tool call
+        expect(allCalls).toHaveLength(1);
+        expect(allCalls[0].name).toBe('test_tool');
+        expect(allCalls[0].parameters).toEqual({ param: 'value' });
+        // Complete the tool call tracking
+        await ToolCallTrackerService.completeToolCallTracking(sessionId, toolCallId);
+        // Verify the tool call is still there (now completed)
+        const updatedCalls = ToolCallTrackerService.getAllToolCalls(sessionId, todoId);
+        expect(updatedCalls).toHaveLength(1);
+        expect(updatedCalls[0].name).toBe('test_tool');
     });
 });
 //# sourceMappingURL=todo-system.test.js.map