agileflow 2.43.0 → 2.45.0

package/scripts/generators/skill-registry.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * Skill Registry Scanner
+ *
+ * Scans skills/ directory and extracts metadata from SKILL.md frontmatter.
+ * Returns structured skill registry for use in generators.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract YAML 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 skill based on its name/description
+ * @param {string} name - Skill name
+ * @param {string} description - Skill description
+ * @returns {string} Category name
+ */
+function categorizeSkill(name, description) {
+  const categories = {
+    'Story & Planning': ['story', 'epic', 'sprint', 'acceptance-criteria'],
+    'Code Generation': ['type-definitions', 'validation-schema', 'error-handler'],
+    'Testing': ['test-case'],
+    'Documentation': ['adr', 'api-documentation', 'changelog', 'pr-description'],
+    'Architecture': ['sql-schema', 'diagram'],
+    'Deployment': ['deployment-guide', 'migration-checklist']
+  };
+
+  const lowerName = name.toLowerCase();
+  const lowerDesc = description.toLowerCase();
+
+  for (const [category, keywords] of Object.entries(categories)) {
+    if (keywords.some(kw => lowerName.includes(kw) || lowerDesc.includes(kw))) {
+      return category;
+    }
+  }
+
+  return 'Other';
+}
+
+/**
+ * Scan skills directory and build registry
+ * @param {string} skillsDir - Path to skills directory
+ * @returns {Array} Array of skill metadata objects
+ */
+function scanSkills(skillsDir) {
+  const skills = [];
+
+  // Each skill is in its own directory with a SKILL.md file
+  const skillDirs = fs.readdirSync(skillsDir);
+
+  for (const skillDir of skillDirs) {
+    const skillPath = path.join(skillsDir, skillDir);
+
+    // Skip if not a directory
+    if (!fs.statSync(skillPath).isDirectory()) continue;
+
+    const skillFile = path.join(skillPath, 'SKILL.md');
+
+    // Skip if SKILL.md doesn't exist
+    if (!fs.existsSync(skillFile)) continue;
+
+    const frontmatter = extractFrontmatter(skillFile);
+    const name = frontmatter.name || skillDir;
+    const description = frontmatter.description || '';
+
+    skills.push({
+      name,
+      directory: skillDir,
+      file: 'SKILL.md',
+      path: skillFile,
+      description,
+      category: categorizeSkill(name, description)
+    });
+  }
+
+  // Sort by category, then by name
+  skills.sort((a, b) => {
+    if (a.category !== b.category) {
+      return a.category.localeCompare(b.category);
+    }
+    return a.name.localeCompare(b.name);
+  });
+
+  return skills;
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const rootDir = path.resolve(__dirname, '../..');
+  const skillsDir = path.join(rootDir, 'src/core/skills');
+
+  if (!fs.existsSync(skillsDir)) {
+    console.error(`Skills directory not found: ${skillsDir}`);
+    process.exit(1);
+  }
+
+  const skills = scanSkills(skillsDir);
+
+  // If called directly, output JSON
+  if (require.main === module) {
+    console.log(JSON.stringify(skills, null, 2));
+  }
+
+  return skills;
+}
+
+// Export for use in other scripts
+module.exports = { scanSkills, extractFrontmatter, categorizeSkill };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

