@polymorphism-tech/morph-spec 1.0.2 → 2.0.0

package/src/commands/sprint-status.js

@@ -0,0 +1,250 @@
+/**
+ * MORPH-SPEC Sprint Status Manager
+ * Updates sprint-status.yaml and shows next story
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function loadSprintStatus(featureName) {
+  const statusPath = path.join(process.cwd(), `.morph/project/outputs/${featureName}/sprint-status.yaml`);
+
+  if (!fs.existsSync(statusPath)) {
+    throw new Error(`Sprint status not found: ${statusPath}\n\n💡 Create a sprint status file first:\n   morph-spec story create ${featureName} STORY-001`);
+  }
+
+  const content = fs.readFileSync(statusPath, 'utf-8');
+  return { path: statusPath, data: yaml.parse(content) };
+}
+
+function saveSprintStatus(statusPath, data) {
+  const content = yaml.stringify(data);
+  fs.writeFileSync(statusPath, content);
+}
+
+function updateMetrics(sprint) {
+  const stories = sprint.stories || [];
+  const metrics = {
+    total_stories: stories.length,
+    ready: stories.filter(s => s.status === 'ready').length,
+    in_progress: stories.filter(s => s.status === 'in_progress').length,
+    ready_for_qa: stories.filter(s => s.status === 'ready_for_qa').length,
+    done: stories.filter(s => s.status === 'done').length,
+  };
+
+  metrics.completion_percent = stories.length > 0
+    ? Math.round((metrics.done / stories.length) * 100)
+    : 0;
+
+  sprint.metrics = metrics;
+  sprint.updated = new Date().toISOString().split('T')[0];
+}
+
+function findStory(sprint, storyId) {
+  return sprint.stories.find(s => s.id === storyId);
+}
+
+function getNextStory(sprint) {
+  // Find first story that is "ready" (not in_progress or done)
+  return sprint.stories.find(s => s.status === 'ready' || s.status === 'pending');
+}
+
+function displayStatus(sprint) {
+  logger.header(`Sprint Status: ${sprint.feature}`);
+  logger.blank();
+  logger.info(`Epic: ${chalk.cyan(sprint.epic)}`);
+  logger.info(`Progress: ${chalk.green(`${sprint.metrics.completion_percent}%`)} (${sprint.metrics.done}/${sprint.metrics.total_stories} stories done)`);
+  logger.blank();
+
+  logger.header('Stories:');
+  sprint.stories.forEach(story => {
+    const statusEmoji = {
+      pending: '⏸️ ',
+      ready: '✅',
+      in_progress: '🔄',
+      ready_for_qa: '👀',
+      done: '✔️ ',
+    }[story.status] || '❓';
+
+    const statusColor = {
+      pending: chalk.dim,
+      ready: chalk.cyan,
+      in_progress: chalk.yellow,
+      ready_for_qa: chalk.magenta,
+      done: chalk.green,
+    }[story.status] || chalk.white;
+
+    logger.dim(`  ${statusEmoji} ${story.id}: ${story.title} ${statusColor(`(${story.status})`)}`);
+  });
+  logger.blank();
+
+  if (sprint.current && sprint.current.story_id) {
+    logger.info(`🎯 Current Focus: ${chalk.cyan(sprint.current.story_id)} (${sprint.current.agent} agent)`);
+  }
+
+  if (sprint.next && sprint.next.story_id) {
+    logger.info(`📋 Next Story: ${chalk.cyan(sprint.next.story_id)}`);
+    logger.dim(`   ${sprint.next.recommendation || 'Ready for development'}`);
+  }
+
+  logger.blank();
+}
+
+// ============================================================================
+// Command Function
+// ============================================================================
+
+export async function sprintStatusCommand(feature, action, storyId, options) {
+  // Default action is 'show'
+  const cmd = action || 'show';
+
+  if (cmd === 'help' || options.help) {
+    logger.header('MORPH-SPEC Sprint Status Manager');
+    logger.blank();
+    logger.info('Usage:');
+    logger.dim('  morph-spec story status <feature> [command] [story-id]');
+    logger.blank();
+    logger.info('Commands:');
+    logger.dim('  show                      Display current sprint status (default)');
+    logger.dim('  start <story-id>          Mark story as in_progress');
+    logger.dim('  qa <story-id>             Mark story as ready_for_qa');
+    logger.dim('  done <story-id>           Mark story as done');
+    logger.dim('  next                      Show next story to work on');
+    logger.blank();
+    logger.info('Examples:');
+    logger.dim('  morph-spec story status scheduled-reports show');
+    logger.dim('  morph-spec story status scheduled-reports start SR-001');
+    logger.dim('  morph-spec story status scheduled-reports qa SR-001');
+    logger.dim('  morph-spec story status scheduled-reports done SR-001');
+    logger.dim('  morph-spec story status scheduled-reports next');
+    logger.blank();
+    return;
+  }
+
+  try {
+    // Load sprint status
+    const { path: statusPath, data: sprint } = loadSprintStatus(feature);
+
+    // Execute command
+    switch (cmd) {
+      case 'show':
+        displayStatus(sprint);
+        break;
+
+      case 'start':
+        if (!storyId) {
+          throw new Error('Story ID required for "start" command');
+        }
+        const storyToStart = findStory(sprint, storyId);
+        if (!storyToStart) {
+          throw new Error(`Story not found: ${storyId}`);
+        }
+
+        const spinner = ora('Updating story status...').start();
+        storyToStart.status = 'in_progress';
+        storyToStart.started = new Date().toISOString().split('T')[0];
+        storyToStart.assigned = 'dev';
+        sprint.current = { story_id: storyId, agent: 'dev', phase: 'implementation' };
+        updateMetrics(sprint);
+        saveSprintStatus(statusPath, sprint);
+        spinner.succeed(`Story ${chalk.cyan(storyId)} marked as IN PROGRESS`);
+        logger.blank();
+        logger.info('💡 Recommendation: Run this story in a FRESH Claude session');
+        logger.dim('   /dev → Implement story → Add Dev Notes');
+        logger.blank();
+        break;
+
+      case 'qa':
+        if (!storyId) {
+          throw new Error('Story ID required for "qa" command');
+        }
+        const storyForQA = findStory(sprint, storyId);
+        if (!storyForQA) {
+          throw new Error(`Story not found: ${storyId}`);
+        }
+
+        const qaSpinner = ora('Updating story status...').start();
+        storyForQA.status = 'ready_for_qa';
+        storyForQA.assigned = 'qa';
+        sprint.current = { story_id: storyId, agent: 'qa', phase: 'review' };
+        updateMetrics(sprint);
+        saveSprintStatus(statusPath, sprint);
+        qaSpinner.succeed(`Story ${chalk.cyan(storyId)} marked as READY FOR QA`);
+        logger.blank();
+        logger.info('💡 Recommendation: QA in a FRESH Claude session');
+        logger.dim('   /qa → Review code → Add QA Notes');
+        logger.blank();
+        break;
+
+      case 'done':
+        if (!storyId) {
+          throw new Error('Story ID required for "done" command');
+        }
+        const storyDone = findStory(sprint, storyId);
+        if (!storyDone) {
+          throw new Error(`Story not found: ${storyId}`);
+        }
+
+        const doneSpinner = ora('Updating story status...').start();
+        storyDone.status = 'done';
+        storyDone.completed = new Date().toISOString().split('T')[0];
+        updateMetrics(sprint);
+
+        // Update next story
+        const nextStory = getNextStory(sprint);
+        if (nextStory) {
+          sprint.next = {
+            story_id: nextStory.id,
+            recommendation: `Story ${nextStory.id} is ready for development`,
+          };
+        } else {
+          sprint.next = null;
+        }
+
+        saveSprintStatus(statusPath, sprint);
+        doneSpinner.succeed(`Story ${chalk.cyan(storyId)} marked as DONE`);
+        logger.blank();
+
+        if (nextStory) {
+          logger.info(`📋 Next Story: ${chalk.cyan(nextStory.id)}`);
+          logger.dim(`   ${nextStory.title}`);
+          logger.blank();
+        } else {
+          logger.success('🎉 All stories completed! Feature ready for final review.');
+          logger.blank();
+        }
+        break;
+
+      case 'next':
+        const next = getNextStory(sprint);
+        if (next) {
+          logger.header('Next Story:');
+          logger.blank();
+          logger.info(`📋 Story ID: ${chalk.cyan(next.id)}`);
+          logger.info(`   Title: ${next.title}`);
+          logger.info(`   File: ${chalk.dim(next.file)}`);
+          logger.info(`   Status: ${next.status}`);
+          logger.blank();
+        } else {
+          logger.success('🎉 No pending stories! Sprint complete.');
+          logger.blank();
+        }
+        break;
+
+      default:
+        throw new Error(`Unknown command: ${cmd}\n   Use --help to see available commands`);
+    }
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}

package/src/commands/state.js

@@ -0,0 +1,333 @@
+/**
+ * MORPH-SPEC State Command
+ * CLI wrapper for state management operations
+ */
+
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import * as StateManager from '../lib/state-manager.js';
+
+// ============================================================================
+// Command Functions
+// ============================================================================
+
+/**
+ * Main state command router
+ */
+export async function stateCommand(action, args, options) {
+  switch (action) {
+    case 'init':
+      await initCommand(options);
+      break;
+
+    case 'get':
+      await getCommand(args[0], options);
+      break;
+
+    case 'set':
+      await setCommand(args[0], args[1], args[2], options);
+      break;
+
+    case 'checkpoint':
+      await checkpointCommand(args[0], args.slice(1).join(' '), options);
+      break;
+
+    case 'list':
+      await listCommand(options);
+      break;
+
+    case 'add-agent':
+      await addAgentCommand(args[0], args[1], options);
+      break;
+
+    case 'remove-agent':
+      await removeAgentCommand(args[0], args[1], options);
+      break;
+
+    case 'mark-output':
+      await markOutputCommand(args[0], args[1], options);
+      break;
+
+    default:
+      logger.error(`Unknown action: ${action}`);
+      logger.blank();
+      logger.info('Available actions:');
+      logger.dim('  init, get, set, checkpoint, list, add-agent, remove-agent, mark-output');
+      logger.blank();
+      logger.dim('Run "morph-spec state --help" for more information');
+      process.exit(1);
+  }
+}
+
+/**
+ * Initialize state file
+ */
+async function initCommand(options) {
+  logger.header('Initialize State');
+  logger.blank();
+
+  try {
+    if (StateManager.stateExists() && !options.force) {
+      logger.warn('State file already exists.');
+      logger.dim('  Use --force to overwrite');
+      logger.blank();
+      return;
+    }
+
+    const spinner = ora('Initializing state.json...').start();
+
+    StateManager.initState({
+      force: options.force,
+      projectName: options.project || '{PROJECT_NAME}',
+      projectType: options.type || 'blazor-server'
+    });
+
+    spinner.succeed('State initialized!');
+    logger.blank();
+    logger.dim(`Location: ${StateManager.getStatePath()}`);
+    logger.blank();
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Get feature state
+ */
+async function getCommand(featureName, options) {
+  if (!featureName) {
+    logger.error('Feature name required');
+    logger.dim('  Usage: morph-spec state get <feature>');
+    process.exit(1);
+  }
+
+  try {
+    const feature = StateManager.getFeature(featureName);
+
+    if (!feature) {
+      logger.error(`Feature '${featureName}' not found`);
+      process.exit(1);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(feature, null, 2));
+    } else {
+      logger.header(`Feature: ${featureName}`);
+      logger.blank();
+      logger.info(`Status: ${chalk.cyan(feature.status)}`);
+      logger.info(`Phase: ${chalk.cyan(feature.phase)}`);
+      logger.info(`Tasks: ${chalk.cyan(`${feature.tasks.completed}/${feature.tasks.total}`)}`);
+      logger.info(`Agents: ${chalk.cyan(feature.activeAgents.join(', ') || 'None')}`);
+      logger.blank();
+    }
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Set feature property
+ */
+async function setCommand(featureName, key, value, options) {
+  if (!featureName || !key || value === undefined) {
+    logger.error('Missing required arguments');
+    logger.dim('  Usage: morph-spec state set <feature> <key> <value>');
+    logger.blank();
+    logger.dim('  Example: morph-spec state set my-feature phase implement');
+    process.exit(1);
+  }
+
+  try {
+    const spinner = ora('Updating state...').start();
+
+    // Parse value automatically (JSON, number, boolean)
+    let parsedValue = value;
+    try {
+      parsedValue = JSON.parse(value);
+    } catch {
+      // Keep as string if not valid JSON
+    }
+
+    StateManager.updateFeature(featureName, key, parsedValue);
+
+    spinner.succeed(`Updated ${chalk.cyan(featureName)}.${chalk.cyan(key)}`);
+    logger.blank();
+    logger.dim(`Value: ${JSON.stringify(parsedValue)}`);
+    logger.blank();
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Add checkpoint
+ */
+async function checkpointCommand(featureName, note, options) {
+  if (!featureName || !note) {
+    logger.error('Missing required arguments');
+    logger.dim('  Usage: morph-spec state checkpoint <feature> "<note>"');
+    logger.blank();
+    logger.dim('  Example: morph-spec state checkpoint my-feature "Completed T001-T003"');
+    process.exit(1);
+  }
+
+  try {
+    const spinner = ora('Creating checkpoint...').start();
+
+    const checkpoint = StateManager.addCheckpoint(featureName, note);
+
+    spinner.succeed(`Checkpoint registered for ${chalk.cyan(featureName)}`);
+    logger.blank();
+    logger.dim(`  ${checkpoint.note}`);
+    logger.dim(`  Phase: ${checkpoint.phase}`);
+    logger.dim(`  Tasks completed: ${checkpoint.completedTasks}`);
+    logger.blank();
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * List all features
+ */
+async function listCommand(options) {
+  logger.header('MORPH-SPEC Project Status');
+  logger.blank();
+
+  try {
+    const summary = StateManager.getSummary();
+    const features = StateManager.listFeatures();
+
+    // Project info
+    logger.info(`Project: ${chalk.cyan(summary.project.name)}`);
+    logger.info(`Type: ${chalk.cyan(summary.project.type)}`);
+    logger.blank();
+
+    if (features.length === 0) {
+      logger.warn('No features found');
+      logger.blank();
+      return;
+    }
+
+    // Features table
+    logger.header('Features:');
+    logger.blank();
+
+    features.forEach(([name, feature]) => {
+      const statusEmoji = {
+        draft: '📝',
+        in_review: '👀',
+        approved: '✅',
+        in_progress: '🚧',
+        done: '✔️',
+        archived: '📦'
+      }[feature.status] || '❓';
+
+      const progress = feature.tasks.total > 0
+        ? `${feature.tasks.completed}/${feature.tasks.total}`
+        : '0/0';
+
+      logger.info(`${statusEmoji}  ${chalk.bright(name)}`);
+      logger.dim(`   Phase: ${feature.phase.padEnd(16)} │ Tasks: ${progress}`);
+      logger.dim(`   Agents: ${feature.activeAgents.slice(0, 5).join(', ') || 'None'}`);
+      logger.blank();
+    });
+
+    // Summary
+    logger.header('Summary:');
+    logger.info(`Total Features: ${chalk.cyan(summary.metadata.totalFeatures)}`);
+    logger.info(`Completed: ${chalk.cyan(summary.metadata.completedFeatures)}`);
+    logger.info(`Estimated Cost: ${chalk.cyan(`$${summary.metadata.totalCostEstimated.toFixed(2)}/month`)}`);
+    logger.blank();
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Add agent to feature
+ */
+async function addAgentCommand(featureName, agentId, options) {
+  if (!featureName || !agentId) {
+    logger.error('Missing required arguments');
+    logger.dim('  Usage: morph-spec state add-agent <feature> <agent-id>');
+    process.exit(1);
+  }
+
+  try {
+    const added = StateManager.addAgent(featureName, agentId);
+
+    if (added) {
+      logger.success(`Agent '${chalk.cyan(agentId)}' added to ${chalk.cyan(featureName)}`);
+    } else {
+      logger.warn(`Agent '${agentId}' already active`);
+    }
+    logger.blank();
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Remove agent from feature
+ */
+async function removeAgentCommand(featureName, agentId, options) {
+  if (!featureName || !agentId) {
+    logger.error('Missing required arguments');
+    logger.dim('  Usage: morph-spec state remove-agent <feature> <agent-id>');
+    process.exit(1);
+  }
+
+  try {
+    const removed = StateManager.removeAgent(featureName, agentId);
+
+    if (removed) {
+      logger.success(`Agent '${chalk.cyan(agentId)}' removed from ${chalk.cyan(featureName)}`);
+    } else {
+      logger.warn(`Agent '${agentId}' not found`);
+    }
+    logger.blank();
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Mark output as created
+ */
+async function markOutputCommand(featureName, outputType, options) {
+  if (!featureName || !outputType) {
+    logger.error('Missing required arguments');
+    logger.dim('  Usage: morph-spec state mark-output <feature> <output-type>');
+    logger.blank();
+    logger.dim('  Valid types: proposal, spec, contracts, tasks, decisions, recap');
+    logger.dim('               uiDesignSystem, uiMockups, uiComponents, uiFlows');
+    process.exit(1);
+  }
+
+  try {
+    StateManager.markOutput(featureName, outputType);
+
+    logger.success(`Output '${chalk.cyan(outputType)}' marked as created for ${chalk.cyan(featureName)}`);
+    logger.blank();
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}