ma-agents 2.22.1 → 3.0.0

package/test/convert-agents-to-skills.test.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+/**
+ * Tests for Story 15-3: Convert 4 Custom Agents to BMAD 6.2.0 Skill Folders
+ *
+ * Verifies:
+ * - Each agent has SKILL.md and bmad-skill-manifest.yaml
+ * - SKILL.md contains Persona, Menu, Critical Actions sections
+ * - bmad-skill-manifest.yaml has all required fields
+ * - Menu items reference new skill names (not old paths)
+ */
+'use strict';
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const SKILLS_DIR = path.join(PROJECT_ROOT, 'lib', 'bmad-extension', 'skills');
+
+let passed = 0;
+let failed = 0;
+const errors = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  \u2713 ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  \u2717 ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+// ─── Agent definitions ───────────────────────────────────────────────────────
+const AGENTS = [
+  {
+    folder: 'bmad-ma-agent-sre',
+    name: 'bmad-ma-agent-sre',
+    displayName: 'Alex',
+    title: 'SRE Agent',
+    skillNames: ['sre-health-check', 'sre-fix-deployments', 'sre-performance-opt'],
+    oldPaths: ['bmm/workflows/sre/', '_bmad/bmm/workflows/sre/'],
+    chatTopic: 'reliability',
+    menuItemCount: 6 // MH, CH, HC, FD, PO, DA
+  },
+  {
+    folder: 'bmad-ma-agent-devops',
+    name: 'bmad-ma-agent-devops',
+    displayName: 'Amit',
+    title: 'DevOps Agent',
+    skillNames: ['devops-configure-infrastructure', 'devops-optimize-pipelines', 'devops-manage-helm'],
+    oldPaths: ['bmm/workflows/devops/', '_bmad/bmm/workflows/devops/'],
+    chatTopic: 'DevOps',
+    menuItemCount: 6 // MH, CH, CO, PL, MH(helm), DA
+  },
+  {
+    folder: 'bmad-ma-agent-cyber',
+    name: 'bmad-ma-agent-cyber',
+    displayName: 'Yael',
+    title: 'Cyber Analyst',
+    skillNames: ['cyber-vulnerability-scan', 'cyber-security-audit', 'cyber-threat-modeling'],
+    oldPaths: ['bmm/workflows/cyber/', '_bmad/custom/workflows/cyber/'],
+    chatTopic: 'security',
+    menuItemCount: 6 // MH, CH, VS, SA, TM, DA
+  },
+  {
+    folder: 'bmad-ma-agent-mil498',
+    name: 'bmad-ma-agent-mil498',
+    displayName: 'Joseph',
+    title: 'MIL-STD-498 Expert',
+    skillNames: ['mil498-srs', 'mil498-sdd', 'mil498-sdp', 'mil498-ocd', 'mil498-sss', 'mil498-std', 'mil498-ssdd'],
+    oldPaths: ['bmm/workflows/mil498/', '_bmad/bmm/workflows/mil498/'],
+    chatTopic: 'MIL-STD-498',
+    menuItemCount: 10 // MH, CH, GS, GD, GP, GO, SS, GT, SD, DA
+  }
+];
+
+const REQUIRED_MANIFEST_FIELDS = [
+  'type', 'name', 'displayName', 'title', 'capabilities',
+  'role', 'identity', 'communicationStyle', 'principles', 'module'
+];
+
+// ─── File existence tests ────────────────────────────────────────────────────
+console.log('\n File existence tests\n');
+
+for (const agent of AGENTS) {
+  const skillDir = path.join(SKILLS_DIR, agent.folder);
+
+  test(`${agent.folder}: SKILL.md exists`, () => {
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
+    assert.ok(fs.existsSync(skillMdPath), `Missing: ${skillMdPath}`);
+  });
+
+  test(`${agent.folder}: bmad-skill-manifest.yaml exists`, () => {
+    const manifestPath = path.join(skillDir, 'bmad-skill-manifest.yaml');
+    assert.ok(fs.existsSync(manifestPath), `Missing: ${manifestPath}`);
+  });
+}
+
+// ─── SKILL.md content tests ─────────────────────────────────────────────────
+console.log('\n SKILL.md content tests\n');
+
+for (const agent of AGENTS) {
+  const skillDir = path.join(SKILLS_DIR, agent.folder);
+  const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+  let content = '';
+  try {
+    content = fs.readFileSync(skillMdPath, 'utf8');
+  } catch (e) {
+    // File not found — tests will fail naturally
+  }
+
+  test(`${agent.folder}: SKILL.md contains Persona section`, () => {
+    assert.ok(content.includes('## Persona'), 'Missing ## Persona section');
+  });
+
+  test(`${agent.folder}: SKILL.md contains Menu section`, () => {
+    assert.ok(content.includes('## Menu'), 'Missing ## Menu section');
+  });
+
+  test(`${agent.folder}: SKILL.md contains Critical Actions section`, () => {
+    assert.ok(content.includes('## Critical Actions'), 'Missing ## Critical Actions section');
+  });
+
+  test(`${agent.folder}: SKILL.md contains Activation Sequence section`, () => {
+    assert.ok(content.includes('## Activation Sequence'), 'Missing ## Activation Sequence section');
+  });
+
+  test(`${agent.folder}: SKILL.md contains agent display name (${agent.displayName})`, () => {
+    assert.ok(content.includes(agent.displayName), `Missing display name: ${agent.displayName}`);
+  });
+
+  test(`${agent.folder}: SKILL.md contains Role field`, () => {
+    assert.ok(content.includes('**Role:**'), 'Missing **Role:** field');
+  });
+
+  test(`${agent.folder}: SKILL.md contains Identity field`, () => {
+    assert.ok(content.includes('**Identity:**'), 'Missing **Identity:** field');
+  });
+
+  test(`${agent.folder}: SKILL.md contains Communication Style field`, () => {
+    assert.ok(content.includes('**Communication Style:**'), 'Missing **Communication Style:** field');
+  });
+
+  test(`${agent.folder}: SKILL.md contains Principles field`, () => {
+    assert.ok(content.includes('**Principles:**'), 'Missing **Principles:** field');
+  });
+
+  // Verify menu references new skill names
+  for (const skillName of agent.skillNames) {
+    test(`${agent.folder}: Menu references skill "${skillName}"`, () => {
+      assert.ok(content.includes(skillName), `Missing skill reference: ${skillName}`);
+    });
+  }
+
+  // Verify NO old workflow paths remain in menu
+  for (const oldPath of agent.oldPaths) {
+    test(`${agent.folder}: No old path references "${oldPath}" in SKILL.md`, () => {
+      assert.ok(!content.includes(oldPath), `Old path still referenced: ${oldPath}`);
+    });
+  }
+}
+
+// ─── bmad-skill-manifest.yaml content tests ──────────────────────────────────
+console.log('\n bmad-skill-manifest.yaml content tests\n');
+
+for (const agent of AGENTS) {
+  const skillDir = path.join(SKILLS_DIR, agent.folder);
+  const manifestPath = path.join(skillDir, 'bmad-skill-manifest.yaml');
+
+  let content = '';
+  try {
+    content = fs.readFileSync(manifestPath, 'utf8');
+  } catch (e) {
+    // File not found — tests will fail naturally
+  }
+
+  // Parse simple YAML key-value pairs (no nested structures expected)
+  const fields = {};
+  for (const line of content.split('\n')) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      fields[match[1]] = match[2].replace(/^["']|["']$/g, '');
+    }
+  }
+
+  for (const field of REQUIRED_MANIFEST_FIELDS) {
+    test(`${agent.folder}: manifest has required field "${field}"`, () => {
+      assert.ok(fields[field], `Missing or empty field: ${field}`);
+    });
+  }
+
+  test(`${agent.folder}: manifest type is "agent"`, () => {
+    assert.strictEqual(fields.type, 'agent', `Expected type: agent, got: ${fields.type}`);
+  });
+
+  test(`${agent.folder}: manifest name matches "${agent.name}"`, () => {
+    assert.strictEqual(fields.name, agent.name, `Expected name: ${agent.name}, got: ${fields.name}`);
+  });
+
+  test(`${agent.folder}: manifest displayName is "${agent.displayName}"`, () => {
+    assert.strictEqual(fields.displayName, agent.displayName, `Expected displayName: ${agent.displayName}, got: ${fields.displayName}`);
+  });
+
+  test(`${agent.folder}: manifest module is "ma-skills"`, () => {
+    assert.strictEqual(fields.module, 'ma-skills', `Expected module: ma-skills, got: ${fields.module}`);
+  });
+}
+
+// ─── Cross-validation: Critical Actions match extension customize.yaml ────────
+console.log('\n Critical Actions cross-validation\n');
+
+for (const agent of AGENTS) {
+  const skillDir = path.join(SKILLS_DIR, agent.folder);
+  const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+  let content = '';
+  try {
+    content = fs.readFileSync(skillMdPath, 'utf8');
+  } catch (e) {
+    // File not found
+  }
+
+  test(`${agent.folder}: Critical Actions includes MANIFEST reading`, () => {
+    assert.ok(content.includes('Read the skills MANIFEST'), 'Missing MANIFEST reading action');
+  });
+
+  test(`${agent.folder}: Critical Actions includes always_load skill reading`, () => {
+    assert.ok(content.includes('always_load: true'), 'Missing always_load skill reading action');
+  });
+
+  test(`${agent.folder}: Critical Actions includes project-context check`, () => {
+    assert.ok(content.includes('project-context.md'), 'Missing project-context check');
+  });
+}
+
+// ─── Results ──────────────────────────────────────────────────────────────────
+console.log(`\n  ${passed} passed, ${failed} failed\n`);
+if (failed > 0) {
+  errors.forEach(e => console.error(`  \u2717 ${e.name}: ${e.error}`));
+  process.exit(1);
+}

