@polymorphism-tech/morph-spec 4.11.0 → 4.12.0

package/src/commands/mcp/mcp-setup.js

@@ -211,12 +211,17 @@ async function setupSpecificMcp(targetPath, name, stack, existingMcps) {
     }]);
 
     if (installNow) {
-      const spinner = ora(`Configuring ${name}...`).start();
-      const result = await installAutoMcps(targetPath, { [name]: mcpEntry });
-      if (result.added.length > 0) {
-        spinner.succeed(`${name} MCP configured (authenticate via /mcp in Claude Code)`);
-      } else {
-        spinner.info(`${name} MCP already configured`);
+      console.log(chalk.cyan(`  Launching ${name} OAuth authentication...`));
+      try {
+        const { execSync } = await import('child_process');
+        execSync(`claude mcp add --transport http ${name} ${mcpEntry.install.config.url}`, {
+          stdio: 'inherit',
+          timeout: 120000
+        });
+        console.log(chalk.green(`  ✓ ${name} MCP configured via OAuth`));
+      } catch {
+        const instructions = generateSetupInstructions(name, mcpEntry);
+        console.log(chalk.yellow(`  Setup cancelled. Run later: ${instructions.cliCommand}`));
       }
     }
 
@@ -323,6 +328,23 @@ async function interactiveWizard(targetPath, stack, existingMcps) {
       }]);
 
       if (setupNow) {
+        // Remote MCPs — launch OAuth via claude mcp add
+        if (isRemoteMcp(entry.install.config)) {
+          console.log(chalk.cyan(`  Launching ${capitalizedName} OAuth...`));
+          try {
+            const { execSync } = await import('child_process');
+            execSync(`claude mcp add --transport http ${name} ${entry.install.config.url}`, {
+              stdio: 'inherit',
+              timeout: 120000
+            });
+            console.log(chalk.green(`  ✓ ${capitalizedName} configured via OAuth`));
+          } catch {
+            const instructions = generateSetupInstructions(name, entry);
+            console.log(chalk.yellow(`  Setup cancelled. Run later: ${instructions.cliCommand}`));
+          }
+          continue;
+        }
+
         const credentialValues = {};
         for (const cred of entry.install.credentials) {
           const { value } = await inquirer.prompt([{

package/src/commands/project/init.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'url';
 import { homedir } from 'os';
 import fs from 'fs-extra';
 import ora from 'ora';
+import { execSync } from 'child_process';
 import { logger } from '../../utils/logger.js';
 import {
   pathExists,
@@ -21,7 +22,8 @@ import {
   installAutoMcps,
   installMcpWithCredentials,
   generateSetupInstructions,
-  formatMcpStatusTable
+  formatMcpStatusTable,
+  isRemoteMcp
 } from '../../lib/installers/mcp-installer.js';
 import { setupInfra, installRulesForStack } from '../../scripts/setup-infra.js';
 import { installSkills } from '../../utils/skills-installer.js';
@@ -277,6 +279,23 @@ export async function initCommand(options) {
               }]);
 
               if (setupNow) {
+                // Remote MCPs — launch OAuth via claude mcp add
+                if (isRemoteMcp(entry.install.config)) {
+                  const url = entry.install.config.url;
+                  logger.info(`  Launching ${capitalizedName} OAuth authentication...`);
+                  try {
+                    execSync(`claude mcp add --transport http ${name} ${url}`, {
+                      stdio: 'inherit',
+                      timeout: 120000
+                    });
+                    logger.success(`  ${capitalizedName} MCP configured`);
+                    manualInstalled[name] = entry;
+                  } catch {
+                    logger.warn(`  ${capitalizedName} setup cancelled. Run later: claude mcp add --transport http ${name} ${url}`);
+                  }
+                  continue;
+                }
+
                 // Collect credentials
                 const credentialValues = {};
                 for (const cred of entry.install.credentials) {

package/src/commands/tasks/task.js

@@ -42,6 +42,8 @@ export async function taskDoneCommand(featureName, taskIds, options) {
   try {
     const args = ['done', featureName, ...taskIds];
     if (options.skipValidation) args.push('--skip-validation');
+    if (options.reason) args.push('--reason', options.reason);
+    if (options.note) args.push('--note', options.note);
     if (options.dryRun) args.push('--dry-run');
     await executeTaskManager(args);
   } catch (error) {
@@ -64,6 +66,58 @@ export async function taskStartCommand(featureName, taskId, options) {
   }
 }
 
+/**
+ * Bulk-start tasks command
+ */
+export async function taskBulkStartCommand(featureName, range, options) {
+  try {
+    const args = ['bulk-start', featureName];
+    if (range) args.push(range);
+    if (options.all) args.push('--all');
+    if (options.from) args.push('--from', options.from);
+    if (options.to) args.push('--to', options.to);
+    await executeTaskManager(args);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Bulk-done tasks command
+ */
+export async function taskBulkDoneCommand(featureName, range, options) {
+  try {
+    const args = ['bulk-done', featureName];
+    if (range) args.push(range);
+    if (options.all) args.push('--all');
+    if (options.from) args.push('--from', options.from);
+    if (options.to) args.push('--to', options.to);
+    if (options.skipValidation) args.push('--skip-validation');
+    if (options.reason) args.push('--reason', options.reason);
+    if (options.note) args.push('--note', options.note);
+    if (options.dryRun) args.push('--dry-run');
+    await executeTaskManager(args);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Annotate a task with a note
+ */
+export async function taskAnnotateCommand(featureName, taskId, text, options) {
+  try {
+    const args = ['annotate', featureName, taskId, text];
+    if (options.type) args.push('--type', options.type);
+    await executeTaskManager(args);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
 /**
  * Get next task command
  */

package/src/lib/build/build-runner.js

@@ -0,0 +1,99 @@
+/**
+ * Build Runner — Resolves and executes the project's build command.
+ *
+ * Resolution order for build command:
+ *   1. .morph/config/config.json → project.buildCommand
+ *   2. Stack profile → profile.buildCommand
+ *   3. package.json → scripts.build → "npm run build"
+ *   4. tsconfig.json at root → "npx tsc --noEmit"
+ *   5. null (no build command detected)
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getStackProfile } from '../stack/stack-profile.js';
+
+/**
+ * Resolve the build command for a project.
+ *
+ * @param {string} [projectPath] - Project root directory (defaults to '.')
+ * @returns {string | null} The build command to run, or null if none found
+ */
+export function resolveBuildCommand(projectPath = '.') {
+  // 1. Explicit override from .morph/config/config.json
+  const configPath = join(projectPath, '.morph', 'config', 'config.json');
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf8'));
+      const cmd = config?.project?.buildCommand;
+      if (cmd && typeof cmd === 'string') {
+        return cmd;
+      }
+    } catch {
+      // Malformed config — fall through to detection
+    }
+  }
+
+  // 2. Stack profile default (only when an actual stack is configured)
+  const profile = getStackProfile(projectPath);
+  if (profile.stack !== 'unknown' && profile.buildCommand) {
+    return profile.buildCommand;
+  }
+
+  // 3. package.json with a build script
+  const packageJsonPath = join(projectPath, 'package.json');
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+      if (pkg?.scripts?.build) {
+        return 'npm run build';
+      }
+    } catch {
+      // Malformed package.json — fall through
+    }
+  }
+
+  // 4. tsconfig.json at root → generic type-check
+  if (existsSync(join(projectPath, 'tsconfig.json'))) {
+    return 'npx tsc --noEmit';
+  }
+
+  // 5. Nothing found
+  return null;
+}
+
+/**
+ * Run the project's build check.
+ *
+ * @param {string} [projectPath] - Project root directory (defaults to '.')
+ * @param {object} [opts] - Optional overrides for testing
+ * @param {Function} [opts._execSync] - Override execSync for unit testing
+ * @returns {{ passed?: boolean, output?: string, exitCode?: number, command?: string, skipped?: boolean, reason?: string }}
+ */
+export function runBuildCheck(projectPath = '.', opts = {}) {
+  const cmd = resolveBuildCommand(projectPath);
+
+  if (!cmd) {
+    return { skipped: true, reason: 'No buildCommand configured and no known project file detected' };
+  }
+
+  const exec = opts._execSync ?? execSync;
+
+  try {
+    const output = exec(cmd, {
+      cwd: projectPath,
+      timeout: 120_000,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    return { passed: true, output: output ?? '', exitCode: 0, command: cmd };
+  } catch (err) {
+    return {
+      passed: false,
+      output: (err.stdout || '') + (err.stderr || ''),
+      exitCode: err.status ?? 1,
+      command: cmd
+    };
+  }
+}

package/src/lib/checkpoints/checkpoint-hooks.js

@@ -0,0 +1,110 @@
+/**
+ * Checkpoint Hooks — Orchestrates validation, build, and test phases at checkpoints.
+ *
+ * This is the module that task-manager.js imports at:
+ *   import('../src/lib/checkpoints/checkpoint-hooks.js')
+ *
+ * All three phases run independently (failures don't short-circuit) so the user
+ * gets a complete picture of all issues in a single checkpoint report.
+ */
+
+import chalk from 'chalk';
+import { runValidation } from '../validators/validation-runner.js';
+import { runBuildCheck } from '../build/build-runner.js';
+import { runTestSuite } from '../tasks/test-runner.js';
+import { persistCheckpointValidation } from '../validators/checkpoint-persistence.js';
+
+/**
+ * Determine whether a checkpoint should run based on task count and frequency.
+ *
+ * @param {number} tasksCompleted - Number of tasks completed so far
+ * @param {number} frequency - Run every N tasks (default: 3)
+ * @returns {boolean}
+ */
+export function shouldRunCheckpoint(tasksCompleted, frequency = 3) {
+  return tasksCompleted > 0 && tasksCompleted % frequency === 0;
+}
+
+/**
+ * Run all checkpoint hooks: static validation, build check, and test suite.
+ *
+ * @param {string} featureName - The feature being worked on
+ * @param {number} checkpointNum - Checkpoint sequence number
+ * @param {object} [opts] - Options
+ * @param {string} [opts.projectPath] - Project root (defaults to cwd)
+ * @returns {Promise<{ passed: boolean, summary: { errors: number, warnings: number }, results: object }>}
+ */
+export async function runCheckpointHooks(featureName, checkpointNum, opts = {}) {
+  const projectPath = opts.projectPath ?? process.cwd();
+  const results = {};
+  let totalErrors = 0;
+  let totalWarnings = 0;
+
+  // Phase 1: Static validators
+  console.log(chalk.gray('\n  Phase 1/3: Running static validators...'));
+  try {
+    const valResult = await runValidation(projectPath, featureName, { verbose: false, mode: 'full' });
+    results.validators = {
+      passed: valResult.passed,
+      errors: valResult.errors,
+      warnings: valResult.warnings,
+      details: valResult.results
+    };
+    totalErrors += valResult.errors;
+    totalWarnings += valResult.warnings;
+  } catch (err) {
+    results.validators = { passed: false, errors: 1, warnings: 0, details: {}, error: err.message };
+    totalErrors += 1;
+  }
+
+  // Phase 2: Build check
+  console.log(chalk.gray('  Phase 2/3: Running build check...'));
+  const buildResult = runBuildCheck(projectPath);
+  results.build = buildResult;
+  if (buildResult.skipped) {
+    console.log(chalk.gray(`    Skipped: ${buildResult.reason}`));
+  } else if (buildResult.passed) {
+    console.log(chalk.green(`    ✓ Build passed (${buildResult.command})`));
+  } else {
+    console.log(chalk.red(`    ✗ Build failed (${buildResult.command})`));
+    totalErrors += 1;
+  }
+
+  // Phase 3: Test suite
+  console.log(chalk.gray('  Phase 3/3: Running test suite...'));
+  const testResult = runTestSuite(projectPath);
+  results.tests = testResult;
+  if (testResult.skipped) {
+    console.log(chalk.gray(`    Skipped: ${testResult.reason}`));
+  } else if (testResult.passed) {
+    console.log(chalk.green('    ✓ Tests passed'));
+  } else {
+    console.log(chalk.red('    ✗ Tests failed'));
+    totalErrors += 1;
+  }
+
+  // Persist results
+  const summaryText = [
+    `Validators: ${results.validators?.errors || 0} errors, ${results.validators?.warnings || 0} warnings`,
+    buildResult.skipped ? 'Build: skipped' : `Build: ${buildResult.passed ? 'passed' : 'FAILED'}`,
+    testResult.skipped ? 'Tests: skipped' : `Tests: ${testResult.passed ? 'passed' : 'FAILED'}`
+  ].join(' | ');
+
+  try {
+    persistCheckpointValidation(projectPath, featureName, {
+      checkpointNum,
+      timestamp: new Date().toISOString(),
+      passed: totalErrors === 0,
+      validators: results,
+      summary: summaryText
+    });
+  } catch {
+    // Non-blocking — persistence failure shouldn't break the checkpoint
+  }
+
+  return {
+    passed: totalErrors === 0,
+    summary: { errors: totalErrors, warnings: totalWarnings },
+    results
+  };
+}