@polymorphism-tech/morph-spec 4.7.1 → 4.8.1

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/project/update.js

@@ -24,11 +24,9 @@ import {
   getUpdateInstructions,
   detectInstallMethod
 } from '../../utils/version-checker.js';
-import { installClaudeHooks } from '../../utils/claude-settings-manager.js';
+import { installClaudeHooks, installGlobalStatusline } from '../../utils/claude-settings-manager.js';
 import { installSkills } from '../../utils/skills-installer.js';
 import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
-import { AutoContextOrchestrator } from '../../core/orchestrator.js';
-import { detectClaudeCode } from '../../llm/environment-detector.js';
 
 /**
  * Backup user's config.json before cleaning
@@ -57,6 +55,7 @@ async function cleanFrameworkDirs(morphPath, targetPath) {
   const dirsToClean = [
     join(morphPath, 'framework', 'templates'),
     join(morphPath, 'framework', 'standards'),
+    join(morphPath, 'framework', 'hooks'),
     join(morphPath, 'config'),
     join(targetPath, '.claude')
   ];
@@ -208,6 +207,14 @@ export async function updateCommand(options) {
       await copyDirectory(standardsSrc, standardsDest);
     }
 
+    // Update hooks (runtime hook scripts under .morph/framework/hooks/)
+    updateSpinner.text = 'Updating hooks...';
+    const hooksSrc = join(__dirname, '..', '..', '..', 'framework', 'hooks');
+    const hooksDest = join(morphPath, 'framework', 'hooks');
+    if (await pathExists(hooksSrc)) {
+      await copyDirectory(hooksSrc, hooksDest);
+    }
+
     // Update agents.json (sourced from framework/ — canonical single source of truth)
     updateSpinner.text = 'Updating agents configuration...';
     const agentsSrc = join(__dirname, '..', '..', '..', 'framework', 'agents.json');
@@ -279,6 +286,16 @@ export async function updateCommand(options) {
       await copyFile(runtimeSrc, runtimeDest);
     }
 
+    // Sync statusline globally to ~/.claude/
+    updateSpinner.text = 'Syncing statusline to ~/.claude/...';
+    const HOOKS_SRC = join(__dirname, '..', '..', '..', 'framework', 'hooks', 'claude-code');
+    try {
+      await installGlobalStatusline(HOOKS_SRC);
+    } catch {
+      // Non-critical: global dir may not be writable in all environments
+      logger.dim('  ⚠ Could not install statusline globally (non-critical)');
+    }
+
     // Update Claude Code hooks in .claude/settings.local.json
     updateSpinner.text = 'Updating Claude Code hooks...';
     const hooksResult = await installClaudeHooks(targetPath);
@@ -314,6 +331,7 @@ export async function updateCommand(options) {
     logger.info('Updated files:');
     if (updateTemplates) logger.dim('  ✓ .morph/framework/templates/');
     if (updateStandards) logger.dim('  ✓ .morph/framework/standards/');
+    logger.dim('  ✓ .morph/framework/hooks/');
     logger.dim('  ✓ .morph/framework/agents.json');
     if (commandsCopied) logger.dim('  ✓ .claude/commands/');
 
@@ -322,46 +340,13 @@ export async function updateCommand(options) {
     logger.dim('  ✓ .claude/agents/ (native subagents refreshed)');
     logger.dim('  ✓ .claude/rules/ (path-scoped rules synced)');
     logger.dim('  ✓ .claude/CLAUDE.md (runtime quick reference)');
+    logger.dim('  ✓ ~/.claude/statusline.sh (global statusline synced)');
     logger.dim('  ✓ CLAUDE.md');
     logger.blank();
     logger.info('Your config.json was preserved.');
     logger.dim('Review the updated files for any new features.');
     logger.blank();
 
-    // Re-analyze project context (unless --skip-detection)
-    if (!options.skipDetection && detectClaudeCode()) {
-      logger.header('Re-Analyzing Project Context');
-      logger.dim('Using Claude Code LLM to update project detection...');
-      logger.blank();
-
-      try {
-        const orchestrator = new AutoContextOrchestrator();
-        const result = await orchestrator.execute(targetPath, {
-          skipReview: false,
-          fallbackOnError: true,
-          wizardMode: options.wizard || false
-        });
-
-        if (result.success) {
-          logger.success('Project context re-analyzed and updated');
-          logger.dim('  ✓ .morph/project.md updated with latest detection');
-          logger.dim('  ✓ .morph/config/config.json updated with stack info');
-        } else {
-          logger.warn('Context re-analysis incomplete');
-        }
-      } catch (error) {
-        logger.warn(`Auto-detection failed: ${error.message}`);
-        logger.dim('Your existing config.json was preserved.');
-      }
-
-      logger.blank();
-    } else if (options.skipDetection) {
-      logger.dim('Skipped auto-detection (--skip-detection flag)');
-    } else {
-      logger.warn('⚠️  Claude Code not detected - skipping auto-detection');
-      logger.dim('Run with --wizard to configure manually.');
-    }
-
   } catch (error) {
     updateSpinner.fail('Update failed');
     logger.error(error.message);