@sparkleideas/integration 3.0.1

package/src/__tests__/agentic-flow-agent.test.ts

@@ -0,0 +1,176 @@
+/**
+ * AgenticFlowAgent Test Suite
+ *
+ * Tests for ADR-001 agent delegation implementation
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AgenticFlowAgent, createAgenticFlowAgent } from '../agentic-flow-agent.js';
+
+describe('AgenticFlowAgent', () => {
+  let agent: AgenticFlowAgent;
+
+  beforeEach(async () => {
+    agent = new AgenticFlowAgent({
+      id: 'test-agent-1',
+      name: 'Test Agent',
+      type: 'coder',
+      capabilities: ['code-generation', 'refactoring'],
+      maxConcurrentTasks: 3,
+      priority: 5,
+    });
+  });
+
+  afterEach(async () => {
+    if (agent) {
+      await agent.shutdown();
+    }
+  });
+
+  describe('Initialization', () => {
+    it('should create an agent with correct configuration', () => {
+      expect(agent.id).toBe('test-agent-1');
+      expect(agent.name).toBe('Test Agent');
+      expect(agent.type).toBe('coder');
+      expect(agent.status).toBe('spawning');
+    });
+
+    it('should initialize successfully', async () => {
+      await agent.initialize();
+
+      expect(agent.status).toBe('idle');
+      expect(agent.metrics?.tasksCompleted).toBe(0);
+      expect(agent.metrics?.tasksFailed).toBe(0);
+    });
+
+    it('should be idempotent on multiple initialize calls', async () => {
+      await agent.initialize();
+      await agent.initialize();
+      await agent.initialize();
+
+      expect(agent.status).toBe('idle');
+    });
+  });
+
+  describe('Task Execution', () => {
+    beforeEach(async () => {
+      await agent.initialize();
+    });
+
+    it('should execute a simple task', async () => {
+      const result = await agent.executeTask({
+        id: 'task-1',
+        type: 'code',
+        description: 'Generate function',
+        input: { name: 'hello' },
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.taskId).toBe('task-1');
+      expect(result.duration).toBeGreaterThan(0);
+      expect(agent.metrics?.tasksCompleted).toBe(1);
+    });
+
+    it('should update status during task execution', async () => {
+      const taskPromise = agent.executeTask({
+        id: 'task-2',
+        type: 'code',
+        description: 'Test task',
+      });
+
+      // Status should be busy during execution
+      // (Note: This might be flaky due to timing)
+
+      const result = await taskPromise;
+      expect(result.success).toBe(true);
+      expect(agent.status).toBe('idle'); // Should return to idle after completion
+    });
+
+    it('should track metrics correctly', async () => {
+      await agent.executeTask({
+        id: 'task-3',
+        type: 'code',
+        description: 'Task 1',
+      });
+
+      await agent.executeTask({
+        id: 'task-4',
+        type: 'code',
+        description: 'Task 2',
+      });
+
+      expect(agent.metrics?.tasksCompleted).toBe(2);
+      expect(agent.metrics?.avgTaskDuration).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Health Monitoring', () => {
+    beforeEach(async () => {
+      await agent.initialize();
+    });
+
+    it('should return health status', () => {
+      const health = agent.getHealth();
+
+      expect(health.status).toBe('healthy');
+      expect(health.metrics.tasksCompleted).toBe(0);
+      expect(health.metrics.uptime).toBeGreaterThan(0);
+    });
+
+    it('should report healthy status with low error rate', async () => {
+      await agent.executeTask({
+        id: 'task-5',
+        type: 'code',
+        description: 'Successful task',
+      });
+
+      const health = agent.getHealth();
+      expect(health.status).toBe('healthy');
+    });
+  });
+
+  describe('Delegation', () => {
+    it('should accept delegation reference', () => {
+      const mockAgenticFlowAgent = {
+        id: 'mock-agent',
+        type: 'coder',
+        status: 'ready',
+        initialize: async () => {},
+        shutdown: async () => {},
+        execute: async (task: unknown) => ({ result: 'delegated' }),
+      };
+
+      agent.setAgenticFlowReference(mockAgenticFlowAgent);
+
+      expect(agent.isDelegationEnabled()).toBe(true);
+      expect(agent.getAgenticFlowReference()).toBe(mockAgenticFlowAgent);
+    });
+  });
+
+  describe('Shutdown', () => {
+    it('should shutdown gracefully', async () => {
+      await agent.initialize();
+      await agent.shutdown();
+
+      expect(agent.status).toBe('terminated');
+    });
+  });
+});
+
+describe('createAgenticFlowAgent', () => {
+  it('should create and initialize an agent', async () => {
+    const agent = await createAgenticFlowAgent({
+      id: 'factory-agent-1',
+      name: 'Factory Agent',
+      type: 'tester',
+      capabilities: ['testing'],
+      maxConcurrentTasks: 1,
+      priority: 3,
+    });
+
+    expect(agent.id).toBe('factory-agent-1');
+    expect(agent.status).toBe('idle'); // Should be initialized
+
+    await agent.shutdown();
+  });
+});

package/src/__tests__/token-optimizer.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Token Optimizer Integration Tests
+ * Validates @sparkleideas/agentic-flow Agent Booster integration
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { TokenOptimizer, getTokenOptimizer } from '../token-optimizer.js';
+
+describe('TokenOptimizer', () => {
+  let optimizer: TokenOptimizer;
+
+  beforeAll(async () => {
+    optimizer = await getTokenOptimizer();
+  });
+
+  describe('initialization', () => {
+    it('should initialize successfully', async () => {
+      const newOptimizer = new TokenOptimizer();
+      await newOptimizer.initialize();
+
+      const stats = newOptimizer.getStats();
+      expect(stats).toBeDefined();
+      expect(typeof stats.agenticFlowAvailable).toBe('boolean');
+    });
+
+    it('should detect @sparkleideas/agentic-flow availability', async () => {
+      const stats = optimizer.getStats();
+      // @sparkleideas/agentic-flow is installed in v3/node_modules
+      expect(stats.agenticFlowAvailable).toBe(true);
+    });
+  });
+
+  describe('getCompactContext', () => {
+    it('should return context structure', async () => {
+      const ctx = await optimizer.getCompactContext('authentication patterns');
+
+      expect(ctx).toHaveProperty('query');
+      expect(ctx).toHaveProperty('memories');
+      expect(ctx).toHaveProperty('compactPrompt');
+      expect(ctx).toHaveProperty('tokensSaved');
+      expect(ctx.query).toBe('authentication patterns');
+    });
+
+    it('should track tokens saved', async () => {
+      const before = optimizer.getStats().totalTokensSaved;
+      await optimizer.getCompactContext('test query');
+      const after = optimizer.getStats().totalTokensSaved;
+
+      // Should increase (or stay same if no memories found)
+      expect(after).toBeGreaterThanOrEqual(before);
+    });
+  });
+
+  describe('optimizedEdit', () => {
+    it('should return edit optimization result', async () => {
+      const result = await optimizer.optimizedEdit(
+        '/test/file.ts',
+        'const x = 1;',
+        'const x = 2;',
+        'typescript'
+      );
+
+      expect(result).toHaveProperty('speedupFactor');
+      expect(result).toHaveProperty('executionMs');
+      expect(result).toHaveProperty('method');
+      expect(['agent-booster', 'traditional']).toContain(result.method);
+    });
+
+    it('should track edits optimized', async () => {
+      const before = optimizer.getStats().editsOptimized;
+      await optimizer.optimizedEdit('/test.ts', 'a', 'b', 'typescript');
+      const after = optimizer.getStats().editsOptimized;
+
+      expect(after).toBeGreaterThanOrEqual(before);
+    });
+  });
+
+  describe('getOptimalConfig', () => {
+    it('should return anti-drift config for small teams', () => {
+      const config = optimizer.getOptimalConfig(4);
+
+      expect(config.batchSize).toBeLessThanOrEqual(5);
+      expect(config.cacheSizeMB).toBeGreaterThanOrEqual(10);
+      expect(config.topology).toBe('hierarchical');
+      expect(config.expectedSuccessRate).toBeGreaterThanOrEqual(0.9);
+    });
+
+    it('should recommend mesh for very small teams', () => {
+      const config = optimizer.getOptimalConfig(3);
+      // Anti-drift still prefers hierarchical
+      expect(['mesh', 'hierarchical']).toContain(config.topology);
+    });
+
+    it('should handle large agent counts', () => {
+      const config = optimizer.getOptimalConfig(15);
+
+      expect(config.topology).toBe('hierarchical');
+      expect(config.batchSize).toBeLessThanOrEqual(5);
+    });
+  });
+
+  describe('cachedLookup', () => {
+    it('should cache results', async () => {
+      let callCount = 0;
+      const generator = async () => {
+        callCount++;
+        return { data: 'test' };
+      };
+
+      // First call - cache miss
+      await optimizer.cachedLookup('test-key-1', generator);
+      expect(callCount).toBe(1);
+
+      // Second call - cache hit
+      await optimizer.cachedLookup('test-key-1', generator);
+      expect(callCount).toBe(1); // Should not increment
+    });
+
+    it('should track cache hits and misses', async () => {
+      const before = optimizer.getStats();
+      const totalBefore = before.cacheHits + before.cacheMisses;
+
+      await optimizer.cachedLookup('unique-key-' + Date.now(), async () => 'value');
+
+      const after = optimizer.getStats();
+      const totalAfter = after.cacheHits + after.cacheMisses;
+
+      expect(totalAfter).toBe(totalBefore + 1);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return all statistics', () => {
+      const stats = optimizer.getStats();
+
+      expect(stats).toHaveProperty('totalTokensSaved');
+      expect(stats).toHaveProperty('editsOptimized');
+      expect(stats).toHaveProperty('cacheHits');
+      expect(stats).toHaveProperty('cacheMisses');
+      expect(stats).toHaveProperty('memoriesRetrieved');
+      expect(stats).toHaveProperty('agenticFlowAvailable');
+      expect(stats).toHaveProperty('cacheHitRate');
+      expect(stats).toHaveProperty('estimatedMonthlySavings');
+    });
+
+    it('should calculate cache hit rate', () => {
+      const stats = optimizer.getStats();
+      expect(stats.cacheHitRate).toMatch(/^\d+(\.\d+)?%$/);
+    });
+
+    it('should estimate monthly savings', () => {
+      const stats = optimizer.getStats();
+      expect(stats.estimatedMonthlySavings).toMatch(/^\$\d+(\.\d+)?$/);
+    });
+  });
+
+  describe('generateReport', () => {
+    it('should generate markdown report', () => {
+      const report = optimizer.generateReport();
+
+      expect(report).toContain('Token Optimization Report');
+      expect(report).toContain('Tokens Saved');
+      expect(report).toContain('Edits Optimized');
+      expect(report).toContain('Cache Hit Rate');
+    });
+  });
+
+  describe('singleton', () => {
+    it('should return same instance via getTokenOptimizer', async () => {
+      const opt1 = await getTokenOptimizer();
+      const opt2 = await getTokenOptimizer();
+
+      expect(opt1).toBe(opt2);
+    });
+  });
+});