dev-harness-cli 1.0.0

package/cli/commands/phase.mjs

@@ -0,0 +1,182 @@
+/**
+ * phase — Invoke a phase by name.
+ *
+ * Transitions the state machine, runs the inner loop,
+ * then triggers the outer loop for autopilot advancement.
+ *
+ * Usage:
+ *   harness-dev phase <name>
+ *   harness-dev phase <name> --json
+ */
+import { CliError, EXIT, die } from '../lib/errors.mjs';
+import { transitionPhase, getPhaseOrder, loadConfig } from '../lib/state.mjs';
+import { runPhase, getPhaseType } from '../lib/ralph-inner.mjs';
+import { continuePipeline } from '../lib/ralph-outer.mjs';
+import { promptYesNo, shouldConfirmGates, shouldAutoPrompt } from '../lib/modes.mjs';
+import { parseCommandArgs, phaseLabel } from '../lib/command-helpers.mjs';
+
+export default async function phaseCommand(args) {
+  const { json, targetDir, gitOps } = parseCommandArgs(args);
+  const phase = args.subcommand;
+
+  // Load config to get enabled phases (e.g. simplify may be enabled)
+  const { config: cfg, ok: cfgOk } = loadConfig(targetDir);
+  const enabledPhases = cfgOk ? cfg.phases?.enabled : undefined;
+
+  // Validate phase name
+  const validPhases = getPhaseOrder(enabledPhases);
+  if (!phase) {
+    die(
+      new CliError(
+        `Phase name required.\nValid phases: ${validPhases.join(', ')}`,
+        EXIT.USAGE_ERROR,
+      ),
+      json,
+    );
+    return;
+  }
+
+  if (!validPhases.includes(phase)) {
+    die(
+      new CliError(
+        `Invalid phase "${phase}". Valid: ${validPhases.join(', ')}`,
+        EXIT.USAGE_ERROR,
+      ),
+      json,
+    );
+    return;
+  }
+
+  // Pre-transition pause check for autopilot
+  const { config: preConfig, ok: preOk } = loadConfig(targetDir);
+  const preMode = preOk ? (preConfig.mode ?? 'copilot') : 'copilot';
+  if (preOk && preConfig.paused && preMode === 'autopilot') {
+    const msg = 'Pipeline is paused. Run: harness-dev resume';
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'phase',
+        phase,
+        status: 'paused',
+        message: msg,
+        currentPhase: preConfig.currentPhase,
+        mode: preMode,
+      }) + '\n');
+    } else {
+      process.stdout.write(`  ⏸ ${msg}\n`);
+    }
+    return;
+  }
+
+  // Attempt phase transition
+  const transitionResult = transitionPhase(targetDir, phase);
+
+  if (!transitionResult.ok) {
+    die(
+      new CliError(transitionResult.error || 'Phase transition failed', EXIT.VALIDATION_FAILURE),
+      json,
+    );
+    return;
+  }
+
+  const mode = transitionResult.config?.mode ?? 'copilot';
+  const phaseType = getPhaseType(phase);
+
+  // Run the inner loop for this phase
+  const loopResult = runPhase(targetDir, phase, { json, gitOps });
+
+  if (!loopResult.ok) {
+    die(
+      new CliError(loopResult.message, EXIT.VALIDATION_FAILURE),
+      json,
+    );
+    return;
+  }
+
+  // ── Phase complete — trigger outer loop ──────────────────────────────
+  const order = getPhaseOrder(transitionResult.config?.phases?.enabled);
+  const phaseIdx = order.indexOf(phase);
+  const nextPhase = (phaseIdx >= 0 && phaseIdx < order.length - 1) ? order[phaseIdx + 1] : null;
+
+  if (json) {
+    // Build JSON output
+    const out = {
+      command: 'phase',
+      phase,
+      status: loopResult.status,
+      message: loopResult.message,
+      currentPhase: phase,
+      mode,
+      phaseType,
+      iteration: loopResult.iteration,
+      nextPhase,
+    };
+
+    if (loopResult.details) {
+      Object.assign(out, loopResult.details);
+    }
+
+    // In autopilot mode with complete status — continue pipeline
+    if (mode === 'autopilot' && loopResult.status === 'complete') {
+      const pipelineResult = continuePipeline(targetDir, phase, { json, verbose: false });
+      out.pipeline = {
+        status: pipelineResult.status,
+        message: pipelineResult.message,
+        phasesRemaining: pipelineResult.phasesRemaining,
+        nextPhase: pipelineResult.nextPhase || null,
+      };
+    }
+
+    process.stdout.write(JSON.stringify(out) + '\n');
+    return;
+  }
+
+  // ── Human output ────────────────────────────────────────────────────
+  if (loopResult.status === 'complete') {
+    process.stdout.write(`\n${phaseLabel(phase)} phase complete.\n`);
+
+    if (mode === 'autopilot') {
+      // Autopilot: continue pipeline automatically
+      const pipelineResult = continuePipeline(targetDir, phase, { json: false, verbose: true });
+      if (pipelineResult.status === 'complete') {
+        process.stdout.write(`\n✓ Pipeline complete. All phases done.\n`);
+      } else if (pipelineResult.status === 'instruction') {
+        process.stdout.write(`\nNext: harness-dev phase ${pipelineResult.nextPhase}\n`);
+      }
+    } else if (nextPhase) {
+      // Copilot: print next step
+      process.stdout.write(`Next: harness-dev phase ${nextPhase}\n`);
+      // Auto-prompt: controlled by two independent flags:
+      //   autoPrompt=true  → show the prompt
+      //   confirmGates=true → require y/n answer before continuing
+      if (shouldAutoPrompt(targetDir)) {
+        if (shouldConfirmGates(targetDir)) {
+          const answer = await promptYesNo(`Advance to ${nextPhase.toUpperCase()}?`);
+          if (answer === true) {
+            process.stdout.write(`\n  ● Advancing to "${nextPhase}"...\n`);
+            const pipelineResult = continuePipeline(targetDir, phase, { json: false, verbose: true });
+            if (pipelineResult.status === 'complete') {
+              process.stdout.write(`\n✓ Pipeline complete. All phases done.\n`);
+            }
+          } else if (answer === false) {
+            process.stdout.write(`  Staying in ${phase.toUpperCase()}. Run: harness-dev phase ${nextPhase} when ready.\n`);
+          }
+          // null = no TTY, skipped
+        } else {
+          // confirmGates disabled — auto-advance without waiting for input
+          process.stdout.write(`  ● Auto-advancing to "${nextPhase}"...\n`);
+          const pipelineResult = continuePipeline(targetDir, phase, { json: false, verbose: true });
+          if (pipelineResult.status === 'complete') {
+            process.stdout.write(`\n✓ Pipeline complete. All phases done.\n`);
+          }
+        }
+      }
+    } else {
+      process.stdout.write('Pipeline complete.\n');
+    }
+  } else if (loopResult.status === 'instruction') {
+    // runPhase already printed the task instructions
+    if (mode === 'autopilot' && nextPhase) {
+      process.stdout.write(`After gate passes, autopilot will continue to "${nextPhase}".\n`);
+    }
+  }
+}