package/test/extension-module-restructure.test.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+/**
+ * Tests for extension module restructure (Story 15-2)
+ *
+ * Verifies:
+ *   - module.yaml has all required fields for BMAD 6.2.0 conventions
+ *   - skills/ directory exists with correct subdirectories
+ *   - module-help.csv has entries for all skills
+ *   - Old agents/ and workflows/ directories still exist (preserved for 15.3-15.6)
+ */
+'use strict';
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const EXTENSION_DIR = path.join(PROJECT_ROOT, 'lib', 'bmad-extension');
+
+let passed = 0;
+let failed = 0;
+const errors = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  \u2713 ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  \u2717 ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+// ─── Helper: parse simple YAML (key: value pairs) ──────────────────────────
+function parseSimpleYaml(content) {
+  const result = {};
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    let val = trimmed.slice(colonIdx + 1).trim();
+    // Strip surrounding quotes
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    result[key] = val;
+  }
+  return result;
+}
+
+// ─── Helper: parse CSV ──────────────────────────────────────────────────────
+function parseCsv(content) {
+  const lines = content.trim().split('\n').filter(l => l.trim());
+  if (lines.length === 0) return { headers: [], rows: [] };
+  const headers = lines[0].split(',').map(h => h.trim());
+  const rows = lines.slice(1).map(line => {
+    // Handle quoted fields with commas
+    const fields = [];
+    let current = '';
+    let inQuotes = false;
+    for (const ch of line) {
+      if (ch === '"') {
+        inQuotes = !inQuotes;
+      } else if (ch === ',' && !inQuotes) {
+        fields.push(current.trim());
+        current = '';
+      } else {
+        current += ch;
+      }
+    }
+    fields.push(current.trim());
+    return fields;
+  });
+  return { headers, rows };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+//  Task 1: module.yaml validation
+// ═══════════════════════════════════════════════════════════════════════════════
+console.log('\n--- Task 1: module.yaml ---');
+
+const moduleYamlPath = path.join(EXTENSION_DIR, 'module.yaml');
+
+test('module.yaml file exists', () => {
+  assert.ok(fs.existsSync(moduleYamlPath), 'module.yaml must exist');
+});
+
+let moduleYaml = {};
+test('module.yaml is parseable', () => {
+  const content = fs.readFileSync(moduleYamlPath, 'utf8');
+  moduleYaml = parseSimpleYaml(content);
+  assert.ok(Object.keys(moduleYaml).length > 0, 'module.yaml must have fields');
+});
+
+test('module.yaml has code: ma-skills', () => {
+  assert.strictEqual(moduleYaml.code, 'ma-skills', 'code field must be ma-skills');
+});
+
+test('module.yaml has name field', () => {
+  assert.ok(moduleYaml.name, 'name field must be present');
+  assert.strictEqual(moduleYaml.name, 'MA-Agents Skills & Agents');
+});
+
+test('module.yaml has description field', () => {
+  assert.ok(moduleYaml.description, 'description field must be present');
+  assert.strictEqual(
+    moduleYaml.description,
+    'Enterprise methodology enforcement, specialized agents, and operational workflows'
+  );
+});
+
+test('module.yaml has extends-module: bmm', () => {
+  assert.strictEqual(moduleYaml['extends-module'], 'bmm', 'extends-module must be bmm');
+});
+
+test('module.yaml has default_selected: false', () => {
+  assert.strictEqual(moduleYaml['default_selected'], 'false', 'default_selected must be false');
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+//  Task 2: skills/ directory structure
+// ═══════════════════════════════════════════════════════════════════════════════
+console.log('\n--- Task 2: skills/ directory ---');
+
+const skillsDir = path.join(EXTENSION_DIR, 'skills');
+
+test('skills/ directory exists', () => {
+  assert.ok(fs.existsSync(skillsDir), 'skills/ directory must exist');
+  assert.ok(fs.statSync(skillsDir).isDirectory(), 'skills/ must be a directory');
+});
+
+// Expected skill directories based on ACTUAL file inventory
+const expectedAgentSkills = [
+  'bmad-ma-agent-sre',
+  'bmad-ma-agent-devops',
+  'bmad-ma-agent-cyber',
+  'bmad-ma-agent-mil498',
+];
+
+const expectedMil498Skills = [
+  'mil498-sss', 'mil498-ssdd', 'mil498-ocd', 'mil498-sdp',
+  'mil498-srs', 'mil498-sdd', 'mil498-std',
+];
+
+const expectedSreSkills = [
+  'sre-check-deployment-status', 'sre-check-secrets', 'sre-check-system-status',
+  'sre-day-2-ops', 'sre-deployment-strategies', 'sre-fix-deployments',
+  'sre-gitops-status',
+];
+
+const expectedDevopsSkills = [
+  'devops-configure-infrastructure', 'devops-disconnected-deployment',
+  'devops-docker-compose-setup', 'devops-manage-helm', 'devops-sign-docker-image',
+];
+
+const expectedCyberSkills = [
+  'cyber-generate-certs', 'cyber-immunity-estimation', 'cyber-security-audit',
+  'cyber-vault-secrets', 'cyber-verify-docker-users', 'cyber-verify-image-signature',
+  'cyber-vulnerability-scan',
+];
+
+const expectedExtensionSkills = [
+  'create-bug-story', 'add-sprint', 'modify-sprint',
+  'add-to-sprint', 'project-context-expansion', 'sprint-status-view',
+];
+
+const allExpectedSkills = [
+  ...expectedAgentSkills,
+  ...expectedMil498Skills,
+  ...expectedSreSkills,
+  ...expectedDevopsSkills,
+  ...expectedCyberSkills,
+  ...expectedExtensionSkills,
+];
+
+test('skills/ has exactly 36 subdirectories', () => {
+  const entries = fs.readdirSync(skillsDir).filter(e =>
+    fs.statSync(path.join(skillsDir, e)).isDirectory()
+  );
+  assert.strictEqual(entries.length, 36, `Expected 36 skill dirs, found ${entries.length}`);
+});
+
+test('all 4 agent skill directories exist', () => {
+  for (const skill of expectedAgentSkills) {
+    const p = path.join(skillsDir, skill);
+    assert.ok(fs.existsSync(p), `Missing agent skill dir: ${skill}`);
+  }
+});
+
+test('all 7 MIL-498 skill directories exist', () => {
+  for (const skill of expectedMil498Skills) {
+    const p = path.join(skillsDir, skill);
+    assert.ok(fs.existsSync(p), `Missing MIL-498 skill dir: ${skill}`);
+  }
+});
+
+test('all 7 SRE skill directories exist', () => {
+  for (const skill of expectedSreSkills) {
+    const p = path.join(skillsDir, skill);
+    assert.ok(fs.existsSync(p), `Missing SRE skill dir: ${skill}`);
+  }
+});
+
+test('all 5 DevOps skill directories exist', () => {
+  for (const skill of expectedDevopsSkills) {
+    const p = path.join(skillsDir, skill);
+    assert.ok(fs.existsSync(p), `Missing DevOps skill dir: ${skill}`);
+  }
+});
+
+test('all 7 Cyber skill directories exist', () => {
+  for (const skill of expectedCyberSkills) {
+    const p = path.join(skillsDir, skill);
+    assert.ok(fs.existsSync(p), `Missing Cyber skill dir: ${skill}`);
+  }
+});
+
+test('all 6 extension workflow skill directories exist', () => {
+  for (const skill of expectedExtensionSkills) {
+    const p = path.join(skillsDir, skill);
+    assert.ok(fs.existsSync(p), `Missing extension skill dir: ${skill}`);
+  }
+});
+
+test('every skill directory contains a .gitkeep file', () => {
+  for (const skill of allExpectedSkills) {
+    const gk = path.join(skillsDir, skill, '.gitkeep');
+    assert.ok(fs.existsSync(gk), `Missing .gitkeep in ${skill}`);
+  }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+//  Task 3: module-help.csv validation
+// ═══════════════════════════════════════════════════════════════════════════════
+console.log('\n--- Task 3: module-help.csv ---');
+
+const csvPath = path.join(EXTENSION_DIR, 'module-help.csv');
+
+test('module-help.csv exists', () => {
+  assert.ok(fs.existsSync(csvPath), 'module-help.csv must exist');
+});
+
+let csvData = { headers: [], rows: [] };
+test('module-help.csv is parseable', () => {
+  const content = fs.readFileSync(csvPath, 'utf8');
+  csvData = parseCsv(content);
+  assert.ok(csvData.headers.length > 0, 'CSV must have headers');
+  assert.ok(csvData.rows.length > 0, 'CSV must have data rows');
+});
+
+test('module-help.csv has correct header columns', () => {
+  const expected = ['module', 'phase', 'name', 'code'];
+  for (const col of expected) {
+    assert.ok(csvData.headers.includes(col), `Missing header column: ${col}`);
+  }
+});
+
+test('module-help.csv has 36 skill entries (excluding header)', () => {
+  assert.strictEqual(csvData.rows.length, 36, `Expected 36 rows, found ${csvData.rows.length}`);
+});
+
+test('all CSV entries use module code ma-skills', () => {
+  const moduleIdx = csvData.headers.indexOf('module');
+  for (const row of csvData.rows) {
+    assert.strictEqual(row[moduleIdx], 'ma-skills', `Row has wrong module: ${row[moduleIdx]}`);
+  }
+});
+
+test('CSV has entries for all 4 agent skills', () => {
+  const codeIdx = csvData.headers.indexOf('code');
+  const codes = csvData.rows.map(r => r[codeIdx]);
+  for (const skill of expectedAgentSkills) {
+    assert.ok(codes.includes(skill), `Missing CSV entry for agent skill: ${skill}`);
+  }
+});
+
+test('CSV has entries for all 7 MIL-498 skills', () => {
+  const codeIdx = csvData.headers.indexOf('code');
+  const codes = csvData.rows.map(r => r[codeIdx]);
+  for (const skill of expectedMil498Skills) {
+    assert.ok(codes.includes(skill), `Missing CSV entry for MIL-498 skill: ${skill}`);
+  }
+});
+
+test('CSV has entries for all 7 SRE skills', () => {
+  const codeIdx = csvData.headers.indexOf('code');
+  const codes = csvData.rows.map(r => r[codeIdx]);
+  for (const skill of expectedSreSkills) {
+    assert.ok(codes.includes(skill), `Missing CSV entry for SRE skill: ${skill}`);
+  }
+});
+
+test('CSV has entries for all 5 DevOps skills', () => {
+  const codeIdx = csvData.headers.indexOf('code');
+  const codes = csvData.rows.map(r => r[codeIdx]);
+  for (const skill of expectedDevopsSkills) {
+    assert.ok(codes.includes(skill), `Missing CSV entry for DevOps skill: ${skill}`);
+  }
+});
+
+test('CSV has entries for all 7 Cyber skills', () => {
+  const codeIdx = csvData.headers.indexOf('code');
+  const codes = csvData.rows.map(r => r[codeIdx]);
+  for (const skill of expectedCyberSkills) {
+    assert.ok(codes.includes(skill), `Missing CSV entry for Cyber skill: ${skill}`);
+  }
+});
+
+test('CSV has entries for all 6 extension workflow skills', () => {
+  const codeIdx = csvData.headers.indexOf('code');
+  const codes = csvData.rows.map(r => r[codeIdx]);
+  for (const skill of expectedExtensionSkills) {
+    assert.ok(codes.includes(skill), `Missing CSV entry for extension skill: ${skill}`);
+  }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+//  Task 4: Directory state after Story 15.6 migration
+// ═══════════════════════════════════════════════════════════════════════════════
+console.log('\n--- Task 4: Directory state after Story 15.6 ---');
+
+test('agents/ directory is empty or absent (Story 15.6 moved files to bmad-customize/)', () => {
+  const agentsDir = path.join(EXTENSION_DIR, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    const files = fs.readdirSync(agentsDir).filter(f => f.endsWith('.customize.yaml'));
+    assert.strictEqual(files.length, 0, `agents/ must have 0 .customize.yaml files after 15.6, found ${files.length}`);
+  }
+  // If directory doesn't exist, that's also correct
+});
+
+test('workflows/ directory still exists', () => {
+  const workflowsDir = path.join(EXTENSION_DIR, 'workflows');
+  assert.ok(fs.existsSync(workflowsDir), 'workflows/ directory must be preserved');
+  assert.ok(fs.statSync(workflowsDir).isDirectory(), 'workflows/ must be a directory');
+});
+
+test('workflows/ directory contains workflow subdirs', () => {
+  const workflowsDir = path.join(EXTENSION_DIR, 'workflows');
+  const dirs = fs.readdirSync(workflowsDir).filter(e =>
+    fs.statSync(path.join(workflowsDir, e)).isDirectory()
+  );
+  assert.ok(dirs.length >= 6, `Expected at least 6 workflow dirs, found ${dirs.length}`);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+//  Summary
+// ═══════════════════════════════════════════════════════════════════════════════
+console.log(`\n--- Results: ${passed} passed, ${failed} failed ---`);
+if (errors.length > 0) {
+  console.error('\nFailures:');
+  for (const { name, error } of errors) {
+    console.error(`  ${name}: ${error}`);
+  }
+}
+process.exit(failed > 0 ? 1 : 0);