@iservu-inc/adf-cli 0.16.0 → 0.17.0

package/lib/commands/deploy.js

@@ -159,6 +159,20 @@ async function deployToTool(tool, options = {}) {
       console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate AGENTS.md: ${error.message}`));
     }
 
+    // Generate A2A agent cards (if not already present)
+    const a2aDir = path.join(cwd, '.a2a');
+    if (!await fs.pathExists(a2aDir)) {
+      try {
+        const { generateA2A } = require('../generators');
+        await generateA2A(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated A2A agent cards'));
+        }
+      } catch (error) {
+        console.warn(chalk.yellow(`⚠ Could not generate A2A cards: ${error.message}`));
+      }
+    }
+
     // Generate tool-specific configurations
     if (spinner) spinner.text = `Generating ${TOOLS[tool]?.name || tool} configurations...`;
 

package/lib/commands/guide.js

@@ -295,6 +295,38 @@ const TOOL_GUIDES = {
     ]
   },
 
+  'a2a': {
+    name: 'A2A (Agent-to-Agent) Protocol',
+    files: [
+      { path: '.a2a/agent-card.json', desc: 'Combined discovery card with all agent skills' },
+      { path: '.a2a/agents/*.json', desc: 'Individual agent cards (dev, qa, pm, etc.)' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' }
+    ],
+    setup: [
+      '1. A2A cards are auto-generated during `adf init`',
+      '2. Cards are also created as fallback during `adf deploy <tool>`',
+      '3. No additional setup required — cards follow the A2A protocol spec',
+      '4. Individual agent cards are in .a2a/agents/',
+      '5. Combined discovery card at .a2a/agent-card.json'
+    ],
+    usage: [
+      '• A2A cards enable interoperability with any A2A-compatible tool',
+      '• Combined card (.a2a/agent-card.json) lists all agents and skills',
+      '• Individual cards (.a2a/agents/<name>.json) per agent role',
+      '• Skills are derived from agent markdown frontmatter',
+      '• Cards include MCP tool references from agent definitions',
+      '• Protocol version: 0.3 (JSONRPC binding)',
+      '• Spec: https://google.github.io/A2A/'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• Cards not generated? Run `adf init` or `adf deploy <tool>`',
+      '• Missing agents? Check workflow level (rapid=2, balanced=4, comprehensive=6)',
+      '• Regenerate by deleting .a2a/ directory and running deploy again',
+      '• Validate JSON: cat .a2a/agent-card.json | python -m json.tool'
+    ]
+  },
+
   'deepagent': {
     name: 'Abacus.ai DeepAgent',
     files: [

package/lib/commands/init.js

@@ -322,6 +322,15 @@ async function init(options) {
   console.log(chalk.gray(`  ✓ Files saved to: ${sessionPath}/outputs/`));
   console.log(chalk.gray(`  ✓ You can review your requirements anytime\n`));
 
+  // Generate A2A agent cards
+  try {
+    const { generateA2A } = require('../generators');
+    await generateA2A(sessionPath, cwd, workflow);
+    console.log(chalk.gray('  ✓ A2A agent cards generated'));
+  } catch (error) {
+    console.warn(chalk.yellow(`  ⚠ Could not generate A2A cards: ${error.message}`));
+  }
+
   // Optional: Deploy to tool
   if (options.tool) {
     console.log('');

package/lib/generators/a2a-generator.js

@@ -0,0 +1,289 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ToolConfigGenerator = require('./tool-config-generator');
+
+/**
+ * Generator for A2A (Agent-to-Agent) protocol agent cards
+ * Creates compliant agent discovery cards for interoperability
+ * with any A2A-compatible tool.
+ *
+ * Output structure:
+ *   .a2a/
+ *   ├── agent-card.json       # Combined discovery card (all agents)
+ *   └── agents/
+ *       ├── dev.json           # Individual agent cards
+ *       ├── qa.json
+ *       └── ...
+ */
+class A2AGenerator extends ToolConfigGenerator {
+  /**
+   * Generate A2A agent cards for all agents in the current framework
+   */
+  async generate() {
+    await this.initialize();
+
+    const a2aDir = path.join(this.projectPath, '.a2a');
+    const agentsDir = path.join(a2aDir, 'agents');
+    await fs.ensureDir(agentsDir);
+
+    const agentsList = this.getAgentsList();
+    const individualCards = [];
+
+    for (const agentName of agentsList) {
+      const card = await this.generateAgentCard(agentName);
+      if (card) {
+        await fs.writeJson(
+          path.join(agentsDir, `${agentName}.json`),
+          card,
+          { spaces: 2 }
+        );
+        individualCards.push(card);
+      }
+    }
+
+    const combinedCard = this.generateCombinedCard(individualCards);
+    await fs.writeJson(
+      path.join(a2aDir, 'agent-card.json'),
+      combinedCard,
+      { spaces: 2 }
+    );
+
+    return {
+      agentCard: path.join(a2aDir, 'agent-card.json'),
+      agents: agentsList.map(a => path.join(agentsDir, `${a}.json`))
+    };
+  }
+
+  /**
+   * Generate an individual A2A agent card from agent markdown frontmatter
+   */
+  async generateAgentCard(agentName) {
+    const agentPath = path.join(__dirname, '../templates/shared/agents', `${agentName}.md`);
+
+    if (!await fs.pathExists(agentPath)) {
+      return null;
+    }
+
+    const content = await fs.readFile(agentPath, 'utf-8');
+    const frontmatter = this.parseAgentFrontmatter(content);
+    const skills = this.mapAgentToSkills(agentName, frontmatter);
+
+    const agentId = (frontmatter.agent && frontmatter.agent.id) || agentName;
+    const agentDisplayName = (frontmatter.agent && frontmatter.agent.name) || agentName;
+    const role = (frontmatter.agent && frontmatter.agent.role) || agentName;
+    const focus = (frontmatter.agent && frontmatter.agent.focus) || '';
+
+    const description = focus ? `${role} - ${focus}` : role;
+
+    return {
+      name: `ADF ${agentDisplayName} Agent`,
+      description,
+      version: this.getADFVersion(),
+      url: `local://adf/agents/${agentId}`,
+      supportedInterfaces: [{
+        url: `local://adf/agents/${agentId}`,
+        protocolBinding: 'JSONRPC',
+        protocolVersion: '0.3'
+      }],
+      defaultInputModes: ['text/plain', 'application/json'],
+      defaultOutputModes: ['text/plain', 'application/json'],
+      capabilities: {
+        streaming: false,
+        pushNotifications: false
+      },
+      provider: {
+        organization: 'ADF CLI',
+        url: 'https://github.com/iservu-inc/adf-cli'
+      },
+      skills
+    };
+  }
+
+  /**
+   * Generate combined agent-card.json with all agents' skills merged
+   */
+  generateCombinedCard(individualCards) {
+    const projectName = this.getProjectName();
+    const allSkills = [];
+
+    for (const card of individualCards) {
+      if (card.skills) {
+        allSkills.push(...card.skills);
+      }
+    }
+
+    return {
+      name: `ADF ${projectName} Agents`,
+      description: `Agent-to-Agent discovery card for ${projectName} (${this.framework} workflow)`,
+      version: this.getADFVersion(),
+      url: 'local://adf/agents',
+      supportedInterfaces: [{
+        url: 'local://adf/agents',
+        protocolBinding: 'JSONRPC',
+        protocolVersion: '0.3'
+      }],
+      defaultInputModes: ['text/plain', 'application/json'],
+      defaultOutputModes: ['text/plain', 'application/json'],
+      capabilities: {
+        streaming: false,
+        pushNotifications: false
+      },
+      provider: {
+        organization: 'ADF CLI',
+        url: 'https://github.com/iservu-inc/adf-cli'
+      },
+      skills: allSkills,
+      agents: individualCards.map(card => ({
+        name: card.name,
+        url: card.url,
+        description: card.description
+      }))
+    };
+  }
+
+  /**
+   * Parse YAML frontmatter from agent markdown file
+   */
+  parseAgentFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return {};
+
+    const yaml = match[1];
+    return this.simpleYamlParse(yaml);
+  }
+
+  /**
+   * Simple YAML parser for agent frontmatter
+   * Handles the specific nested structure used in agent files
+   */
+  simpleYamlParse(yaml) {
+    const result = {};
+    const lines = yaml.split('\n');
+    let currentTopKey = null;
+    let currentSubKey = null;
+    let currentArray = null;
+
+    for (const line of lines) {
+      // Skip empty lines and comments
+      if (!line.trim() || line.trim().startsWith('#')) continue;
+
+      // Check for top-level key (no indentation)
+      const topMatch = line.match(/^(\w[\w_]*):(.*)$/);
+      if (topMatch) {
+        currentTopKey = topMatch[1];
+        const value = topMatch[2].trim();
+        if (value && !value.startsWith('|')) {
+          result[currentTopKey] = value;
+        } else if (!value) {
+          result[currentTopKey] = {};
+        }
+        currentSubKey = null;
+        currentArray = null;
+        continue;
+      }
+
+      // Check for sub-key (2-space indentation)
+      const subMatch = line.match(/^  (\w[\w_]*):(.*)$/);
+      if (subMatch && currentTopKey) {
+        currentSubKey = subMatch[1];
+        const value = subMatch[2].trim();
+        if (typeof result[currentTopKey] !== 'object') {
+          result[currentTopKey] = {};
+        }
+        if (value) {
+          result[currentTopKey][currentSubKey] = value;
+        } else {
+          result[currentTopKey][currentSubKey] = [];
+          currentArray = result[currentTopKey][currentSubKey];
+        }
+        continue;
+      }
+
+      // Check for array item (4-space indentation with dash)
+      const arrayMatch = line.match(/^    - (.+)$/);
+      if (arrayMatch && currentArray) {
+        // Strip inline comments
+        const val = arrayMatch[1].replace(/#.*$/, '').trim();
+        currentArray.push(val);
+        continue;
+      }
+
+      // Check for top-level array item (2-space indentation with dash)
+      const topArrayMatch = line.match(/^  - (.+)$/);
+      if (topArrayMatch && currentTopKey && !currentSubKey) {
+        if (!Array.isArray(result[currentTopKey])) {
+          result[currentTopKey] = [];
+        }
+        const val = topArrayMatch[1].replace(/#.*$/, '').trim();
+        result[currentTopKey].push(val);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Map an ADF agent's frontmatter to A2A skills
+   */
+  mapAgentToSkills(agentName, frontmatter) {
+    const AGENT_SKILLS = {
+      dev: [
+        { id: 'tdd-implementation', name: 'TDD Implementation', description: 'Test-driven development with context engineering', tags: ['development', 'tdd', 'testing'] },
+        { id: 'code-review', name: 'Code Review', description: 'Self-review against coding standards', tags: ['development', 'review'] },
+        { id: 'refactoring', name: 'Refactoring', description: 'Code refactoring while maintaining tests', tags: ['development', 'refactoring'] }
+      ],
+      qa: [
+        { id: 'risk-assessment', name: 'Risk Assessment', description: 'Identify and score project risks', tags: ['quality', 'risk'] },
+        { id: 'test-design', name: 'Test Design', description: 'Comprehensive test strategy creation', tags: ['quality', 'testing'] },
+        { id: 'quality-gates', name: 'Quality Gates', description: 'Quality gate management and decisions', tags: ['quality', 'gates'] }
+      ],
+      pm: [
+        { id: 'requirements-gathering', name: 'Requirements Gathering', description: 'Product requirements analysis and documentation', tags: ['product', 'requirements'] },
+        { id: 'story-creation', name: 'Story Creation', description: 'User story and specification writing', tags: ['product', 'stories'] },
+        { id: 'project-planning', name: 'Project Planning', description: 'Sprint planning and backlog management', tags: ['product', 'planning'] }
+      ],
+      analyst: [
+        { id: 'market-analysis', name: 'Market Analysis', description: 'Market research and competitive analysis', tags: ['analysis', 'market'] },
+        { id: 'business-requirements', name: 'Business Requirements', description: 'Business requirements documentation', tags: ['analysis', 'requirements'] }
+      ],
+      architect: [
+        { id: 'system-design', name: 'System Design', description: 'System architecture and technical design', tags: ['architecture', 'design'] },
+        { id: 'tech-stack-selection', name: 'Tech Stack Selection', description: 'Technology evaluation and selection', tags: ['architecture', 'technology'] }
+      ],
+      sm: [
+        { id: 'sprint-management', name: 'Sprint Management', description: 'Agile sprint planning and execution', tags: ['agile', 'sprint'] },
+        { id: 'ceremony-facilitation', name: 'Ceremony Facilitation', description: 'Scrum ceremony facilitation', tags: ['agile', 'ceremonies'] }
+      ]
+    };
+
+    const skills = AGENT_SKILLS[agentName] || [];
+
+    // Enrich with MCP tools from frontmatter if present
+    if (frontmatter.mcp_tools && Array.isArray(frontmatter.mcp_tools)) {
+      for (const tool of frontmatter.mcp_tools) {
+        skills.push({
+          id: `mcp-${tool}`,
+          name: `MCP: ${tool}`,
+          description: `Integration with ${tool} MCP server`,
+          tags: ['mcp', tool]
+        });
+      }
+    }
+
+    return skills;
+  }
+
+  /**
+   * Get ADF CLI version from package.json
+   */
+  getADFVersion() {
+    try {
+      const packageJson = require('../../package.json');
+      return packageJson.version;
+    } catch (error) {
+      return '0.16.0';
+    }
+  }
+}
+
+module.exports = A2AGenerator;

package/lib/generators/index.js

@@ -15,6 +15,7 @@ const DeepAgentGenerator = require('./deepagent-generator');
 const KiroGenerator = require('./kiro-generator');
 const TraeGenerator = require('./trae-generator');
 const CodexCLIGenerator = require('./codex-cli-generator');
+const A2AGenerator = require('./a2a-generator');
 const ToolConfigGenerator = require('./tool-config-generator');
 
 /**
@@ -171,6 +172,14 @@ async function generateCodexCLI(sessionPath, projectPath, framework) {
   return await generator.generate();
 }
 
+/**
+ * Generate A2A (Agent-to-Agent) protocol agent cards
+ */
+async function generateA2A(sessionPath, projectPath, framework) {
+  const generator = new A2AGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
 module.exports = {
   generateAll,
   generateAgentsMd,
@@ -185,6 +194,7 @@ module.exports = {
   generateKiro,
   generateTrae,
   generateCodexCLI,
+  generateA2A,
   AgentsMdGenerator,
   WindsurfGenerator,
   CursorGenerator,
@@ -197,5 +207,6 @@ module.exports = {
   KiroGenerator,
   TraeGenerator,
   CodexCLIGenerator,
+  A2AGenerator,
   ToolConfigGenerator
 };

package/lib/templates/shared/agents/analyst.md

@@ -536,4 +536,4 @@ Brief ready for PM to create PRD.
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: Agent-Native + Market Research Best Practices
+**Methodology**: BMAD-METHOD + Market Research Best Practices

package/lib/templates/shared/agents/architect.md

@@ -550,4 +550,4 @@ Ready for SM to create stories.
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: Agent-Native + Software Architecture Best Practices
+**Methodology**: BMAD-METHOD + Software Architecture Best Practices

package/lib/templates/shared/agents/dev.md

@@ -118,7 +118,7 @@ You are a Senior Full-Stack Developer focused on implementing features from deta
 ### Core Commands
 
 ```bash
-/implement <story-id>    # Implement a feature from requirements
+/implement <story-id>    # Implement a story from PRD
 /test                    # Run tests and analyze results
 /review                  # Perform self-code-review
 /commit                  # Create well-formatted commit

package/lib/templates/shared/agents/pm.md

@@ -50,7 +50,7 @@ You are a Product Manager focused on creating comprehensive Product Requirements
 
 ## Primary Responsibilities
 
-### 1. PRD Creation (Path A: Agent-Native)
+### 1. PRD Creation (Path A: Greenfield)
 
 **Create comprehensive Product Requirements Document**:
 - Executive Summary
@@ -672,4 +672,4 @@ PRD complete. Ready for architect review.
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: Agent-Native + Agile Best Practices
+**Methodology**: BMAD-METHOD + Agile Best Practices

package/lib/templates/shared/agents/qa.md

@@ -537,4 +537,4 @@ Recommendation: Implement rate limiting and CAPTCHA before beginning development
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: Agent-Native + Risk-Based Testing Best Practices
+**Methodology**: BMAD-METHOD QA + Risk-Based Testing Best Practices

package/lib/templates/shared/agents/sm.md

@@ -67,7 +67,7 @@ You are Samira, a Scrum Master focused on creating implementation-ready stories
 
 ## Story Creation Workflow
 
-### 1. Context Gathering (Path A: Agent-Native)
+### 1. Context Gathering (Path A: Greenfield)
 
 ```
 1. Read Planning Phase Outputs
@@ -77,7 +77,7 @@ You are Samira, a Scrum Master focused on creating implementation-ready stories
    - Related stories
 ```
 
-### 2. Task Breakdown (Level 2: Balanced (OpenSpec))
+### 2. Task Breakdown (Path B: OpenSpec)
 
 ```
 1. Read Change Context
@@ -785,4 +785,4 @@ Would you like me to:
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: Agent-Native + Agile Best Practices
+**Methodology**: BMAD-METHOD + Context Engineering + Agile Best Practices

package/lib/templates/shared/memory/constitution.md

@@ -1,6 +1,6 @@
 # Development Constitution
 
-This document defines the immutable principles governing all development in this project. These principles synthesize best practices from Agent-Native and OpenSpec methodologies.
+This document defines the immutable principles governing all development in this project. These principles synthesize best practices from BMAD-METHOD, Spec-Kit, and Context Engineering methodologies.
 
 ## Article 1: Specification-First Development
 
@@ -287,6 +287,6 @@ This constitution is enforced through:
 
 **Version**: 1.0.0
 **Last Updated**: 2025-01-XX
-**Source**: Synthesized from Agent-Native and OpenSpec methodologies
+**Source**: Synthesized from BMAD-METHOD, Spec-Kit, Context Engineering
 
 **Living Document**: This constitution evolves with project needs while maintaining core principles.

package/lib/templates/shared/templates/README.md

@@ -1,10 +1,10 @@
 # Template Library
 
-This directory contains all templates for the AgentDevFramework, synthesizing best practices from Agent-Native and OpenSpec methodologies.
+This directory contains all templates for the AgentDevFramework, synthesizing best practices from BMAD-METHOD, Spec-Kit, Context Engineering, and PRPs Agentic Engineering.
 
 ## Template Categories
 
-### Rapid (Agent-Native) Templates
+### PRPs Templates (Product Requirement Prompts)
 
 **Philosophy**: One-pass implementation success through comprehensive context and validation
 
@@ -50,7 +50,7 @@ This directory contains all templates for the AgentDevFramework, synthesizing be
 - **Complexity**: Low-Medium
 - **Best For**: Quick feature implementation with validation
 
-### Comprehensive (Agent-Native) Templates
+### BMAD Templates
 
 #### `prd-template.md` - Product Requirements Document
 - **Use For**: Comprehensive product requirements
@@ -64,7 +64,7 @@ This directory contains all templates for the AgentDevFramework, synthesizing be
 - **Best For**: Story-driven development, team handoffs
 - **Includes**: Context, acceptance criteria, technical approach, validation
 
-### OpenSpec Templates
+### Spec-Kit Templates
 
 #### `spec-template.md` - Formal Specification
 - **Use For**: Detailed specifications with validation checkpoints
@@ -88,13 +88,13 @@ This directory contains all templates for the AgentDevFramework, synthesizing be
 
 | Template | Workflow Level | Use Case | Time | Validation | Complexity |
 |----------|---------------|----------|------|------------|-----------|
-| **prp_task.md** | Level 1 (Rapid (Agent-Native)) | Sprint tasks, bug fixes | 5-10 min | Inline | Low |
-| **prp-template.md** | Level 1 (Rapid (Agent-Native)) | Quick features | 10-20 min | Basic | Low-Med |
+| **prp_task.md** | Level 1 (Rapid) | Sprint tasks, bug fixes | 5-10 min | Inline | Low |
+| **prp-template.md** | Level 1 (Rapid) | Quick features | 10-20 min | Basic | Low-Med |
 | **prp_spec.md** | Level 1-2 | Rapid prototyping | 20-30 min | L1-L2 | Medium |
-| **prp_base.md** | Level 2 (Balanced (OpenSpec)) | Feature implementation | 30-45 min | 4-level | Med-High |
-| **spec-template.md** | Level 2 (Balanced (OpenSpec)) | Formal specifications | 30-60 min | Gates | Medium |
-| **prp_planning.md** | Level 3 (Comprehensive (Agent-Native)) | PRD with diagrams | 1-2 hours | Pre-impl | High |
-| **prd-template.md** | Level 3 (Comprehensive (Agent-Native)) | Product requirements | 1-2 hours | - | High |
+| **prp_base.md** | Level 2 (Balanced) | Feature implementation | 30-45 min | 4-level | Med-High |
+| **spec-template.md** | Level 2 (Balanced) | Formal specifications | 30-60 min | Gates | Medium |
+| **prp_planning.md** | Level 3 (Comprehensive) | PRD with diagrams | 1-2 hours | Pre-impl | High |
+| **prd-template.md** | Level 3 (Comprehensive) | Product requirements | 1-2 hours | - | High |
 | **story-template.md** | Level 2-3 | Story-driven dev | 30-60 min | Context | Medium |
 
 ## 4-Level Validation System (From PRPs)
@@ -171,20 +171,20 @@ bandit -r src/
 
 ## Template Usage by Workflow
 
-### Level 1: Rapid (Agent-Native)
+### Level 1: Rapid Development
 **Templates**: prp_task.md, prp-template.md
 **Time**: 5-20 minutes upfront
 **Best For**: Sprint tasks, bug fixes, solo dev
 
-### Level 2: Balanced (OpenSpec)
+### Level 2: Specification-Driven
 **Templates**: prp_base.md, prp_spec.md, spec-template.md
 **Time**: 30-60 minutes upfront
 **Best For**: New features, clear scope, teams
 
-### Level 3: Comprehensive (Agent-Native)
+### Level 3: BMAD Comprehensive
 **Templates**: prp_planning.md, prd-template.md, story-template.md
 **Time**: 1-4 hours upfront
-**Best For**: Complex projects, enterprise, iterative strategic orchestration
+**Best For**: Complex projects, enterprise, unclear requirements
 
 ## Related Documentation
 

package/lib/templates/shared/templates/prd-template.md

@@ -560,4 +560,4 @@ So that [benefit]
 
 **Framework**: AgentDevFramework
 **Template Version**: 1.0.0
-**Methodology**: Agent-Native + Product Management Best Practices
+**Methodology**: BMAD-METHOD + Product Management Best Practices

package/lib/utils/tool-feature-registry.js

@@ -76,6 +76,12 @@ class ToolFeatureRegistry {
         status: 'supported',
         configFiles: ['.deepagent/'],
         features: ['Full Agent Suite']
+      },
+      a2a: {
+        name: 'A2A Protocol',
+        status: 'auto',
+        configFiles: ['.a2a/agent-card.json', '.a2a/agents/'],
+        features: ['Agent Cards', 'Skills Discovery', 'Protocol Compliance']
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "CLI tool for AgentDevFramework - Agent-Native development framework with multi-provider AI support",
   "main": "index.js",
   "bin": {

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');
+      }
+    });
+  });
+});