@polymorphism-tech/morph-spec 3.0.1 → 3.2.0

package/bin/detect-agents.js

@@ -15,9 +15,11 @@
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { resolveAgentsConfigPath } from '../src/lib/stack-resolver.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const AGENTS_CONFIG_PATH = join(__dirname, '../content/.morph/config/agents.json');
+const frameworkRoot = join(__dirname, '..');
+const AGENTS_CONFIG_PATH = resolveAgentsConfigPath(frameworkRoot);
 
 // Cores para output no terminal
 const colors = {

package/bin/morph-spec.js

@@ -1,10 +1,11 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { program } from 'commander';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { readFileSync } from 'fs';
+import { setGlobalStack } from '../src/lib/stack-resolver.js';
 
 import { initCommand } from '../src/commands/init.js';
 import { updateCommand } from '../src/commands/update.js';
@@ -31,6 +32,13 @@ import { validatePhaseCommand } from '../src/commands/validate-phase.js';
 import { sessionSummaryCommand } from '../src/commands/session-summary.js';
 import { rollbackPhaseCommand } from '../src/commands/rollback-phase.js';
 import { advancePhaseCommand } from '../src/commands/advance-phase.js';
+import { approveCommand, rejectCommand, approvalStatusCommand } from '../src/commands/approve.js';
+import { spawnTeamCommand } from '../src/commands/spawn-team.js';
+import capturePatternProgram from '../src/commands/capture-pattern.js';
+import searchPatternsProgram from '../src/commands/search-patterns.js';
+import { generateMetadataCommand } from '../src/commands/generate.js';
+import migrateStateProgram from '../src/commands/migrate-state.js';
+import upgradeProgram from '../src/commands/upgrade.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
@@ -51,6 +59,7 @@ program
   .name('morph-spec')
   .description('MORPH-SPEC Framework CLI')
   .version(pkg.version)
+  .option('--stack <stack>', 'Override stack detection (blazor-azure | nextjs-supabase)')
   .addHelpText('beforeAll', banner);
 
 program
@@ -187,6 +196,13 @@ generateCommand
     await generateContextCommand('.', feature);
   });
 
+generateCommand
+  .command('metadata <feature>')
+  .description('Generate metadata.json summary from markdown outputs')
+  .option('--output <path>', 'Custom output path')
+  .option('--verbose', 'Show detailed extraction info')
+  .action((feature, options) => generateMetadataCommand(feature, options));
+
 // Validation commands (Sprint 4: Continuous Validation)
 program
   .command('validate [validator]')
@@ -363,4 +379,47 @@ program
   .option('-v, --verbose', 'Show detailed output')
   .action(rollbackPhaseCommand);
 
+// Approval workflow commands (MORPH-SPEC 3.0)
+program
+  .command('approve <feature> <gate>')
+  .description('Approve a phase gate (design, tasks, uiux, proposal)')
+  .option('--approver <name>', 'Name of approver (default: current user)')
+  .option('--notes <notes>', 'Approval notes')
+  .action((feature, gate, options) => approveCommand(feature, gate, options));
+
+program
+  .command('reject <feature> <gate> [reason]')
+  .description('Reject a phase gate with optional reason')
+  .action((feature, gate, reason, options) => rejectCommand(feature, gate, reason, options));
+
+program
+  .command('approval-status <feature>')
+  .description('Show approval status for all gates')
+  .option('--json', 'Output as JSON')
+  .action((feature, options) => approvalStatusCommand(feature, options));
+
+// Agent team spawning (MORPH-SPEC 3.0)
+program
+  .command('spawn-team <feature>')
+  .description('Generate agent team configuration for Task tool')
+  .option('--json', 'Output as JSON')
+  .option('--verbose', 'Show detailed team configuration')
+  .action((feature, options) => spawnTeamCommand(feature, options));
+
+// Pattern learning system (MORPH-SPEC 3.0) - Add as subcommands
+program.addCommand(capturePatternProgram);
+program.addCommand(searchPatternsProgram);
+
+// Migration and upgrade commands (MORPH-SPEC 3.0) - Add as subcommands
+program.addCommand(migrateStateProgram);
+program.addCommand(upgradeProgram);
+
+// Wire global --stack flag to stack-resolver before any command executes
+program.hook('preAction', () => {
+  const opts = program.opts();
+  if (opts.stack) {
+    setGlobalStack(opts.stack);
+  }
+});
+
 program.parse();

