claude-autopm 1.25.0 → 1.27.0

package/autopm/.claude/lib/cli-parser.js

@@ -0,0 +1,148 @@
+/**
+ * CLI Parser for PM Commands
+ *
+ * Provides unified command-line argument parsing with --local flag support
+ * across all PM commands using yargs best practices.
+ *
+ * Following Context7 yargs documentation patterns:
+ * - .boolean() for boolean flags
+ * - .alias() for short flags
+ * - .parse() for argument processing
+ */
+
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Read project configuration to determine default provider
+ * @returns {string} Default provider ('github', 'azure', or 'local')
+ */
+function getDefaultProvider() {
+  try {
+    const configPath = path.join(process.cwd(), '.claude/config.json');
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      return config.provider || 'github';
+    }
+  } catch (error) {
+    // Silently fall back to github if config cannot be read
+  }
+  return 'github';
+}
+
+/**
+ * Parse PM command arguments with --local flag support
+ *
+ * @param {string[]} args - Command arguments (usually process.argv)
+ * @returns {object} Parsed arguments with mode determined
+ *
+ * @example
+ * // Local mode
+ * parsePMCommand(['prd-new', 'feature', '--local'])
+ * // => { _: ['prd-new', 'feature'], local: true, mode: 'local' }
+ *
+ * @example
+ * // Remote mode (from config)
+ * parsePMCommand(['prd-list'])
+ * // => { _: ['prd-list'], local: false, mode: 'github' }
+ */
+function parsePMCommand(args) {
+  let failureMessage = null;
+
+  // Don't use hideBin if args are already clean (for testing)
+  const cleanArgs = Array.isArray(args) && !args[0]?.includes('node') ? args : hideBin(args);
+
+  const argv = yargs(cleanArgs)
+    .option('local', {
+      alias: 'l',
+      type: 'boolean',
+      describe: 'Use local mode (offline, no GitHub/Azure)',
+      default: false
+    })
+    .option('github', {
+      type: 'boolean',
+      describe: 'Use GitHub provider',
+      default: false
+    })
+    .option('azure', {
+      type: 'boolean',
+      describe: 'Use Azure DevOps provider',
+      default: false
+    })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'Enable verbose output',
+      default: false
+    })
+    .option('force', {
+      alias: 'f',
+      type: 'boolean',
+      describe: 'Force operation',
+      default: false
+    })
+    .option('output', {
+      alias: 'o',
+      type: 'string',
+      describe: 'Output format (json, text)',
+      choices: ['json', 'text']
+    })
+    .check((argv) => {
+      // Validate: cannot use --local with --github or --azure
+      if (argv.local && (argv.github || argv.azure)) {
+        throw new Error('Cannot use both --local and remote provider (--github or --azure)');
+      }
+      return true;
+    })
+    .fail((msg, err) => {
+      // Capture failure for throwing
+      failureMessage = msg || (err && err.message) || 'Unknown error';
+    })
+    .exitProcess(false)  // Don't call process.exit on error (for testing)
+    .parse();
+
+  // Throw error if validation failed
+  if (failureMessage) {
+    throw new Error(failureMessage);
+  }
+
+  // Determine mode based on flags and config
+  if (argv.local) {
+    argv.mode = 'local';
+  } else if (argv.github) {
+    argv.mode = 'github';
+  } else if (argv.azure) {
+    argv.mode = 'azure';
+  } else {
+    // Read from config
+    argv.mode = getDefaultProvider();
+  }
+
+  return argv;
+}
+
+/**
+ * Get help text for CLI parser
+ * Used for testing help text includes --local flag
+ *
+ * @returns {Promise<string>} Help text
+ */
+async function getHelpText() {
+  const parser = yargs([])
+    .option('local', {
+      alias: 'l',
+      type: 'boolean',
+      describe: 'Use local mode (offline, no GitHub/Azure)',
+      default: false
+    });
+
+  return await parser.getHelp();
+}
+
+module.exports = {
+  parsePMCommand,
+  getHelpText,
+  getDefaultProvider
+};

