claude-flow-novice 2.15.11 → 2.16.0

package/claude-assets/skills/cfn-loop-orchestration/tests/redis-coordinator.test.ts

@@ -0,0 +1,321 @@
+/**
+ * Unit tests for redis-coordinator module
+ * Validates Redis coordination implementation
+ */
+
+import { RedisCoordinator } from '../src/redis/redis-coordinator';
+
+describe('redis-coordinator', () => {
+  let coordinator: RedisCoordinator;
+
+  beforeEach(() => {
+    coordinator = new RedisCoordinator();
+  });
+
+  describe('connect', () => {
+    it('should connect to Redis', async () => {
+      await expect(coordinator.connect()).resolves.toBeUndefined();
+    });
+
+    it('should not throw on connect', async () => {
+      await expect(coordinator.connect()).resolves.not.toThrow();
+    });
+  });
+
+  describe('disconnect', () => {
+    it('should disconnect from Redis', async () => {
+      await expect(coordinator.disconnect()).resolves.toBeUndefined();
+    });
+
+    it('should not throw on disconnect', async () => {
+      await expect(coordinator.disconnect()).resolves.not.toThrow();
+    });
+
+    it('should allow disconnect without connect', async () => {
+      const newCoordinator = new RedisCoordinator();
+      await expect(newCoordinator.disconnect()).resolves.not.toThrow();
+    });
+  });
+
+  describe('lpush', () => {
+    it('should push message to queue', async () => {
+      const result = await coordinator.lpush('test-queue', 'test-message');
+
+      expect(result).toBe(0);
+    });
+
+    it('should accept any queue name', async () => {
+      await expect(coordinator.lpush('queue1', 'msg1')).resolves.toBe(0);
+      await expect(coordinator.lpush('queue2', 'msg2')).resolves.toBe(0);
+    });
+
+    it('should accept any message', async () => {
+      await expect(coordinator.lpush('queue', 'simple')).resolves.toBe(0);
+      await expect(coordinator.lpush('queue', JSON.stringify({ key: 'value' }))).resolves.toBe(0);
+    });
+
+    it('should handle empty message', async () => {
+      await expect(coordinator.lpush('queue', '')).resolves.toBe(0);
+    });
+
+    it('should handle empty queue name', async () => {
+      await expect(coordinator.lpush('', 'message')).resolves.toBe(0);
+    });
+
+    it('should return number type', async () => {
+      const result = await coordinator.lpush('queue', 'message');
+      expect(typeof result).toBe('number');
+    });
+  });
+
+  describe('blpop', () => {
+    it('should return null for blocking pop', async () => {
+      const result = await coordinator.blpop('test-queue', 1);
+
+      expect(result).toBeNull();
+    });
+
+    it('should accept any queue name', async () => {
+      await expect(coordinator.blpop('queue1', 1)).resolves.toBeNull();
+      await expect(coordinator.blpop('queue2', 1)).resolves.toBeNull();
+    });
+
+    it('should accept any timeout value', async () => {
+      await expect(coordinator.blpop('queue', 0)).resolves.toBeNull();
+      await expect(coordinator.blpop('queue', 10)).resolves.toBeNull();
+      await expect(coordinator.blpop('queue', 1000)).resolves.toBeNull();
+    });
+
+    it('should handle negative timeout', async () => {
+      await expect(coordinator.blpop('queue', -1)).resolves.toBeNull();
+    });
+
+    it('should return null or tuple type', async () => {
+      const result = await coordinator.blpop('queue', 1);
+      expect(result === null || Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe('hGetAll', () => {
+    it('should return empty object', async () => {
+      const result = await coordinator.hGetAll('test-key');
+
+      expect(result).toEqual({});
+    });
+
+    it('should accept any key name', async () => {
+      await expect(coordinator.hGetAll('key1')).resolves.toEqual({});
+      await expect(coordinator.hGetAll('key2')).resolves.toEqual({});
+    });
+
+    it('should handle empty key', async () => {
+      await expect(coordinator.hGetAll('')).resolves.toEqual({});
+    });
+
+    it('should handle special characters in key', async () => {
+      await expect(coordinator.hGetAll('key:with:colons')).resolves.toEqual({});
+      await expect(coordinator.hGetAll('key_with_underscores')).resolves.toEqual({});
+    });
+
+    it('should return object type', async () => {
+      const result = await coordinator.hGetAll('key');
+      expect(typeof result).toBe('object');
+      expect(Array.isArray(result)).toBe(false);
+    });
+  });
+
+  describe('set', () => {
+    it('should set key-value pair', async () => {
+      const result = await coordinator.set('test-key', 'test-value');
+
+      expect(result).toBe('OK');
+    });
+
+    it('should accept any key', async () => {
+      await expect(coordinator.set('key1', 'value1')).resolves.toBe('OK');
+      await expect(coordinator.set('key2', 'value2')).resolves.toBe('OK');
+    });
+
+    it('should accept any value', async () => {
+      await expect(coordinator.set('key', 'simple')).resolves.toBe('OK');
+      await expect(coordinator.set('key', JSON.stringify({ data: 123 }))).resolves.toBe('OK');
+    });
+
+    it('should handle empty key', async () => {
+      await expect(coordinator.set('', 'value')).resolves.toBe('OK');
+    });
+
+    it('should handle empty value', async () => {
+      await expect(coordinator.set('key', '')).resolves.toBe('OK');
+    });
+
+    it('should return string type', async () => {
+      const result = await coordinator.set('key', 'value');
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  describe('get', () => {
+    it('should return null for get', async () => {
+      const result = await coordinator.get('test-key');
+
+      expect(result).toBeNull();
+    });
+
+    it('should accept any key', async () => {
+      await expect(coordinator.get('key1')).resolves.toBeNull();
+      await expect(coordinator.get('key2')).resolves.toBeNull();
+    });
+
+    it('should handle empty key', async () => {
+      await expect(coordinator.get('')).resolves.toBeNull();
+    });
+
+    it('should return null or string type', async () => {
+      const result = await coordinator.get('key');
+      expect(result === null || typeof result === 'string').toBe(true);
+    });
+  });
+
+  describe('sMembers', () => {
+    it('should return empty array', async () => {
+      const result = await coordinator.sMembers('test-set');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should accept any key', async () => {
+      await expect(coordinator.sMembers('set1')).resolves.toEqual([]);
+      await expect(coordinator.sMembers('set2')).resolves.toEqual([]);
+    });
+
+    it('should handle empty key', async () => {
+      await expect(coordinator.sMembers('')).resolves.toEqual([]);
+    });
+
+    it('should return array type', async () => {
+      const result = await coordinator.sMembers('set');
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe('del', () => {
+    it('should delete key', async () => {
+      const result = await coordinator.del('test-key');
+
+      expect(result).toBe(0);
+    });
+
+    it('should accept any key', async () => {
+      await expect(coordinator.del('key1')).resolves.toBe(0);
+      await expect(coordinator.del('key2')).resolves.toBe(0);
+    });
+
+    it('should handle empty key', async () => {
+      await expect(coordinator.del('')).resolves.toBe(0);
+    });
+
+    it('should return number type', async () => {
+      const result = await coordinator.del('key');
+      expect(typeof result).toBe('number');
+    });
+  });
+
+  describe('method chaining', () => {
+    it('should allow sequential operations', async () => {
+      await coordinator.connect();
+      await coordinator.set('key', 'value');
+      const result = await coordinator.get('key');
+      await coordinator.del('key');
+      await coordinator.disconnect();
+
+      expect(result).toBeNull();
+    });
+
+    it('should allow operations without connect', async () => {
+      const newCoordinator = new RedisCoordinator();
+
+      await expect(newCoordinator.set('key', 'value')).resolves.toBe('OK');
+      await expect(newCoordinator.get('key')).resolves.toBeNull();
+    });
+
+    it('should allow operations after disconnect', async () => {
+      await coordinator.connect();
+      await coordinator.disconnect();
+
+      await expect(coordinator.set('key', 'value')).resolves.toBe('OK');
+    });
+  });
+
+  describe('multiple instances', () => {
+    it('should allow multiple coordinator instances', () => {
+      const coordinator1 = new RedisCoordinator();
+      const coordinator2 = new RedisCoordinator();
+
+      expect(coordinator1).toBeInstanceOf(RedisCoordinator);
+      expect(coordinator2).toBeInstanceOf(RedisCoordinator);
+      expect(coordinator1).not.toBe(coordinator2);
+    });
+
+    it('should not interfere with each other', async () => {
+      const coordinator1 = new RedisCoordinator();
+      const coordinator2 = new RedisCoordinator();
+
+      await coordinator1.set('key1', 'value1');
+      await coordinator2.set('key2', 'value2');
+
+      await expect(coordinator1.get('key1')).resolves.toBeNull();
+      await expect(coordinator2.get('key2')).resolves.toBeNull();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle very long keys', async () => {
+      const longKey = 'k'.repeat(10000);
+      await expect(coordinator.set(longKey, 'value')).resolves.toBe('OK');
+    });
+
+    it('should handle very long values', async () => {
+      const longValue = 'v'.repeat(10000);
+      await expect(coordinator.set('key', longValue)).resolves.toBe('OK');
+    });
+
+    it('should handle special characters in keys', async () => {
+      const specialKey = 'key:with:special_chars.123';
+      await expect(coordinator.set(specialKey, 'value')).resolves.toBe('OK');
+    });
+
+    it('should handle JSON values', async () => {
+      const jsonValue = JSON.stringify({ nested: { data: [1, 2, 3] } });
+      await expect(coordinator.set('key', jsonValue)).resolves.toBe('OK');
+    });
+
+    it('should handle Unicode in keys and values', async () => {
+      await expect(coordinator.set('键', '值')).resolves.toBe('OK');
+    });
+
+    it('should handle zero timeout for blpop', async () => {
+      await expect(coordinator.blpop('queue', 0)).resolves.toBeNull();
+    });
+
+    it('should handle large timeout for blpop', async () => {
+      await expect(coordinator.blpop('queue', 999999)).resolves.toBeNull();
+    });
+
+    it('should handle numeric queue names', async () => {
+      await expect(coordinator.lpush('12345', 'message')).resolves.toBe(0);
+    });
+  });
+
+  describe('placeholder implementation validation', () => {
+    it('should consistently return expected placeholder values', async () => {
+      expect(await coordinator.lpush('q', 'm')).toBe(0);
+      expect(await coordinator.blpop('q', 1)).toBeNull();
+      expect(await coordinator.hGetAll('k')).toEqual({});
+      expect(await coordinator.set('k', 'v')).toBe('OK');
+      expect(await coordinator.get('k')).toBeNull();
+      expect(await coordinator.sMembers('s')).toEqual([]);
+      expect(await coordinator.del('k')).toBe(0);
+    });
+  });
+});

package/claude-assets/skills/cfn-loop-orchestration/tests/spawn-agents.test.ts

@@ -0,0 +1,284 @@
+/**
+ * Unit tests for spawn-agents.ts
+ *
+ * Tests agent type validation, CLI command formatting,
+ * dry-run mode, and error handling.
+ */
+
+import { spawnAgents, spawnLoop3Agents, spawnLoop2Agents, type SpawnAgentsConfig } from '../src/helpers/spawn-agents';
+
+describe('spawn-agents', () => {
+  describe('agent type validation', () => {
+    test('accepts loop3 agent type', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-1',
+        iteration: 1,
+        agents: ['loop3'],
+        originalContext: '{"task": "test"}',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.totalSpawned).toBe(1);
+      expect(summary.successCount).toBe(1);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.agentType).toBe('loop3');
+    });
+
+    test('accepts loop2 agent type', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-2',
+        iteration: 1,
+        agents: ['loop2'],
+        originalContext: '{"task": "test"}',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.totalSpawned).toBe(1);
+      expect(summary.successCount).toBe(1);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.agentType).toBe('loop2');
+    });
+
+    test('rejects invalid agent type', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-3',
+        iteration: 1,
+        agents: ['invalid-agent'],
+        originalContext: '{"task": "test"}',
+        dryRun: true,
+      };
+
+      await expect(spawnAgents(config)).rejects.toThrow('Invalid agent type');
+    });
+
+    test('validates all agents in array', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-4',
+        iteration: 1,
+        agents: ['loop3', 'unknown'],
+        originalContext: '{"task": "test"}',
+        dryRun: true,
+      };
+
+      await expect(spawnAgents(config)).rejects.toThrow('Invalid agent type');
+    });
+  });
+
+  describe('CLI command formatting', () => {
+    test('formats valid spawn command for loop3', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-5',
+        iteration: 2,
+        agents: ['loop3'],
+        originalContext: 'test-context',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.success).toBe(true);
+      expect(summary.results[0]!.agentType).toBe('loop3');
+      expect(summary.results[0]!.agentId).toMatch(/loop3-2-\d+/);
+    });
+
+    test('formats valid spawn command for loop2', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-6',
+        iteration: 3,
+        agents: ['loop2'],
+        originalContext: 'test-context',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.success).toBe(true);
+      expect(summary.results[0]!.agentType).toBe('loop2');
+      expect(summary.results[0]!.agentId).toMatch(/loop2-3-\d+/);
+    });
+
+    test('sanitizes special characters in input', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-7!@#$',
+        iteration: 1,
+        agents: ['loop3'],
+        originalContext: 'context-with-special!@#$',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.totalSpawned).toBe(1);
+      // Command should execute with sanitized inputs
+      expect(summary.successCount).toBe(1);
+    });
+  });
+
+  describe('dry-run mode', () => {
+    test('dry-run mode logs command without executing', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-8',
+        iteration: 1,
+        agents: ['loop3'],
+        originalContext: '{"task": "dry-run-test"}',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.totalSpawned).toBe(1);
+      expect(summary.successCount).toBe(1);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.success).toBe(true);
+      expect(summary.results[0]!.pid).toBeUndefined();
+    });
+
+    test('dry-run mode succeeds for multiple agents', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-9',
+        iteration: 1,
+        agents: ['loop3', 'loop2'],
+        originalContext: 'context',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.totalSpawned).toBe(2);
+      expect(summary.successCount).toBe(2);
+      expect(summary.results.every((r) => r.success)).toBe(true);
+    });
+  });
+
+  describe('error handling', () => {
+    test('throws error on missing task ID', async () => {
+      const config = {
+        taskId: '',
+        iteration: 1,
+        agents: ['loop3'],
+        originalContext: 'context',
+        dryRun: true,
+      } as SpawnAgentsConfig;
+
+      await expect(spawnAgents(config)).rejects.toThrow('Task ID is required');
+    });
+
+    test('throws error on invalid iteration', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task',
+        iteration: -1,
+        agents: ['loop3'],
+        originalContext: 'context',
+        dryRun: true,
+      };
+
+      await expect(spawnAgents(config)).rejects.toThrow('Iteration must be a non-negative integer');
+    });
+
+    test('throws error on empty agents array', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task',
+        iteration: 1,
+        agents: [],
+        originalContext: 'context',
+        dryRun: true,
+      };
+
+      await expect(spawnAgents(config)).rejects.toThrow('Agents array is required');
+    });
+
+    test('throws error on missing context', async () => {
+      const config = {
+        taskId: 'test-task',
+        iteration: 1,
+        agents: ['loop3'],
+        originalContext: '',
+        dryRun: true,
+      } as SpawnAgentsConfig;
+
+      await expect(spawnAgents(config)).rejects.toThrow('Original context is required');
+    });
+  });
+
+  describe('spawn summary', () => {
+    test('returns accurate spawn summary', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-10',
+        iteration: 1,
+        agents: ['loop3', 'loop2'],
+        originalContext: 'context',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.totalSpawned).toBe(2);
+      expect(summary.successCount).toBe(2);
+      expect(summary.failureCount).toBe(0);
+      expect(summary.results).toHaveLength(2);
+      expect(summary.duration).toBeGreaterThan(0);
+    });
+
+    test('counts failures correctly', async () => {
+      // We can't easily trigger real failures in dry-run mode,
+      // but we can verify the structure is correct
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-11',
+        iteration: 1,
+        agents: ['loop3'],
+        originalContext: 'context',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.successCount + summary.failureCount).toBe(summary.totalSpawned);
+    });
+  });
+
+  describe('convenience functions', () => {
+    test('spawnLoop3Agents works correctly', async () => {
+      const summary = await spawnLoop3Agents('test-task-12', 1, 'context', true);
+      expect(summary.totalSpawned).toBe(1);
+      expect(summary.successCount).toBe(1);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.agentType).toBe('loop3');
+    });
+
+    test('spawnLoop2Agents works correctly', async () => {
+      const summary = await spawnLoop2Agents('test-task-13', 2, 'context', true);
+      expect(summary.totalSpawned).toBe(1);
+      expect(summary.successCount).toBe(1);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.agentType).toBe('loop2');
+    });
+  });
+
+  describe('iteration tracking', () => {
+    test('tracks iteration numbers in agent IDs', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-14',
+        iteration: 5,
+        agents: ['loop3'],
+        originalContext: 'context',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.results).toHaveLength(1);
+      expect(summary.results[0]!.agentId).toMatch(/loop3-5-/);
+    });
+
+    test('tracks instance numbers for duplicate agent types', async () => {
+      const config: SpawnAgentsConfig = {
+        taskId: 'test-task-15',
+        iteration: 1,
+        agents: ['loop3', 'loop3'],
+        originalContext: 'context',
+        dryRun: true,
+      };
+
+      const summary = await spawnAgents(config);
+      expect(summary.results).toHaveLength(2);
+      expect(summary.results[0]!.agentId).toMatch(/loop3-1-1/);
+      expect(summary.results[1]!.agentId).toMatch(/loop3-1-2/);
+    });
+  });
+});