agileflow 2.43.0 → 2.45.0

package/scripts/generators/command-registry.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+/**
+ * Command Registry Scanner
+ *
+ * Scans commands/ directory and extracts metadata from frontmatter.
+ * Returns structured command registry for use in generators.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract frontmatter from markdown file
+ * @param {string} filePath - Path to markdown file
+ * @returns {object} Frontmatter object
+ */
+function extractFrontmatter(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+
+  if (!frontmatterMatch) {
+    return {};
+  }
+
+  const frontmatter = {};
+  const lines = frontmatterMatch[1].split('\n');
+
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      const [, key, value] = match;
+      // Remove quotes if present
+      frontmatter[key] = value.replace(/^["']|["']$/g, '');
+    }
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Categorize command based on its name/description
+ * @param {string} name - Command name
+ * @param {string} description - Command description
+ * @returns {string} Category name
+ */
+function categorizeCommand(name, description) {
+  const categories = {
+    'Story Management': ['story', 'epic', 'assign', 'status'],
+    'Development': ['verify', 'baseline', 'resume', 'session-init', 'babysit'],
+    'Quality & Testing': ['tests', 'review', 'ci'],
+    'Documentation': ['docs', 'adr', 'readme-sync'],
+    'Planning & Metrics': ['sprint', 'velocity', 'metrics', 'board', 'deps'],
+    'Research & Strategy': ['research', 'product'],
+    'Deployment & Operations': ['deploy', 'packages'],
+    'Collaboration': ['update', 'handoff', 'feedback', 'retro'],
+    'Maintenance': ['debt', 'compress', 'template'],
+    'System': ['setup', 'help', 'diagnose', 'auto', 'agent']
+  };
+
+  for (const [category, keywords] of Object.entries(categories)) {
+    if (keywords.some(kw => name.includes(kw))) {
+      return category;
+    }
+  }
+
+  return 'Other';
+}
+
+/**
+ * Scan commands directory and build registry
+ * @param {string} commandsDir - Path to commands directory
+ * @returns {Array} Array of command metadata objects
+ */
+function scanCommands(commandsDir) {
+  const commands = [];
+  const files = fs.readdirSync(commandsDir);
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue;
+
+    const filePath = path.join(commandsDir, file);
+    const frontmatter = extractFrontmatter(filePath);
+    const name = file.replace('.md', '');
+
+    commands.push({
+      name,
+      file,
+      path: filePath,
+      description: frontmatter.description || '',
+      argumentHint: frontmatter['argument-hint'] || '',
+      category: categorizeCommand(name, frontmatter.description || '')
+    });
+  }
+
+  // Sort by category, then by name
+  commands.sort((a, b) => {
+    if (a.category !== b.category) {
+      return a.category.localeCompare(b.category);
+    }
+    return a.name.localeCompare(b.name);
+  });
+
+  return commands;
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const rootDir = path.resolve(__dirname, '../..');
+  const commandsDir = path.join(rootDir, 'src/core/commands');
+
+  if (!fs.existsSync(commandsDir)) {
+    console.error(`Commands directory not found: ${commandsDir}`);
+    process.exit(1);
+  }
+
+  const commands = scanCommands(commandsDir);
+
+  // If called directly, output JSON
+  if (require.main === module) {
+    console.log(JSON.stringify(commands, null, 2));
+  }
+
+  return commands;
+}
+
+// Export for use in other scripts
+module.exports = { scanCommands, extractFrontmatter, categorizeCommand };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

package/scripts/generators/index.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+/**
+ * Content Generation Orchestrator
+ *
+ * Runs all content generators to update AgileFlow plugin files.
+ * Single source of truth: frontmatter and directory structure.
+ */
+
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Run a generator script
+ * @param {string} scriptName - Name of the generator script
+ * @returns {boolean} Success status
+ */
+function runGenerator(scriptName) {
+  const scriptPath = path.join(__dirname, scriptName);
+
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`Running: ${scriptName}`);
+  console.log('='.repeat(60));
+
+  try {
+    execSync(`node "${scriptPath}"`, {
+      cwd: __dirname,
+      stdio: 'inherit'
+    });
+    console.log(`✅ ${scriptName} completed successfully`);
+    return true;
+  } catch (error) {
+    console.error(`❌ ${scriptName} failed:`, error.message);
+    return false;
+  }
+}
+
+/**
+ * Main orchestrator
+ */
+function main() {
+  console.log('🚀 AgileFlow Content Generation System');
+  console.log('Generating content from metadata...\n');
+
+  const generators = [
+    'inject-help.js',
+    'inject-babysit.js',
+    'inject-readme.js'
+  ];
+
+  const results = [];
+
+  for (const generator of generators) {
+    const success = runGenerator(generator);
+    results.push({ generator, success });
+  }
+
+  // Summary
+  console.log(`\n${'='.repeat(60)}`);
+  console.log('GENERATION SUMMARY');
+  console.log('='.repeat(60));
+
+  let allSuccess = true;
+  for (const { generator, success } of results) {
+    const status = success ? '✅' : '❌';
+    console.log(`${status} ${generator}`);
+    if (!success) allSuccess = false;
+  }
+
+  console.log('');
+
+  if (allSuccess) {
+    console.log('🎉 All generators completed successfully!');
+    console.log('📝 Generated content is ready for commit.');
+    process.exit(0);
+  } else {
+    console.log('⚠️  Some generators failed. Please check errors above.');
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { runGenerator };

package/scripts/generators/inject-babysit.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+/**
+ * Babysit Command Content Injector
+ *
+ * Injects agent list and command references into /agileflow:babysit command file.
+ * Handles multiple AUTOGEN sections.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { scanAgents } = require('./agent-registry');
+const { scanCommands } = require('./command-registry');
+
+/**
+ * Generate agent list content with details
+ * @param {Array} agents - Array of agent metadata
+ * @returns {string} Formatted agent list
+ */
+function generateAgentList(agents) {
+  const lines = [];
+
+  lines.push(`**AVAILABLE AGENTS** (${agents.length} total):`);
+  lines.push('');
+
+  let count = 1;
+  for (const agent of agents) {
+    lines.push(`${count}. **${agent.name}** (model: ${agent.model})`);
+    lines.push(`   - **Purpose**: ${agent.description}`);
+    lines.push(`   - **Tools**: ${agent.tools.join(', ')}`);
+    lines.push(`   - **Category**: ${agent.category}`);
+    lines.push('');
+    count++;
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate command reference list (compact format for babysit)
+ * @param {Array} commands - Array of command metadata
+ * @returns {string} Formatted command list
+ */
+function generateCommandReference(commands) {
+  const lines = [];
+
+  // Group by category
+  const categories = {};
+  for (const cmd of commands) {
+    if (!categories[cmd.category]) {
+      categories[cmd.category] = [];
+    }
+    categories[cmd.category].push(cmd);
+  }
+
+  for (const [category, cmds] of Object.entries(categories)) {
+    const cmdNames = cmds.map(c => c.name).join(', ');
+    lines.push(`- **${category}**: ${cmdNames}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Inject content between specified AUTOGEN markers
+ * @param {string} content - Original file content
+ * @param {string} markerName - Name of the marker (e.g., AGENT_LIST, COMMAND_REF)
+ * @param {string} generated - Generated content to inject
+ * @returns {string} Updated file content
+ */
+function injectContentByMarker(content, markerName, generated) {
+  const startMarker = `<!-- AUTOGEN:${markerName}:START -->`;
+  const endMarker = `<!-- AUTOGEN:${markerName}:END -->`;
+
+  const startIdx = content.indexOf(startMarker);
+  const endIdx = content.indexOf(endMarker);
+
+  if (startIdx === -1 || endIdx === -1) {
+    console.warn(`AUTOGEN:${markerName} markers not found - skipping`);
+    return content;
+  }
+
+  const timestamp = new Date().toISOString().split('T')[0];
+  const injectedContent = `${startMarker}\n<!-- Auto-generated on ${timestamp}. Do not edit manually. -->\n\n${generated}\n${endMarker}`;
+
+  return content.substring(0, startIdx) + injectedContent + content.substring(endIdx + endMarker.length);
+}
+
+/**
+ * Add AUTOGEN markers to babysit file if they don't exist
+ * @param {string} content - Original file content
+ * @returns {string} Updated content with markers
+ */
+function addMarkersIfMissing(content) {
+  let updated = content;
+
+  // Add AGENT_LIST markers around the agent list section
+  if (!content.includes('<!-- AUTOGEN:AGENT_LIST:START -->')) {
+    // Find "**AVAILABLE AGENTS**" and wrap it
+    const agentSectionStart = content.indexOf('**AVAILABLE AGENTS**');
+    if (agentSectionStart !== -1) {
+      // Find the end of the agent list (before "**WHEN TO SPAWN AGENTS**")
+      const agentSectionEnd = content.indexOf('**WHEN TO SPAWN AGENTS**', agentSectionStart);
+      if (agentSectionEnd !== -1) {
+        const before = content.substring(0, agentSectionStart);
+        const agentSection = content.substring(agentSectionStart, agentSectionEnd);
+        const after = content.substring(agentSectionEnd);
+
+        updated = `${before}<!-- AUTOGEN:AGENT_LIST:START -->\n${agentSection}<!-- AUTOGEN:AGENT_LIST:END -->\n\n${after}`;
+        console.log('✅ Added AGENT_LIST markers to babysit.md');
+      }
+    }
+  }
+
+  return updated;
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const rootDir = path.resolve(__dirname, '../..');
+  const babysitFile = path.join(rootDir, 'src/core/commands/babysit.md');
+  const agentsDir = path.join(rootDir, 'src/core/agents');
+  const commandsDir = path.join(rootDir, 'src/core/commands');
+
+  // Check if babysit file exists
+  if (!fs.existsSync(babysitFile)) {
+    console.error(`Babysit file not found: ${babysitFile}`);
+    process.exit(1);
+  }
+
+  // Scan agents and commands
+  console.log('Scanning agents...');
+  const agents = scanAgents(agentsDir);
+  console.log(`Found ${agents.length} agents`);
+
+  console.log('Scanning commands...');
+  const commands = scanCommands(commandsDir);
+  console.log(`Found ${commands.length} commands`);
+
+  // Read babysit file
+  let babysitContent = fs.readFileSync(babysitFile, 'utf-8');
+
+  // Add markers if missing
+  babysitContent = addMarkersIfMissing(babysitContent);
+
+  // Generate content
+  console.log('Generating agent list...');
+  const agentList = generateAgentList(agents);
+
+  // Inject content
+  console.log('Injecting content into babysit.md...');
+  babysitContent = injectContentByMarker(babysitContent, 'AGENT_LIST', agentList);
+
+  // Write back
+  fs.writeFileSync(babysitFile, babysitContent, 'utf-8');
+  console.log('✅ Successfully updated babysit.md');
+}
+
+// Export for use in orchestrator
+module.exports = { generateAgentList, generateCommandReference, injectContentByMarker, addMarkersIfMissing };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

package/scripts/generators/inject-help.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+/**
+ * Help Command Content Injector
+ *
+ * Injects command list into /agileflow:help command file.
+ * Finds AUTOGEN markers and replaces content with generated command directory.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { scanCommands } = require('./command-registry');
+
+/**
+ * Generate command list content grouped by category
+ * @param {Array} commands - Array of command metadata
+ * @returns {string} Formatted command list
+ */
+function generateCommandList(commands) {
+  const lines = [];
+
+  // Group commands by category
+  const categories = {};
+  for (const cmd of commands) {
+    if (!categories[cmd.category]) {
+      categories[cmd.category] = [];
+    }
+    categories[cmd.category].push(cmd);
+  }
+
+  // Generate markdown for each category
+  for (const [category, cmds] of Object.entries(categories)) {
+    lines.push(`**${category}:**`);
+    for (const cmd of cmds) {
+      const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : '';
+      lines.push(`- \`/agileflow:${cmd.name}${hint}\` - ${cmd.description}`);
+    }
+    lines.push(''); // Blank line between categories
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Inject content between AUTOGEN markers
+ * @param {string} content - Original file content
+ * @param {string} generated - Generated content to inject
+ * @returns {string} Updated file content
+ */
+function injectContent(content, generated) {
+  const startMarker = '<!-- AUTOGEN:COMMAND_LIST:START -->';
+  const endMarker = '<!-- AUTOGEN:COMMAND_LIST:END -->';
+
+  const startIdx = content.indexOf(startMarker);
+  const endIdx = content.indexOf(endMarker);
+
+  if (startIdx === -1 || endIdx === -1) {
+    console.error('AUTOGEN markers not found in file');
+    return content;
+  }
+
+  const timestamp = new Date().toISOString().split('T')[0];
+  const injectedContent = `${startMarker}\n<!-- Auto-generated on ${timestamp}. Do not edit manually. -->\n\n${generated}\n${endMarker}`;
+
+  return content.substring(0, startIdx) + injectedContent + content.substring(endIdx + endMarker.length);
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const rootDir = path.resolve(__dirname, '../..');
+  const helpFile = path.join(rootDir, 'src/core/commands/help.md');
+  const commandsDir = path.join(rootDir, 'src/core/commands');
+
+  // Check if help file exists
+  if (!fs.existsSync(helpFile)) {
+    console.error(`Help file not found: ${helpFile}`);
+    process.exit(1);
+  }
+
+  // Scan commands
+  console.log('Scanning commands...');
+  const commands = scanCommands(commandsDir);
+  console.log(`Found ${commands.length} commands`);
+
+  // Generate command list
+  console.log('Generating command list...');
+  const commandList = generateCommandList(commands);
+
+  // Read help file
+  const helpContent = fs.readFileSync(helpFile, 'utf-8');
+
+  // Inject content
+  console.log('Injecting content into help.md...');
+  const updatedContent = injectContent(helpContent, commandList);
+
+  // Write back
+  fs.writeFileSync(helpFile, updatedContent, 'utf-8');
+  console.log('✅ Successfully updated help.md');
+}
+
+// Export for use in orchestrator
+module.exports = { generateCommandList, injectContent };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

package/scripts/generators/inject-readme.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+/**
+ * README Content Injector
+ *
+ * Injects stats, agent tables, and skill lists into README.md.
+ * Handles multiple AUTOGEN sections for different content types.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { scanAgents } = require('./agent-registry');
+const { scanCommands } = require('./command-registry');
+const { scanSkills } = require('./skill-registry');
+
+/**
+ * Generate stats content (command/agent/skill counts)
+ * @param {Object} counts - {commands, agents, skills}
+ * @returns {string} Formatted stats
+ */
+function generateStats(counts) {
+  return `- **${counts.commands}** slash commands\n- **${counts.agents}** specialized agents\n- **${counts.skills}** code generation skills`;
+}
+
+/**
+ * Generate agent table (markdown table format)
+ * @param {Array} agents - Array of agent metadata
+ * @returns {string} Formatted table
+ */
+function generateAgentTable(agents) {
+  const lines = [];
+
+  lines.push('| Agent | Description | Model | Category |');
+  lines.push('|-------|-------------|-------|----------|');
+
+  for (const agent of agents) {
+    const tools = agent.tools.slice(0, 3).join(', ') + (agent.tools.length > 3 ? '...' : '');
+    lines.push(`| ${agent.name} | ${agent.description} | ${agent.model} | ${agent.category} |`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate skill list (bulleted list grouped by category)
+ * @param {Array} skills - Array of skill metadata
+ * @returns {string} Formatted list
+ */
+function generateSkillList(skills) {
+  const lines = [];
+
+  // Group by category
+  const categories = {};
+  for (const skill of skills) {
+    if (!categories[skill.category]) {
+      categories[skill.category] = [];
+    }
+    categories[skill.category].push(skill);
+  }
+
+  for (const [category, categorySkills] of Object.entries(categories)) {
+    lines.push(`**${category}:**`);
+    for (const skill of categorySkills) {
+      lines.push(`- **${skill.name}**: ${skill.description}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Inject content between specified AUTOGEN markers
+ * @param {string} content - Original file content
+ * @param {string} markerName - Name of the marker (e.g., STATS, AGENT_TABLE)
+ * @param {string} generated - Generated content to inject
+ * @returns {string} Updated file content
+ */
+function injectContentByMarker(content, markerName, generated) {
+  const startMarker = `<!-- AUTOGEN:${markerName}:START -->`;
+  const endMarker = `<!-- AUTOGEN:${markerName}:END -->`;
+
+  const startIdx = content.indexOf(startMarker);
+  const endIdx = content.indexOf(endMarker);
+
+  if (startIdx === -1 || endIdx === -1) {
+    console.warn(`AUTOGEN:${markerName} markers not found - skipping`);
+    return content;
+  }
+
+  const timestamp = new Date().toISOString().split('T')[0];
+  const injectedContent = `${startMarker}\n<!-- Auto-generated on ${timestamp}. Do not edit manually. -->\n\n${generated}\n${endMarker}`;
+
+  return content.substring(0, startIdx) + injectedContent + content.substring(endIdx + endMarker.length);
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const cliDir = path.resolve(__dirname, '../..');
+  const rootDir = path.resolve(cliDir, '../..');
+  const readmeFile = path.join(rootDir, 'README.md');
+  const agentsDir = path.join(cliDir, 'src/core/agents');
+  const commandsDir = path.join(cliDir, 'src/core/commands');
+  const skillsDir = path.join(cliDir, 'src/core/skills');
+
+  // Check if README exists
+  if (!fs.existsSync(readmeFile)) {
+    console.error(`README not found: ${readmeFile}`);
+    process.exit(1);
+  }
+
+  // Scan all registries
+  console.log('Scanning commands, agents, and skills...');
+  const commands = scanCommands(commandsDir);
+  const agents = scanAgents(agentsDir);
+  const skills = scanSkills(skillsDir);
+
+  console.log(`Found: ${commands.length} commands, ${agents.length} agents, ${skills.length} skills`);
+
+  // Read README
+  let readmeContent = fs.readFileSync(readmeFile, 'utf-8');
+
+  // Generate content
+  console.log('Generating stats...');
+  const stats = generateStats({
+    commands: commands.length,
+    agents: agents.length,
+    skills: skills.length
+  });
+
+  console.log('Generating agent table...');
+  const agentTable = generateAgentTable(agents);
+
+  console.log('Generating skill list...');
+  const skillList = generateSkillList(skills);
+
+  // Inject content
+  console.log('Injecting content into README.md...');
+  readmeContent = injectContentByMarker(readmeContent, 'STATS', stats);
+  readmeContent = injectContentByMarker(readmeContent, 'AGENT_TABLE', agentTable);
+  readmeContent = injectContentByMarker(readmeContent, 'SKILL_LIST', skillList);
+
+  // Write back
+  fs.writeFileSync(readmeFile, readmeContent, 'utf-8');
+  console.log('✅ Successfully updated README.md');
+}
+
+// Export for use in orchestrator
+module.exports = { generateStats, generateAgentTable, generateSkillList, injectContentByMarker };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}