agileflow 2.42.0 → 2.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agileflow",
-  "version": "2.42.0",
+  "version": "2.44.0",
   "description": "AI-driven agile development system for Claude Code, Cursor, Windsurf, and more",
   "keywords": [
     "agile",
@@ -31,6 +31,7 @@
   "files": [
     "tools/",
     "src/",
+    "scripts/",
     "LICENSE",
     "README.md"
   ],

package/scripts/generate-all.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+
+###############################################################################
+# AgileFlow Content Generation Script
+#
+# Regenerates all dynamic content in AgileFlow plugin files.
+# Run this after:
+# - Adding/removing/renaming commands
+# - Adding/removing/renaming agents
+# - Adding/removing/renaming skills
+# - Changing command/agent/skill descriptions or metadata
+#
+# Usage:
+#   bash scripts/generate-all.sh
+#   npm run generate  (if added to package.json)
+###############################################################################
+
+set -e  # Exit on error
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+GENERATORS_DIR="$SCRIPT_DIR/generators"
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}============================================================${NC}"
+echo -e "${BLUE}  AgileFlow Content Generation System${NC}"
+echo -e "${BLUE}============================================================${NC}"
+echo ""
+
+# Check if Node.js is available
+if ! command -v node &> /dev/null; then
+    echo -e "${RED}❌ Error: Node.js is not installed or not in PATH${NC}"
+    exit 1
+fi
+
+# Check if generators directory exists
+if [ ! -d "$GENERATORS_DIR" ]; then
+    echo -e "${RED}❌ Error: Generators directory not found: $GENERATORS_DIR${NC}"
+    exit 1
+fi
+
+# Run the orchestrator
+echo -e "${YELLOW}Running content generators...${NC}"
+echo ""
+
+cd "$GENERATORS_DIR"
+node index.js
+
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -eq 0 ]; then
+    echo ""
+    echo -e "${GREEN}============================================================${NC}"
+    echo -e "${GREEN}✅ Content generation completed successfully!${NC}"
+    echo -e "${GREEN}============================================================${NC}"
+    echo ""
+    echo -e "${YELLOW}Next steps:${NC}"
+    echo "1. Review the changes: git diff"
+    echo "2. Test the plugin to ensure everything works"
+    echo "3. Commit the generated content: git add -A && git commit -m 'chore: regenerate plugin content'"
+    echo ""
+else
+    echo ""
+    echo -e "${RED}============================================================${NC}"
+    echo -e "${RED}❌ Content generation failed${NC}"
+    echo -e "${RED}============================================================${NC}"
+    echo ""
+    echo -e "${YELLOW}Please check the errors above and fix any issues.${NC}"
+    echo ""
+    exit 1
+fi

package/scripts/generators/agent-registry.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+/**
+ * Agent Registry Scanner
+ *
+ * Scans agents/ directory and extracts metadata from frontmatter.
+ * Returns structured agent registry for use in generators.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract YAML frontmatter from markdown file
+ * Handles multi-line values like tools arrays
+ * @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');
+  let currentKey = null;
+  let currentArray = null;
+
+  for (const line of lines) {
+    // Handle array items (lines starting with -)
+    if (line.trim().startsWith('-')) {
+      if (currentArray) {
+        currentArray.push(line.trim().substring(1).trim());
+      }
+      continue;
+    }
+
+    // Handle key-value pairs
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      currentKey = key;
+
+      // If value is empty, it's likely an array
+      if (!value) {
+        currentArray = [];
+        frontmatter[key] = currentArray;
+      } else {
+        // Remove quotes if present
+        frontmatter[key] = value.replace(/^["']|["']$/g, '');
+        currentArray = null;
+      }
+    }
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Categorize agent based on its role
+ * @param {string} name - Agent name
+ * @param {string} description - Agent description
+ * @returns {string} Category name
+ */
+function categorizeAgent(name, description) {
+  const categories = {
+    'Core Development': ['ui', 'api', 'database', 'devops', 'ci'],
+    'Specialized Development': ['mobile', 'integrations', 'datamigration'],
+    'Quality & Testing': ['qa', 'testing', 'security', 'accessibility'],
+    'Architecture & Design': ['design', 'adr-writer', 'epic-planner', 'product'],
+    'Maintenance & Optimization': ['refactor', 'performance', 'monitoring'],
+    'Documentation & Knowledge': ['documentation', 'readme-updater', 'research'],
+    'Compliance & Governance': ['compliance', 'analytics'],
+    'Mentorship': ['mentor']
+  };
+
+  for (const [category, keywords] of Object.entries(categories)) {
+    if (keywords.some(kw => name.includes(kw))) {
+      return category;
+    }
+  }
+
+  return 'Other';
+}
+
+/**
+ * Scan agents directory and build registry
+ * @param {string} agentsDir - Path to agents directory
+ * @returns {Array} Array of agent metadata objects
+ */
+function scanAgents(agentsDir) {
+  const agents = [];
+  const files = fs.readdirSync(agentsDir);
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue;
+
+    const filePath = path.join(agentsDir, file);
+    const frontmatter = extractFrontmatter(filePath);
+    const name = file.replace('.md', '');
+
+    // Parse tools array if it exists
+    let tools = [];
+    if (frontmatter.tools) {
+      if (Array.isArray(frontmatter.tools)) {
+        tools = frontmatter.tools;
+      } else if (typeof frontmatter.tools === 'string') {
+        tools = frontmatter.tools.split(',').map(t => t.trim());
+      }
+    }
+
+    agents.push({
+      name,
+      file,
+      path: filePath,
+      displayName: frontmatter.name || name,
+      description: frontmatter.description || '',
+      tools,
+      model: frontmatter.model || 'haiku',
+      color: frontmatter.color || 'blue',
+      category: categorizeAgent(name, frontmatter.description || '')
+    });
+  }
+
+  // Sort by category, then by name
+  agents.sort((a, b) => {
+    if (a.category !== b.category) {
+      return a.category.localeCompare(b.category);
+    }
+    return a.name.localeCompare(b.name);
+  });
+
+  return agents;
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const rootDir = path.resolve(__dirname, '../..');
+  const agentsDir = path.join(rootDir, 'src/core/agents');
+
+  if (!fs.existsSync(agentsDir)) {
+    console.error(`Agents directory not found: ${agentsDir}`);
+    process.exit(1);
+  }
+
+  const agents = scanAgents(agentsDir);
+
+  // If called directly, output JSON
+  if (require.main === module) {
+    console.log(JSON.stringify(agents, null, 2));
+  }
+
+  return agents;
+}
+
+// Export for use in other scripts
+module.exports = { scanAgents, extractFrontmatter, categorizeAgent };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

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();
+}