@polymorphism-tech/morph-spec 4.7.2 → 4.8.4

package/src/commands/project/install-plugin-cmd.js

@@ -0,0 +1,28 @@
+// src/commands/project/install-plugin-cmd.js
+import { installPlugin } from '../../scripts/install-plugin.js';
+import { logger } from '../../utils/logger.js';
+
+export async function installPluginCommand(pluginName, _options) {
+  if (!pluginName) {
+    logger.error('Plugin name required. Usage: morph-spec install-plugin <name>');
+    logger.dim('  Available: superpowers, context7');
+    process.exit(1);
+  }
+  try {
+    const result = await installPlugin(pluginName);
+    if (result.alreadyInstalled) {
+      logger.dim(`  ✓ ${pluginName} already installed (${result.version})`);
+    } else {
+      logger.success(`  ✓ ${pluginName} installed (${result.version})`);
+      logger.dim('  Restart Claude Code to activate.');
+    }
+  } catch (err) {
+    logger.error(`Failed to install plugin "${pluginName}": ${err.message}`);
+    logger.blank();
+    logger.warn('Manual installation:');
+    logger.dim('  1. Claude Code → Settings (Cmd/Ctrl+,) → Extensions');
+    logger.dim(`  2. Browse → search "${pluginName}" → Install`);
+    logger.dim('  3. Restart Claude Code');
+    process.exit(1);
+  }
+}

package/src/commands/project/setup-infra-cmd.js

