@sparkleideas/shared 3.0.0-alpha.7

package/__tests__/hooks/session-hooks.test.ts

@@ -0,0 +1,357 @@
+/**
+ * V3 Session Hooks Tests
+ *
+ * Tests for session-end and session-restore hook functionality.
+ *
+ * @module v3/shared/hooks/__tests__/session-hooks.test
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  createHookRegistry,
+  createSessionHooksManager,
+  SessionHooksManager,
+  HookRegistry,
+  HookEvent,
+  InMemorySessionStorage,
+} from '../../src/hooks/index.js';
+
+describe('SessionHooksManager', () => {
+  let registry: HookRegistry;
+  let sessionManager: SessionHooksManager;
+  let storage: InMemorySessionStorage;
+
+  beforeEach(() => {
+    registry = createHookRegistry();
+    storage = new InMemorySessionStorage();
+    sessionManager = createSessionHooksManager(registry, storage);
+  });
+
+  describe('session lifecycle hooks', () => {
+    it('should register session hooks on creation', () => {
+      const startHooks = registry.getHandlers(HookEvent.SessionStart);
+      const endHooks = registry.getHandlers(HookEvent.SessionEnd);
+      const resumeHooks = registry.getHandlers(HookEvent.SessionResume);
+
+      expect(startHooks.some(h => h.name === 'session-hooks:start')).toBe(true);
+      expect(endHooks.some(h => h.name === 'session-hooks:end')).toBe(true);
+      expect(resumeHooks.some(h => h.name === 'session-hooks:resume')).toBe(true);
+    });
+  });
+
+  describe('session-end hook', () => {
+    it('should end session and return summary', async () => {
+      // Simulate session start by triggering tracking
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'test-session', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+
+      // Wait a moment to ensure duration > 0
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      const result = await sessionManager.executeSessionEnd();
+
+      expect(result.success).toBe(true);
+      expect(result.duration).toBeGreaterThanOrEqual(0);
+      expect(result.summary).toBeDefined();
+      expect(result.summary!.tasksExecuted).toBe(0);
+      expect(result.summary!.commandsExecuted).toBe(0);
+    });
+
+    it('should persist session state', async () => {
+      // Start session
+      const startContext = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'persist-session', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](startContext);
+
+      const result = await sessionManager.executeSessionEnd();
+
+      expect(result.persistedState).toBeDefined();
+      expect(result.statePath).toBeDefined();
+
+      // Verify state was saved
+      const sessions = await storage.list();
+      expect(sessions.length).toBeGreaterThan(0);
+    });
+
+    it('should handle ending session without active session', async () => {
+      const result = await sessionManager.executeSessionEnd();
+      expect(result.success).toBe(true);
+    });
+
+    it('should reset activity tracking after session end', async () => {
+      // Start session
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'reset-session', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+
+      await sessionManager.executeSessionEnd();
+
+      expect(sessionManager.getCurrentSessionId()).toBeNull();
+    });
+  });
+
+  describe('session-restore hook', () => {
+    it('should restore a previous session', async () => {
+      // Create and end a session first
+      const startContext = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'restore-test', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](startContext);
+      await sessionManager.executeSessionEnd();
+
+      // Restore the session
+      const result = await sessionManager.executeSessionRestore('restore-test');
+
+      expect(result.success).toBe(true);
+      expect(result.restoredState).toBeDefined();
+      expect(result.restoredState!.sessionId).toBe('restore-test');
+    });
+
+    it('should restore latest session when no ID specified', async () => {
+      // Create and end multiple sessions
+      for (const id of ['session-1', 'session-2', 'session-3']) {
+        const context = {
+          event: HookEvent.SessionStart,
+          timestamp: new Date(),
+          session: { id, startTime: new Date() },
+        };
+        await sessionManager['handleSessionStart'](context);
+        await sessionManager.executeSessionEnd();
+        await new Promise(resolve => setTimeout(resolve, 5));
+      }
+
+      const result = await sessionManager.executeSessionRestore();
+
+      expect(result.success).toBe(true);
+      expect(result.restoredState).toBeDefined();
+    });
+
+    it('should fail gracefully when session not found', async () => {
+      const result = await sessionManager.executeSessionRestore('non-existent');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.warnings).toBeDefined();
+    });
+
+    it('should return warnings for old sessions', async () => {
+      // Create a session with an old timestamp
+      const oldSession = {
+        sessionId: 'old-session',
+        startTime: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000), // 8 days ago
+        endTime: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000),
+      };
+      await storage.save('old-session', oldSession);
+
+      const result = await sessionManager.executeSessionRestore('old-session');
+
+      expect(result.success).toBe(true);
+      expect(result.warnings).toBeDefined();
+      expect(result.warnings!.some(w => w.includes('days old'))).toBe(true);
+    });
+
+    it('should start a new session after restoration', async () => {
+      // Create and end a session
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'new-after-restore', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+      await sessionManager.executeSessionEnd();
+
+      await sessionManager.executeSessionRestore('new-after-restore');
+
+      expect(sessionManager.getCurrentSessionId()).toBeDefined();
+      expect(sessionManager.getCurrentSessionId()).toContain('restored');
+    });
+
+    it('should count restored items', async () => {
+      // Create a session with tasks and agents
+      const sessionState = {
+        sessionId: 'count-test',
+        startTime: new Date(),
+        endTime: new Date(),
+        activeTasks: [
+          { id: 'task-1', description: 'Task 1', status: 'completed' as const },
+          { id: 'task-2', description: 'Task 2', status: 'in_progress' as const },
+        ],
+        spawnedAgents: [
+          { id: 'agent-1', type: 'coder', status: 'active' as const },
+        ],
+        memoryEntries: [
+          { key: 'key-1', namespace: 'default', type: 'string' },
+        ],
+      };
+      await storage.save('count-test', sessionState);
+
+      const result = await sessionManager.executeSessionRestore('count-test');
+
+      expect(result.tasksRestored).toBe(2);
+      expect(result.agentsRestored).toBe(1);
+      expect(result.memoryRestored).toBe(1);
+    });
+  });
+
+  describe('activity tracking', () => {
+    it('should track task executions', async () => {
+      // Start session
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'track-tasks', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+
+      // Track a successful task
+      await sessionManager['trackTaskExecution']({
+        event: HookEvent.PostTaskExecute,
+        timestamp: new Date(),
+        metadata: { success: true },
+      });
+
+      // Track a failed task
+      await sessionManager['trackTaskExecution']({
+        event: HookEvent.PostTaskExecute,
+        timestamp: new Date(),
+        metadata: { success: false },
+      });
+
+      const activity = sessionManager.getCurrentActivity();
+      expect(activity.tasksExecuted).toBe(2);
+      expect(activity.tasksSucceeded).toBe(1);
+      expect(activity.tasksFailed).toBe(1);
+    });
+
+    it('should track command executions', async () => {
+      // Start session
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'track-commands', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+
+      // Track commands
+      await sessionManager['trackCommandExecution']({
+        event: HookEvent.PostCommand,
+        timestamp: new Date(),
+      });
+      await sessionManager['trackCommandExecution']({
+        event: HookEvent.PostCommand,
+        timestamp: new Date(),
+      });
+
+      const activity = sessionManager.getCurrentActivity();
+      expect(activity.commandsExecuted).toBe(2);
+    });
+
+    it('should track file modifications', async () => {
+      // Start session
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'track-files', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+
+      // Track file modifications
+      await sessionManager['trackFileModification']({
+        event: HookEvent.PostEdit,
+        timestamp: new Date(),
+        file: { path: '/src/file1.ts', operation: 'edit' },
+      });
+      await sessionManager['trackFileModification']({
+        event: HookEvent.PostEdit,
+        timestamp: new Date(),
+        file: { path: '/src/file2.ts', operation: 'edit' },
+      });
+      // Same file again
+      await sessionManager['trackFileModification']({
+        event: HookEvent.PostEdit,
+        timestamp: new Date(),
+        file: { path: '/src/file1.ts', operation: 'edit' },
+      });
+
+      const activity = sessionManager.getCurrentActivity();
+      expect(activity.filesModified.size).toBe(2);
+    });
+
+    it('should track agent spawns', async () => {
+      // Start session
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'track-agents', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+
+      // Track agent spawns
+      await sessionManager['trackAgentSpawn']({
+        event: HookEvent.PostAgentSpawn,
+        timestamp: new Date(),
+        agent: { id: 'agent-1', type: 'coder' },
+      });
+      await sessionManager['trackAgentSpawn']({
+        event: HookEvent.PostAgentSpawn,
+        timestamp: new Date(),
+        agent: { id: 'agent-2', type: 'tester' },
+      });
+
+      const activity = sessionManager.getCurrentActivity();
+      expect(activity.agentsSpawned.size).toBe(2);
+    });
+  });
+
+  describe('session management', () => {
+    it('should list available sessions', async () => {
+      // Create multiple sessions
+      for (const id of ['list-1', 'list-2', 'list-3']) {
+        const context = {
+          event: HookEvent.SessionStart,
+          timestamp: new Date(),
+          session: { id, startTime: new Date() },
+        };
+        await sessionManager['handleSessionStart'](context);
+        await sessionManager.executeSessionEnd();
+      }
+
+      const sessions = await sessionManager.listSessions();
+      expect(sessions.length).toBe(3);
+    });
+
+    it('should delete a session', async () => {
+      // Create a session
+      const context = {
+        event: HookEvent.SessionStart,
+        timestamp: new Date(),
+        session: { id: 'delete-me', startTime: new Date() },
+      };
+      await sessionManager['handleSessionStart'](context);
+      await sessionManager.executeSessionEnd();
+
+      const deleted = await sessionManager.deleteSession('delete-me');
+      expect(deleted).toBe(true);
+
+      const sessions = await sessionManager.listSessions();
+      expect(sessions.find(s => s.id === 'delete-me')).toBeUndefined();
+    });
+
+    it('should return false when deleting non-existent session', async () => {
+      const deleted = await sessionManager.deleteSession('non-existent');
+      expect(deleted).toBe(false);
+    });
+  });
+});

package/__tests__/hooks/task-hooks.test.ts

@@ -0,0 +1,193 @@
+/**
+ * V3 Task Hooks Tests
+ *
+ * Tests for pre-task and post-task hook functionality.
+ *
+ * @module v3/shared/hooks/__tests__/task-hooks.test
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  createHookRegistry,
+  createTaskHooksManager,
+  TaskHooksManager,
+  HookRegistry,
+  HookEvent,
+} from '../../src/hooks/index.js';
+
+describe('TaskHooksManager', () => {
+  let registry: HookRegistry;
+  let taskManager: TaskHooksManager;
+
+  beforeEach(() => {
+    registry = createHookRegistry();
+    taskManager = createTaskHooksManager(registry);
+  });
+
+  describe('pre-task hook', () => {
+    it('should register pre-task hook on creation', () => {
+      const hooks = registry.getHandlers(HookEvent.PreTaskExecute);
+      expect(hooks.length).toBeGreaterThan(0);
+      expect(hooks.some(h => h.name === 'task-hooks:pre-task')).toBe(true);
+    });
+
+    it('should analyze task and suggest agents for coding task', async () => {
+      const result = await taskManager.executePreTask(
+        'task-123',
+        'Implement user authentication feature'
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.suggestedAgents).toBeDefined();
+      expect(result.suggestedAgents!.length).toBeGreaterThan(0);
+      expect(result.suggestedAgents![0].type).toBe('coder');
+      expect(result.suggestedAgents![0].confidence).toBeGreaterThan(0);
+    });
+
+    it('should suggest security-architect for security tasks', async () => {
+      const result = await taskManager.executePreTask(
+        'task-456',
+        'Fix security vulnerability in authentication'
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.suggestedAgents).toBeDefined();
+      const securityAgent = result.suggestedAgents!.find(a => a.type === 'security-architect');
+      expect(securityAgent).toBeDefined();
+    });
+
+    it('should suggest tester for test-related tasks', async () => {
+      const result = await taskManager.executePreTask(
+        'task-789',
+        'Write unit tests for user service'
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.suggestedAgents).toBeDefined();
+      const testerAgent = result.suggestedAgents!.find(a => a.type === 'tester');
+      expect(testerAgent).toBeDefined();
+    });
+
+    it('should estimate complexity based on task description', async () => {
+      // Simple task
+      const simpleResult = await taskManager.executePreTask(
+        'task-simple',
+        'Fix typo in readme'
+      );
+      expect(simpleResult.complexity).toBe('low');
+
+      // Complex task
+      const complexResult = await taskManager.executePreTask(
+        'task-complex',
+        'Refactor and redesign the entire authentication system with multiple OAuth providers'
+      );
+      expect(complexResult.complexity).toBe('high');
+    });
+
+    it('should detect risks in task description', async () => {
+      const result = await taskManager.executePreTask(
+        'task-risky',
+        'Delete old data from production database'
+      );
+
+      expect(result.risks).toBeDefined();
+      expect(result.risks!.length).toBeGreaterThan(0);
+      expect(result.risks!.some(r => r.includes('production'))).toBe(true);
+    });
+
+    it('should track active tasks', async () => {
+      await taskManager.executePreTask('task-1', 'Task 1');
+      await taskManager.executePreTask('task-2', 'Task 2');
+
+      const activeTasks = taskManager.getActiveTasks();
+      expect(activeTasks.size).toBe(2);
+      expect(activeTasks.has('task-1')).toBe(true);
+      expect(activeTasks.has('task-2')).toBe(true);
+    });
+
+    it('should provide recommendations for high complexity tasks', async () => {
+      const result = await taskManager.executePreTask(
+        'task-high-complexity',
+        'Implement complex distributed system with multiple services'
+      );
+
+      expect(result.recommendations).toBeDefined();
+      expect(result.recommendations!.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('post-task hook', () => {
+    it('should register post-task hook on creation', () => {
+      const hooks = registry.getHandlers(HookEvent.PostTaskExecute);
+      expect(hooks.length).toBeGreaterThan(0);
+      expect(hooks.some(h => h.name === 'task-hooks:post-task')).toBe(true);
+    });
+
+    it('should record successful task outcome', async () => {
+      // First start the task
+      await taskManager.executePreTask('task-success', 'Test task');
+
+      // Then complete it
+      const result = await taskManager.executePostTask('task-success', true);
+
+      expect(result.success).toBe(true);
+      expect(result.outcome).toBeDefined();
+      expect(result.outcome!.success).toBe(true);
+      expect(result.outcome!.duration).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should record failed task outcome', async () => {
+      await taskManager.executePreTask('task-failed', 'Test task');
+
+      const result = await taskManager.executePostTask('task-failed', false, {
+        error: 'Test failed due to timeout',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.outcome).toBeDefined();
+      expect(result.outcome!.success).toBe(false);
+    });
+
+    it('should create learning trajectory', async () => {
+      await taskManager.executePreTask('task-learn', 'Test task');
+      const result = await taskManager.executePostTask('task-learn', true);
+
+      expect(result.trajectoryId).toBeDefined();
+      expect(result.trajectoryId).toContain('trajectory-');
+    });
+
+    it('should track learning updates', async () => {
+      await taskManager.executePreTask('task-updates', 'Test task');
+      const result = await taskManager.executePostTask('task-updates', true);
+
+      expect(result.learningUpdates).toBeDefined();
+      expect(result.learningUpdates!.trajectoriesRecorded).toBe(1);
+    });
+
+    it('should remove task from active tasks after completion', async () => {
+      await taskManager.executePreTask('task-cleanup', 'Test task');
+      expect(taskManager.getActiveTasks().has('task-cleanup')).toBe(true);
+
+      await taskManager.executePostTask('task-cleanup', true);
+      expect(taskManager.getActiveTasks().has('task-cleanup')).toBe(false);
+    });
+
+    it('should handle post-task without pre-task gracefully', async () => {
+      const result = await taskManager.executePostTask('task-no-pre', true);
+
+      expect(result.success).toBe(true);
+      expect(result.outcome).toBeDefined();
+    });
+  });
+
+  describe('clearActiveTasks', () => {
+    it('should clear all active tasks', async () => {
+      await taskManager.executePreTask('task-1', 'Task 1');
+      await taskManager.executePreTask('task-2', 'Task 2');
+      expect(taskManager.getActiveTasks().size).toBe(2);
+
+      taskManager.clearActiveTasks();
+      expect(taskManager.getActiveTasks().size).toBe(0);
+    });
+  });
+});