@iservu-inc/adf-cli 0.14.6 → 0.17.0

package/tests/a2a-generator.test.js

@@ -0,0 +1,288 @@
+const fs = require('fs-extra');
+const path = require('path');
+const A2AGenerator = require('../lib/generators/a2a-generator');
+
+const TEST_PROJECT_PATH = path.join(__dirname, 'test-project-a2a');
+const TEST_SESSION_PATH = path.join(TEST_PROJECT_PATH, '.adf', 'sessions', 'test-session');
+
+describe('A2AGenerator', () => {
+  beforeEach(async () => {
+    await fs.remove(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_SESSION_PATH);
+    await fs.ensureDir(path.join(TEST_SESSION_PATH, 'outputs'));
+  });
+
+  afterEach(async () => {
+    await fs.remove(TEST_PROJECT_PATH);
+  });
+
+  async function createPRPOutput() {
+    const prpContent = `# Product Requirement Prompt (PRP)
+
+## 1. Goal Definition
+Build a React dashboard for analytics.
+
+## 2. Business Justification
+Improve data-driven decisions.
+
+## 3. Contextual Intelligence
+### Technology Stack
+- Frontend: React 18, TypeScript
+- Backend: Node.js, Express
+`;
+    await fs.writeFile(
+      path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+      prpContent,
+      'utf-8'
+    );
+    await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+      framework: 'rapid',
+      projectName: 'Test Dashboard'
+    });
+  }
+
+  async function createBalancedOutputs() {
+    await fs.writeFile(
+      path.join(TEST_SESSION_PATH, 'outputs', 'constitution.md'),
+      '# Constitution\n\n## Core Principles\n1. Privacy first',
+      'utf-8'
+    );
+    await fs.writeFile(
+      path.join(TEST_SESSION_PATH, 'outputs', 'specification.md'),
+      '# Specification\n\n## Overview\nUser management system.',
+      'utf-8'
+    );
+    await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+      framework: 'balanced',
+      projectName: 'Test UserMgmt'
+    });
+  }
+
+  async function createComprehensiveOutputs() {
+    await fs.writeFile(
+      path.join(TEST_SESSION_PATH, 'outputs', 'prd.md'),
+      '# PRD\n\n## Executive Summary\nE-commerce platform.',
+      'utf-8'
+    );
+    await fs.writeFile(
+      path.join(TEST_SESSION_PATH, 'outputs', 'architecture.md'),
+      '# Architecture\n\n## System Overview\nMicroservices.',
+      'utf-8'
+    );
+    await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+      framework: 'comprehensive',
+      projectName: 'Test Ecommerce'
+    });
+  }
+
+  describe('Rapid Framework', () => {
+    it('should generate A2A cards for rapid workflow (dev, qa)', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      const result = await generator.generate();
+
+      // Check combined card exists
+      expect(await fs.pathExists(result.agentCard)).toBe(true);
+
+      // Check individual agents
+      expect(result.agents).toHaveLength(2);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'dev.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'qa.json'))).toBe(true);
+    });
+
+    it('should include correct fields in individual agent card', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const devCard = await fs.readJson(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'dev.json'));
+
+      expect(devCard).toHaveProperty('name');
+      expect(devCard).toHaveProperty('description');
+      expect(devCard).toHaveProperty('version');
+      expect(devCard).toHaveProperty('url', 'local://adf/agents/dev');
+      expect(devCard).toHaveProperty('supportedInterfaces');
+      expect(devCard.supportedInterfaces[0]).toHaveProperty('protocolBinding', 'JSONRPC');
+      expect(devCard.supportedInterfaces[0]).toHaveProperty('protocolVersion', '0.3');
+      expect(devCard).toHaveProperty('defaultInputModes');
+      expect(devCard).toHaveProperty('defaultOutputModes');
+      expect(devCard).toHaveProperty('capabilities');
+      expect(devCard).toHaveProperty('provider');
+      expect(devCard.provider.organization).toBe('ADF CLI');
+      expect(devCard).toHaveProperty('skills');
+      expect(devCard.skills.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Balanced Framework', () => {
+    it('should generate A2A cards for balanced workflow (analyst, pm, dev, qa)', async () => {
+      await createBalancedOutputs();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'balanced');
+      const result = await generator.generate();
+
+      expect(result.agents).toHaveLength(4);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'analyst.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'pm.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'dev.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'qa.json'))).toBe(true);
+    });
+  });
+
+  describe('Comprehensive Framework', () => {
+    it('should generate A2A cards for comprehensive workflow (all 6 agents)', async () => {
+      await createComprehensiveOutputs();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'comprehensive');
+      const result = await generator.generate();
+
+      expect(result.agents).toHaveLength(6);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'architect.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'sm.json'))).toBe(true);
+    });
+  });
+
+  describe('Combined Agent Card', () => {
+    it('should contain all agents and merged skills', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const combined = await fs.readJson(path.join(TEST_PROJECT_PATH, '.a2a', 'agent-card.json'));
+
+      expect(combined.name).toContain('Test Dashboard');
+      expect(combined.description).toContain('rapid');
+      expect(combined).toHaveProperty('agents');
+      expect(combined.agents).toHaveLength(2);
+      expect(combined).toHaveProperty('skills');
+      expect(combined.skills.length).toBeGreaterThan(0);
+
+      // Skills from both dev and qa should be present
+      const skillIds = combined.skills.map(s => s.id);
+      expect(skillIds).toContain('tdd-implementation');
+      expect(skillIds).toContain('risk-assessment');
+    });
+
+    it('should have correct A2A protocol fields', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const combined = await fs.readJson(path.join(TEST_PROJECT_PATH, '.a2a', 'agent-card.json'));
+
+      expect(combined).toHaveProperty('supportedInterfaces');
+      expect(combined.supportedInterfaces[0].protocolBinding).toBe('JSONRPC');
+      expect(combined).toHaveProperty('defaultInputModes');
+      expect(combined.defaultInputModes).toContain('text/plain');
+      expect(combined.defaultInputModes).toContain('application/json');
+    });
+  });
+
+  describe('Frontmatter Parsing', () => {
+    it('should parse agent YAML frontmatter correctly', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+
+      const content = `---
+agent:
+  id: dev
+  name: Dev
+  role: Senior Full-Stack Developer
+  focus: TDD implementation with context engineering
+
+mcp_tools:
+  - context7
+  - mem0
+---
+
+# Dev Agent`;
+
+      const frontmatter = generator.parseAgentFrontmatter(content);
+
+      expect(frontmatter.agent).toBeDefined();
+      expect(frontmatter.agent.id).toBe('dev');
+      expect(frontmatter.agent.name).toBe('Dev');
+      expect(frontmatter.agent.role).toBe('Senior Full-Stack Developer');
+      expect(frontmatter.mcp_tools).toContain('context7');
+      expect(frontmatter.mcp_tools).toContain('mem0');
+    });
+
+    it('should return empty object for content without frontmatter', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+
+      const content = '# Just a heading\nNo frontmatter here.';
+      const frontmatter = generator.parseAgentFrontmatter(content);
+
+      expect(frontmatter).toEqual({});
+    });
+  });
+
+  describe('Skills Mapping', () => {
+    it('should include MCP tools as skills', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const devCard = await fs.readJson(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'dev.json'));
+      const mcpSkills = devCard.skills.filter(s => s.id.startsWith('mcp-'));
+
+      expect(mcpSkills.length).toBeGreaterThan(0);
+      expect(mcpSkills.some(s => s.id === 'mcp-context7')).toBe(true);
+    });
+
+    it('should map dev agent to development skills', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const devCard = await fs.readJson(path.join(TEST_PROJECT_PATH, '.a2a', 'agents', 'dev.json'));
+      const coreSkills = devCard.skills.filter(s => !s.id.startsWith('mcp-'));
+
+      expect(coreSkills.some(s => s.id === 'tdd-implementation')).toBe(true);
+      expect(coreSkills.some(s => s.id === 'code-review')).toBe(true);
+    });
+  });
+
+  describe('Idempotency', () => {
+    it('should safely regenerate without errors', async () => {
+      await createPRPOutput();
+      const generator1 = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator1.generate();
+
+      // Run again — should not throw
+      const generator2 = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      const result = await generator2.generate();
+
+      expect(await fs.pathExists(result.agentCard)).toBe(true);
+      expect(result.agents).toHaveLength(2);
+    });
+  });
+
+  describe('Output Structure', () => {
+    it('should create .a2a directory with correct structure', async () => {
+      await createPRPOutput();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agent-card.json'))).toBe(true);
+      expect(await fs.pathExists(path.join(TEST_PROJECT_PATH, '.a2a', 'agents'))).toBe(true);
+    });
+
+    it('should produce valid JSON in all output files', async () => {
+      await createComprehensiveOutputs();
+      const generator = new A2AGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'comprehensive');
+      await generator.generate();
+
+      // All files should be parseable JSON
+      const agentsDir = path.join(TEST_PROJECT_PATH, '.a2a', 'agents');
+      const files = await fs.readdir(agentsDir);
+
+      for (const file of files) {
+        const content = await fs.readJson(path.join(agentsDir, file));
+        expect(content).toHaveProperty('name');
+        expect(content).toHaveProperty('skills');
+      }
+    });
+  });
+});

package/tests/progress-tracker.test.js

@@ -76,6 +76,22 @@ describe('ProgressTracker', () => {
       expect(progress.averageAnswerQuality).toBe(80); // (80+90+70)/3 = 80
     });
 
+    it('should update existing answer correctly', async () => {
+      const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
+      await tracker.initialize();
+
+      const initialMetrics = { qualityScore: 80, wordCount: 10, isComprehensive: true };
+      await tracker.answerQuestion('q1', 'Q1', 'Initial Answer', initialMetrics);
+
+      const newAnswerText = 'Updated Answer with more words';
+      await tracker.updateAnswer('q1', newAnswerText);
+
+      const progress = tracker.getProgress();
+      expect(progress.answers['q1'].text).toBe(newAnswerText);
+      expect(progress.answers['q1'].quality.wordCount).toBe(5); // Updated word count
+      expect(progress.totalWordCount).toBe(5); // totalWordCount should be updated correctly
+    });
+
     it('should calculate information richness based on quality and completion', async () => {
       const tracker = new ProgressTracker(TEST_SESSION_PATH, 5, 'rapid');
       await tracker.initialize();