@polymorphism-tech/morph-spec 8.0.0 → 8.1.1

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/worktree.js

@@ -35,7 +35,7 @@
  */
 
 import { execSync, execFileSync } from 'child_process';
-import { existsSync, mkdirSync, symlinkSync, readFileSync, lstatSync, unlinkSync, rmdirSync, readdirSync, cpSync } from 'fs';
+import { existsSync, mkdirSync, symlinkSync, readFileSync, appendFileSync, lstatSync, unlinkSync, rmdirSync, readdirSync, cpSync } from 'fs';
 import { join, resolve, dirname, relative } from 'path';
 import chalk from 'chalk';
 
@@ -190,6 +190,88 @@ export function setupInfraLinks(worktreePath, mainCwd, opts = {}) {
       symlinkSync(target, linkPath, 'junction');
     } catch { /* fail-open */ }
   }
+
+  // Only the reparse points: a REAL directory at one of these paths was not
+  // created by us, is not a link out of the worktree, and git's normal rules
+  // already speak for it. `lstat` reports a POSIX symlink and a Windows
+  // junction alike as a symbolic link, so the exclude lands identically on
+  // both platforms — as does the bug it prevents (see excludeInfraLinks).
+  excludeInfraLinks(mainAbs, dirLinks.filter((rel) => {
+    try {
+      return lstatSync(join(wtAbs, rel)).isSymbolicLink();
+    } catch {
+      return false; // never created (target absent, or the symlink call failed)
+    }
+  }));
+}
+
+/** Marks the block `excludeInfraLinks` owns in `.git/info/exclude`. */
+const EXCLUDE_MARKER = '# morph-spec: infra links inside worktrees (managed — see setupInfraLinks)';
+
+/**
+ * Teach the repo's git to ignore the infra links a worktree carries.
+ *
+ * CRITICAL — without this, `worktree finish` is unusable on POSIX and
+ * destructive at worst, because git never sees a link as a link: it sees what
+ * the OS reports. A Windows junction IS a directory, so a `.morph/framework/`
+ * rule (trailing slash = directories only) matches it and git ignores it. A
+ * POSIX symlink is a FILE (mode 120000), so the very same rule does NOT match
+ * and the link surfaces as untracked (`??`). Both endings are bad:
+ *   - `finish` refuses on its clean-worktree gate (`worktree-dirty`) — the
+ *     careful user who commits only real work can never finish at all; or
+ *   - a `git add -A` COMMITS the links onto the feature branch, and the merge
+ *     then replaces the primary root's real `.claude/` and `.morph/framework/`
+ *     with symlinks pointing at themselves. The installation is gone, and
+ *     `finished: true` is reported.
+ *
+ * The user's `.gitignore` cannot be the fix: it is a TRACKED file (rewriting it
+ * dirties the very tree these gates read), morph deliberately ignores only the
+ * morph-OWNED subpaths of `.claude/` so a user's own settings stay trackable,
+ * and existing installs would only pick up a new rule on a re-init.
+ * `.git/info/exclude` is git's own answer to "ignore this locally": never
+ * committed, additive (it does not override the user's global excludes, and an
+ * exclude NEVER applies to a tracked file), and — unlike the per-worktree
+ * `.git/worktrees/<id>/info/exclude`, which git does not read for a linked
+ * worktree — honored from the COMMON git dir by every worktree of the repo.
+ *
+ * TRADEOFF, deliberate: patterns are matched against each working tree's own
+ * top and the file is shared, so `/.claude` also hides an UNTRACKED `.claude/`
+ * in the primary root. gitignore cannot express "only when it is a symlink",
+ * and no negation can re-include a path under an excluded directory. The cost
+ * is narrow — tracked files are untouched, and a team that versions
+ * `.claude/settings.json` has it tracked — and it buys the links being
+ * invisible to `git add -A`, which is what keeps the merge from eating the
+ * installation.
+ *
+ * Idempotent (never duplicates a pattern) and fail-open: an exclude we could
+ * not write costs a refused finish, never a wrong one.
+ *
+ * @param {string} mainCwd - Absolute path to the main project root
+ * @param {string[]} rels - worktree-relative link paths to exclude
+ */
+function excludeInfraLinks(mainCwd, rels) {
+  if (!rels.length) return;
+  try {
+    // `--git-common-dir`, never `join(mainCwd, '.git')`: the primary root may
+    // itself be a worktree (whose `.git` is a FILE), and the common dir is the
+    // only exclude every linked worktree actually reads.
+    const common = execSync('git rev-parse --git-common-dir', { cwd: mainCwd, stdio: 'pipe' }).toString().trim();
+    if (!common) return;
+    const infoDir = join(resolve(mainCwd, common), 'info');
+    const excludePath = join(infoDir, 'exclude');
+    const current = existsSync(excludePath) ? readFileSync(excludePath, 'utf8') : '';
+    const present = new Set(current.split(/\r?\n/).map((l) => l.trim()));
+    // Anchored (`/x`): these live at the top of a worktree, and an unanchored
+    // `node_modules` would also swallow nested ones the user may track.
+    const missing = rels.map((rel) => `/${rel.replace(/\\/g, '/')}`).filter((p) => !present.has(p));
+    if (!missing.length) return;
+    mkdirSync(infoDir, { recursive: true });
+    appendFileSync(excludePath, [
+      current && !current.endsWith('\n') ? '\n' : '',
+      present.has(EXCLUDE_MARKER) ? '' : `${EXCLUDE_MARKER}\n`,
+      `${missing.join('\n')}\n`,
+    ].join(''));
+  } catch { /* fail-open */ }
 }
 
 /**