package/scripts/get-env.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+/**
+ * get-env.js - Helper script to output environment information
+ *
+ * This script can be called from hooks or other automation to get
+ * consistent environment information about the AgileFlow project.
+ *
+ * Usage:
+ *   node scripts/get-env.js [--json] [--compact]
+ *
+ * Flags:
+ *   --json     Output as JSON
+ *   --compact  Minimal output for status line
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+function getProjectInfo() {
+  const rootDir = path.resolve(__dirname, '..');
+
+  // Read package.json files
+  let cliPackage = {};
+  let rootPackage = {};
+
+  try {
+    cliPackage = JSON.parse(
+      fs.readFileSync(path.join(rootDir, 'packages/cli/package.json'), 'utf8')
+    );
+  } catch (err) {
+    // Ignore if not found
+  }
+
+  try {
+    rootPackage = JSON.parse(
+      fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8')
+    );
+  } catch (err) {
+    // Ignore if not found
+  }
+
+  // Get git info
+  let gitBranch = 'unknown';
+  let gitCommit = 'unknown';
+  let recentCommits = [];
+
+  try {
+    gitBranch = execSync('git branch --show-current', {
+      cwd: rootDir,
+      encoding: 'utf8'
+    }).trim();
+    gitCommit = execSync('git rev-parse --short HEAD', {
+      cwd: rootDir,
+      encoding: 'utf8'
+    }).trim();
+
+    // Get recent commits (last 5)
+    const commitLog = execSync('git log --oneline -5 2>/dev/null', {
+      cwd: rootDir,
+      encoding: 'utf8'
+    }).trim();
+    recentCommits = commitLog.split('\n').filter(Boolean);
+  } catch (err) {
+    // Ignore if git not available
+  }
+
+  // Get AgileFlow status info
+  let activeStories = [];
+  let wipCount = 0;
+  let blockedCount = 0;
+  let activeEpics = [];
+
+  try {
+    const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
+    if (fs.existsSync(statusPath)) {
+      const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+
+      // Get active stories
+      if (status.stories) {
+        Object.entries(status.stories).forEach(([id, story]) => {
+          if (story.status === 'in_progress') {
+            activeStories.push({ id, title: story.title, owner: story.owner });
+            wipCount++;
+          }
+          if (story.status === 'blocked') {
+            blockedCount++;
+          }
+        });
+      }
+
+      // Get active epics
+      if (status.epics) {
+        Object.entries(status.epics).forEach(([id, epic]) => {
+          if (epic.status !== 'complete') {
+            activeEpics.push({ id, title: epic.title });
+          }
+        });
+      }
+    }
+  } catch (err) {
+    // Ignore if status.json not available
+  }
+
+  return {
+    project: {
+      name: cliPackage.name || rootPackage.name || 'AgileFlow',
+      version: cliPackage.version || rootPackage.version || 'unknown',
+      description: cliPackage.description || rootPackage.description || '',
+      rootDir: rootDir,
+    },
+    git: {
+      branch: gitBranch,
+      commit: gitCommit,
+      recentCommits: recentCommits,
+    },
+    agileflow: {
+      activeStories: activeStories,
+      wipCount: wipCount,
+      blockedCount: blockedCount,
+      activeEpics: activeEpics,
+    },
+    system: {
+      node: process.version,
+      platform: os.platform(),
+      arch: os.arch(),
+      hostname: os.hostname(),
+      user: os.userInfo().username,
+    },
+    timestamp: new Date().toISOString(),
+  };
+}
+
+function formatOutput(info, asJson = false, compact = false) {
+  if (asJson) {
+    return JSON.stringify(info, null, 2);
+  }
+
+  if (compact) {
+    // Minimal output for status line
+    const story = info.agileflow.activeStories[0];
+    const storyStr = story ? `${story.id}: ${story.title.substring(0, 30)}` : 'No active story';
+    return `[${info.git.branch}] ${storyStr} | WIP: ${info.agileflow.wipCount}`;
+  }
+
+  // ANSI colors (including brand color #e8683a as RGB)
+  const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    red: '\x1b[31m',
+    brand: '\x1b[38;2;232;104;58m', // #e8683a - AgileFlow brand orange
+  };
+
+  // Beautiful compact colorful format
+  const lines = [];
+
+  // Header line with project info (brand color name, dim version, colored branch)
+  const branchColor = info.git.branch === 'main' ? c.green : c.cyan;
+  lines.push(`${c.brand}${c.bold}${info.project.name}${c.reset} ${c.dim}v${info.project.version}${c.reset} | ${branchColor}${info.git.branch}${c.reset} ${c.dim}(${info.git.commit})${c.reset}`);
+
+  // Status line (yellow WIP, red blocked)
+  const wipColor = info.agileflow.wipCount > 0 ? c.yellow : c.dim;
+  let statusLine = info.agileflow.wipCount > 0
+    ? `${wipColor}WIP: ${info.agileflow.wipCount}${c.reset}`
+    : `${c.dim}No active work${c.reset}`;
+  if (info.agileflow.blockedCount > 0) {
+    statusLine += ` | ${c.red}Blocked: ${info.agileflow.blockedCount}${c.reset}`;
+  }
+  lines.push(statusLine);
+
+  // Active story (if any) - just the first one (blue label)
+  if (info.agileflow.activeStories.length > 0) {
+    const story = info.agileflow.activeStories[0];
+    lines.push(`${c.blue}Current:${c.reset} ${story.id} - ${story.title}`);
+  }
+
+  // Last commit (just one, dim)
+  if (info.git.recentCommits.length > 0) {
+    lines.push(`${c.dim}Last: ${info.git.recentCommits[0]}${c.reset}`);
+  }
+
+  return lines.join('\n');
+}
+
+// Main execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const asJson = args.includes('--json');
+  const compact = args.includes('--compact');
+
+  try {
+    const info = getProjectInfo();
+    console.log(formatOutput(info, asJson, compact));
+    process.exit(0);
+  } catch (err) {
+    console.error('Error getting environment info:', err.message);
+    process.exit(1);
+  }
+}
+
+// Export for use as module
+module.exports = { getProjectInfo, formatOutput };

package/scripts/obtain-context.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+/**
+ * obtain-context.js
+ *
+ * Gathers all project context in a single execution for any AgileFlow command or agent.
+ * Optionally registers the command/agent for PreCompact context preservation.
+ * Outputs structured summary to reduce tool calls and startup time.
+ *
+ * Usage:
+ *   node scripts/obtain-context.js              # Just gather context
+ *   node scripts/obtain-context.js babysit      # Gather + register 'babysit'
+ *   node scripts/obtain-context.js mentor       # Gather + register 'mentor'
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Optional: Register command for PreCompact context preservation
+const commandName = process.argv[2];
+if (commandName) {
+  const sessionStatePath = 'docs/09-agents/session-state.json';
+  if (fs.existsSync(sessionStatePath)) {
+    try {
+      const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+      state.active_command = { name: commandName, activated_at: new Date().toISOString(), state: {} };
+      fs.writeFileSync(sessionStatePath, JSON.stringify(state, null, 2) + '\n');
+    } catch (e) {
+      // Silently continue if session state can't be updated
+    }
+  }
+}
+
+// ANSI colors
+const C = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+};
+
+function safeRead(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function safeReadJSON(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function safeLs(dirPath) {
+  try {
+    return fs.readdirSync(dirPath);
+  } catch {
+    return [];
+  }
+}
+
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function section(title) {
+  console.log(`\n${C.cyan}${C.bold}═══ ${title} ═══${C.reset}`);
+}
+
+function subsection(title) {
+  console.log(`${C.dim}───${C.reset} ${title}`);
+}
+
+// ============================================
+// MAIN CONTEXT GATHERING
+// ============================================
+
+const title = commandName ? `AgileFlow Context [${commandName}]` : 'AgileFlow Context';
+console.log(`${C.magenta}${C.bold}${title}${C.reset}`);
+console.log(`${C.dim}Generated: ${new Date().toISOString()}${C.reset}`);
+
+// 1. GIT STATUS
+section('Git Status');
+const branch = safeExec('git branch --show-current') || 'unknown';
+const status = safeExec('git status --short') || '';
+const statusLines = status.split('\n').filter(Boolean);
+const lastCommit = safeExec('git log -1 --format="%h %s"') || 'no commits';
+
+console.log(`Branch: ${C.green}${branch}${C.reset}`);
+console.log(`Last commit: ${C.dim}${lastCommit}${C.reset}`);
+if (statusLines.length > 0) {
+  console.log(`Uncommitted: ${C.yellow}${statusLines.length} file(s)${C.reset}`);
+  statusLines.slice(0, 10).forEach(line => console.log(`  ${C.dim}${line}${C.reset}`));
+  if (statusLines.length > 10) console.log(`  ${C.dim}... and ${statusLines.length - 10} more${C.reset}`);
+} else {
+  console.log(`Uncommitted: ${C.green}clean${C.reset}`);
+}
+
+// 2. STATUS.JSON - Stories & Epics
+section('Stories & Epics');
+const statusJson = safeReadJSON('docs/09-agents/status.json');
+if (statusJson) {
+  // Epics summary
+  const epics = statusJson.epics || {};
+  const epicList = Object.entries(epics);
+  if (epicList.length > 0) {
+    subsection('Epics');
+    epicList.forEach(([id, epic]) => {
+      const statusColor = epic.status === 'complete' ? C.green : epic.status === 'active' ? C.yellow : C.dim;
+      console.log(`  ${id}: ${epic.title} ${statusColor}[${epic.status}]${C.reset}`);
+    });
+  }
+
+  // Stories summary by status
+  const stories = statusJson.stories || {};
+  const storyList = Object.entries(stories);
+  const byStatus = {};
+  storyList.forEach(([id, story]) => {
+    const s = story.status || 'unknown';
+    if (!byStatus[s]) byStatus[s] = [];
+    byStatus[s].push({ id, ...story });
+  });
+
+  // Priority order for display
+  const statusOrder = ['in-progress', 'ready', 'blocked', 'draft', 'in-review', 'done'];
+
+  subsection('Stories by Status');
+  statusOrder.forEach(status => {
+    if (byStatus[status] && byStatus[status].length > 0) {
+      const color = status === 'in-progress' ? C.yellow :
+                    status === 'ready' ? C.green :
+                    status === 'blocked' ? C.red :
+                    status === 'done' ? C.dim : C.reset;
+      console.log(`  ${color}${status}${C.reset}: ${byStatus[status].length}`);
+      byStatus[status].slice(0, 5).forEach(story => {
+        console.log(`    ${C.dim}${story.id}: ${story.title}${C.reset}`);
+      });
+      if (byStatus[status].length > 5) {
+        console.log(`    ${C.dim}... and ${byStatus[status].length - 5} more${C.reset}`);
+      }
+    }
+  });
+
+  // Show READY stories prominently (these are actionable)
+  if (byStatus['ready'] && byStatus['ready'].length > 0) {
+    subsection(`${C.green}⭐ Ready to Implement${C.reset}`);
+    byStatus['ready'].forEach(story => {
+      console.log(`  ${story.id}: ${story.title} (${story.epic || 'no epic'})`);
+    });
+  }
+} else {
+  console.log(`${C.dim}No status.json found${C.reset}`);
+}
+
+// 3. SESSION STATE
+section('Session State');
+const sessionState = safeReadJSON('docs/09-agents/session-state.json');
+if (sessionState) {
+  const current = sessionState.current_session;
+  if (current && current.started_at) {
+    const started = new Date(current.started_at);
+    const duration = Math.round((Date.now() - started.getTime()) / 60000);
+    console.log(`Active session: ${C.green}${duration} min${C.reset}`);
+    if (current.current_story) {
+      console.log(`Working on: ${C.yellow}${current.current_story}${C.reset}`);
+    }
+  } else {
+    console.log(`${C.dim}No active session${C.reset}`);
+  }
+
+  const last = sessionState.last_session;
+  if (last && last.ended_at) {
+    console.log(`Last session: ${C.dim}${last.ended_at} (${last.duration_minutes || '?'} min)${C.reset}`);
+    if (last.summary) console.log(`  Summary: ${C.dim}${last.summary}${C.reset}`);
+  }
+
+  // Active command (for context preservation)
+  if (sessionState.active_command) {
+    console.log(`Active command: ${C.cyan}${sessionState.active_command.name}${C.reset}`);
+  }
+} else {
+  console.log(`${C.dim}No session-state.json found${C.reset}`);
+}
+
+// 4. DOCS STRUCTURE
+section('Documentation');
+const docsDir = 'docs';
+const docFolders = safeLs(docsDir).filter(f => {
+  try {
+    return fs.statSync(path.join(docsDir, f)).isDirectory();
+  } catch {
+    return false;
+  }
+});
+
+if (docFolders.length > 0) {
+  docFolders.forEach(folder => {
+    const folderPath = path.join(docsDir, folder);
+    const files = safeLs(folderPath);
+    const mdFiles = files.filter(f => f.endsWith('.md'));
+    const jsonFiles = files.filter(f => f.endsWith('.json') || f.endsWith('.jsonl'));
+
+    let info = [];
+    if (mdFiles.length > 0) info.push(`${mdFiles.length} md`);
+    if (jsonFiles.length > 0) info.push(`${jsonFiles.length} json`);
+
+    console.log(`  ${C.dim}${folder}/${C.reset} ${info.length > 0 ? `(${info.join(', ')})` : ''}`);
+  });
+}
+
+// 5. RESEARCH NOTES
+section('Research Notes');
+const researchDir = 'docs/10-research';
+const researchFiles = safeLs(researchDir).filter(f => f.endsWith('.md') && f !== 'README.md');
+if (researchFiles.length > 0) {
+  // Sort by date (filename starts with YYYYMMDD)
+  researchFiles.sort().reverse();
+  researchFiles.slice(0, 5).forEach(file => {
+    console.log(`  ${C.dim}${file}${C.reset}`);
+  });
+  if (researchFiles.length > 5) {
+    console.log(`  ${C.dim}... and ${researchFiles.length - 5} more${C.reset}`);
+  }
+} else {
+  console.log(`${C.dim}No research notes${C.reset}`);
+}
+
+// 6. BUS MESSAGES (last 5)
+section('Recent Agent Messages');
+const busPath = 'docs/09-agents/bus/log.jsonl';
+const busContent = safeRead(busPath);
+if (busContent) {
+  const lines = busContent.trim().split('\n').filter(Boolean);
+  const recent = lines.slice(-5);
+  if (recent.length > 0) {
+    recent.forEach(line => {
+      try {
+        const msg = JSON.parse(line);
+        const time = msg.timestamp ? new Date(msg.timestamp).toLocaleTimeString() : '?';
+        console.log(`  ${C.dim}[${time}]${C.reset} ${msg.from || '?'}: ${msg.type || msg.message || '?'}`);
+      } catch {
+        console.log(`  ${C.dim}${line.substring(0, 80)}...${C.reset}`);
+      }
+    });
+  } else {
+    console.log(`${C.dim}No messages${C.reset}`);
+  }
+} else {
+  console.log(`${C.dim}No bus log found${C.reset}`);
+}
+
+// 7. KEY FILES PRESENCE
+section('Key Files');
+const keyFiles = [
+  { path: 'CLAUDE.md', label: 'CLAUDE.md (project instructions)' },
+  { path: 'README.md', label: 'README.md (project overview)' },
+  { path: 'docs/08-project/roadmap.md', label: 'Roadmap' },
+  { path: 'docs/02-practices/README.md', label: 'Practices index' },
+  { path: '.claude/settings.json', label: 'Claude settings' },
+];
+
+keyFiles.forEach(({ path: filePath, label }) => {
+  const exists = fs.existsSync(filePath);
+  const icon = exists ? `${C.green}✓${C.reset}` : `${C.dim}○${C.reset}`;
+  console.log(`  ${icon} ${label}`);
+});
+
+// 8. EPICS FOLDER
+section('Epic Files');
+const epicFiles = safeLs('docs/05-epics').filter(f => f.endsWith('.md') && f !== 'README.md');
+if (epicFiles.length > 0) {
+  epicFiles.forEach(file => {
+    console.log(`  ${C.dim}${file}${C.reset}`);
+  });
+} else {
+  console.log(`${C.dim}No epic files${C.reset}`);
+}
+
+// FOOTER
+console.log(`\n${C.dim}─────────────────────────────────────────${C.reset}`);
+console.log(`${C.dim}Context gathered in single execution. Ready for task selection.${C.reset}\n`);