package/cli/commands/resume.mjs

@@ -0,0 +1,33 @@
+/**
+ * resume — Resume autopilot execution.
+ *
+ * Sets config.paused = false. Allows autopilot to continue.
+ *
+ * Usage: harness-dev resume [--json]
+ */
+import { set } from '../lib/state.mjs';
+import { parseCommandArgs } from '../lib/command-helpers.mjs';
+import { emitJson, emitHuman, emitHumanError } from '../lib/output.mjs';
+
+export default async function resumeCommand(args) {
+  const { json, targetDir } = parseCommandArgs(args);
+
+  const result = set(targetDir, 'paused', false);
+
+  if (json) {
+    emitJson({
+      command: 'resume',
+      status: result.ok ? 'ok' : 'error',
+      message: result.ok
+        ? 'Pipeline resumed. Run: harness-dev phase <name> to continue.'
+        : (result.error || 'Failed to resume'),
+    });
+    return;
+  }
+
+  if (result.ok) {
+    emitHuman('✓ Pipeline resumed. Run: harness-dev phase <name> to continue.\n');
+  } else {
+    emitHumanError(`✗ ${result.error}\n`);
+  }
+}

package/cli/commands/rollback.mjs

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+/**
+ * rollback — Checkpoint recovery (list/to/branch).
+ *
+ * T18 implementation:
+ *   list              — List available checkpoints (tags)
+ *   to <checkpoint>   — Restore working tree to checkpoint state
+ *   branch <checkpoint> — Create recovery branch at checkpoint
+ *
+ * Supports tag patterns:
+ *   phase/<name>     — Phase completion tags (set by outer loop)
+ *   iter/<N>         — Iteration tags (set by inner loop)
+ *   manual/<label>   — User-created manual checkpoints
+ *   recovery/*       — Recovery branches (for informational display)
+ *
+ * Usage: harness-dev rollback <subcommand> [checkpoint]
+ */
+import { die, CliError, EXIT } from '../lib/errors.mjs';
+import { execGit, getGitRoot } from '../lib/git.mjs';
+import { parseCommandArgs } from '../lib/command-helpers.mjs';
+
+const SUBCOMMANDS = ['list', 'to', 'branch'];
+
+/**
+ * Parse git tag list and return structured checkpoint data.
+ */
+function listCheckpoints(gitRoot) {
+  // Get all harness-related tags with their dates
+  const r = execGit(
+    'git tag --list "phase/*" "iter/*" "manual/*" --sort=-taggerdate --format="%(refname:short)|%(taggerdate:iso)|%(objectname)"',
+    gitRoot,
+  );
+
+  if (!r.ok || !r.stdout) {
+    return [];
+  }
+
+  const checkpoints = [];
+  for (const line of r.stdout.split('\n').filter(Boolean)) {
+    const [ref, date, hash] = line.split('|');
+    if (!ref) {continue;}
+    const segments = ref.split('/');
+    const type = segments[0]; // phase, iter, manual
+    const name = segments.slice(1).join('/');
+    checkpoints.push({ ref, type, name, date: date || 'unknown', hash: hash || '—' });
+  }
+
+  // Also add annotated tags that may not have taggerdate (fallback to *-taggerdate)
+  // Sort reverse chronologically (newest first)
+  return checkpoints;
+}
+
+/**
+ * Get short description for a checkpoint type.
+ */
+function checkpointTypeLabel(type) {
+  switch (type) {
+    case 'phase': return 'Phase gate pass';
+    case 'iter': return 'Iteration checkpoint';
+    case 'manual': return 'Manual checkpoint';
+    default: return 'Checkpoint';
+  }
+}
+
+export default async function rollbackCommand(args) {
+  const { json, targetDir } = parseCommandArgs(args);
+  const sub = args.subcommand;
+
+  if (!sub || !SUBCOMMANDS.includes(sub)) {
+    die(new CliError(`Usage: harness-dev rollback ${SUBCOMMANDS.join('|')}`, EXIT.USAGE_ERROR), json);
+    return;
+  }
+
+  if (sub !== 'list' && args.positionals.length < 1) {
+    die(new CliError(`Usage: harness-dev rollback ${sub} <checkpoint>`, EXIT.USAGE_ERROR), json);
+    return;
+  }
+
+  const gitRoot = getGitRoot(targetDir);
+  if (!gitRoot) {
+    const msg = 'Not inside a git repository. This command requires a git repo with checkpoint tags.';
+    if (json) {
+      process.stdout.write(JSON.stringify({ command: 'rollback', subcommand: sub, status: 'error', message: msg }) + '\n');
+    } else {
+      process.stderr.write(`Error: ${msg}\n`);
+    }
+    return;
+  }
+
+  const checkpoint = args.positionals[0] || null;
+
+  // ── list ─────────────────────────────────────────────────────────────────
+  if (sub === 'list') {
+    const checkpoints = listCheckpoints(gitRoot);
+
+    // Also list recovery branches
+    const branchR = execGit(
+      'git branch --list "recovery/*" --format="%(refname:short)|%(subject)|%(objectname:short)"',
+      gitRoot,
+    );
+    const recoveryBranches = [];
+    if (branchR.ok && branchR.stdout) {
+      for (const line of branchR.stdout.split('\n').filter(Boolean)) {
+        const [ref, subject, hash] = line.split('|');
+        recoveryBranches.push({ branch: ref || line, subject: subject || '', hash: hash || '' });
+      }
+    }
+
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'rollback',
+        subcommand: 'list',
+        status: 'ok',
+        message: `${checkpoints.length} checkpoint(s) found`,
+        checkpoints,
+        recoveryBranches,
+      }) + '\n');
+    } else {
+      if (checkpoints.length === 0 && recoveryBranches.length === 0) {
+        process.stdout.write('No checkpoints found. Phase tags (phase/*) and iteration tags (iter/*) are created automatically when auto-tagging is enabled.\n');
+        process.stdout.write('Manual checkpoints: harness-dev checkpoint create <label>\n');
+      } else {
+        if (checkpoints.length > 0) {
+          process.stdout.write('Checkpoints:\n');
+          process.stdout.write(`${''.padEnd(32)} Type                      Date                       Hash\n`);
+          process.stdout.write(`${''.padEnd(32, '-')} ${''.padEnd(26, '-')} ${''.padEnd(26, '-')} ${''.padEnd(10, '-')}\n`);
+          for (const cp of checkpoints) {
+            const typeLabel = checkpointTypeLabel(cp.type).padEnd(26);
+            const date = (cp.date || '—').padEnd(26);
+            process.stdout.write(`${cp.ref.padEnd(32)} ${typeLabel} ${date} ${cp.hash}\n`);
+          }
+        }
+        if (recoveryBranches.length > 0) {
+          process.stdout.write('\nRecovery branches:\n');
+          for (const rb of recoveryBranches) {
+            process.stdout.write(`  ${rb.branch}  (${rb.hash})\n`);
+          }
+        }
+      }
+    }
+    return;
+  }
+
+  // ── to ───────────────────────────────────────────────────────────────────
+  if (sub === 'to') {
+    // Verify the tag exists
+    const tagCheck = execGit(`git rev-parse --verify "${checkpoint}^{commit}"`, gitRoot);
+    if (!tagCheck.ok) {
+      const msg = `Checkpoint "${checkpoint}" not found. Run: harness-dev rollback list`;
+      if (json) {
+        process.stdout.write(JSON.stringify({ command: 'rollback', subcommand: 'to', checkpoint, status: 'error', message: msg }) + '\n');
+      } else {
+        process.stderr.write(`Error: ${msg}\n`);
+      }
+      return;
+    }
+    const targetHash = tagCheck.stdout;
+
+    // Stash any uncommitted changes
+    execGit('git stash push -m "rollback-auto-stash"', gitRoot);
+
+    // Restore all files from the checkpoint
+    const restoreFiles = [
+      'harness-config.json',
+      'progress.md',
+      'feature_list.json',
+    ];
+
+    // First, restore the whole working tree from the tag
+    const restoreResult = execGit(`git checkout "${checkpoint}" -- .`, gitRoot);
+    if (!restoreResult.ok) {
+      const msg = `Failed to restore files from ${checkpoint}: ${restoreResult.stderr || restoreResult.stdout}`;
+      if (json) {
+        process.stdout.write(JSON.stringify({ command: 'rollback', subcommand: 'to', checkpoint, status: 'error', message: msg }) + '\n');
+      } else {
+        process.stderr.write(`Error: ${msg}\n`);
+      }
+      return;
+    }
+
+    // Also explicitly restore harness state files from the tag
+    for (const file of restoreFiles) {
+      execGit(`git checkout "${checkpoint}" -- "${file}"`, gitRoot);
+    }
+
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'rollback',
+        subcommand: 'to',
+        checkpoint,
+        hash: targetHash,
+        status: 'ok',
+        message: `Working tree restored to checkpoint "${checkpoint}" (${targetHash.slice(0, 8)})`,
+      }) + '\n');
+    } else {
+      process.stdout.write(`✓ Working tree restored to checkpoint "${checkpoint}" (${targetHash.slice(0, 8)})\n`);
+      process.stdout.write(`  Files restored from ${checkpoint}\n`);
+      process.stdout.write('  Note: Uncommitted changes were stashed (git stash list)\n');
+    }
+    return;
+  }
+
+  // ── branch ───────────────────────────────────────────────────────────────
+  if (sub === 'branch') {
+    // Verify the tag exists
+    const tagCheck = execGit(`git rev-parse --verify "${checkpoint}^{commit}"`, gitRoot);
+    if (!tagCheck.ok) {
+      const msg = `Checkpoint "${checkpoint}" not found. Run: harness-dev rollback list`;
+      if (json) {
+        process.stdout.write(JSON.stringify({ command: 'rollback', subcommand: 'branch', checkpoint, status: 'error', message: msg }) + '\n');
+      } else {
+        process.stderr.write(`Error: ${msg}\n`);
+      }
+      return;
+    }
+    const targetHash = tagCheck.stdout;
+
+    // Generate a safe branch name
+    const safeName = checkpoint.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/\//g, '-');
+    const branchName = `recovery/from-${safeName}`;
+
+    // Check branch doesn't already exist
+    const branchCheck = execGit(`git show-ref --verify --quiet refs/heads/${branchName}`, gitRoot);
+    if (branchCheck.ok) {
+      const msg = `Recovery branch "${branchName}" already exists. Check it out directly: git checkout ${branchName}`;
+      if (json) {
+        process.stdout.write(JSON.stringify({ command: 'rollback', subcommand: 'branch', checkpoint, branch: branchName, status: 'error', message: msg }) + '\n');
+      } else {
+        process.stderr.write(`Error: ${msg}\n`);
+      }
+      return;
+    }
+
+    // Create the recovery branch
+    const branchResult = execGit(`git checkout -b "${branchName}" "${checkpoint}"`, gitRoot);
+    if (!branchResult.ok) {
+      const msg = `Failed to create recovery branch: ${branchResult.stderr || branchResult.stdout}`;
+      if (json) {
+        process.stdout.write(JSON.stringify({ command: 'rollback', subcommand: 'branch', checkpoint, branch: branchName, status: 'error', message: msg }) + '\n');
+      } else {
+        process.stderr.write(`Error: ${msg}\n`);
+      }
+      return;
+    }
+
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'rollback',
+        subcommand: 'branch',
+        checkpoint,
+        branch: branchName,
+        hash: targetHash,
+        status: 'ok',
+        message: `Recovery branch "${branchName}" created at checkpoint "${checkpoint}"`,
+      }) + '\n');
+    } else {
+      process.stdout.write(`✓ Recovery branch "${branchName}" created at checkpoint "${checkpoint}" (${targetHash.slice(0, 8)})\n`);
+    }
+    return;
+  }
+}

