ma-agents 2.19.2 → 2.20.0

package/lib/installer.js

@@ -276,7 +276,13 @@ async function performInstall(skillId, skill, agent, installPath) {
 // --- Install with upgrade detection ---
 
 async function installSkill(skillId, agentIds, customPath = '', scope = 'project', options = {}) {
-  const { force = false } = options;
+  const { force = false, yes = false } = options;
+
+  // Task 4.3: Pre-set batch global action for non-interactive mode (shared batchState reference)
+  if (yes && options.batchState && !options.batchState.globalAction) {
+    options.batchState.globalAction = 'update';
+  }
+
   const skills = listSkills();
   const skill = skills.find(s => s.id === skillId);
 
@@ -317,6 +323,7 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
 
         // Check if a global action was already chosen for this batch
         const batchState = options.batchState || {};
+
         if (batchState.globalAction) {
           action = batchState.globalAction;
         } else if (cmp > 0) {
@@ -335,6 +342,11 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
               { title: 'Remove (uninstall)', value: 'remove' }
             ]
           });
+          // Task 4.4: Guard against unexpected prompts in non-interactive mode
+          if (yes && choice === undefined) {
+            console.error(chalk.red('Error: Unexpected interactive prompt in non-interactive mode'));
+            process.exit(1);
+          }
           action = choice;
         } else if (cmp === 0) {
           // Same version
@@ -350,6 +362,11 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
               { title: 'Remove (uninstall)', value: 'remove' }
             ]
           });
+          // Task 4.4: Guard against unexpected prompts in non-interactive mode
+          if (yes && choice === undefined) {
+            console.error(chalk.red('Error: Unexpected interactive prompt in non-interactive mode'));
+            process.exit(1);
+          }
           action = choice;
         } else {
           // Downgrade
@@ -366,6 +383,11 @@ async function installSkill(skillId, agentIds, customPath = '', scope = 'project
               { title: 'Remove (uninstall)', value: 'remove' }
             ]
           });
