@polymorphism-tech/morph-spec 8.33.0 → 8.34.2

package/src/commands/project/checkpoint.js

@@ -1,209 +1,209 @@
-/**
- * MORPH-SPEC Checkpoint Save/Restore Command
- *
- * Save and restore full context at phase boundaries.
- *
- * Usage:
- *   morph-spec checkpoint save <feature-name>
- *   morph-spec checkpoint restore <feature-name>
- *   morph-spec checkpoint list <feature-name>
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
-
-/**
- * Get checkpoints directory for a feature
- */
-function getCheckpointsDir(featureName) {
-  return path.join(process.cwd(), '.morph/checkpoints', featureName);
-}
-
-/**
- * Save checkpoint command
- */
-export async function checkpointSaveCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const feature = getFeature(featureName);
-  if (!feature) {
-    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
-    process.exit(1);
-  }
-
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  if (!fs.existsSync(outputDir)) {
-    console.error(chalk.red(`Error: No outputs found for '${featureName}'`));
-    process.exit(1);
-  }
-
-  // Create checkpoint directory with timestamp
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const label = options.label || feature.phase;
-  const checkpointName = `${label}_${timestamp}`;
-  const checkpointDir = path.join(getCheckpointsDir(featureName), checkpointName);
-  fs.mkdirSync(checkpointDir, { recursive: true });
-
-  // Copy all output files
-  const files = fs.readdirSync(outputDir);
-  let fileCount = 0;
-  for (const file of files) {
-    const src = path.join(outputDir, file);
-    const stat = fs.statSync(src);
-    if (stat.isFile()) {
-      fs.copyFileSync(src, path.join(checkpointDir, file));
-      fileCount++;
-    }
-  }
-
-  // Save state snapshot
-  const stateSnapshot = {
-    feature: { ...feature },
-    timestamp: new Date().toISOString(),
-    phase: feature.phase,
-    label,
-    files: files.filter(f => fs.statSync(path.join(outputDir, f)).isFile())
-  };
-  fs.writeFileSync(
-    path.join(checkpointDir, '_checkpoint.json'),
-    JSON.stringify(stateSnapshot, null, 2)
-  );
-
-  console.log(chalk.green(`\n✓ Checkpoint saved: ${checkpointName}`));
-  console.log(chalk.gray(`  Phase: ${feature.phase}`));
-  console.log(chalk.gray(`  Files: ${fileCount}`));
-  console.log(chalk.gray(`  Path: ${checkpointDir}\n`));
-}
-
-/**
- * Restore checkpoint command
- */
-export async function checkpointRestoreCommand(featureName, checkpointName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const checkpointsDir = getCheckpointsDir(featureName);
-  if (!fs.existsSync(checkpointsDir)) {
-    console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
-    process.exit(1);
-  }
-
-  // Find checkpoint to restore
-  let targetDir;
-  if (checkpointName) {
-    targetDir = path.join(checkpointsDir, checkpointName);
-    if (!fs.existsSync(targetDir)) {
-      console.error(chalk.red(`Error: Checkpoint '${checkpointName}' not found`));
-      process.exit(1);
-    }
-  } else {
-    // Restore latest
-    const checkpoints = fs.readdirSync(checkpointsDir)
-      .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
-      .sort()
-      .reverse();
-
-    if (checkpoints.length === 0) {
-      console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
-      process.exit(1);
-    }
-
-    targetDir = path.join(checkpointsDir, checkpoints[0]);
-    checkpointName = checkpoints[0];
-  }
-
-  // Read checkpoint metadata
-  const metaPath = path.join(targetDir, '_checkpoint.json');
-  if (!fs.existsSync(metaPath)) {
-    console.error(chalk.red('Error: Checkpoint metadata not found'));
-    process.exit(1);
-  }
-
-  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-
-  // Restore output files
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  fs.mkdirSync(outputDir, { recursive: true });
-
-  const files = fs.readdirSync(targetDir).filter(f => f !== '_checkpoint.json');
-  for (const file of files) {
-    fs.copyFileSync(path.join(targetDir, file), path.join(outputDir, file));
-  }
-
-  // Restore state
-  const state = loadState();
-  if (state.features[featureName] && meta.feature) {
-    // Preserve some current fields, restore phase and outputs
-    state.features[featureName].phase = meta.feature.phase;
-    state.features[featureName].outputs = meta.feature.outputs;
-    state.features[featureName].tasks = meta.feature.tasks;
-    state.features[featureName].approvalGates = meta.feature.approvalGates;
-    state.features[featureName].updatedAt = new Date().toISOString();
-    saveState(state);
-  }
-
-  console.log(chalk.green(`\n✓ Checkpoint restored: ${checkpointName}`));
-  console.log(chalk.gray(`  Phase: ${meta.phase}`));
-  console.log(chalk.gray(`  Files restored: ${files.length}`));
-  console.log(chalk.gray(`  Original date: ${meta.timestamp}\n`));
-}
-
-/**
- * List checkpoints command
- */
-export async function checkpointListCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const checkpointsDir = getCheckpointsDir(featureName);
-  if (!fs.existsSync(checkpointsDir)) {
-    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
-    return;
-  }
-
-  const checkpoints = fs.readdirSync(checkpointsDir)
-    .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
-    .sort()
-    .reverse();
-
-  if (checkpoints.length === 0) {
-    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
-    return;
-  }
-
-  // JSON output
-  if (options.json) {
-    const list = checkpoints.map(cp => {
-      const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
-      const meta = fs.existsSync(metaPath) ? JSON.parse(fs.readFileSync(metaPath, 'utf8')) : {};
-      return { name: cp, phase: meta.phase, timestamp: meta.timestamp, files: meta.files?.length || 0 };
-    });
-    console.log(JSON.stringify({ feature: featureName, checkpoints: list }, null, 2));
-    return;
-  }
-
-  // Visual output
-  console.log(chalk.cyan(`\nCheckpoints for '${featureName}':\n`));
-
-  for (const cp of checkpoints) {
-    const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
-    let meta = {};
-    if (fs.existsSync(metaPath)) {
-      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-    }
-
-    const date = meta.timestamp ? new Date(meta.timestamp).toLocaleString() : 'unknown';
-    console.log(chalk.white(`  ${cp}`));
-    console.log(chalk.gray(`    Phase: ${meta.phase || 'unknown'} | Files: ${meta.files?.length || '?'} | ${date}`));
-  }
-  console.log('');
-}
+/**
+ * MORPH-SPEC Checkpoint Save/Restore Command
+ *
+ * Save and restore full context at phase boundaries.
+ *
+ * Usage:
+ *   morph-spec checkpoint save <feature-name>
+ *   morph-spec checkpoint restore <feature-name>
+ *   morph-spec checkpoint list <feature-name>
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
+
+/**
+ * Get checkpoints directory for a feature
+ */
+function getCheckpointsDir(featureName) {
+  return path.join(process.cwd(), '.morph/checkpoints', featureName);
+}
+
+/**
+ * Save checkpoint command
+ */
+export async function checkpointSaveCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const feature = getFeature(featureName);
+  if (!feature) {
+    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
+    process.exit(1);
+  }
+
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  if (!fs.existsSync(outputDir)) {
+    console.error(chalk.red(`Error: No outputs found for '${featureName}'`));
+    process.exit(1);
+  }
+
+  // Create checkpoint directory with timestamp
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const label = options.label || feature.phase;
+  const checkpointName = `${label}_${timestamp}`;
+  const checkpointDir = path.join(getCheckpointsDir(featureName), checkpointName);
+  fs.mkdirSync(checkpointDir, { recursive: true });
+
+  // Copy all output files
+  const files = fs.readdirSync(outputDir);
+  let fileCount = 0;
+  for (const file of files) {
+    const src = path.join(outputDir, file);
+    const stat = fs.statSync(src);
+    if (stat.isFile()) {
+      fs.copyFileSync(src, path.join(checkpointDir, file));
+      fileCount++;
+    }
+  }
+
+  // Save state snapshot
+  const stateSnapshot = {
+    feature: { ...feature },
+    timestamp: new Date().toISOString(),
+    phase: feature.phase,
+    label,
+    files: files.filter(f => fs.statSync(path.join(outputDir, f)).isFile())
+  };
+  fs.writeFileSync(
+    path.join(checkpointDir, '_checkpoint.json'),
+    JSON.stringify(stateSnapshot, null, 2)
+  );
+
+  console.log(chalk.green(`\n✓ Checkpoint saved: ${checkpointName}`));
+  console.log(chalk.gray(`  Phase: ${feature.phase}`));
+  console.log(chalk.gray(`  Files: ${fileCount}`));
+  console.log(chalk.gray(`  Path: ${checkpointDir}\n`));
+}
+
+/**
+ * Restore checkpoint command
+ */
+export async function checkpointRestoreCommand(featureName, checkpointName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const checkpointsDir = getCheckpointsDir(featureName);
+  if (!fs.existsSync(checkpointsDir)) {
+    console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
+    process.exit(1);
+  }
+
+  // Find checkpoint to restore
+  let targetDir;
+  if (checkpointName) {
+    targetDir = path.join(checkpointsDir, checkpointName);
+    if (!fs.existsSync(targetDir)) {
+      console.error(chalk.red(`Error: Checkpoint '${checkpointName}' not found`));
+      process.exit(1);
+    }
+  } else {
+    // Restore latest
+    const checkpoints = fs.readdirSync(checkpointsDir)
+      .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
+      .sort()
+      .reverse();
+
+    if (checkpoints.length === 0) {
+      console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
+      process.exit(1);
+    }
+
+    targetDir = path.join(checkpointsDir, checkpoints[0]);
+    checkpointName = checkpoints[0];
+  }
+
+  // Read checkpoint metadata
+  const metaPath = path.join(targetDir, '_checkpoint.json');
+  if (!fs.existsSync(metaPath)) {
+    console.error(chalk.red('Error: Checkpoint metadata not found'));
+    process.exit(1);
+  }
+
+  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+
+  // Restore output files
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const files = fs.readdirSync(targetDir).filter(f => f !== '_checkpoint.json');
+  for (const file of files) {
+    fs.copyFileSync(path.join(targetDir, file), path.join(outputDir, file));
+  }
+
+  // Restore state
+  const state = loadState();
+  if (state.features[featureName] && meta.feature) {
+    // Preserve some current fields, restore phase and outputs
+    state.features[featureName].phase = meta.feature.phase;
+    state.features[featureName].outputs = meta.feature.outputs;
+    state.features[featureName].tasks = meta.feature.tasks;
+    state.features[featureName].approvalGates = meta.feature.approvalGates;
+    state.features[featureName].updatedAt = new Date().toISOString();
+    saveState(state);
+  }
+
+  console.log(chalk.green(`\n✓ Checkpoint restored: ${checkpointName}`));
+  console.log(chalk.gray(`  Phase: ${meta.phase}`));
+  console.log(chalk.gray(`  Files restored: ${files.length}`));
+  console.log(chalk.gray(`  Original date: ${meta.timestamp}\n`));
+}
+
+/**
+ * List checkpoints command
+ */
+export async function checkpointListCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const checkpointsDir = getCheckpointsDir(featureName);
+  if (!fs.existsSync(checkpointsDir)) {
+    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
+    return;
+  }
+
+  const checkpoints = fs.readdirSync(checkpointsDir)
+    .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
+    .sort()
+    .reverse();
+
+  if (checkpoints.length === 0) {
+    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
+    return;
+  }
+
+  // JSON output
+  if (options.json) {
+    const list = checkpoints.map(cp => {
+      const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
+      const meta = fs.existsSync(metaPath) ? JSON.parse(fs.readFileSync(metaPath, 'utf8')) : {};
+      return { name: cp, phase: meta.phase, timestamp: meta.timestamp, files: meta.files?.length || 0 };
+    });
+    console.log(JSON.stringify({ feature: featureName, checkpoints: list }, null, 2));
+    return;
+  }
+
+  // Visual output
+  console.log(chalk.cyan(`\nCheckpoints for '${featureName}':\n`));
+
+  for (const cp of checkpoints) {
+    const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
+    let meta = {};
+    if (fs.existsSync(metaPath)) {
+      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+    }
+
+    const date = meta.timestamp ? new Date(meta.timestamp).toLocaleString() : 'unknown';
+    console.log(chalk.white(`  ${cp}`));
+    console.log(chalk.gray(`    Phase: ${meta.phase || 'unknown'} | Files: ${meta.files?.length || '?'} | ${date}`));
+  }
+  console.log('');
+}