package/autopm/.claude/lib/commands/pm/epicStatus.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Epic Status - Complete epic progress tracking
+ *
+ * Replaces epic-status.sh with clean, testable JavaScript
+ * - Counts tasks by status (completed/in-progress/pending)
+ * - Calculates progress percentage
+ * - Shows progress bar visualization
+ * - Provides sub-epic breakdown
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse frontmatter from markdown file
+ */
+function parseFrontmatter(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    let inFrontmatter = false;
+    let frontmatterCount = 0;
+    const frontmatter = {};
+
+    for (const line of lines) {
+      if (line === '---') {
+        frontmatterCount++;
+        if (frontmatterCount === 1) {
+          inFrontmatter = true;
+          continue;
+        } else if (frontmatterCount === 2) {
+          break;
+        }
+      }
+
+      if (inFrontmatter) {
+        const match = line.match(/^(\w+):\s*(.+)$/);
+        if (match) {
+          const [, key, value] = match;
+          frontmatter[key] = value;
+        }
+      }
+    }
+
+    return frontmatter;
+  } catch (error) {
+    return {};
+  }
+}
+
+/**
+ * Find all task files in directory
+ */
+function findTaskFiles(dir, maxDepth = 2, currentDepth = 0) {
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    return [];
+  }
+
+  if (currentDepth >= maxDepth) {
+    return [];
+  }
+
+  const files = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isFile() && /^\d+\.md$/.test(entry.name)) {
+      files.push(fullPath);
+    } else if (entry.isDirectory() && currentDepth < maxDepth - 1) {
+      files.push(...findTaskFiles(fullPath, maxDepth, currentDepth + 1));
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Count tasks by status
+ */
+function countTasksByStatus(taskFiles) {
+  const counts = {
+    completed: 0,
+    in_progress: 0,
+    pending: 0,
+    total: taskFiles.length
+  };
+
+  for (const taskFile of taskFiles) {
+    const frontmatter = parseFrontmatter(taskFile);
+    const status = frontmatter.status || '';
+
+    if (status === 'completed') {
+      counts.completed++;
+    } else if (status === 'in-progress' || status === 'in_progress') {
+      counts.in_progress++;
+    } else {
+      counts.pending++;
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * Generate progress bar
+ */
+function generateProgressBar(percentage, length = 50) {
+  const filled = Math.round((percentage * length) / 100);
+  const empty = length - filled;
+
+  const bar = '='.repeat(filled) + '-'.repeat(empty);
+  return `[${bar}] ${percentage}%`;
+}
+
+/**
+ * Get sub-epic breakdown
+ */
+function getSubEpicBreakdown(epicDir) {
+  const breakdown = [];
+
+  if (!fs.existsSync(epicDir)) {
+    return breakdown;
+  }
+
+  const entries = fs.readdirSync(epicDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const subDir = path.join(epicDir, entry.name);
+      const taskFiles = findTaskFiles(subDir, 1);
+
+      if (taskFiles.length > 0) {
+        const counts = countTasksByStatus(taskFiles);
+        breakdown.push({
+          name: entry.name,
+          total: counts.total,
+          completed: counts.completed
+        });
+      }
+    }
+  }
+
+  return breakdown;
+}
+
+/**
+ * Format epic status report
+ */
+function formatEpicStatus(epicName, epicDir) {
+  // Find all tasks
+  const taskFiles = findTaskFiles(epicDir);
+  const counts = countTasksByStatus(taskFiles);
+
+  // Calculate progress
+  const progress = counts.total > 0
+    ? Math.round((counts.completed * 100) / counts.total)
+    : 0;
+
+  // Build report
+  const lines = [];
+  lines.push(`Epic: ${epicName}`);
+  lines.push('='.repeat(20 + epicName.length));
+  lines.push('');
+  lines.push(`Total tasks:     ${counts.total}`);
+  lines.push(`Completed:       ${counts.completed} (${progress}%)`);
+  lines.push(`In Progress:     ${counts.in_progress}`);
+  lines.push(`Pending:         ${counts.pending}`);
+  lines.push('');
+
+  // Progress bar
+  if (counts.total > 0) {
+    lines.push(`Progress: ${generateProgressBar(progress)}`);
+    lines.push('');
+  }
+
+  // Sub-epic breakdown
+  const breakdown = getSubEpicBreakdown(epicDir);
+  if (breakdown.length > 0) {
+    lines.push('Sub-Epic Breakdown:');
+    lines.push('-'.repeat(19));
+
+    for (const sub of breakdown) {
+      const name = sub.name.padEnd(30);
+      lines.push(`  ${name} ${sub.total.toString().padStart(3)} tasks (${sub.completed} completed)`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * List available epics
+ */
+function listAvailableEpics(epicsDir) {
+  if (!fs.existsSync(epicsDir)) {
+    return [];
+  }
+
+  const entries = fs.readdirSync(epicsDir, { withFileTypes: true });
+  return entries
+    .filter(entry => entry.isDirectory())
+    .map(entry => entry.name);
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = process.argv.slice(2);
+  const epicName = args[0];
+
+  const epicsDir = path.join(process.cwd(), '.claude/epics');
+
+  if (!epicName) {
+    console.log('Usage: epicStatus.js <epic-name>');
+    console.log('');
+    console.log('Available epics:');
+
+    const epics = listAvailableEpics(epicsDir);
+    if (epics.length > 0) {
+      epics.forEach(epic => console.log(`  ${epic}`));
+    } else {
+      console.log('  No epics found');
+    }
+
+    process.exit(1);
+  }
+
+  const epicDir = path.join(epicsDir, epicName);
+
+  if (!fs.existsSync(epicDir)) {
+    console.error(`Error: Epic '${epicName}' not found`);
+    console.log('');
+    console.log('Available epics:');
+
+    const epics = listAvailableEpics(epicsDir);
+    epics.forEach(epic => console.log(`  ${epic}`));
+
+    process.exit(1);
+  }
+
+  // Generate and display status
+  const status = formatEpicStatus(epicName, epicDir);
+  console.log(status);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parseFrontmatter,
+  findTaskFiles,
+  countTasksByStatus,
+  generateProgressBar,
+  getSubEpicBreakdown,
+  formatEpicStatus,
+  listAvailableEpics
+};

package/autopm/.claude/lib/dependency-analyzer.js

@@ -0,0 +1,157 @@
+/**
+ * Dependency Analyzer
+ *
+ * Analyzes task dependencies and validates dependency graphs.
+ * Detects circular dependencies and builds execution order.
+ *
+ * Usage:
+ *   const { analyzeDependencies } = require('./dependency-analyzer');
+ *
+ *   const result = analyzeDependencies(tasks);
+ *   if (result.hasCircularDependencies) {
+ *     console.error('Circular dependencies found:', result.cycles);
+ *   }
+ */
+
+const { generateShortTaskId } = require('./task-utils');
+
+/**
+ * Analyze task dependencies
+ *
+ * @param {Array} tasks - Array of task objects with dependencies
+ * @returns {Object} Analysis result with cycles, order, and validation
+ */
+function analyzeDependencies(tasks) {
+  const graph = buildDependencyGraph(tasks);
+  const cycles = detectCircularDependencies(graph);
+  const order = cycles.length === 0 ? topologicalSort(graph) : [];
+
+  return {
+    hasCircularDependencies: cycles.length > 0,
+    cycles,
+    executionOrder: order,
+    isValid: cycles.length === 0
+  };
+}
+
+/**
+ * Build dependency graph from tasks
+ *
+ * @param {Array} tasks - Array of task objects
+ * @returns {Map} Dependency graph (task -> dependencies)
+ */
+function buildDependencyGraph(tasks) {
+  const graph = new Map();
+
+  tasks.forEach((task, index) => {
+    const taskId = generateShortTaskId(index + 1);
+    const dependencies = task.dependencies || [];
+
+    graph.set(taskId, dependencies);
+  });
+
+  return graph;
+}
+
+/**
+ * Detect circular dependencies using DFS
+ *
+ * @param {Map} graph - Dependency graph
+ * @returns {Array} Array of circular dependency cycles
+ */
+function detectCircularDependencies(graph) {
+  const visited = new Set();
+  const recursionStack = new Set();
+  const cycles = [];
+
+  function dfs(node, path = []) {
+    if (recursionStack.has(node)) {
+      // Found a cycle
+      const cycleStart = path.indexOf(node);
+      cycles.push(path.slice(cycleStart));
+      return;
+    }
+
+    if (visited.has(node)) {
+      return;
+    }
+
+    visited.add(node);
+    recursionStack.add(node);
+    path.push(node);
+
+    const dependencies = graph.get(node) || [];
+    for (const dep of dependencies) {
+      dfs(dep, path);
+    }
+
+    path.pop(); // Cleanup: remove node from path after exploring
+    recursionStack.delete(node);
+  }
+
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node);
+    }
+  }
+
+  return cycles;
+}
+
+/**
+ * Topological sort for task execution order
+ *
+ * @param {Map} graph - Dependency graph
+ * @returns {Array} Ordered array of task IDs
+ */
+function topologicalSort(graph) {
+  const inDegree = new Map();
+  const order = [];
+
+  // Initialize in-degree for all nodes
+  for (const node of graph.keys()) {
+    inDegree.set(node, 0);
+  }
+
+  // Calculate in-degree
+  for (const deps of graph.values()) {
+    for (const dep of deps) {
+      if (graph.has(dep)) {
+        inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+      }
+    }
+  }
+
+  // Queue nodes with in-degree 0
+  const queue = [];
+  for (const [node, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(node);
+    }
+  }
+
+  // Process queue
+  while (queue.length > 0) {
+    const node = queue.shift();
+    order.push(node);
+
+    const dependencies = graph.get(node) || [];
+    for (const dep of dependencies) {
+      const newDegree = inDegree.get(dep) - 1;
+      inDegree.set(dep, newDegree);
+
+      if (newDegree === 0) {
+        queue.push(dep);
+      }
+    }
+  }
+
+  return order;
+}
+
+module.exports = {
+  analyzeDependencies,
+  buildDependencyGraph,
+  detectCircularDependencies,
+  topologicalSort
+};