package/cli/commands/set-mode.mjs

@@ -0,0 +1,75 @@
+/**
+ * set-mode — Switch between copilot and autopilot.
+ *
+ * Usage: harness-dev set-mode <mode>
+ *   harness-dev set-mode autopilot
+ *   harness-dev set-mode copilot
+ *   harness-dev set-mode autopilot --json
+ */
+import { die, CliError, EXIT } from '../lib/errors.mjs';
+import { set, loadConfig, getPhaseOrder } from '../lib/state.mjs';
+import { ensureCopilotConfig } from '../lib/modes.mjs';
+import { parseCommandArgs } from '../lib/command-helpers.mjs';
+import { emitJson, emitHuman, emitHumanError } from '../lib/output.mjs';
+
+export default async function setModeCommand(args) {
+  const { json, targetDir, subcommand: mode } = parseCommandArgs(args);
+  const valid = ['copilot', 'autopilot'];
+
+  if (!mode || !valid.includes(mode)) {
+    die(
+      new CliError(
+        `Mode required. Valid: ${valid.join(', ')}.\n  Example: harness-dev set-mode autopilot`,
+        EXIT.USAGE_ERROR,
+      ),
+      json,
+    );
+    return;
+  }
+
+  // Require DEFINE phase or later for autopilot
+  if (mode === 'autopilot') {
+    const { config, ok } = loadConfig(targetDir);
+    if (ok) {
+      const order = getPhaseOrder(config.phases?.enabled);
+      const defineIdx = order.indexOf('define');
+      const currentIdx = config.currentPhase ? order.indexOf(config.currentPhase) : -1;
+      if (currentIdx < 0 || currentIdx < defineIdx) {
+        const phase = config.currentPhase || 'start';
+        die(
+          new CliError(
+            `Autopilot requires DEFINE phase or later (current: "${phase}").\n  Complete INIT and DEFINE first, then switch to autopilot.`,
+            EXIT.VALIDATION_FAILURE,
+          ),
+          json,
+        );
+        return;
+      }
+    }
+  }
+
+  const result = set(targetDir, 'mode', mode);
+
+  // Ensure copilot config block exists when switching to copilot
+  if (result.ok && mode === 'copilot') {
+    ensureCopilotConfig(targetDir);
+  }
+
+  if (json) {
+    emitJson({
+      command: 'set-mode',
+      mode,
+      status: result.ok ? 'ok' : 'error',
+      message: result.ok
+        ? `Mode set to "${mode}"`
+        : (result.error || 'Failed to set mode'),
+    });
+    return;
+  }
+
+  if (result.ok) {
+    emitHuman(`✓ Mode set to "${mode}"\n`);
+  } else {
+    emitHumanError(`✗ ${result.error}\n`);
+  }
+}