@polymorphism-tech/morph-spec 3.1.0 → 3.2.0

package/src/commands/spawn-team.js

@@ -0,0 +1,172 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getFeature } from '../lib/state-manager.js';
+import { orchestrateTeam } from '../lib/team-orchestrator.js';
+
+/**
+ * Spawn Team Command - Generate agent team configurations
+ *
+ * Reads active agents from feature state and generates ready-to-use
+ * Task tool configurations for spawning agent teams.
+ */
+
+const program = new Command();
+
+/**
+ * Spawn team action function
+ */
+export async function spawnTeamCommand(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);
+      }
+
+      if (!feature.activeAgents || feature.activeAgents.length === 0) {
+        console.error(chalk.yellow(`\n⚠️  No active agents found for feature: ${featureName}`));
+        console.log(chalk.gray('Run "morph-spec detect-agents" first to identify agents.\n'));
+        process.exit(1);
+      }
+
+      // Determine if multi-domain
+      const domains = new Set();
+      feature.activeAgents.forEach(agentId => {
+        if (agentId.includes('dotnet') || agentId.includes('ef') || agentId.includes('api')) {
+          domains.add('backend');
+        }
+        if (agentId.includes('blazor') || agentId.includes('nextjs') || agentId.includes('ui')) {
+          domains.add('frontend');
+        }
+        if (agentId.includes('azure') || agentId.includes('bicep') || agentId.includes('container')) {
+          domains.add('infrastructure');
+        }
+      });
+
+      const multiDomain = domains.size > 1;
+
+      // Orchestrate team
+      const teamConfig = orchestrateTeam({
+        activeAgents: feature.activeAgents,
+        complexity: options.complexity,
+        estimatedFiles: parseInt(options.estimatedFiles, 10),
+        multiDomain
+      });
+
+      if (options.json) {
+        // Output as JSON for programmatic use
+        console.log(JSON.stringify(teamConfig, null, 2));
+        return;
+      }
+
+      // Pretty output for human reading
+      console.log(chalk.bold(`\n🤖 Agent Team Configuration for: ${featureName}`));
+      console.log('━'.repeat(60));
+
+      console.log(chalk.cyan(`\nShould Spawn Agents: ${teamConfig.useAgentTeams ? chalk.green('YES') : chalk.yellow('NO')}`));
+      console.log(chalk.gray(`Reason: ${teamConfig.useAgentTeams ? 'Meets spawn threshold' : 'Below threshold - implement directly'}`));
+
+      if (!teamConfig.useAgentTeams) {
+        console.log(chalk.yellow('\n⚠️  Team spawning not recommended for this feature.'));
+        console.log(chalk.gray('Implement directly in main session.\n'));
+        return;
+      }
+
+      console.log(chalk.cyan(`\nDisplay Mode: ${teamConfig.displayMode}`));
+      console.log(chalk.cyan(`Total Teammates: ${teamConfig.teamHierarchy.totalTeammates}`));
+
+      // Show team hierarchy
+      console.log(chalk.bold('\nTeam Hierarchy:'));
+      console.log(chalk.green(`  Team Lead: ${teamConfig.teamHierarchy.teamLead}`));
+
+      if (teamConfig.teamHierarchy.squads && teamConfig.teamHierarchy.squads.length > 0) {
+        console.log(chalk.cyan('\n  Squad Leaders:'));
+        teamConfig.teamHierarchy.squads.forEach(squad => {
+          console.log(chalk.cyan(`    • ${squad}`));
+        });
+      }
+
+      if (teamConfig.teamHierarchy.validators && teamConfig.teamHierarchy.validators.length > 0) {
+        console.log(chalk.gray('\n  Validators (run in hooks):'));
+        teamConfig.teamHierarchy.validators.forEach(validator => {
+          console.log(chalk.gray(`    • ${validator}`));
+        });
+      }
+
+      // Show Task tool usage
+      console.log(chalk.bold('\n📝 Task Tool Usage:'));
+      console.log(chalk.gray('\nUse the following pattern to spawn the team:\n'));
+
+      console.log(chalk.cyan('```typescript'));
+      console.log(chalk.white(`{
+  subagent_type: "general-purpose",
+  description: "Implement ${featureName}",
+  prompt: \`You are the Team Lead (${teamConfig.teamHierarchy.teamLead})...
+
+Your Mission: Implement ${featureName}
+
+Your Domain Leaders:
+${teamConfig.teammates
+  .filter(t => t.tier === 2)
+  .map(t => `- ${t.id}: ${t.role}`)
+  .join('\n')}
+
+Your Specialists:
+${teamConfig.teammates
+  .filter(t => t.tier === 3)
+  .map(t => `- ${t.id}: ${t.role}`)
+  .join('\n')}
+
+Standards to follow: [coding.md, architecture.md]
+
+Deliverables: [list specific outputs]
+\`
+}`));
+      console.log(chalk.cyan('```\n'));
+
+      // Show individual teammates
+      console.log(chalk.bold('Individual Teammates:'));
+      teamConfig.teammates.forEach(teammate => {
+        console.log(chalk.cyan(`\n  ${teammate.icon} ${teammate.id} (Tier ${teammate.tier})`));
+        console.log(chalk.gray(`     Role: ${teammate.role}`));
+
+        if (teammate.spawnPrompt && teammate.spawnPrompt.length < 200) {
+          console.log(chalk.gray(`     Prompt: ${teammate.spawnPrompt.substring(0, 100)}...`));
+        }
+      });
+
+      console.log('\n' + '━'.repeat(60));
+      console.log(chalk.green('\n✅ Team configuration generated successfully\n'));
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Error generating team configuration: ${error.message}\n`));
+      if (error.stack) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exit(1);
+    }
+  }
+
+/**
+ * Commander program command
+ */
+program
+  .name('spawn-team')
+  .description('Generate agent team configuration for Task tool spawning')
+  .argument('<feature>', 'Feature name')
+  .option('--json', 'Output as JSON')
+  .option('--complexity <level>', 'Override complexity level (low/medium/high/critical)', 'high')
+  .option('--estimated-files <count>', 'Override estimated file count', '20')
+  .action(spawnTeamCommand);
+
+// 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/task.js

@@ -16,9 +16,9 @@ const taskManagerPath = join(__dirname, '..', '..', 'bin', 'task-manager.cjs');
  */
 function executeTaskManager(args) {
   return new Promise((resolve, reject) => {
+    // Note: shell: false (default) is intentional to preserve arguments with spaces
     const child = spawn('node', [taskManagerPath, ...args], {
-      stdio: 'inherit',
-      shell: true
+      stdio: 'inherit'
     });
 
     child.on('close', (code) => {

package/src/commands/update.js

@@ -19,6 +19,8 @@ import {
   getUpdateInstructions,
   detectInstallMethod
 } from '../utils/version-checker.js';
+import { AutoContextOrchestrator } from '../orchestrator.js';
+import { detectClaudeCode } from '../llm/environment-detector.js';
 
 export async function updateCommand(options) {
   const targetPath = process.cwd();
@@ -196,6 +198,40 @@ export async function updateCommand(options) {
     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);

package/src/commands/upgrade.js

@@ -0,0 +1,346 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * Upgrade Command - Upgrade MORPH-SPEC project to v3.0
+ *
+ * Orchestrates:
+ * - State migration (add approval gates)
+ * - llm-interaction.json creation
+ * - patterns-learned.md creation
+ * - Documentation updates
+ */
+
+const program = new Command();
+
+program
+  .name('upgrade')
+  .description('Upgrade MORPH-SPEC project to v3.0')
+  .option('--to-version <version>', 'Target version (default: 3.0.0)', '3.0.0')
+  .option('--preset <preset>', 'Configuration preset (strict | lightweight | no-guardrails)', 'strict')
+  .option('--dry-run', 'Preview changes without writing')
+  .option('--force', 'Skip confirmations')
+  .action(async (options) => {
+    try {
+      console.log(chalk.cyan(`
+███████╗ MORPH-SPEC Upgrade
+╚══════╝ Upgrading to v${options.toVersion}
+`));
+
+      // Validate project
+      if (!existsSync(join(process.cwd(), '.morph'))) {
+        console.error(chalk.red('❌ No .morph directory found'));
+        console.log(chalk.yellow('   This does not appear to be a MORPH-SPEC project.\n'));
+        process.exit(1);
+      }
+
+      // Read current state
+      const statePath = join(process.cwd(), '.morph/state.json');
+      if (!existsSync(statePath)) {
+        console.error(chalk.red('❌ No state.json found'));
+        console.log(chalk.yellow('   Run "morph-spec init" first.\n'));
+        process.exit(1);
+      }
+
+      const state = JSON.parse(readFileSync(statePath, 'utf8'));
+      const currentVersion = state.version || '2.0.0';
+
+      console.log(chalk.gray(`Current version: ${currentVersion}`));
+      console.log(chalk.gray(`Target version: ${options.toVersion}\n`));
+
+      // Check if upgrade needed
+      if (currentVersion === options.toVersion) {
+        console.log(chalk.green(`✅ Already at v${options.toVersion}\n`));
+        process.exit(0);
+      }
+
+      // Upgrade steps
+      const steps = [
+        { name: 'Migrate state.json', fn: migrateState },
+        { name: 'Create llm-interaction.json', fn: createLLMConfig },
+        { name: 'Create patterns-learned.md', fn: createPatternsLibrary },
+        { name: 'Update CLAUDE.md', fn: updateClaudeMd },
+        { name: 'Create metadata directory', fn: createMetadataDir }
+      ];
+
+      console.log(chalk.bold('📋 Upgrade Plan:\n'));
+      steps.forEach((step, i) => {
+        console.log(chalk.cyan(`   ${i + 1}. ${step.name}`));
+      });
+      console.log('');
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('🔍 DRY RUN - No changes will be written\n'));
+      }
+
+      if (!options.force && !options.dryRun) {
+        console.log(chalk.yellow('⚠️  This will modify your project'));
+        console.log(chalk.gray('   Backups will be created for modified files\n'));
+        console.log(chalk.gray('   Press Ctrl+C to cancel, or run with --force to skip confirmation.\n'));
+        // In real implementation, use inquirer for confirmation
+      }
+
+      // Execute steps
+      const results = [];
+      for (const [index, step] of steps.entries()) {
+        console.log(chalk.cyan(`\n[${index + 1}/${steps.length}] ${step.name}...`));
+
+        try {
+          const result = await step.fn(options);
+          results.push({ step: step.name, status: 'success', result });
+          console.log(chalk.green(`✅ ${step.name} complete`));
+        } catch (error) {
+          results.push({ step: step.name, status: 'failed', error: error.message });
+          console.log(chalk.red(`❌ ${step.name} failed: ${error.message}`));
+
+          if (!options.force) {
+            console.log(chalk.yellow('\nUpgrade halted due to error.'));
+            console.log(chalk.gray('Run with --force to continue despite errors.\n'));
+            process.exit(1);
+          }
+        }
+      }
+
+      // Summary
+      console.log(chalk.bold('\n\n📊 Upgrade Summary:\n'));
+
+      const succeeded = results.filter(r => r.status === 'success').length;
+      const failed = results.filter(r => r.status === 'failed').length;
+
+      results.forEach(result => {
+        const icon = result.status === 'success' ? '✅' : '❌';
+        const color = result.status === 'success' ? chalk.green : chalk.red;
+        console.log(color(`   ${icon} ${result.step}`));
+
+        if (result.status === 'failed') {
+          console.log(chalk.gray(`      Error: ${result.error}`));
+        }
+      });
+
+      console.log('');
+
+      if (failed === 0) {
+        console.log(chalk.green.bold('🎉 Upgrade to v3.0 complete!\n'));
+
+        console.log(chalk.bold('Next steps:\n'));
+        console.log(chalk.gray('1. Review .morph/config/llm-interaction.json'));
+        console.log(chalk.gray('2. Read docs/llm-interaction-config.md for configuration options'));
+        console.log(chalk.gray('3. Try new features:'));
+        console.log(chalk.gray('   - npx morph-spec search-patterns "{keyword}"'));
+        console.log(chalk.gray('   - npx morph-spec approve {feature} design'));
+        console.log(chalk.gray('   - npx morph-spec spawn-team {feature}'));
+        console.log(chalk.gray('4. Continue development with v3.0 workflow\n'));
+      } else {
+        console.log(chalk.yellow(`⚠️  Upgrade completed with ${failed} error(s)\n`));
+        console.log(chalk.gray('Review errors above and fix manually.\n'));
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Upgrade failed: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+/**
+ * Step 1: Migrate state.json
+ */
+async function migrateState(options) {
+  const migrateCommand = options.dryRun
+    ? 'npx morph-spec migrate-state --dry-run --force'
+    : 'npx morph-spec migrate-state --force';
+
+  try {
+    execSync(migrateCommand, { cwd: process.cwd(), stdio: 'pipe' });
+    return { featuresUpdated: 'N/A' };
+  } catch (error) {
+    // If migrate-state doesn't exist yet, do inline migration
+    const statePath = join(process.cwd(), '.morph/state.json');
+    const state = JSON.parse(readFileSync(statePath, 'utf8'));
+
+    let featuresUpdated = 0;
+
+    Object.values(state.features || {}).forEach(feature => {
+      if (!feature.approvalGates) {
+        feature.approvalGates = {
+          proposal: { approved: true, timestamp: new Date().toISOString(), approvedBy: 'auto-migration' },
+          uiux: { approved: false, timestamp: null, approvedBy: null },
+          design: { approved: true, timestamp: new Date().toISOString(), approvedBy: 'auto-migration' },
+          tasks: { approved: true, timestamp: new Date().toISOString(), approvedBy: 'auto-migration' }
+        };
+        featuresUpdated++;
+      }
+    });
+
+    state.version = '3.0.0';
+
+    if (!options.dryRun) {
+      writeFileSync(`${statePath}.backup`, readFileSync(statePath));
+      writeFileSync(statePath, JSON.stringify(state, null, 2));
+    }
+
+    return { featuresUpdated };
+  }
+}
+
+/**
+ * Step 2: Create llm-interaction.json
+ */
+async function createLLMConfig(options) {
+  const configPath = join(process.cwd(), '.morph/config/llm-interaction.json');
+
+  // Choose preset
+  const presets = {
+    strict: {
+      approvalGates: { enabled: true, required: ['design', 'tasks'], allowSkip: false },
+      checkpoints: { frequency: 3, autoValidate: true, onFailure: { blockProgress: true } },
+      phaseValidation: { strictTransitions: true, requireContentValidation: true },
+      agentSpawning: { enabled: true, teamMode: 'auto' },
+      metadata: { autoGenerate: true },
+      patterns: { searchBeforeStart: true, captureOnComplete: true },
+      interactiveDecisions: { enabled: true }
+    },
+    lightweight: {
+      approvalGates: { enabled: true, required: ['design'], allowSkip: true },
+      checkpoints: { frequency: 5, autoValidate: true, onFailure: { blockProgress: false } },
+      phaseValidation: { strictTransitions: true, allowPhaseSkip: true },
+      agentSpawning: { enabled: false },
+      metadata: { autoGenerate: false },
+      patterns: { searchBeforeStart: true, captureOnComplete: false },
+      interactiveDecisions: { enabled: true }
+    },
+    'no-guardrails': {
+      approvalGates: { enabled: false },
+      checkpoints: { autoValidate: false },
+      phaseValidation: { strictTransitions: false, allowPhaseSkip: true },
+      agentSpawning: { enabled: false },
+      metadata: { autoGenerate: false },
+      patterns: { searchBeforeStart: false, captureOnComplete: false },
+      interactiveDecisions: { enabled: false }
+    }
+  };
+
+  const preset = presets[options.preset] || presets.strict;
+
+  const config = {
+    version: '1.0.0',
+    enabled: true,
+    ...preset,
+    checkpoints: {
+      ...preset.checkpoints,
+      validators: { enabled: ['architecture', 'packages', 'design-system', 'security'] },
+      hooks: { runTests: false, runLinters: true, buildCheck: false },
+      onFailure: { ...preset.checkpoints.onFailure, maxRetries: 3 }
+    },
+    agentSpawning: {
+      ...preset.agentSpawning,
+      autoDetect: true,
+      spawnThreshold: { complexity: 'high', fileCount: 15, multiDomain: true, agentCount: 5 }
+    },
+    metadata: { ...preset.metadata, updateFrequency: 'on_task_done' },
+    patterns: { ...preset.patterns, location: '.morph/memory/patterns-learned.md' },
+    templates: { mcpDataInjection: true, dataSources: ['projectStructure', 'complianceStatus', 'recentActivity'] },
+    interactiveDecisions: {
+      ...preset.interactiveDecisions,
+      usePromptTemplates: true,
+      requireUserInput: ['architecture-choice', 'scope-change', 'validator-override']
+    }
+  };
+
+  if (!options.dryRun) {
+    mkdirSync(join(process.cwd(), '.morph/config'), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  }
+
+  return { preset: options.preset, path: configPath };
+}
+
+/**
+ * Step 3: Create patterns-learned.md
+ */
+async function createPatternsLibrary(options) {
+  const patternsPath = join(process.cwd(), '.morph/memory/patterns-learned.md');
+
+  if (existsSync(patternsPath)) {
+    return { status: 'already exists' };
+  }
+
+  const initialContent = `# Patterns Learned
+
+This file tracks reusable patterns, lessons learned, and anti-patterns discovered during development.
+
+**Usage:**
+- Search: \`npx morph-spec search-patterns "{keyword}"\`
+- Capture: \`npx morph-spec capture-pattern {feature} {category} "Description"\`
+
+---
+
+## Pre-Seeded Framework Patterns
+
+See framework/.morph/memory/patterns-learned.md for standard patterns.
+
+---
+`;
+
+  if (!options.dryRun) {
+    mkdirSync(join(process.cwd(), '.morph/memory'), { recursive: true });
+    writeFileSync(patternsPath, initialContent);
+  }
+
+  return { path: patternsPath };
+}
+
+/**
+ * Step 4: Update CLAUDE.md
+ */
+async function updateClaudeMd(options) {
+  const claudePath = join(process.cwd(), 'CLAUDE.md');
+
+  if (!existsSync(claudePath)) {
+    return { status: 'not found, skipped' };
+  }
+
+  const content = readFileSync(claudePath, 'utf8');
+
+  // Check if already updated
+  if (content.includes('## APPROVAL GATES')) {
+    return { status: 'already up-to-date' };
+  }
+
+  // Add note about v3.0 features
+  const note = `\n---\n\n> **MORPH-SPEC v3.0 Features:** This project now supports approval gates, checkpoint automation, pattern learning, and metadata generation. See \`.morph/config/llm-interaction.json\` for configuration.\n\n---\n`;
+
+  if (!options.dryRun) {
+    writeFileSync(`${claudePath}.backup`, content);
+    writeFileSync(claudePath, content + note);
+  }
+
+  return { status: 'updated with v3.0 note' };
+}
+
+/**
+ * Step 5: Create metadata output directory
+ */
+async function createMetadataDir(options) {
+  const metadataDir = join(process.cwd(), '.morph/project/outputs');
+
+  if (!options.dryRun) {
+    mkdirSync(metadataDir, { recursive: true });
+  }
+
+  return { path: metadataDir };
+}
+
+// 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;