ma-agents 2.20.3 → 2.22.0

package/test/skill-customize-agent.test.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+/**
+ * Tests for customize-agent command implementation
+ * Story 3.4: BMAD Persona Customization Tooling
+ *
+ * Task 5.1: customize-agent bmm-sre runs and generates full file
+ * Task 5.2: customize-agent bmm-pm generates critical_actions-only file
+ * Task 5.3: Existing file loaded as defaults
+ * Task 5.4: Generated YAML is valid structure
+ */
+'use strict';
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const CLI_PATH = path.join(__dirname, '..', 'bin', 'cli.js');
+const PROJECT_ROOT = path.join(__dirname, '..');
+const AGENTS_DIR = path.join(PROJECT_ROOT, 'lib', 'bmad-extension', 'agents');
+
+let passed = 0;
+let failed = 0;
+const errors = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✓ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ✗ ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+// ─── Module imports ────────────────────────────────────────────────────────────
+let validateBmadAgent, generateCustomizeYaml, writeCustomizeFile, loadExistingCustomization;
+try {
+  ({ validateBmadAgent, generateCustomizeYaml, writeCustomizeFile, loadExistingCustomization } = require('../lib/skill-authoring'));
+} catch (e) {
+  console.error('\n  FATAL: Cannot load skill-authoring module');
+  console.error(' ', e.message);
+  process.exit(1);
+}
+
+// ─── Unit tests: validateBmadAgent() ─────────────────────────────────────────
+console.log('\n validateBmadAgent unit tests\n');
+
+test('validates custom agents (full customization)', () => {
+  const customAgents = ['bmm-sre', 'bmm-devops', 'bmm-cyber', 'bmm-mil498'];
+  for (const agent of customAgents) {
+    const result = validateBmadAgent(agent);
+    assert.strictEqual(result.valid, true, `Expected ${agent} to be valid`);
+    assert.strictEqual(result.type, 'custom', `Expected ${agent} to be type custom`);
+  }
+});
+
+test('validates builtin agents (critical_actions only)', () => {
+  const builtinAgents = ['bmm-pm', 'bmm-architect', 'bmm-dev', 'bmm-qa', 'bmm-sm', 'bmm-tech-writer', 'bmm-ux-designer'];
+  for (const agent of builtinAgents) {
+    const result = validateBmadAgent(agent);
+    assert.strictEqual(result.valid, true, `Expected ${agent} to be valid`);
+    assert.strictEqual(result.type, 'builtin', `Expected ${agent} to be type builtin`);
+  }
+});
+
+test('rejects unknown agents', () => {
+  const result = validateBmadAgent('bmm-unknown');
+  assert.strictEqual(result.valid, false);
+  assert.ok(result.hint.length > 0, 'Expected hint with available agents');
+});
+
+test('rejects empty agent name', () => {
+  const result = validateBmadAgent('');
+  assert.strictEqual(result.valid, false);
+});
+
+// ─── Unit tests: generateCustomizeYaml() ─────────────────────────────────────
+console.log('\n generateCustomizeYaml unit tests\n');
+
+const MANDATORY_ACTIONS = [
+  'Read the skills MANIFEST at skills/MANIFEST.yaml (relative to project root)',
+  'For each skill marked always_load: true, read the skill file completely',
+  'Follow all skill directives during this session'
+];
+
+test('generateCustomizeYaml: builtin agent produces critical_actions only', () => {
+  const yaml = generateCustomizeYaml('bmm-pm', {}, 'builtin');
+  assert.ok(yaml.includes('critical_actions'), 'Expected critical_actions');
+  assert.ok(!yaml.includes('persona:'), 'Builtin must not include persona section');
+  assert.ok(!yaml.includes('menu:'), 'Builtin must not include menu section');
+});
+
+test('generateCustomizeYaml: builtin always includes mandatory actions 1-3', () => {
+  const yaml = generateCustomizeYaml('bmm-pm', {}, 'builtin');
+  assert.ok(yaml.includes('1:'), 'Expected action 1');
+  assert.ok(yaml.includes('2:'), 'Expected action 2');
+  assert.ok(yaml.includes('3:'), 'Expected action 3');
+  assert.ok(yaml.includes('MANIFEST'), 'Expected MANIFEST reference in action 1');
+  assert.ok(yaml.includes('always_load'), 'Expected always_load reference in action 2');
+});
+
+test('generateCustomizeYaml: custom agent with persona includes persona section', () => {
+  const data = {
+    persona: {
+      role: 'Site Reliability Engineer',
+      identity: 'Expert in system reliability.',
+      communication_style: 'Calm and data-driven.',
+      principles: ['Automate everything', 'Monitor all the things']
+    }
+  };
+  const yaml = generateCustomizeYaml('bmm-sre', data, 'custom');
+  assert.ok(yaml.includes('persona:'), 'Expected persona section');
+  assert.ok(yaml.includes('role:'), 'Expected role field');
+  assert.ok(yaml.includes('Site Reliability Engineer'), 'Expected role value');
+  assert.ok(yaml.includes('critical_actions:'), 'Expected critical_actions section');
+});
+
+test('generateCustomizeYaml: custom agent with menu includes menu section', () => {
+  const data = {
+    menu: [
+      { trigger: 'bmad-sre-health', workflow: 'workflows/health.md', description: 'Health Check' }
+    ]
+  };
+  const yaml = generateCustomizeYaml('bmm-sre', data, 'custom');
+  assert.ok(yaml.includes('menu:'), 'Expected menu section');
+  assert.ok(yaml.includes('trigger:'), 'Expected trigger field');
+  assert.ok(yaml.includes('bmad-sre-health'), 'Expected trigger value');
+});
+
+test('generateCustomizeYaml: mandatory actions 1-3 not overridable', () => {
+  // Even if caller passes custom actions, 1-3 must come from the hardcoded set
+  const data = {
+    extraActions: { 4: 'Custom action 4' }
+  };
+  const yaml = generateCustomizeYaml('bmm-sre', data, 'custom');
+  assert.ok(yaml.includes('MANIFEST'), 'Expected mandatory action 1 content (MANIFEST)');
+  assert.ok(yaml.includes('always_load'), 'Expected mandatory action 2 content');
+  assert.ok(yaml.includes('Follow all skill directives'), 'Expected mandatory action 3 content');
+});
+
+test('generateCustomizeYaml: extra actions appended starting at 4', () => {
+  const data = {
+    extraActions: { 4: 'Read the project context file' }
+  };
+  const yaml = generateCustomizeYaml('bmm-sre', data, 'custom');
+  assert.ok(yaml.includes('4:'), 'Expected action 4');
+  assert.ok(yaml.includes('Read the project context file'), 'Expected action 4 content');
+});
+
+test('generateCustomizeYaml: includes header comment', () => {
+  const yaml = generateCustomizeYaml('bmm-pm', {}, 'builtin');
+  assert.ok(yaml.startsWith('#'), 'Expected YAML to start with comment');
+  assert.ok(yaml.includes('bmm-pm'), 'Expected agent name in header');
+});
+
+// ─── Unit tests: writeCustomizeFile() / loadExistingCustomization() ───────────
+console.log('\n writeCustomizeFile / loadExistingCustomization unit tests\n');
+
+test('writeCustomizeFile: writes file to specified directory', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-customize-test-'));
+  const agentsDir = path.join(tmpDir, 'agents');
+  fs.mkdirSync(agentsDir, { recursive: true });
+  try {
+    const yaml = generateCustomizeYaml('bmm-pm', {}, 'builtin');
+    writeCustomizeFile('bmm-pm', yaml, agentsDir);
+    const filePath = path.join(agentsDir, 'bmm-pm.customize.yaml');
+    assert.ok(fs.existsSync(filePath), 'Expected file to be written');
+    const content = fs.readFileSync(filePath, 'utf8');
+    assert.ok(content.includes('critical_actions'), 'Expected content to be written');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('loadExistingCustomization: returns null for non-existent file', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-customize-load-'));
+  try {
+    const result = loadExistingCustomization('bmm-pm', tmpDir);
+    assert.strictEqual(result, null, 'Expected null for missing file');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('loadExistingCustomization: returns raw content for existing file', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-customize-load2-'));
+  const filePath = path.join(tmpDir, 'bmm-pm.customize.yaml');
+  try {
+    fs.writeFileSync(filePath, 'critical_actions:\n  1: "Test"\n', 'utf8');
+    const result = loadExistingCustomization('bmm-pm', tmpDir);
+    assert.ok(result !== null, 'Expected non-null for existing file');
+    assert.ok(typeof result === 'string', 'Expected string content');
+    assert.ok(result.includes('critical_actions'), 'Expected file content');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+// ─── CLI integration tests ─────────────────────────────────────────────────────
+console.log('\n customize-agent CLI integration tests\n');
+
+// Unknown agent
+test('customize-agent: rejects unknown agent with exit 1', () => {
+  const result = spawnSync('node', [CLI_PATH, 'customize-agent', 'bmm-unknown'], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  assert.strictEqual(result.status, 1, 'Expected exit 1 for unknown agent');
+  const output = result.stdout + result.stderr;
+  assert.ok(output.includes('Error') || output.includes('Unknown'), 'Expected error message');
+});
+
+// No agent name
+test('customize-agent: no agent name exits 1', () => {
+  const result = spawnSync('node', [CLI_PATH, 'customize-agent'], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  assert.strictEqual(result.status, 1, 'Expected exit 1 for missing agent name');
+});
+
+// --yes mode skips (non-interactive)
+test('customize-agent: --yes flag skips interactive wizard with exit 0', () => {
+  const srePath = path.join(AGENTS_DIR, 'bmm-sre.customize.yaml');
+  const originalContent = fs.existsSync(srePath) ? fs.readFileSync(srePath, 'utf8') : null;
+  try {
+    const result = spawnSync('node', [CLI_PATH, 'customize-agent', 'bmm-sre', '--yes'], {
+      encoding: 'utf8', cwd: PROJECT_ROOT, input: ''
+    });
+    // Should skip gracefully (exit 0) or generate minimal file
+    assert.ok(result.status === 0 || result.status === null, `Expected exit 0 or null, got: ${result.status}. stderr: ${result.stderr}`);
+    assert.ok(
+      result.stdout.includes('Skipping') || result.stdout.includes('non-interactive') || result.stdout.includes('generated'),
+      `Expected skip or generate message: ${result.stdout}`
+    );
+  } finally {
+    // Restore original file to avoid polluting real agent configs
+    if (originalContent !== null) {
+      fs.writeFileSync(srePath, originalContent, 'utf8');
+    } else if (fs.existsSync(srePath)) {
+      fs.rmSync(srePath);
+    }
+  }
+});
+
+// ─── Results ──────────────────────────────────────────────────────────────────
+console.log(`\n  ${passed} passed, ${failed} failed\n`);
+if (failed > 0) {
+  errors.forEach(e => console.error(`  ✗ ${e.name}: ${e.error}`));
+  process.exit(1);
+}

package/test/skill-mandatory.test.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+/**
+ * Tests for set-mandatory command and list --mandatory filter
+ * Story 3.3: Mandatory Skill Designation Tooling
+ *
+ * Task 5.1: set-mandatory enables always_load
+ * Task 5.2: set-mandatory --off disables always_load
+ * Task 5.3: list --mandatory filters correctly
+ * Task 5.4: MANIFEST.yaml reflects changes
+ */
+'use strict';
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const CLI_PATH = path.join(__dirname, '..', 'bin', 'cli.js');
+const PROJECT_ROOT = path.join(__dirname, '..');
+
+let passed = 0;
+let failed = 0;
+const errors = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✓ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ✗ ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+// ─── Module imports ────────────────────────────────────────────────────────────
+let setMandatory;
+try {
+  ({ setMandatory } = require('../lib/skill-authoring'));
+} catch (e) {
+  console.error('\n  FATAL: Cannot load skill-authoring module');
+  console.error(' ', e.message);
+  process.exit(1);
+}
+
+// ─── Helper: build a temporary skill with a real skill.json ──────────────────
+function makeTmpSkill(alwaysLoad = false, extraFields = {}) {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-mandatory-test-'));
+  const skillName = 'test-mandatory-skill';
+  const skillDir = path.join(tmpBase, skillName);
+  fs.mkdirSync(skillDir, { recursive: true });
+
+  const json = Object.assign({
+    name: 'Test Mandatory Skill',
+    description: 'Test skill',
+    version: '1.0.0',
+    category: 'workflow',
+    author: 'ma-agents',
+    tags: ['test'],
+    always_load: alwaysLoad
+  }, extraFields);
+
+  fs.writeFileSync(path.join(skillDir, 'skill.json'), JSON.stringify(json, null, 2) + '\n', 'utf8');
+  fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Test Mandatory Skill\n', 'utf8');
+
+  return { tmpBase, skillDir, skillName };
+}
+
+// ─── Unit tests: setMandatory() ───────────────────────────────────────────────
+console.log('\n setMandatory unit tests\n');
+
+// AC #1: Enable
+test('setMandatory: sets always_load=true in skill.json', () => {
+  const { tmpBase, skillName } = makeTmpSkill(false);
+  try {
+    const result = setMandatory(skillName, true, tmpBase);
+    assert.strictEqual(result.success, true, `Expected success, got: ${JSON.stringify(result)}`);
+
+    const updated = JSON.parse(fs.readFileSync(path.join(tmpBase, skillName, 'skill.json'), 'utf8'));
+    assert.strictEqual(updated.always_load, true, 'Expected always_load=true');
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+// AC #2: Disable
+test('setMandatory: sets always_load=false with enable=false', () => {
+  const { tmpBase, skillName } = makeTmpSkill(true);
+  try {
+    const result = setMandatory(skillName, false, tmpBase);
+    assert.strictEqual(result.success, true);
+
+    const updated = JSON.parse(fs.readFileSync(path.join(tmpBase, skillName, 'skill.json'), 'utf8'));
+    assert.strictEqual(updated.always_load, false, 'Expected always_load=false');
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('setMandatory: preserves all other fields in skill.json', () => {
+  const { tmpBase, skillName } = makeTmpSkill(false, { custom_field: 'preserved' });
+  try {
+    setMandatory(skillName, true, tmpBase);
+    const updated = JSON.parse(fs.readFileSync(path.join(tmpBase, skillName, 'skill.json'), 'utf8'));
+    assert.strictEqual(updated.name, 'Test Mandatory Skill', 'Expected name preserved');
+    assert.strictEqual(updated.version, '1.0.0', 'Expected version preserved');
+    assert.deepStrictEqual(updated.tags, ['test'], 'Expected tags preserved');
+    assert.strictEqual(updated.custom_field, 'preserved', 'Expected custom_field preserved');
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('setMandatory: returns error for non-existent skill', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-mandatory-empty-'));
+  try {
+    const result = setMandatory('no-such-skill', true, tmpBase);
+    assert.strictEqual(result.success, false);
+    assert.ok(result.error.includes('not found') || result.error.includes('no-such-skill'),
+      `Expected not-found error, got: ${result.error}`);
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('setMandatory: error and hint are label-free data', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-mandatory-empty2-'));
+  try {
+    const result = setMandatory('no-such-skill', true, tmpBase);
+    assert.ok(!result.error.startsWith('Error:'), 'error field should not start with "Error:"');
+    assert.ok(!result.hint.startsWith('Hint:'), 'hint field should not start with "Hint:"');
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+// ─── CLI integration tests: set-mandatory ────────────────────────────────────
+console.log('\n set-mandatory CLI integration tests\n');
+
+// Use a real skill in the project's skills/ dir for CLI tests
+const TEST_SKILL = 'git-workflow-skill';
+const SKILL_JSON_PATH = path.join(PROJECT_ROOT, 'skills', TEST_SKILL, 'skill.json');
+
+// Save and restore original always_load value
+let originalAlwaysLoad;
+try {
+  const original = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
+  originalAlwaysLoad = original.always_load;
+} catch (_) {
+  originalAlwaysLoad = true;
+}
+
+// AC #1: Enable
+test('set-mandatory: sets always_load=true with exit 0', () => {
+  const result = spawnSync('node', [CLI_PATH, 'set-mandatory', TEST_SKILL], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  assert.strictEqual(result.status, 0, `Expected exit 0. stderr: ${result.stderr}`);
+  assert.ok(result.stdout.includes('mandatory') || result.stdout.includes('always_load'),
+    `Expected confirmation in output: ${result.stdout}`);
+
+  const updated = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
+  assert.strictEqual(updated.always_load, true, 'Expected always_load=true in skill.json');
+});
+
+// AC #2: Disable
+test('set-mandatory --off: sets always_load=false with exit 0', () => {
+  const result = spawnSync('node', [CLI_PATH, 'set-mandatory', TEST_SKILL, '--off'], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  assert.strictEqual(result.status, 0, `Expected exit 0. stderr: ${result.stderr}`);
+
+  const updated = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
+  assert.strictEqual(updated.always_load, false, 'Expected always_load=false in skill.json');
+});
+
+// Restore original value
+try {
+  const current = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
+  current.always_load = originalAlwaysLoad;
+  fs.writeFileSync(SKILL_JSON_PATH, JSON.stringify(current, null, 2) + '\n', 'utf8');
+} catch (_) {}
+
+// Missing skill name
+test('set-mandatory: no skill name exits 1', () => {
+  const result = spawnSync('node', [CLI_PATH, 'set-mandatory'], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  assert.strictEqual(result.status, 1, 'Expected exit 1');
+});
+
+// Unknown skill
+test('set-mandatory: unknown skill exits 1 with error', () => {
+  const result = spawnSync('node', [CLI_PATH, 'set-mandatory', 'no-such-skill'], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  assert.strictEqual(result.status, 1, 'Expected exit 1 for missing skill');
+  const output = result.stdout + result.stderr;
+  assert.ok(output.includes('Error') || output.includes('not found'), 'Expected error message');
+});
+
+// ─── CLI integration tests: list --mandatory ──────────────────────────────────
+console.log('\n list --mandatory CLI integration tests\n');
+
+// AC #3: Filter mandatory skills
+test('list --mandatory: exits 0', () => {
+  const result = spawnSync('node', [CLI_PATH, 'list', '--mandatory'], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  assert.strictEqual(result.status, 0, `Expected exit 0. stderr: ${result.stderr}`);
+});
+
+test('list --mandatory: only shows skills with always_load=true', () => {
+  const result = spawnSync('node', [CLI_PATH, 'list', '--mandatory'], {
+    encoding: 'utf8', cwd: PROJECT_ROOT
+  });
+  // git-workflow-skill has always_load: true — should appear
+  assert.ok(result.stdout.includes('git-workflow-skill'), 'Expected git-workflow-skill in mandatory list');
+});
+
+test('list --mandatory: output differs from full list', () => {
+  const full = spawnSync('node', [CLI_PATH, 'list'], { encoding: 'utf8', cwd: PROJECT_ROOT });
+  const filtered = spawnSync('node', [CLI_PATH, 'list', '--mandatory'], { encoding: 'utf8', cwd: PROJECT_ROOT });
+  // Mandatory list should be shorter or equal (never longer)
+  assert.ok(filtered.stdout.length <= full.stdout.length, 'Mandatory list should not be longer than full list');
+});
+
+// ─── Results ──────────────────────────────────────────────────────────────────
+console.log(`\n  ${passed} passed, ${failed} failed\n`);
+if (failed > 0) {
+  errors.forEach(e => console.error(`  ✗ ${e.name}: ${e.error}`));
+  process.exit(1);
+}