package/src/commands/project/doctor.js

@@ -586,11 +586,13 @@ export async function doctorWorktreesCommand(targetPath, options = {}) {
   }
 
   const issues = auditWorktrees(targetPath);
-  // `severity: 'info'` entries (a worktree carrying unintegrated work) are
-  // REPORTED but are not failures — a `doctor --worktrees || ...` in CI must not
-  // go red because somebody has an open PR. The human path below splits the same
-  // way; both surfaces must agree on what counts as broken.
-  const isProblem = (i) => i.severity !== 'info';
+  // `severity: 'info'` entries (a worktree carrying unintegrated work) and
+  // `severity: 'warn'` entries (a worktree created outside morph's container)
+  // are REPORTED but are not failures — a `doctor --worktrees || ...` in CI must
+  // not go red because somebody has an open PR or a hand-made tree. The human
+  // path below splits the same way; both surfaces must agree on what counts as
+  // broken.
+  const isProblem = (i) => !['info', 'warn'].includes(i.severity);
 
   if (options.json) {
     console.log(JSON.stringify({ issues }, null, 2));
@@ -617,7 +619,7 @@ export async function doctorWorktreesCommand(targetPath, options = {}) {
     console.log(`     → ${i.fix}`);
   }
   for (const i of informational) {
-    console.log(`  ℹ ${i.type}`);
+    console.log(i.severity === 'warn' ? chalk.yellow(`  ⚠ ${i.type}`) : `  ℹ ${i.type}`);
     console.log(`     ${i.detail}`);
     console.log(`     → ${i.fix}`);
   }

package/src/commands/project/env.js

@@ -0,0 +1,95 @@
+/**
+ * `morph-spec env [feature] [--json|--posix|--powershell]` — print the
+ * dedicated environment of a worktree (port block + compose project) in a
+ * shell-loadable form.
+ *
+ * Inside Claude Code the `worktree-env-inject` hook applies this block to
+ * every dev-server / compose launcher automatically. This command is the same
+ * contract for everything OUTSIDE the harness: a human terminal
+ * (`eval "$(morph-spec env)"`), a CI step, a sub-agent running without hooks.
+ * It derives from `buildComposeEnv` — the function the `verify` e2e node and
+ * `e2e up` already use — so a shell and the stack can never disagree.
+ *
+ * Feature resolution: explicit argument, else the `morph/{f}` (or
+ * `morph-task/{n}`) branch of the cwd. Read-only: allocation is idempotent and
+ * never moves an existing block.
+ */
+
+import { execFileSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import { buildComposeEnv } from '../../lib/e2e/compose-env.js';
+import { resolvePrimaryRoot } from './worktree.js';
+import { currentBranch } from '../../lib/worktree/feature-truth.js';
+
+/** `morph/<f>` → `<f>`; `morph-task/<n>` → `task/<n>`; anything else → null. */
+export function envKeyFromBranch(branch) {
+  if (!branch) return null;
+  const feature = branch.match(/^morph\/(.+)$/)?.[1];
+  if (feature) return feature;
+  const task = branch.match(/^morph-task\/(.+)$/)?.[1];
+  return task ? `task/${task}` : null;
+}
+
+function readConfig(root) {
+  try {
+    return JSON.parse(readFileSync(join(root, '.morph', 'config', 'config.json'), 'utf8').replace(/^/, ''));
+  } catch {
+    return null;
+  }
+}
+
+function gitCommonDir(cwd) {
+  try {
+    const out = execFileSync('git', ['rev-parse', '--git-common-dir'], { cwd, stdio: 'pipe' }).toString().trim();
+    return out ? resolve(cwd, out) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** POSIX single-quote. */
+const shq = (v) => `'${String(v).replace(/'/g, "'\\''")}'`;
+
+/**
+ * Pure: the env map for a key, or `{ error }`.
+ * @param {string|null} featureArg
+ * @param {string} cwd
+ */
+export function resolveWorktreeEnv(featureArg, cwd = process.cwd()) {
+  const key = featureArg || envKeyFromBranch(currentBranch(cwd));
+  if (!key) {
+    return { error: 'no-feature', message: 'Nenhuma feature: passe o nome ou rode de uma branch morph/{f} / morph-task/{n}.' };
+  }
+  const common = gitCommonDir(cwd);
+  if (!common) {
+    return { error: 'not-a-git-repo', message: 'Fora de um repositório git não há bloco de portas.' };
+  }
+  const root = resolvePrimaryRoot(cwd);
+  const env = buildComposeEnv({ cwd: root, config: readConfig(root), featureName: key, gitCommonDir: common });
+  return { key, env };
+}
+
+export function render(env, format) {
+  const entries = Object.entries(env);
+  if (format === 'json') return JSON.stringify(env, null, 2);
+  if (format === 'powershell') return entries.map(([k, v]) => `$env:${k}="${String(v).replace(/"/g, '`"')}"`).join('\n');
+  return entries.map(([k, v]) => `export ${k}=${shq(v)}`).join('\n');
+}
+
+/**
+ * @param {string|undefined} featureArg
+ * @param {{ json?: boolean, posix?: boolean, powershell?: boolean }} options
+ */
+export function envCommand(featureArg, options = {}) {
+  const result = resolveWorktreeEnv(featureArg || null, process.cwd());
+  if (result.error) {
+    if (options.json) console.log(JSON.stringify({ error: result.error, message: result.message }));
+    else console.error(chalk.red(`✗ ${result.message}`));
+    process.exit(1);
+  }
+  const format = options.json ? 'json' : options.powershell ? 'powershell' : 'posix';
+  console.log(render(result.env, format));
+  process.exit(0);
+}