package/bin/render-template.js

@@ -10,7 +10,7 @@
  *
  * Example:
  *   node bin/render-template.js \
- *     content/.morph/templates/spec.md \
+ *     stacks/blazor-azure/.morph/templates/spec.md \
  *     .morph/project/outputs/my-feature/spec.md \
  *     '{"FEATURE_NAME":"my-feature","STACK":"Blazor","DATE":"2024-01-15"}'
  */
@@ -18,6 +18,8 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { resolveConfigDir } from '../src/lib/stack-resolver.js';
+import { getAllTemplatePlaceholders } from '../src/lib/template-data-sources.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -37,8 +39,8 @@ const colors = {
 function loadConfig() {
   const configPaths = [
     path.join(process.cwd(), '.morph/config/config.json'),
-    path.join(process.cwd(), 'content/.morph/config/config.json'),
-    path.join(__dirname, '../content/.morph/config/config.template.json')
+    path.join(resolveConfigDir(process.cwd()), 'config.json'),
+    path.join(resolveConfigDir(path.join(__dirname, '..')), 'config.template.json')
   ];
 
   for (const configPath of configPaths) {
@@ -110,7 +112,7 @@ function transformCase(str) {
 /**
  * Render template by replacing placeholders
  */
-function renderTemplate(templatePath, variables) {
+function renderTemplate(templatePath, variables, mcpData = null) {
   if (!fs.existsSync(templatePath)) {
     throw new Error(`Template file not found: ${templatePath}`);
   }
@@ -120,8 +122,8 @@ function renderTemplate(templatePath, variables) {
   // Get default variables
   const defaults = getDefaultVariables();
 
-  // Merge with provided variables (provided takes precedence)
-  const allVariables = { ...defaults, ...variables };
+  // Merge: defaults → MCP data → provided variables (rightmost takes precedence)
+  const allVariables = { ...defaults, ...(mcpData || {}), ...variables };
 
   // Auto-generate case transformations for FEATURE_NAME if provided
   if (allVariables.FEATURE_NAME) {
@@ -199,14 +201,34 @@ ${colors.green}Standard Placeholders:${colors.reset}
 
 ${colors.green}Example:${colors.reset}
   node bin/render-template.js \\
-    content/.morph/templates/spec.md \\
+    stacks/blazor-azure/.morph/templates/spec.md \\
     .morph/project/outputs/scheduled-reports/spec.md \\
     '{"FEATURE_NAME":"scheduled-reports","STACK":"Blazor"}'
 
 ${colors.green}Flags:${colors.reset}
-  --help, -h       Show this help message
-  --verbose, -v    Show detailed replacement information
-  --dry-run, -d    Preview output without writing file
+  --help, -h           Show this help message
+  --verbose, -v        Show detailed replacement information
+  --dry-run, -d        Preview output without writing file
+  --with-mcp-data      Inject dynamic MCP data (project stats, compliance, activity)
+
+${colors.green}MCP Data Placeholders:${colors.reset} (Available with --with-mcp-data flag)
+  {{MCP_PROJECT_FILES}}            - Total files in project
+  {{MCP_TEST_COVERAGE}}            - Test coverage percentage (or N/A)
+  {{MCP_COMPLIANCE_SCORE}}         - Overall compliance score (0-100)
+  {{MCP_LAST_FEATURE}}             - Name of last feature worked on
+  {{MCP_LAST_COMMIT}}              - Last git commit message
+  {{MCP_LAST_COMMIT_AUTHOR}}       - Author of last commit
+  {{MCP_LAST_COMMIT_TIME}}         - Relative time of last commit
+  {{MCP_CS_FILES}}                 - Number of .cs files
+  {{MCP_RAZOR_FILES}}              - Number of .razor files
+  {{MCP_TS_FILES}}                 - Number of .ts files
+  {{MCP_JS_FILES}}                 - Number of .js files
+  {{MCP_NUGET_PACKAGES}}           - Number of NuGet packages
+  {{MCP_NPM_PACKAGES}}             - Number of npm packages
+  {{MCP_ARCHITECTURE_VIOLATIONS}}  - Architecture validator errors
+  {{MCP_PACKAGE_CONFLICTS}}        - Package conflict count
+  {{MCP_SECURITY_ISSUES}}          - Security validator issues
+  {{MCP_RECENT_BRANCHES}}          - Recent git branches (up to 3)
 
 ${colors.yellow}Note:${colors.reset} DATE, YEAR, AUTHOR, PROJECT_NAME, STACK, NAMESPACE are auto-populated from config.json
   `);
@@ -215,7 +237,7 @@ ${colors.yellow}Note:${colors.reset} DATE, YEAR, AUTHOR, PROJECT_NAME, STACK, NA
 /**
  * Main CLI logic
  */
-function main() {
+async function main() {
   const args = process.argv.slice(2);
 
   // Check for help flag
@@ -227,9 +249,10 @@ function main() {
   // Parse flags
   const verbose = args.includes('--verbose') || args.includes('-v');
   const dryRun = args.includes('--dry-run') || args.includes('-d');
+  const withMcpData = args.includes('--with-mcp-data');
 
   // Filter out flags
-  const flags = ['--verbose', '-v', '--dry-run', '-d', '--help', '-h'];
+  const flags = ['--verbose', '-v', '--dry-run', '-d', '--help', '-h', '--with-mcp-data'];
   const cleanArgs = args.filter(arg => !flags.includes(arg));
 
   // Validate arguments
@@ -252,10 +275,31 @@ function main() {
   }
 
   try {
+    // Get MCP data if requested
+    let mcpData = null;
+    if (withMcpData) {
+      try {
+        console.log(`${colors.cyan}🔍 Gathering MCP data from project...${colors.reset}`);
+        mcpData = await getAllTemplatePlaceholders(process.cwd());
+
+        if (verbose) {
+          console.log(`${colors.green}✅ MCP data loaded:${colors.reset}`);
+          console.log(`   Files: ${mcpData.MCP_PROJECT_FILES}`);
+          console.log(`   Coverage: ${mcpData.MCP_TEST_COVERAGE}`);
+          console.log(`   Compliance: ${mcpData.MCP_COMPLIANCE_SCORE}%`);
+          console.log(`   Last Feature: ${mcpData.MCP_LAST_FEATURE}\n`);
+        }
+      } catch (error) {
+        console.error(`${colors.yellow}⚠️  Warning: Failed to load MCP data - ${error.message}${colors.reset}`);
+        console.error(`   Continuing with standard placeholders only...\n`);
+      }
+    }
+
     // Render template
     const { content, replacedPlaceholders, unreplacedPlaceholders } = renderTemplate(
       templatePath,
-      variables
+      variables,
+      mcpData
     );
 
     // Dry run: just preview
@@ -299,4 +343,7 @@ function main() {
 }
 
 // Run CLI
-main();
+main().catch(error => {
+  console.error(`${colors.red}❌ Fatal error: ${error.message}${colors.reset}`);
+  process.exit(1);
+});

package/bin/semantic-detect-agents.js

@@ -17,6 +17,7 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
+import { resolveAgentsConfigPath } from '../src/lib/stack-resolver.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -121,7 +122,7 @@ function keywordBasedDetection(userRequest) {
  * Load agent descriptions for LLM context
  */
 function loadAgentDescriptions() {
-  const agentsPath = path.join(process.cwd(), 'content/.morph/config/agents.json');
+  const agentsPath = resolveAgentsConfigPath(process.cwd());
 
   if (!fs.existsSync(agentsPath)) {
     throw new Error('agents.json not found');

package/bin/{task-manager.js → task-manager.cjs}

@@ -9,7 +9,18 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const chalk = require('chalk');
+
+// Simple ANSI color helpers (chalk v5 is ESM-only, can't require in CJS)
+const chalk = {
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  blue: (s) => `\x1b[34m${s}\x1b[0m`,
+  magenta: (s) => `\x1b[35m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  gray: (s) => `\x1b[90m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+};
 
 class TaskManager {
   constructor(statePath = '.morph/state.json') {
@@ -127,6 +138,9 @@ class TaskManager {
     // Save state
     await this.saveState(state);
 
+    // Auto-generate metadata.json (for quick LLM access)
+    await this.generateMetadata(featureName, feature);
+
     // Display progress
     this.displayProgress(feature);
 
@@ -219,10 +233,40 @@ class TaskManager {
    * Auto-checkpoint every 3 tasks (includes validation summary)
    */
   async autoCheckpoint(feature, tasks, featureName) {
+    const tasksCompleted = feature.tasks?.completed || tasks.length;
+    const checkpointNum = Math.floor(tasksCompleted / 3);
+
+    console.log(chalk.magenta(`\n🔍 CHECKPOINT ${checkpointNum} - Running automated validation...`));
+
+    let checkpointResult = null;
     let validationNote = '';
 
-    // Run validation and include summary in checkpoint
-    if (featureName) {
+    // Run checkpoint hooks (new enhanced validation system)
+    try {
+      const { runCheckpointHooks, shouldRunCheckpoint } = await import('../src/lib/checkpoint-hooks.js');
+
+      if (shouldRunCheckpoint(tasksCompleted, 3)) {
+        checkpointResult = await runCheckpointHooks(featureName, checkpointNum);
+
+        if (checkpointResult.passed) {
+          validationNote = ' | ✓ All validations passed';
+        } else {
+          validationNote = ` | ✗ ${checkpointResult.summary.errors} errors, ${checkpointResult.summary.warnings} warnings`;
+
+          // Check if we should block progress
+          const config = await this.loadCheckpointConfig();
+          if (config.checkpoints?.onFailure?.blockProgress && checkpointResult.summary.errors > 0) {
+            console.log(chalk.red('\n❌ Checkpoint FAILED - Fix violations before proceeding'));
+            throw new Error('Checkpoint validation failed');
+          }
+        }
+      }
+    } catch (error) {
+      if (error.message === 'Checkpoint validation failed') {
+        throw error; // Re-throw to block task completion
+      }
+      // Fallback to old validation if checkpoint-hooks not available
+      console.log(chalk.yellow('⚠️  Checkpoint hooks not available, using legacy validation'));
       try {
         const { runValidation } = await import('../src/lib/validation-runner.js');
         const result = await runValidation('.', featureName, { verbose: false });
@@ -230,23 +274,84 @@ class TaskManager {
           ? ' | Validation: PASSED'
           : ` | Validation: ${result.errors.length} errors, ${result.warnings.length} warnings`;
       } catch {
-        // Validation not available, skip
+        // No validation available
       }
     }
 
+    // Create checkpoint record
     const checkpoint = {
       id: `CHECKPOINT_AUTO_${Date.now()}`,
       timestamp: new Date().toISOString(),
       tasksCompleted: tasks.map(t => t.id),
-      note: `Auto-checkpoint: ${tasks.length} tasks completed${validationNote}`
+      note: `Auto-checkpoint: ${tasks.length} tasks completed${validationNote}`,
+      validationResults: checkpointResult?.results || null
     };
 
     feature.checkpoints = feature.checkpoints || [];
     feature.checkpoints.push(checkpoint);
 
-    console.log(chalk.magenta(`\n🎉 Auto-checkpoint reached! ${tasks.length} tasks completed`));
-    if (validationNote) {
-      console.log(chalk.gray(`   ${validationNote.trim().replace(/^ \| /, '')}`));
+    if (checkpointResult?.passed) {
+      console.log(chalk.green(`\n✅ Checkpoint ${checkpointNum} PASSED`));
+    } else if (checkpointResult) {
+      console.log(chalk.yellow(`\n⚠️  Checkpoint ${checkpointNum} completed with warnings`));
+    } else {
+      console.log(chalk.magenta(`\n🎉 Auto-checkpoint ${checkpointNum} reached!`));
+    }
+  }
+
+  /**
+   * Load checkpoint configuration from llm-interaction.json
+   */
+  async loadCheckpointConfig() {
+    try {
+      const configPath = path.join(process.cwd(), '.morph/config/llm-interaction.json');
+      const content = await fs.readFile(configPath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      // Return defaults if config doesn't exist
+      return {
+        checkpoints: {
+          frequency: 3,
+          autoValidate: true,
+          onFailure: {
+            blockProgress: false
+          }
+        }
+      };
+    }
+  }
+
+  /**
+   * Auto-generate metadata.json after task completion
+   */
+  async generateMetadata(featureName, feature) {
+    try {
+      const config = await this.loadCheckpointConfig();
+
+      // Check if auto-generation is enabled
+      if (!config.metadata?.autoGenerate) {
+        return;
+      }
+
+      const { extractFeatureMetadata } = await import('../src/lib/metadata-extractor.js');
+      const metadata = extractFeatureMetadata(feature);
+
+      const outputPath = path.join(
+        process.cwd(),
+        `.morph/project/outputs/${featureName}/metadata.json`
+      );
+
+      // Ensure directory exists
+      const outputDir = path.dirname(outputPath);
+      await fs.mkdir(outputDir, { recursive: true });
+
+      // Write metadata
+      await fs.writeFile(outputPath, JSON.stringify(metadata, null, 2), 'utf-8');
+
+      console.log(chalk.gray(`   📊 Metadata updated: ${path.relative(process.cwd(), outputPath)}`));
+    } catch (error) {
+      // Don't block task completion if metadata generation fails
+      console.log(chalk.yellow(`   ⚠️  Metadata generation failed: ${error.message}`));
     }
   }
 

package/bin/validate-agents-skills.js

@@ -14,10 +14,12 @@
 import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { resolveAgentsConfigPath, resolveStackPath } from '../src/lib/stack-resolver.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const AGENTS_CONFIG_PATH = join(__dirname, '../content/.morph/config/agents.json');
-const SKILLS_BASE_PATH = join(__dirname, '../content/.claude/skills');
+const frameworkRoot = join(__dirname, '..');
+const AGENTS_CONFIG_PATH = resolveAgentsConfigPath(frameworkRoot);
+const SKILLS_BASE_PATH = join(resolveStackPath(frameworkRoot), '.claude/skills');
 
 // Cores para output
 const colors = {
@@ -60,8 +62,12 @@ function getAllSkillFiles(dir, fileList = []) {
     if (stat.isDirectory()) {
       getAllSkillFiles(filePath, fileList);
     } else if (file.endsWith('.md')) {
-      // Converter para path relativo ao content/
-      const relativePath = filePath.replace(/\\/g, '/').split('/content/')[1];
+      // Converter para path relativo ao stacks/blazor-azure/
+      const stackPath = resolveStackPath(frameworkRoot).replace(/\\/g, '/');
+      const normalizedFile = filePath.replace(/\\/g, '/');
+      const relativePath = normalizedFile.startsWith(stackPath)
+        ? normalizedFile.slice(stackPath.length + 1)
+        : normalizedFile;
       fileList.push(relativePath);
     }
   });

package/bin/validate-agents.js

@@ -4,21 +4,22 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
+import { resolveAgentsConfigPath, resolveStackPath } from '../src/lib/stack-resolver.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 function main() {
   const args = process.argv.slice(2);
-  
+
   if (args.includes('--help') || args.includes('-h')) {
     console.log('Usage: node bin/validate-agents.js [agents-file-path]');
     process.exit(0);
   }
 
-  const defaultPath = path.join(process.cwd(), 'content/.morph/config/agents.json');
+  const defaultPath = resolveAgentsConfigPath(process.cwd());
   const agentsPath = args[0] || defaultPath;
-  const schemaPath = path.join(__dirname, '../content/.morph/schemas/agent.schema.json');
+  const schemaPath = path.join(resolveStackPath(path.join(__dirname, '..')), '.morph/schemas/agent.schema.json');
 
   if (!fs.existsSync(agentsPath)) {
     console.error('Error: agents.json not found at', agentsPath);