+          // Task 4.4: Guard against unexpected prompts in non-interactive mode
+          if (yes && choice === undefined) {
+            console.error(chalk.red('Error: Unexpected interactive prompt in non-interactive mode'));
+            process.exit(1);
+          }
           action = choice;
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ma-agents",
-  "version": "2.19.2",
+  "version": "2.20.0",
   "description": "NPX tool to install skills for AI coding agents (Claude Code, Gemini, Copilot, Kilocode, Cline, Cursor)",
   "main": "index.js",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "scripts": {
     "start": "node bin/cli.js",
-    "test": "node -e \"const {listSkills,listAgents}=require('./lib/installer'); console.log('Skills:',listSkills().length,'Agents:',listAgents().length)\""
+    "test": "node test/yes-flag.test.js",
+    "build:bmad-cache": "node scripts/build-bmad-cache.js"
   },
   "keywords": [
     "ai",
@@ -25,6 +26,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "bmad-method": "6.0.4",
     "prompts": "^2.4.2",
     "chalk": "^4.1.2",
     "fs-extra": "^11.1.1"

package/scripts/build-bmad-cache.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const CACHE_DIR = path.join(__dirname, '..', 'lib', 'bmad-cache');
+const MANIFEST_PATH = path.join(CACHE_DIR, 'cache-manifest.json');
+const force = process.argv.includes('--force');
+
+/**
+ * Locate and parse external-official-modules.yaml from bmad-method.
+ * Uses a simple line-by-line parser to avoid adding js-yaml dependency.
+ */
+function loadModuleDefinitions() {
+  // Locate bmad-method package
+  let bmadMethodDir;
+  try {
+    bmadMethodDir = path.dirname(require.resolve('bmad-method/package.json'));
+  } catch {
+    console.error('Error: bmad-method package not found. Run "npm install" first.');
+    process.exit(1);
+  }
+
+  const yamlPath = path.join(bmadMethodDir, 'tools', 'cli', 'external-official-modules.yaml');
+  if (!fs.existsSync(yamlPath)) {
+    console.error(`Error: external-official-modules.yaml not found at ${yamlPath}`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(yamlPath, 'utf8');
+  return parseModulesYaml(content);
+}
+
+/**
+ * Simple YAML parser for the external-official-modules.yaml structure.
+ * Parses top-level module keys under "modules:" and their properties.
+ */
+function parseModulesYaml(content) {
+  const modules = [];
+  const lines = content.split('\n');
+  let inModules = false;
+  let currentModule = null;
+
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+
+    // Skip comments and empty lines
+    if (trimmed === '' || trimmed.match(/^\s*#/)) continue;
+
+    // Detect the "modules:" top-level key
+    if (trimmed === 'modules:') {
+      inModules = true;
+      continue;
+    }
+
+    if (!inModules) continue;
+
+    // Detect a new module key (indented, no value — just "key:")
+    const moduleKeyMatch = trimmed.match(/^\s{1,4}([a-zA-Z0-9_-]+):\s*$/);
+    if (moduleKeyMatch) {
+      if (currentModule) modules.push(currentModule);
+      currentModule = { key: moduleKeyMatch[1] };
+      continue;
+    }
+
+    // Detect a property of the current module (deeper indent, has a value)
+    if (currentModule) {
+      const propMatch = trimmed.match(/^\s{2,8}([a-zA-Z0-9_-]+):\s+"([^"]*)"$/);
+      if (propMatch) {
+        currentModule[propMatch[1]] = propMatch[2];
+      } else {
+        const unquotedMatch = trimmed.match(/^\s{2,8}([a-zA-Z0-9_-]+):\s+(.+)$/);
+        if (unquotedMatch) {
+          currentModule[unquotedMatch[1]] = unquotedMatch[2].trim();
+        }
+      }
+    }
+  }
+  if (currentModule) modules.push(currentModule);
+
+  // Validate we got the required fields
+  return modules.filter(m => m.code && m.url).map(m => ({
+    code: m.code,
+    url: m.url,
+    name: m.name || m.key,
+    branch: m.branch || 'main'
+  }));
+}
+
+/**
+ * Load existing cache manifest if present.
+ */
+function loadManifest() {
+  if (fs.existsSync(MANIFEST_PATH)) {
+    try {
+      return JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get the remote HEAD SHA for a given repo URL and branch.
+ */
+function getRemoteHead(url, branch) {
+  try {
+    const output = execFileSync('git', ['ls-remote', url, branch], { encoding: 'utf8', timeout: 30000 });
+    const match = output.match(/^([a-f0-9]+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Clone, capture SHA, install deps, remove .git for a single module.
+ */
+function processModule(mod, manifest) {
+  const moduleDir = path.join(CACHE_DIR, mod.code);
+
+  // Incremental update check (AC #6)
+  if (!force && fs.existsSync(moduleDir) && manifest) {
+    const cachedInfo = manifest.modules && manifest.modules[mod.code];
+    if (cachedInfo && cachedInfo.commitSha) {
+      const remoteHead = getRemoteHead(mod.url, mod.branch);
+      if (remoteHead && remoteHead === cachedInfo.commitSha) {
+        console.log(`  ⏭  ${mod.code}: up-to-date (${cachedInfo.commitSha.substring(0, 7)}), skipping`);
+        return { ...cachedInfo, skipped: true };
+      }
+      if (remoteHead) {
+        console.log(`  🔄 ${mod.code}: outdated (cached: ${cachedInfo.commitSha.substring(0, 7)}, remote: ${remoteHead.substring(0, 7)}), rebuilding`);
+      }
+    }
+  }
+
+  // Remove existing module dir if present (force or outdated)
+  if (fs.existsSync(moduleDir)) {
+    fs.removeSync(moduleDir);
+  }
+
+  // Clone (AC #1)
+  console.log(`  📥 ${mod.code}: cloning from ${mod.url} (branch: ${mod.branch})`);
+  try {
+    execFileSync('git', ['clone', '--depth', '1', '--branch', mod.branch, mod.url, moduleDir], {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      timeout: 120000
+    });
+  } catch (err) {
+    console.error(`  ❌ ${mod.code}: clone failed - ${err.message}`);
+    return null;
+  }
+
+  // Capture commit SHA BEFORE removing .git (AC #4 - order matters)
+  let commitSha = '';
+  try {
+    commitSha = execFileSync('git', ['-C', moduleDir, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
+  } catch {
+    console.warn(`  ⚠  ${mod.code}: could not capture commit SHA`);
+  }
+
+  // Install production dependencies (AC #2)
+  const pkgJsonPath = path.join(moduleDir, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+      if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
+        console.log(`  📦 ${mod.code}: installing production dependencies`);
+        execFileSync('npm', ['install', '--omit=dev'], {
+          cwd: moduleDir,
+          encoding: 'utf8',
+          stdio: 'pipe',
+          timeout: 120000,
+          shell: process.platform === 'win32'
+        });
+      } else {
+        console.log(`  📦 ${mod.code}: no production dependencies, skipping npm install`);
+      }
+    } catch (err) {
+      console.warn(`  ⚠  ${mod.code}: npm install failed - ${err.message}`);
+    }
+  } else {
+    console.log(`  📦 ${mod.code}: no package.json, skipping npm install`);
+  }
+
+  // Remove .git directory (AC #3)
+  const gitDir = path.join(moduleDir, '.git');
+  if (fs.existsSync(gitDir)) {
+    fs.removeSync(gitDir);
+    console.log(`  🗑  ${mod.code}: removed .git directory`);
+  }
+
+  return {
+    url: mod.url,
+    branch: mod.branch,
+    commitSha,
+    clonedAt: new Date().toISOString()
+  };
+}
+
+/**
+ * Main build function.
+ */
+function main() {
+  console.log('🔨 BMAD Cache Build Script');
+  console.log('='.repeat(40));
+
+  // Load module definitions (Task 2)
+  const modules = loadModuleDefinitions();
+  if (modules.length === 0) {
+    console.error('Error: No modules found in external-official-modules.yaml');
+    process.exit(1);
+  }
+  console.log(`Found ${modules.length} modules: ${modules.map(m => m.code).join(', ')}`);
+
+  // Handle --force flag (AC #5 / Task 6)
+  if (force && fs.existsSync(CACHE_DIR)) {
+    console.log('🔄 --force: removing existing cache directory');
+    fs.removeSync(CACHE_DIR);
+  }
+
+  // Ensure cache directory exists
+  fs.ensureDirSync(CACHE_DIR);
+
+  // Load existing manifest for incremental updates (Task 7)
+  const existingManifest = loadManifest();
+
+  // Get bmad-method version
+  let bmadMethodVersion = 'unknown';
+  try {
+    const bmadMethodDir = path.dirname(require.resolve('bmad-method/package.json'));
+    const bmadPkg = JSON.parse(fs.readFileSync(path.join(bmadMethodDir, 'package.json'), 'utf8'));
+    bmadMethodVersion = bmadPkg.version || 'unknown';
+  } catch {
+    // continue with unknown version
+  }
+
+  // Process each module (Tasks 3, 4, 5)
+  console.log('\nProcessing modules:');
+  const manifestModules = {};
+  let successCount = 0;
+  let skipCount = 0;
+  let failCount = 0;
+
+  for (const mod of modules) {
+    const result = processModule(mod, existingManifest);
+    if (result) {
+      const { skipped, ...moduleInfo } = result;
+      manifestModules[mod.code] = moduleInfo;
+      if (skipped) {
+        skipCount++;
+      } else {
+        successCount++;
+      }
+    } else {
+      // Preserve existing manifest entry for failed modules (M2 fix)
+      if (existingManifest && existingManifest.modules && existingManifest.modules[mod.code]) {
+        manifestModules[mod.code] = existingManifest.modules[mod.code];
+      }
+      failCount++;
+    }
+  }
+
+  // Write cache-manifest.json (AC #4 / Task 5)
+  const manifest = {
+    generated: new Date().toISOString(),
+    bmadMethodVersion,
+    modules: manifestModules
+  };
+  fs.writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2), 'utf8');
+
+  // Summary
+  console.log('\n' + '='.repeat(40));
+  console.log('✅ BMAD Cache Build Complete');
+  console.log(`   Cloned: ${successCount}, Skipped: ${skipCount}, Failed: ${failCount}`);
+  console.log(`   Cache: ${CACHE_DIR}`);
+  console.log(`   Manifest: ${MANIFEST_PATH}`);
+
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+
+main();

package/test/yes-flag.test.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * Tests for --yes flag and --agent flag implementation
+ * Story 1.1: Add --yes Flag for Non-Interactive Skill Installation
+ *
+ * Task 6.1: Unit test parseFlags() with --yes variants
+ * Task 6.2: Verify installWizard() never calls prompts when yesFlag=true
+ * Task 6.3: Verify installSkill() skips prompts and defaults to 'update'
+ * Task 6.4: Integration test --yes with piped stdin
+ * Task 6.5: Integration test --yes --agent invalid-agent-name
+ */
+'use strict';
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const CLI_PATH = path.join(__dirname, '..', 'bin', 'cli.js');
+
+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 });
+  }
+}
+
+// ─── Require cli.js module (must not auto-run main()) ─────────────────────────
+let parseFlags;
+try {
+  ({ parseFlags } = require('../bin/cli.js'));
+  if (typeof parseFlags !== 'function') {
+    throw new Error('parseFlags is not exported from cli.js');
+  }
+} catch (e) {
+  console.error('\n  FATAL: Cannot load parseFlags from cli.js');
+  console.error(' ', e.message);
+  console.error('  Make sure cli.js exports { parseFlags } and has require.main guard\n');
+  process.exit(1);
+}
+
+// ─── Task 6.1: Unit tests — parseFlags() ──────────────────────────────────────
+console.log('\nTask 6.1 — Unit tests: parseFlags()');
+
+test('--yes sets yesFlag=true, filtered from positional', () => {
+  const result = parseFlags(['--yes']);
+  assert.strictEqual(result.yesFlag, true, 'yesFlag should be true');
+  assert.strictEqual(result.forceFlag, false, 'forceFlag should be false');
+  assert.deepStrictEqual(result.positional, [], 'positional should be empty');
+});
+
+test('--yes --force sets both yesFlag and forceFlag', () => {
+  const result = parseFlags(['--yes', '--force']);
+  assert.strictEqual(result.yesFlag, true, 'yesFlag should be true');
+  assert.strictEqual(result.forceFlag, true, 'forceFlag should be true');
+  assert.deepStrictEqual(result.positional, [], 'positional should be empty');
+});
+
+test('--yes --agent claude-code sets agentFlag, filtered from positional', () => {
+  const result = parseFlags(['--yes', '--agent', 'claude-code']);
+  assert.strictEqual(result.yesFlag, true, 'yesFlag should be true');
+  assert.strictEqual(result.agentFlag, 'claude-code', 'agentFlag should be claude-code');
+  assert.deepStrictEqual(result.positional, [], 'positional should not contain --agent args');
+});
+
+test('--yes with extra positional args — only --yes is filtered', () => {
+  const result = parseFlags(['skill-id', '--yes', 'claude-code']);
+  assert.strictEqual(result.yesFlag, true, 'yesFlag should be true');
+  assert.deepStrictEqual(result.positional, ['skill-id', 'claude-code']);
+});
+
+test('--global and --yes both set, scope=global', () => {
+  const result = parseFlags(['--global', '--yes']);
+  assert.strictEqual(result.globalFlag, true, 'globalFlag should be true');
+  assert.strictEqual(result.yesFlag, true, 'yesFlag should be true');
+  assert.strictEqual(result.scope, 'global', 'scope should be global');
+});
+
+// ─── Task 6.1 — integration: --agent with missing name exits 1 ────────────────
+console.log('\nTask 6.1 — Integration: --agent with missing name');
+
+test('--agent (missing name) exits 1 with error message', () => {
+  const result = spawnSync(process.execPath, [CLI_PATH, 'install', '--agent'], {
+    timeout: 5000,
+    encoding: 'utf-8',
+    input: '',
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+  assert.strictEqual(result.status, 1, `Expected exit code 1, got ${result.status}`);
+  const output = (result.stderr || '') + (result.stdout || '');
+  assert.ok(
+    output.includes('--agent requires an agent name'),
+    `Expected "--agent requires an agent name" in output, got:\n${output}`
+  );
+  assert.ok(
+    output.includes('Hint'),
+    `Expected hint in output, got:\n${output}`
+  );
+});
+
+// ─── Task 6.5 — integration: --yes --agent invalid-agent-name exits 1 ─────────
+console.log('\nTask 6.5 — Integration: --yes --agent invalid-agent-name');
+
+test('--yes --agent invalid-agent-name exits 1 with error', () => {
+  const result = spawnSync(process.execPath, [CLI_PATH, 'install', '--yes', '--agent', 'invalid-agent-xyz'], {
+    timeout: 5000,
+    encoding: 'utf-8',
+    input: '',
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+  assert.strictEqual(result.status, 1, `Expected exit code 1, got ${result.status}. stdout: ${result.stdout}`);
+  const output = (result.stderr || '') + (result.stdout || '');
+  assert.ok(
+    output.includes("Unknown agent 'invalid-agent-xyz'"),
+    `Expected "Unknown agent 'invalid-agent-xyz'" in output, got:\n${output}`
+  );
+  assert.ok(
+    output.includes('Hint'),
+    `Expected hint in output, got:\n${output}`
+  );
+});
+
+// ─── Task 6.3 — installSkill batchState pre-set with yes=true ─────────────────
+console.log('\nTask 6.3 — Unit test: installSkill batchState pre-set with yes=true');
+
+async function testInstallSkillBatchState() {
+  const { installSkill } = require('../lib/installer');
+  assert.ok(typeof installSkill === 'function', 'installSkill must be exported');
+
+  const batchState = {};
+  const opts = { yes: true, batchState };
+  // Call with empty agentIds to short-circuit quickly (no pathGroups to iterate)
+  // installSkill will throw because skill not found, but batchState.globalAction is
+  // set synchronously at the top before any await.
+  await installSkill('nonexistent-skill-xxx', [], '', 'project', opts).catch(() => {});
+  assert.strictEqual(
+    batchState.globalAction,
+    'update',
+    'batchState.globalAction should be pre-set to "update" when yes=true'
+  );
+}
+
+testInstallSkillBatchState()
+  .then(() => {
+    console.log('  ✓ installSkill pre-sets batchState.globalAction="update" when yes=true');
+    passed++;
+  })
+  .catch(err => {
+    console.error(`  ✗ installSkill pre-sets batchState.globalAction="update" when yes=true: ${err.message}`);
+    failed++;
+    errors.push({ name: 'installSkill batchState pre-set', error: err.message });
+  })
+  .finally(() => {
+    // Print summary only after all async tests complete
+    console.log(`\n${passed} passed, ${failed} failed`);
+    if (errors.length > 0) {
+      console.log('\nFailed tests:');
+      errors.forEach(e => console.log(`  - ${e.name}: ${e.error}`));
+    }
+    if (failed > 0) process.exit(1);
+  });
+
+// ─── Task 6.4 — Integration: --yes with piped stdin (no interactive reads) ────
+console.log('\nTask 6.4 — Integration: --yes with piped stdin');
+
+test('--yes exits 0 with piped stdin (no interactive prompts)', () => {
+  // Note: this performs actual skill installation in the current project directory.
+  // It verifies that the process exits without hanging on interactive prompts.
+  const result = spawnSync(process.execPath, [CLI_PATH, 'install', '--yes'], {
+    timeout: 60000,
+    encoding: 'utf-8',
+    input: '',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: path.join(__dirname, '..')
+  });
+  assert.strictEqual(
+    result.status,
+    0,
+    `Expected exit code 0, got ${result.status}.\nstdout: ${result.stdout}\nstderr: ${result.stderr}`
+  );
+  // Verify no interactive prompt was triggered (would hang otherwise)
+  assert.ok(result.stdout !== null, 'Should have stdout output');
+});
+
+// ─── Summary (printed after async tests complete, see .finally() above) ──────