convoke-agents 2.4.0 → 3.0.1

package/scripts/convoke-doctor.js

@@ -5,11 +5,12 @@ const path = require('path');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
 const { findProjectRoot, getPackageVersion } = require('./update/lib/utils');
-const { AGENT_FILES, WORKFLOW_NAMES } = require('./update/lib/agent-registry');
 
 /**
  * convoke-doctor — Diagnose common Convoke installation issues.
- * Runs a series of checks and reports pass/fail with actionable fix suggestions.
+ *
+ * Config-driven: discovers all modules by scanning _bmad/bme/ config.yaml
+ * and validates file existence dynamically per module.
  */
 
 async function main() {
@@ -30,26 +31,41 @@ async function main() {
     return;
   }
 
-  // 2. Config file
-  checks.push(checkConfig(projectRoot));
+  // 2. Discover modules from _bmad/bme/*/config.yaml
+  const modules = discoverModules(projectRoot);
 
-  // 3. Agent files
-  checks.push(checkAgents(projectRoot));
+  if (modules.length === 0) {
+    checks.push({
+      name: 'Module discovery',
+      passed: false,
+      error: 'No modules found — expected config.yaml files in _bmad/bme/*/',
+      fix: 'Run: npx -p convoke-agents convoke-install'
+    });
+    printResults(checks);
+    process.exit(1);
+    return;
+  }
 
-  // 4. Workflow directories
-  checks.push(checkWorkflows(projectRoot));
+  checks.push({
+    name: 'Module discovery',
+    passed: true,
+    info: `Found ${modules.length} module(s): ${modules.map(m => m.name).join(', ')}`
+  });
 
-  // 5. Output directory writable
-  checks.push(await checkOutputDir(projectRoot));
+  // 3. Per-module checks
+  for (const mod of modules) {
+    const configCheck = checkModuleConfig(mod);
+    checks.push(configCheck);
+    if (configCheck.passed) {
+      checks.push(checkModuleAgents(mod));
+      checks.push(checkModuleWorkflows(mod));
+    }
+  }
 
-  // 6. Stale migration lock
+  // 4. Global checks (module-agnostic)
+  checks.push(await checkOutputDir(projectRoot));
   checks.push(checkMigrationLock(projectRoot));
-
-  // 7. Version consistency
-  checks.push(checkVersionConsistency(projectRoot));
-
-  // 8. Workflow step structure
-  checks.push(checkWorkflowStepStructure(projectRoot));
+  checks.push(checkVersionConsistency(projectRoot, modules));
 
   printResults(checks);
 
@@ -57,6 +73,43 @@ async function main() {
   process.exit(failed.length > 0 ? 1 : 0);
 }
 
+/**
+ * Scan _bmad/bme/ for subdirectories containing config.yaml.
+ * Returns an array of module descriptors with parsed config (or null on error).
+ */
+function discoverModules(projectRoot) {
+  const bmeDir = path.join(projectRoot, '_bmad/bme');
+  if (!fs.existsSync(bmeDir)) return [];
+
+  const entries = fs.readdirSync(bmeDir, { withFileTypes: true });
+  const modules = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const configPath = path.join(bmeDir, entry.name, 'config.yaml');
+    if (!fs.existsSync(configPath)) continue;
+
+    let config = null;
+    let parseError = null;
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      config = yaml.load(content);
+    } catch (err) {
+      parseError = err.message;
+    }
+
+    modules.push({
+      name: entry.name,
+      dir: path.join(bmeDir, entry.name),
+      configPath,
+      config,
+      parseError,
+    });
+  }
+
+  return modules;
+}
+
 function checkProjectRoot(projectRoot) {
   if (projectRoot) {
     return {
@@ -73,120 +126,124 @@ function checkProjectRoot(projectRoot) {
   };
 }
 
-function checkConfig(projectRoot) {
-  const configPath = path.join(projectRoot, '_bmad/bme/_vortex/config.yaml');
+function checkModuleConfig(mod) {
+  const label = `${mod.name} config`;
 
-  if (!fs.existsSync(configPath)) {
+  if (mod.parseError) {
     return {
-      name: 'Config file',
+      name: label,
       passed: false,
-      error: 'config.yaml not found',
-      fix: 'Run: npx -p convoke-agents convoke-install'
+      error: `YAML parse error: ${mod.parseError}`,
+      fix: `Check ${mod.configPath} for syntax errors`
     };
   }
 
-  try {
-    const content = fs.readFileSync(configPath, 'utf8');
-    const config = yaml.load(content);
-
-    if (!config || typeof config !== 'object') {
-      return {
-        name: 'Config file',
-        passed: false,
-        error: 'config.yaml is empty or invalid',
-        fix: 'Delete _bmad/bme/_vortex/config.yaml and run: npx -p convoke-agents convoke-install'
-      };
-    }
+  if (!mod.config || typeof mod.config !== 'object') {
+    return {
+      name: label,
+      passed: false,
+      error: 'config.yaml is empty or invalid',
+      fix: `Reinstall the ${mod.name} module`
+    };
+  }
 
-    if (!config.agents) {
-      return {
-        name: 'Config file',
-        passed: false,
-        error: 'config.yaml missing agents section',
-        fix: 'Run: npx -p convoke-agents convoke-update'
-      };
-    }
+  if (!Array.isArray(mod.config.agents) || mod.config.agents.length === 0) {
+    return {
+      name: label,
+      passed: false,
+      error: 'config.yaml missing or empty agents section',
+      fix: `Check ${mod.configPath}`
+    };
+  }
 
-    return { name: 'Config file', passed: true, info: 'Valid YAML with agents section' };
-  } catch (err) {
+  if (!Array.isArray(mod.config.workflows) || mod.config.workflows.length === 0) {
     return {
-      name: 'Config file',
+      name: label,
       passed: false,
-      error: `YAML parse error: ${err.message}`,
-      fix: 'Check config.yaml for syntax errors, or delete and run: npx -p convoke-agents convoke-install'
+      error: 'config.yaml missing or empty workflows section',
+      fix: `Check ${mod.configPath}`
     };
   }
+
+  return {
+    name: label,
+    passed: true,
+    info: `${mod.config.agents.length} agents, ${mod.config.workflows.length} workflows`
+  };
 }
 
-function checkAgents(projectRoot) {
-  const agentsDir = path.join(projectRoot, '_bmad/bme/_vortex/agents');
-  const required = AGENT_FILES;
+function checkModuleAgents(mod) {
+  const label = `${mod.name} agents`;
+  const agentsDir = path.join(mod.dir, 'agents');
+  const agentIds = mod.config.agents;
 
   if (!fs.existsSync(agentsDir)) {
     return {
-      name: 'Agent files',
+      name: label,
       passed: false,
       error: 'agents/ directory not found',
-      fix: 'Run: npx -p convoke-agents convoke-install-vortex'
+      fix: `Reinstall the ${mod.name} module`
     };
   }
 
-  const missing = required.filter(f => !fs.existsSync(path.join(agentsDir, f)));
+  const missing = agentIds.filter(id => !fs.existsSync(path.join(agentsDir, `${id}.md`)));
 
   if (missing.length > 0) {
     return {
-      name: 'Agent files',
+      name: label,
       passed: false,
-      error: `Missing: ${missing.join(', ')}`,
-      fix: 'Run: npx -p convoke-agents convoke-install-vortex to reinstall'
+      error: `Missing: ${missing.map(id => `${id}.md`).join(', ')}`,
+      fix: `Reinstall the ${mod.name} module`
     };
   }
 
   // Check files are non-empty
-  const empty = required.filter(f => {
-    const stat = fs.statSync(path.join(agentsDir, f));
+  const empty = agentIds.filter(id => {
+    const stat = fs.statSync(path.join(agentsDir, `${id}.md`));
     return stat.size === 0;
   });
 
   if (empty.length > 0) {
     return {
-      name: 'Agent files',
+      name: label,
       passed: false,
-      error: `Empty agent files: ${empty.join(', ')}`,
-      fix: 'Run: npx -p convoke-agents convoke-install to restore agent files'
+      error: `Empty agent files: ${empty.map(id => `${id}.md`).join(', ')}`,
+      fix: `Reinstall the ${mod.name} module`
     };
   }
 
-  return { name: 'Agent files', passed: true, info: `${required.length} agents present` };
+  return { name: label, passed: true, info: `${agentIds.length} agents present` };
 }
 
-function checkWorkflows(projectRoot) {
-  const workflowsDir = path.join(projectRoot, '_bmad/bme/_vortex/workflows');
-  const required = WORKFLOW_NAMES;
+function checkModuleWorkflows(mod) {
+  const label = `${mod.name} workflows`;
+  const workflowsDir = path.join(mod.dir, 'workflows');
+  const workflowNames = mod.config.workflows;
 
   if (!fs.existsSync(workflowsDir)) {
     return {
-      name: 'Workflow directories',
+      name: label,
       passed: false,
       error: 'workflows/ directory not found',
-      fix: 'Run: npx -p convoke-agents convoke-install'
+      fix: `Reinstall the ${mod.name} module`
     };
   }
 
-  const missing = required.filter(w =>
-    !fs.existsSync(path.join(workflowsDir, w, 'workflow.md'))
-  );
+  const missing = workflowNames.filter(w => {
+    const name = typeof w === 'object' ? w.name : w;
+    return !fs.existsSync(path.join(workflowsDir, name, 'workflow.md'));
+  });
 
   if (missing.length > 0) {
     return {
-      name: 'Workflow directories',
+      name: label,
       passed: false,
       error: `Missing: ${missing.join(', ')}`,
-      fix: 'Run: npx -p convoke-agents convoke-update to restore workflows'
+      fix: `Reinstall the ${mod.name} module`
     };
   }
 
-  return { name: 'Workflow directories', passed: true, info: `${required.length} workflows present` };
+  return { name: label, passed: true, info: `${workflowNames.length} workflows present` };
 }
 
 async function checkOutputDir(projectRoot) {
@@ -251,75 +308,32 @@ function checkMigrationLock(projectRoot) {
   }
 }
 
-function checkVersionConsistency(projectRoot) {
-  const configPath = path.join(projectRoot, '_bmad/bme/_vortex/config.yaml');
+function checkVersionConsistency(projectRoot, modules) {
   const packageVersion = getPackageVersion();
+  const mismatched = [];
 
-  if (!fs.existsSync(configPath)) {
-    return { name: 'Version consistency', passed: true, info: 'No config to check' };
-  }
-
-  try {
-    const content = fs.readFileSync(configPath, 'utf8');
-    const config = yaml.load(content);
-    const installedVersion = config.version || config.installed_version;
-
-    if (!installedVersion) {
-      return {
-        name: 'Version consistency',
-        passed: true,
-        info: `Package: ${packageVersion} (no installed version recorded in config)`
-      };
-    }
-
-    if (installedVersion === packageVersion) {
-      return {
-        name: 'Version consistency',
-        passed: true,
-        info: `${packageVersion} — package and config match`
-      };
+  for (const mod of modules) {
+    if (!mod.config) continue;
+    const installedVersion = mod.config.version || mod.config.installed_version;
+    if (installedVersion && installedVersion !== packageVersion) {
+      mismatched.push(`${mod.name}: ${installedVersion}`);
     }
+  }
 
+  if (mismatched.length > 0) {
     return {
       name: 'Version consistency',
       passed: false,
-      error: `Package: ${packageVersion}, Config: ${installedVersion}`,
+      error: `Package: ${packageVersion}, ${mismatched.join(', ')}`,
       fix: 'Run: npx -p convoke-agents convoke-update'
     };
-  } catch (_err) {
-    return { name: 'Version consistency', passed: true, info: 'Could not read config version' };
-  }
-}
-
-function checkWorkflowStepStructure(projectRoot) {
-  const workflowsDir = path.join(projectRoot, '_bmad/bme/_vortex/workflows');
-
-  if (!fs.existsSync(workflowsDir)) {
-    return { name: 'Workflow step structure', passed: true, info: 'No workflows directory' };
-  }
-
-  const issues = [];
-
-  for (const wf of WORKFLOW_NAMES) {
-    const stepsDir = path.join(workflowsDir, wf, 'steps');
-    if (!fs.existsSync(stepsDir)) continue;
-
-    const files = fs.readdirSync(stepsDir).filter(f => f.endsWith('.md'));
-    if (files.length < 4 || files.length > 6) {
-      issues.push(`${wf}: ${files.length} step files (expected 4-6)`);
-    }
   }
 
-  if (issues.length > 0) {
-    return {
-      name: 'Workflow step structure',
-      passed: false,
-      error: issues.join('; '),
-      fix: 'Run: npx -p convoke-agents convoke-install-vortex to reinstall clean workflow files'
-    };
-  }
-
-  return { name: 'Workflow step structure', passed: true, info: 'All workflows have valid step counts' };
+  return {
+    name: 'Version consistency',
+    passed: true,
+    info: `${packageVersion} — package and config versions consistent`
+  };
 }
 
 function printResults(checks) {

package/scripts/docs-audit.js

@@ -7,7 +7,8 @@ const path = require('path');
 const chalk = require('chalk');
 const { findProjectRoot } = require('./update/lib/utils');
 const {
-  AGENTS, WORKFLOWS, WORKFLOW_NAMES
+  AGENTS, WORKFLOWS, WORKFLOW_NAMES,
+  GYRE_AGENTS, GYRE_WORKFLOWS,
 } = require('./update/lib/agent-registry');
 
 // --- Constants (Task 1.1, 1.2) ---
@@ -61,6 +62,18 @@ function checkStaleReferences(content, filePath) {
   const agentCount = AGENTS.length;
   const workflowCount = WORKFLOWS.length;
 
+  // Valid counts from all registered teams and their combined totals
+  const validAgentCounts = new Set([
+    AGENTS.length,                              // Vortex
+    GYRE_AGENTS.length,                         // Gyre
+    AGENTS.length + GYRE_AGENTS.length,         // Combined total
+  ]);
+  const validWorkflowCounts = new Set([
+    WORKFLOWS.length,                           // Vortex
+    GYRE_WORKFLOWS.length,                      // Gyre
+    WORKFLOWS.length + GYRE_WORKFLOWS.length,   // Combined total
+  ]);
+
   // Build regex for written-out numbers
   const wordKeys = Object.keys(WORD_TO_NUM).join('|');
 
@@ -86,7 +99,7 @@ function checkStaleReferences(content, filePath) {
     digitAgentRe.lastIndex = 0;
     while ((m = digitAgentRe.exec(line)) !== null) {
       const num = parseInt(m[1], 10);
-      if (num !== agentCount && num > 0 && num < 100) {
+      if (!validAgentCounts.has(num) && num > 0 && num < 100) {
         findings.push({
           file: filePath, line: lineNum,
           category: 'stale-reference',
@@ -99,7 +112,7 @@ function checkStaleReferences(content, filePath) {
     wordAgentRe.lastIndex = 0;
     while ((m = wordAgentRe.exec(line)) !== null) {
       const num = WORD_TO_NUM[m[1].toLowerCase()];
-      if (num !== undefined && num !== agentCount) {
+      if (num !== undefined && !validAgentCounts.has(num)) {
         findings.push({
           file: filePath, line: lineNum,
           category: 'stale-reference',
@@ -112,7 +125,7 @@ function checkStaleReferences(content, filePath) {
     digitWorkflowRe.lastIndex = 0;
     while ((m = digitWorkflowRe.exec(line)) !== null) {
       const num = parseInt(m[1], 10);
-      if (num !== workflowCount && num > 0 && num < 100) {
+      if (!validWorkflowCounts.has(num) && num > 0 && num < 100) {
         findings.push({
           file: filePath, line: lineNum,
           category: 'stale-reference',
@@ -125,7 +138,7 @@ function checkStaleReferences(content, filePath) {
     wordWorkflowRe.lastIndex = 0;
     while ((m = wordWorkflowRe.exec(line)) !== null) {
       const num = WORD_TO_NUM[m[1].toLowerCase()];
-      if (num !== undefined && num !== workflowCount) {
+      if (num !== undefined && !validWorkflowCounts.has(num)) {
         findings.push({
           file: filePath, line: lineNum,
           category: 'stale-reference',
@@ -419,6 +432,9 @@ function checkStaleBrandReferences(content, filePath) {
     const line = lines[i];
     const lineNum = i + 1;
 
+    // Skip lines that document the rename transition (e.g., "bmad-enhanced → convoke-agents")
+    if (/→|->/.test(line) && /convoke/i.test(line)) continue;
+
     staleRe.lastIndex = 0;
     let m;
     while ((m = staleRe.exec(line)) !== null) {

package/scripts/install-gyre-agents.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const { refreshInstallation } = require('./update/lib/refresh-installation');
+const { findProjectRoot } = require('./update/lib/utils');
+const { GYRE_AGENTS } = require('./update/lib/agent-registry');
+
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const CYAN = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const GREY = '\x1b[90m';
+
+function printBanner() {
+  console.log('');
+  console.log(`${GREY}  ██████╗ ██████╗ ███╗   ██╗██╗   ██╗ ██████╗ ██╗  ██╗███████╗${RESET}`);
+  console.log(`${GREY} ██╔════╝██╔═══██╗████╗  ██║██║   ██║██╔═══██╗██║ ██╔╝██╔════╝${RESET}`);
+  console.log(`${GREY} ██║     ██║   ██║██╔██╗ ██║██║   ██║██║   ██║█████╔╝ █████╗  ${RESET}`);
+  console.log(`${GREY} ██║     ██║   ██║██║╚██╗██║╚██╗ ██╔╝██║   ██║██╔═██╗ ██╔══╝  ${RESET}`);
+  console.log(`${GREY} ╚██████╗╚██████╔╝██║ ╚████║ ╚████╔╝ ╚██████╔╝██║  ██╗███████╗${RESET}`);
+  console.log(`${GREY}  ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝  ╚═══╝   ╚═════╝ ╚═╝  ╚═╝╚══════╝${RESET}`);
+  console.log(`${GREY}       Agent teams for complex systems${RESET}`);
+  console.log('');
+  console.log(`${BOLD} Gyre Module — Production readiness discovery${RESET}`);
+  console.log('');
+}
+
+function checkPrerequisites(projectRoot) {
+  console.log(`${CYAN}[1/4]${RESET} Checking prerequisites...`);
+
+  const bmadDir = path.join(projectRoot, '_bmad');
+
+  if (!fs.existsSync(bmadDir)) {
+    console.log(`${YELLOW}  ⚠${RESET} _bmad directory not found - creating it`);
+    fs.mkdirSync(bmadDir, { recursive: true });
+  } else {
+    console.log(`${GREEN}  ✓${RESET} BMAD directory detected`);
+  }
+
+  const bmadConfigPath = path.join(bmadDir, '_config', 'bmad.yaml');
+  if (fs.existsSync(bmadConfigPath)) {
+    console.log(`${GREEN}  ✓${RESET} BMAD Method configuration found`);
+  } else {
+    console.log(`${YELLOW}  ⚠${RESET} BMAD Method not detected (Convoke will install standalone)`);
+  }
+
+  console.log(`${GREEN}  ✓${RESET} Prerequisites met`);
+}
+
+function createOutputDirectory(projectRoot) {
+  console.log(`${CYAN}[2/4]${RESET} Setting up output directory...`);
+
+  const outputDir = path.join(projectRoot, '_bmad-output', 'gyre-artifacts');
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  console.log(`${GREEN}  ✓${RESET} Output directory ready`);
+}
+
+function verifyInstallation(projectRoot) {
+  console.log(`${CYAN}[4/4]${RESET} Verifying installation...`);
+
+  const checks = [
+    ...GYRE_AGENTS.map(a => ({ path: `_bmad/bme/_gyre/agents/${a.id}.md`, name: `${a.name} agent file` })),
+    ...GYRE_AGENTS.map(a => ({ path: `.claude/skills/bmad-agent-bme-${a.id}/SKILL.md`, name: `${a.name} skill` })),
+    { path: '_bmad/bme/_gyre/config.yaml', name: 'Configuration file' },
+  ];
+
+  let allChecksPass = true;
+  checks.forEach(check => {
+    const fullPath = path.join(projectRoot, check.path);
+    if (fs.existsSync(fullPath)) {
+      console.log(`${GREEN}  ✓${RESET} ${check.name}`);
+    } else {
+      console.log(`${RED}  ✗${RESET} ${check.name} - MISSING`);
+      allChecksPass = false;
+    }
+  });
+
+  if (!allChecksPass) {
+    console.log('');
+    console.error(`${RED}Installation verification failed. Some files are missing.${RESET}`);
+    process.exit(1);
+  }
+
+  console.log(`${GREEN}  ✓${RESET} All files installed successfully`);
+}
+
+function printSuccess() {
+  console.log('');
+  console.log(`${GREEN}${BOLD}╔════════════════════════════════════════════════════╗${RESET}`);
+  console.log(`${GREEN}${BOLD}║                                                    ║${RESET}`);
+  console.log(`${GREEN}${BOLD}║    ✓  All Gyre Agents Installed! 🎉               ║${RESET}`);
+  console.log(`${GREEN}${BOLD}║                                                    ║${RESET}`);
+  console.log(`${GREEN}${BOLD}╚════════════════════════════════════════════════════╝${RESET}`);
+  console.log('');
+  console.log(`${BOLD}Installed Agents:${RESET}`);
+  console.log('');
+  for (const agent of GYRE_AGENTS) {
+    console.log(`  ${GREEN}✓${RESET} ${agent.name} (${agent.id}) - ${agent.title} ${agent.icon}`);
+  }
+  console.log('');
+  console.log(`${BOLD}Next Steps:${RESET}`);
+  console.log('');
+  console.log(`  ${YELLOW}1.${RESET} Personalize your config:`);
+  console.log(`     Edit ${CYAN}_bmad/bme/_gyre/config.yaml${RESET} and replace ${YELLOW}{user}${RESET} with your name`);
+  console.log('');
+  console.log(`  ${YELLOW}2.${RESET} Activate an agent (skill) in Claude Code:`);
+  for (const agent of GYRE_AGENTS) {
+    console.log(`     ${CYAN}/bmad-agent-bme-${agent.id}${RESET}  (${agent.name})`);
+  }
+  console.log('');
+  console.log(`  ${YELLOW}3.${RESET} Or read the agent file directly:`);
+  console.log(`     ${CYAN}cat _bmad/bme/_gyre/agents/{agent-id}.md${RESET}`);
+  console.log('');
+}
+
+async function main() {
+  try {
+    const projectRoot = findProjectRoot();
+
+    printBanner();
+    checkPrerequisites(projectRoot);
+    createOutputDirectory(projectRoot);
+
+    console.log(`${CYAN}[3/4]${RESET} Installing agents, workflows, config, and contracts...`);
+    await refreshInstallation(projectRoot, { backupGuides: false });
+    console.log(`${GREEN}  ✓${RESET} Installation refreshed`);
+
+    verifyInstallation(projectRoot);
+    printSuccess();
+  } catch (error) {
+    console.error(`${RED}✗ Installation failed:${RESET}`, error.message);
+    process.exit(1);
+  }
+}
+
+main();