@@ -0,0 +1,12 @@
+import { setupInfra } from '../../scripts/setup-infra.js';
+import { logger } from '../../utils/logger.js';
+
+export async function setupInfraCommand(options) {
+  const targetPath = options.path || process.cwd();
+  try {
+    await setupInfra(targetPath);
+  } catch (err) {
+    logger.error(`setup-infra failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/project/tutorial.js

@@ -0,0 +1,115 @@
+/**
+ * Tutorial Command
+ *
+ * Prints the MORPH-SPEC workflow pipeline and getting-started steps.
+ * Pure stdout — no file I/O, no network, no side effects.
+ *
+ * Usage: morph-spec tutorial
+ */
+
+import chalk from 'chalk';
+
+const PHASES = [
+  {
+    label: 'FASE 0 · PROPOSAL',
+    what: 'Captures user story + acceptance criteria.',
+    produces: '0-proposal/proposal.md',
+    how: '/morph-proposal <feature>  (in Claude Code)',
+  },
+  {
+    label: 'FASE 1 · SETUP',
+    what: 'Detects stack, activates agents, confirms environment.',
+    produces: '.morph/state.json initialized',
+    how: 'auto-triggered inside /morph-proposal',
+  },
+  {
+    label: 'FASE 1.5 · UI/UX',
+    what: 'Design system, mockups, component specs, user flows.',
+    produces: '2-ui/{design-system,mockups,components,flows}.md',
+    how: '/phase-uiux <feature>  (in Claude Code)',
+    optional: true,
+  },
+  {
+    label: 'FASE 2 · DESIGN',
+    what: 'Technical spec + C# contracts + architecture decisions.',
+    produces: '1-design/{spec.md, contracts-level{N}.cs, decisions.md}',
+    how: '/phase-design <feature>  (in Claude Code)',
+  },
+  {
+    label: 'FASE 3 · CLARIFY',
+    what: 'Reviews spec for ambiguities, adds edge cases.',
+    produces: '1-design/spec.md (updated with clarifications)',
+    how: '/phase-clarify <feature>  (in Claude Code)',
+  },
+  {
+    label: 'FASE 4 · TASKS',
+    what: 'Atomic task breakdown, DDD-aware.',
+    produces: '3-tasks/tasks.md',
+    how: 'auto-generated during /morph-proposal, or /phase-tasks <feature>',
+  },
+  {
+    label: 'FASE 5 · IMPLEMENT',
+    what: 'Code implementation with checkpoints every 3 tasks.',
+    produces: '4-implement/recap.md + source code',
+    how: '/morph-apply <feature>  (in Claude Code)',
+  },
+  {
+    label: 'FASE 6 · SYNC',
+    what: 'Syncs decisions back to project standards.',
+    produces: '.morph/framework/standards/ (updated)',
+    how: 'morph-spec sync <feature>',
+    optional: true,
+  },
+];
+
+const SEP = chalk.dim('─'.repeat(58));
+
+export function tutorialCommand() {
+  console.log('');
+  console.log(chalk.cyan.bold('  MORPH-SPEC Workflow Tutorial'));
+  console.log(SEP);
+  console.log('');
+  console.log(
+    chalk.white(
+      '  MORPH-SPEC is spec-first: every feature goes through phases\n' +
+      '  before any code is written. Each phase produces structured\n' +
+      '  outputs that feed the next.'
+    )
+  );
+  console.log('');
+  console.log(SEP);
+  console.log(chalk.cyan.bold('  PIPELINE'));
+  console.log(SEP);
+  console.log('');
+  console.log(
+    chalk.white('  proposal → setup → ') +
+    chalk.dim('[uiux]') +
+    chalk.white(' → design → clarify → tasks → implement → ') +
+    chalk.dim('[sync]')
+  );
+  console.log(chalk.dim('  (phases in brackets are optional)'));
+  console.log('');
+
+  for (const phase of PHASES) {
+    console.log(SEP);
+    const label = phase.optional
+      ? chalk.cyan.bold(`  ${phase.label}`) + chalk.dim('  [optional]')
+      : chalk.cyan.bold(`  ${phase.label}`);
+    console.log(label);
+    console.log(chalk.white(`  What:     ${phase.what}`));
+    console.log(chalk.dim(`  Produces: ${phase.produces}`));
+    console.log(chalk.green(`  How:      ${phase.how}`));
+    console.log('');
+  }
+
+  console.log(SEP);
+  console.log(chalk.cyan.bold('  GETTING STARTED'));
+  console.log(SEP);
+  console.log('');
+  console.log(chalk.white('  1. Open Claude Code in your project'));
+  console.log(chalk.white('  2. Run:  ') + chalk.green('/morph-proposal <your-feature-name>'));
+  console.log(chalk.white('  3. Answer the questions — morph-spec handles the rest'));
+  console.log('');
+  console.log(chalk.dim('  Tip: run `morph-spec doctor` to verify your installation first.'));
+  console.log('');
+}

package/src/commands/state/approve.js

@@ -1,221 +1,213 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory } from '../../core/state/state-manager.js';
-
-/**
- * Approval Commands - Manage approval gates for MORPH workflow
- *
- * Commands:
- * - approve: Mark a gate as approved
- * - reject: Reject a gate with reason
- * - approval-status: Show approval status for all gates
- */
-
-const program = new Command();
-
-/**
- * Valid approval gate names
- */
-const VALID_GATES = ['proposal', 'uiux', 'design', 'tasks'];
-
-/**
- * Approve action function - Mark a gate as approved
- */
-export async function approveCommand(featureName, gateName, options = {}) {
-  try {
-    // Validate gate name
-    if (!VALID_GATES.includes(gateName)) {
-      console.error(chalk.red(`\n❌ Invalid gate: ${gateName}`));
-      console.log(chalk.gray(`Valid gates: ${VALID_GATES.join(', ')}\n`));
-      process.exit(1);
-    }
-
-    // Get feature state
-    const feature = getFeature(featureName);
-    if (!feature) {
-      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
-      process.exit(1);
-    }
-
-    // Check if already approved
-    const currentStatus = getApprovalGate(featureName, gateName);
-    if (currentStatus?.approved) {
-      console.log(chalk.yellow(`\n⚠️  Gate "${gateName}" is already approved`));
-      console.log(chalk.gray(`Approved at: ${currentStatus.timestamp}`));
-      console.log(chalk.gray(`Approved by: ${currentStatus.approvedBy || 'Unknown'}\n`));
-      return;
-    }
-
-    // Set approval
-    setApprovalGate(featureName, gateName, true, {
-      approvedBy: options.approver || process.env.USER || process.env.USERNAME || 'user',
-      approvedAt: new Date().toISOString(),
-      notes: options.notes
-    });
-
-    console.log(chalk.green(`\n✅ Gate "${gateName}" approved for feature: ${featureName}`));
-    console.log(chalk.gray(`Workflow can now proceed past ${gateName} phase\n`));
-
-  } catch (error) {
-    console.error(chalk.red(`\n❌ Error approving gate: ${error.message}\n`));
-    process.exit(1);
-  }
-}
-
-/**
- * Approve command - Mark a gate as approved
- */
-program
-  .command('approve <feature> <gate>')
-  .description('Approve a phase gate to allow workflow progression')
-  .action(approveCommand);
-
-/**
- * Reject action function - Reject a gate with optional reason
- */
-export async function rejectCommand(featureName, gateName, reason, options = {}) {
-  try {
-    // Validate gate name
-    if (!VALID_GATES.includes(gateName)) {
-      console.error(chalk.red(`\n❌ Invalid gate: ${gateName}`));
-      console.log(chalk.gray(`Valid gates: ${VALID_GATES.join(', ')}\n`));
-      process.exit(1);
-    }
-
-    // Get feature state
-    const feature = getFeature(featureName);
-    if (!feature) {
-      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
-      process.exit(1);
-    }
-
-    // Set rejection
-    setApprovalGate(featureName, gateName, false, {
-      rejectedBy: process.env.USER || process.env.USERNAME || 'user',
-      rejectedAt: new Date().toISOString(),
-      reason: reason || 'No reason provided'
-    });
-
-    console.log(chalk.red(`\n❌ Gate "${gateName}" rejected for feature: ${featureName}`));
-    if (reason) {
-      console.log(chalk.gray(`Reason: ${reason}`));
-    }
-    console.log(chalk.yellow(`\n⚠️  Address the concerns and request approval again\n`));
-
-  } catch (error) {
-    console.error(chalk.red(`\n❌ Error rejecting gate: ${error.message}\n`));
-    process.exit(1);
-  }
-}
-
-/**
- * Reject command - Reject a gate with optional reason
- */
-program
-  .command('reject <feature> <gate> [reason]')
-  .description('Reject a phase gate with optional reason')
-  .action(rejectCommand);
-
-/**
- * Approval status action function - Show all gates and their status
- */
-export async function approvalStatusCommand(featureName, options = {}) {
-  try {
-    // Get feature state
-    const feature = getFeature(featureName);
-    if (!feature) {
-      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
-      process.exit(1);
-    }
-
-    // JSON output
-    if (options.json) {
-      const status = {
-        feature: featureName,
-        phase: feature.phase,
-        status: feature.status,
-        gates: {}
-      };
-
-      for (const gateName of VALID_GATES) {
-        status.gates[gateName] = getApprovalGate(featureName, gateName) || { approved: false };
-      }
-
-      console.log(JSON.stringify(status, null, 2));
-      return;
-    }
-
-    console.log(chalk.bold(`\n📋 Approval Status for: ${featureName}`));
-    console.log('━'.repeat(60));
-
-    // Show current phase
-    console.log(chalk.cyan(`\nCurrent Phase: ${feature.phase || 'unknown'}`));
-    console.log(chalk.gray(`Feature Status: ${feature.status || 'unknown'}\n`));
-
-    // Show each gate
-    console.log(chalk.bold('Approval Gates:'));
-
-    for (const gateName of VALID_GATES) {
-      const gateStatus = getApprovalGate(featureName, gateName);
-
-      if (!gateStatus) {
-        console.log(`  ${chalk.gray('○')} ${gateName}: ${chalk.gray('Not yet evaluated')}`);
-        continue;
-      }
-
-      if (gateStatus.approved) {
-        console.log(`  ${chalk.green('✓')} ${gateName}: ${chalk.green('Approved')}`);
-        if (gateStatus.timestamp) {
-          console.log(chalk.gray(`      Approved at: ${gateStatus.timestamp}`));
-        }
-        if (gateStatus.approvedBy) {
-          console.log(chalk.gray(`      Approved by: ${gateStatus.approvedBy}`));
-        }
-      } else {
-        console.log(`  ${chalk.red('✗')} ${gateName}: ${chalk.red('Rejected / Not Approved')}`);
-        if (gateStatus.reason) {
-          console.log(chalk.gray(`      Reason: ${gateStatus.reason}`));
-        }
-        if (gateStatus.timestamp) {
-          console.log(chalk.gray(`      Rejected at: ${gateStatus.timestamp}`));
-        }
-      }
-    }
-
-    // Show approval history if available
-    const history = getApprovalHistory(featureName);
-    if (history && history.length > 0) {
-      console.log(chalk.bold('\nApproval History:'));
-      history.slice(-5).forEach(entry => {
-        const status = entry.approved ? chalk.green('✓ Approved') : chalk.red('✗ Rejected');
-        console.log(`  ${status} ${entry.gate} - ${entry.timestamp}`);
-      });
-    }
-
-    console.log('\n' + '━'.repeat(60) + '\n');
-
-  } catch (error) {
-    console.error(chalk.red(`\n❌ Error showing approval status: ${error.message}\n`));
-    process.exit(1);
-  }
-}
-
-/**
- * Approval status command - Show all gates and their status
- */
-program
-  .command('approval-status <feature>')
-  .alias('status')
-  .description('Show approval status for all gates')
-  .action(approvalStatusCommand);
-
-// Only parse if run directly (not imported as module)
-if (import.meta.url === `file://${process.argv[1]}`) {
-  if (process.argv.length > 2) {
-    program.parse(process.argv);
-  } else {
-    program.help();
-  }
-}
-
-export default program;
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory } from '../../core/state/state-manager.js';
+
+/**
+ * Unapprove action function - Revoke a previously approved gate
+ */
+export async function unapproveCommand(featureName, gateName, options = {}) {
+  try {
+    if (!VALID_GATES.includes(gateName)) {
+      console.error(chalk.red(`\n❌ Invalid gate: ${gateName}`));
+      console.log(chalk.gray(`Valid gates: ${VALID_GATES.join(', ')}\n`));
+      process.exit(1);
+    }
+
+    const feature = getFeature(featureName);
+    if (!feature) {
+      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+      process.exit(1);
+    }
+
+    const currentStatus = getApprovalGate(featureName, gateName);
+    if (!currentStatus?.approved) {
+      console.log(chalk.yellow(`\n⚠️  Gate "${gateName}" is not currently approved — nothing to revoke\n`));
+      return;
+    }
+
+    setApprovalGate(featureName, gateName, false, {
+      revokedBy: options.revoker || process.env.USER || process.env.USERNAME || 'user',
+      revokedAt: new Date().toISOString(),
+      reason: options.reason
+    });
+
+    console.log(chalk.yellow(`\n↩️  Gate "${gateName}" approval revoked for feature: ${featureName}`));
+    console.log(chalk.gray(`Workflow is now blocked at the ${gateName} gate\n`));
+
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error revoking gate: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Approval Commands - Manage approval gates for MORPH workflow
+ *
+ * Commands:
+ * - approve: Mark a gate as approved
+ * - unapprove: Revoke a gate approval
+ * - approval-status: Show approval status for all gates
+ */
+
+const program = new Command();
+
+/**
+ * Valid approval gate names
+ */
+const VALID_GATES = ['proposal', 'uiux', 'design', 'tasks'];
+
+/**
+ * Approve action function - Mark a gate as approved
+ */
+export async function approveCommand(featureName, gateName, options = {}) {
+  try {
+    // Validate gate name
+    if (!VALID_GATES.includes(gateName)) {
+      console.error(chalk.red(`\n❌ Invalid gate: ${gateName}`));
+      console.log(chalk.gray(`Valid gates: ${VALID_GATES.join(', ')}\n`));
+      process.exit(1);
+    }
+
+    // Get feature state
+    const feature = getFeature(featureName);
+    if (!feature) {
+      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+      process.exit(1);
+    }
+
+    // Check if already approved
+    const currentStatus = getApprovalGate(featureName, gateName);
+    if (currentStatus?.approved) {
+      console.log(chalk.yellow(`\n⚠️  Gate "${gateName}" is already approved`));
+      console.log(chalk.gray(`Approved at: ${currentStatus.timestamp}`));
+      console.log(chalk.gray(`Approved by: ${currentStatus.approvedBy || 'Unknown'}\n`));
+      return;
+    }
+
+    // Set approval
+    setApprovalGate(featureName, gateName, true, {
+      approvedBy: options.approver || process.env.USER || process.env.USERNAME || 'user',
+      approvedAt: new Date().toISOString(),
+      notes: options.notes
+    });
+
+    console.log(chalk.green(`\n✅ Gate "${gateName}" approved for feature: ${featureName}`));
+    console.log(chalk.gray(`Workflow can now proceed past ${gateName} phase\n`));
+
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error approving gate: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Approve command - Mark a gate as approved
+ */
+program
+  .command('approve <feature> <gate>')
+  .description('Approve a phase gate to allow workflow progression')
+  .action(approveCommand);
+
+/**
+ * Approval status action function - Show all gates and their status
+ */
+export async function approvalStatusCommand(featureName, options = {}) {
+  try {
+    // Get feature state
+    const feature = getFeature(featureName);
+    if (!feature) {
+      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+      process.exit(1);
+    }
+
+    // JSON output
+    if (options.json) {
+      const status = {
+        feature: featureName,
+        phase: feature.phase,
+        status: feature.status,
+        gates: {}
+      };
+
+      for (const gateName of VALID_GATES) {
+        status.gates[gateName] = getApprovalGate(featureName, gateName) || { approved: false };
+      }
+
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n📋 Approval Status for: ${featureName}`));
+    console.log('━'.repeat(60));
+
+    // Show current phase
+    console.log(chalk.cyan(`\nCurrent Phase: ${feature.phase || 'unknown'}`));
+    console.log(chalk.gray(`Feature Status: ${feature.status || 'unknown'}\n`));
+
+    // Show each gate
+    console.log(chalk.bold('Approval Gates:'));
+
+    for (const gateName of VALID_GATES) {
+      const gateStatus = getApprovalGate(featureName, gateName);
+
+      if (!gateStatus) {
+        console.log(`  ${chalk.gray('○')} ${gateName}: ${chalk.gray('Not yet evaluated')}`);
+        continue;
+      }
+
+      if (gateStatus.approved) {
+        console.log(`  ${chalk.green('✓')} ${gateName}: ${chalk.green('Approved')}`);
+        if (gateStatus.timestamp) {
+          console.log(chalk.gray(`      Approved at: ${gateStatus.timestamp}`));
+        }
+        if (gateStatus.approvedBy) {
+          console.log(chalk.gray(`      Approved by: ${gateStatus.approvedBy}`));
+        }
+      } else {
+        console.log(`  ${chalk.red('✗')} ${gateName}: ${chalk.red('Rejected / Not Approved')}`);
+        if (gateStatus.reason) {
+          console.log(chalk.gray(`      Reason: ${gateStatus.reason}`));
+        }
+        if (gateStatus.timestamp) {
+          console.log(chalk.gray(`      Rejected at: ${gateStatus.timestamp}`));
+        }
+      }
+    }
+
+    // Show approval history if available
+    const history = getApprovalHistory(featureName);
+    if (history && history.length > 0) {
+      console.log(chalk.bold('\nApproval History:'));
+      history.slice(-5).forEach(entry => {
+        const status = entry.approved ? chalk.green('✓ Approved') : chalk.red('✗ Rejected');
+        console.log(`  ${status} ${entry.gate} - ${entry.timestamp}`);
+      });
+    }
+
+    console.log('\n' + '━'.repeat(60) + '\n');
+
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error showing approval status: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Approval status command - Show all gates and their status
+ */
+program
+  .command('approval-status <feature>')
+  .alias('status')
+  .description('Show approval status for all gates')
+  .action(approvalStatusCommand);
+
+// Only parse if run directly (not imported as module)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  if (process.argv.length > 2) {
+    program.parse(process.argv);
+  } else {
+    program.help();
+  }
+}
+
+export default program;

package/src/commands/state/index.js

@@ -3,6 +3,5 @@
  */
 export { stateCommand } from './state.js';
 export { advancePhaseCommand } from './advance-phase.js';
-export { rollbackPhaseCommand } from './rollback-phase.js';
 export { approveCommand, rejectCommand, approvalStatusCommand } from './approve.js';
 export { validatePhaseCommand } from './validate-phase.js';