forgecraft 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,1405 @@
+#!/usr/bin/env node
+import {
+  AutoPipeline,
+  GitManager,
+  Orchestrator,
+  Pipeline,
+  Worker,
+  getAdapter,
+  listAdapters,
+  loadAndValidateConfig,
+  stateManager
+} from "../chunk-2HFEPXBV.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk20 from "chalk";
+
+// src/cli/commands/init.ts
+import fs from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+var DEFAULT_CONFIG = {
+  framework: "nextjs",
+  model: "sonnet",
+  designPreview: "storybook",
+  githubSync: false,
+  githubRepo: null,
+  autoCommit: true,
+  storybook: {
+    port: 6006
+  }
+};
+async function initCommand(options) {
+  console.log(
+    chalk.bold("\n\u26A1 Forge") + " \u2014 Initializing project\n"
+  );
+  const forgeDir = path.join(process.cwd(), ".forge");
+  const exists = await fs.access(forgeDir).then(() => true).catch(() => false);
+  if (exists) {
+    console.log(
+      chalk.yellow("  .forge/ directory already exists. Reinitialize? ")
+    );
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Overwrite existing Forge config?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      console.log(chalk.dim("  Aborted."));
+      return;
+    }
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "framework",
+      message: "What framework are you using?",
+      choices: [
+        { name: "Next.js (TypeScript + Tailwind + App Router)", value: "nextjs" },
+        { name: "React + Vite (TypeScript SPA)", value: "react" },
+        { name: "Django (Python + DRF)", value: "django" },
+        { name: "Flutter (coming soon)", value: "flutter", disabled: true }
+      ],
+      default: options.framework || "nextjs"
+    },
+    {
+      type: "list",
+      name: "model",
+      message: "Which Claude model should agents use?",
+      choices: [
+        { name: "Sonnet (fast, cost-effective)", value: "sonnet" },
+        { name: "Opus (highest quality, slower)", value: "opus" },
+        { name: "Haiku (fastest, basic tasks)", value: "haiku" }
+      ],
+      default: "sonnet"
+    },
+    {
+      type: "confirm",
+      name: "githubSync",
+      message: "Sync sprint board to GitHub Issues/Projects?",
+      default: false
+    }
+  ]);
+  let githubRepo = null;
+  if (answers.githubSync) {
+    const { repo } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "repo",
+        message: "GitHub repo (owner/repo):",
+        validate: (input) => input.includes("/") || "Use format: owner/repo"
+      }
+    ]);
+    githubRepo = repo;
+  }
+  const spinner = ora("Creating .forge directory...").start();
+  const config = {
+    ...DEFAULT_CONFIG,
+    framework: answers.framework,
+    model: answers.model,
+    githubSync: answers.githubSync,
+    githubRepo
+  };
+  try {
+    await fs.mkdir(forgeDir, { recursive: true });
+    await fs.mkdir(path.join(forgeDir, "snapshots"), { recursive: true });
+    await fs.mkdir(path.join(forgeDir, "designs"), { recursive: true });
+    await fs.writeFile(
+      path.join(process.cwd(), "forge.config.json"),
+      JSON.stringify(config, null, 2)
+    );
+    await fs.writeFile(
+      path.join(forgeDir, "state.json"),
+      JSON.stringify(
+        {
+          currentPhase: "init",
+          currentStory: null,
+          workerMode: null,
+          queue: [],
+          history: []
+        },
+        null,
+        2
+      )
+    );
+    const gitignorePath = path.join(process.cwd(), ".gitignore");
+    const gitignoreExists = await fs.access(gitignorePath).then(() => true).catch(() => false);
+    if (gitignoreExists) {
+      const content = await fs.readFile(gitignorePath, "utf-8");
+      if (!content.includes(".forge/snapshots")) {
+        await fs.appendFile(gitignorePath, "\n# Forge snapshots\n.forge/snapshots/\n");
+      }
+    }
+    spinner.succeed("Created .forge/ directory");
+    console.log(
+      chalk.green("\n  \u2705 Forge initialized!\n")
+    );
+    console.log("  Created:");
+    console.log(chalk.dim("    .forge/state.json        \u2014 Sprint state"));
+    console.log(chalk.dim("    .forge/snapshots/        \u2014 Action snapshots"));
+    console.log(chalk.dim("    .forge/designs/          \u2014 Design metadata"));
+    console.log(chalk.dim("    forge.config.json        \u2014 Project config"));
+    if (answers.githubSync) {
+      console.log(
+        chalk.cyan(
+          `
+  \u{1F517} GitHub sync enabled for ${githubRepo}`
+        )
+      );
+    } else {
+      console.log(
+        chalk.dim(
+          "\n  \u{1F4A1} Tip: Run " + chalk.white("forge init --github") + " later to enable GitHub sync"
+        )
+      );
+    }
+    console.log(
+      chalk.bold(
+        "\n  Next step: " + chalk.cyan('forge plan "describe your app"') + "\n"
+      )
+    );
+  } catch (error) {
+    spinner.fail("Failed to initialize Forge");
+    console.error(chalk.red(`  ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/plan.ts
+import chalk2 from "chalk";
+import inquirer2 from "inquirer";
+async function planCommand(description, options) {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(
+      chalk2.red("\n  Forge not initialized. Run: forge init\n")
+    );
+    return;
+  }
+  if (!description) {
+    const { desc } = await inquirer2.prompt([
+      {
+        type: "input",
+        name: "desc",
+        message: "Describe your application:",
+        validate: (input) => input.length > 10 || "Please provide a more detailed description"
+      }
+    ]);
+    description = desc;
+  }
+  const pipeline = new Pipeline(config);
+  await pipeline.runPlanPhase(description);
+}
+
+// src/cli/commands/design.ts
+import chalk3 from "chalk";
+import fs2 from "fs/promises";
+import path2 from "path";
+import ora2 from "ora";
+async function designCommand(options) {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk3.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(
+      chalk3.red('\n  No sprint plan found. Run: forge plan "description"\n')
+    );
+    return;
+  }
+  if (options?.import) {
+    await importDesigns(options.import);
+    return;
+  }
+  const pipeline = new Pipeline(config);
+  await pipeline.runDesignPhase(plan);
+}
+async function importDesigns(importPath) {
+  const spinner = ora2({ text: "Importing designs...", indent: 2 }).start();
+  const absPath = path2.resolve(importPath);
+  try {
+    const stat = await fs2.stat(absPath);
+    let files = [];
+    if (stat.isDirectory()) {
+      const entries = await fs2.readdir(absPath);
+      const imageExts = [".png", ".jpg", ".jpeg", ".svg", ".webp", ".gif"];
+      files = entries.filter((f) => imageExts.includes(path2.extname(f).toLowerCase())).map((f) => path2.join(absPath, f));
+    } else {
+      files = [absPath];
+    }
+    if (files.length === 0) {
+      spinner.warn("No image files found (png, jpg, svg, webp, gif)");
+      return;
+    }
+    await stateManager.saveDesignReferences(files);
+    spinner.succeed(`Imported ${files.length} design reference${files.length > 1 ? "s" : ""}`);
+    console.log("");
+    for (const file of files) {
+      console.log(chalk3.dim(`    ${path2.basename(file)}`));
+    }
+    console.log("");
+    console.log(
+      chalk3.dim("  These references will be used in the design and build phases.")
+    );
+    console.log(
+      chalk3.dim("  The AI agent will read them and match the visual style.\n")
+    );
+  } catch {
+    spinner.fail(`Path not found: ${absPath}`);
+  }
+}
+
+// src/cli/commands/build.ts
+import chalk4 from "chalk";
+async function buildCommand(options) {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk4.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(
+      chalk4.red('\n  No sprint plan found. Run: forge plan "description"\n')
+    );
+    return;
+  }
+  if (options?.story) {
+    const story = plan.epics.flatMap((e) => e.stories).find((s) => s.id === options.story);
+    if (!story) {
+      console.log(chalk4.red(`
+  Story "${options.story}" not found.
+`));
+      return;
+    }
+    if (story.status === "done") {
+      console.log(chalk4.yellow(`
+  Story "${story.title}" is already done.
+`));
+      return;
+    }
+  }
+  const pipeline = new Pipeline(config);
+  await pipeline.runBuildPhase(plan);
+}
+
+// src/cli/commands/review.ts
+import chalk5 from "chalk";
+async function reviewCommand(options) {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk5.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(
+      chalk5.red('\n  No sprint plan found. Run: forge plan "description"\n')
+    );
+    return;
+  }
+  const reviewable = plan.epics.flatMap((e) => e.stories).filter((s) => s.status === "reviewing");
+  if (reviewable.length === 0) {
+    console.log(
+      chalk5.yellow("\n  No stories ready for review. Run: forge build\n")
+    );
+    return;
+  }
+  const pipeline = new Pipeline(config);
+  await pipeline.runReviewPhase(plan);
+}
+
+// src/cli/commands/sprint.ts
+import chalk6 from "chalk";
+import inquirer3 from "inquirer";
+async function sprintCommand(description) {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk6.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  if (!description) {
+    const { desc } = await inquirer3.prompt([
+      {
+        type: "input",
+        name: "desc",
+        message: "What do you want to build?",
+        validate: (input) => input.length > 10 || "Please provide a more detailed description"
+      }
+    ]);
+    description = desc;
+  }
+  const pipeline = new Pipeline(config);
+  await pipeline.runSprint(description);
+}
+
+// src/cli/commands/status.ts
+import chalk7 from "chalk";
+var STATUS_ICONS = {
+  planned: "\u{1F4CB}",
+  designing: "\u{1F3A8}",
+  "design-approved": "\u2705",
+  building: "\u{1F527}",
+  reviewing: "\u{1F50D}",
+  done: "\u2705",
+  blocked: "\u{1F6AB}"
+};
+async function statusCommand() {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk7.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const plan = await stateManager.getPlan();
+  const state = await stateManager.getState();
+  const git = new GitManager();
+  console.log(chalk7.bold("\n\u26A1 Forge Status\n"));
+  if (plan) {
+    console.log(chalk7.bold(`  Project: ${plan.project}`));
+    console.log(chalk7.dim(`  Framework: ${plan.framework}`));
+    console.log(chalk7.dim(`  Phase: ${state.currentPhase}`));
+    const currentBranch = await git.getCurrentBranch();
+    console.log(chalk7.dim(`  Branch: ${currentBranch}`));
+    console.log("");
+    const allStories = plan.epics.flatMap((e) => e.stories);
+    const done = allStories.filter((s) => s.status === "done").length;
+    const total = allStories.length;
+    const percent = total > 0 ? Math.round(done / total * 100) : 0;
+    const barWidth = 30;
+    const filled = Math.round(percent / 100 * barWidth);
+    const bar = chalk7.green("\u2588".repeat(filled)) + chalk7.dim("\u2591".repeat(barWidth - filled));
+    console.log(`  Progress: ${bar} ${percent}% (${done}/${total} stories)`);
+    console.log("");
+    for (const epic of plan.epics) {
+      console.log(chalk7.bold(`  ${epic.title}`));
+      for (const story of epic.stories) {
+        const icon = STATUS_ICONS[story.status] || "\u2753";
+        const statusText = story.status === "done" ? chalk7.green(story.status) : story.status === "building" || story.status === "reviewing" ? chalk7.yellow(story.status) : story.status === "blocked" ? chalk7.red(story.status) : chalk7.dim(story.status);
+        const branchInfo = story.branch ? chalk7.dim(` (${story.branch})`) : "";
+        console.log(
+          `    ${icon} ${story.title} \u2014 ${statusText}${branchInfo}`
+        );
+      }
+      console.log("");
+    }
+    if (state.queue.length > 0) {
+      console.log(chalk7.bold("  Queued Changes:"));
+      for (const change of state.queue) {
+        console.log(chalk7.yellow(`    \u{1F4DD} ${change.message}`));
+      }
+      console.log("");
+    }
+    const tags = await git.listTags();
+    if (tags.length > 0) {
+      console.log(chalk7.bold("  Checkpoints:"));
+      for (const tag of tags) {
+        console.log(chalk7.dim(`    \u{1F3F7}\uFE0F  ${tag}`));
+      }
+      console.log("");
+    }
+  } else {
+    console.log(chalk7.dim("  No sprint plan yet."));
+    console.log(
+      chalk7.dim(
+        "  Run: " + chalk7.white('forge plan "describe your app"') + "\n"
+      )
+    );
+  }
+}
+
+// src/cli/commands/fix.ts
+import chalk8 from "chalk";
+import ora3 from "ora";
+import { existsSync } from "fs";
+async function fixCommand(description, options) {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk8.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  if (!description || description.trim().length === 0) {
+    console.log(chalk8.red('\n  Please describe the fix: forge fix "description"\n'));
+    return;
+  }
+  if (options?.image && !existsSync(options.image)) {
+    console.log(chalk8.red(`
+  Image not found: ${options.image}
+`));
+    return;
+  }
+  console.log(chalk8.bold("\n  forge fix\n"));
+  console.log(chalk8.dim(`  "${description}"`));
+  if (options?.image) {
+    console.log(chalk8.dim(`  image: ${options.image}`));
+  }
+  console.log("");
+  const orchestrator = new Orchestrator(config);
+  const worker = new Worker(config, {});
+  const git = new GitManager();
+  const state = await stateManager.getState();
+  const spinner = ora3({ text: "Analyzing request...", indent: 2 }).start();
+  let decision;
+  try {
+    decision = await orchestrator.routeUserInput(description, state);
+  } catch (err) {
+    spinner.fail("Failed to analyze request");
+    console.log(chalk8.red(`  ${err instanceof Error ? err.message : err}`));
+    return;
+  }
+  switch (decision.action) {
+    case "route-to-worker": {
+      const mode = decision.workerMode || "fix";
+      spinner.text = `Worker (${mode}) applying fix...`;
+      const headBefore = await git.getHead();
+      await stateManager.saveSnapshot({
+        action: "fix",
+        storyId: state.currentStory,
+        branch: "main",
+        commitBefore: headBefore
+      });
+      let fixPrompt = decision.prompt || description;
+      if (options?.image) {
+        fixPrompt += `
+
+A screenshot has been saved at: ${options.image}
+Read this image file to see the visual issue the user is referring to.`;
+      }
+      const result = await worker.run(mode, fixPrompt, {
+        onProgress: (event) => {
+          if (event.type === "tool_use") {
+            spinner.text = event.content;
+          }
+        }
+      });
+      if (result.success) {
+        await git.commitAll(`fix: ${description}`);
+        spinner.succeed("Fix applied");
+        for (const file of result.filesModified) {
+          console.log(chalk8.dim(`    modified: ${file}`));
+        }
+        for (const file of result.filesCreated) {
+          console.log(chalk8.dim(`    created: ${file}`));
+        }
+      } else {
+        spinner.fail("Fix failed");
+        for (const error of result.errors) {
+          console.log(chalk8.red(`    ${error}`));
+        }
+      }
+      await stateManager.addHistoryEntry({
+        action: "fix",
+        storyId: null,
+        details: description
+      });
+      break;
+    }
+    case "add-story": {
+      spinner.succeed("New feature detected");
+      const plan = await stateManager.getPlan();
+      if (plan && plan.epics.length > 0) {
+        const newStory = {
+          id: `story-${Date.now()}`,
+          title: decision.story?.title || description,
+          description: decision.story?.description || description,
+          type: decision.story?.type || "fullstack",
+          status: "planned",
+          branch: null,
+          designApproved: false,
+          tags: [],
+          priority: 99,
+          dependencies: []
+        };
+        plan.epics[plan.epics.length - 1].stories.push(newStory);
+        await stateManager.savePlan(plan);
+        await git.commitAll(`forge: add story "${newStory.title}"`);
+        console.log(chalk8.green(`  Added: ${newStory.title}`));
+        console.log(chalk8.dim(`  Run ${chalk8.white("forge build")} or ${chalk8.white("forge auto")} to build it.
+`));
+      } else {
+        console.log(chalk8.yellow("  No plan found. Run forge plan first to create a sprint plan.\n"));
+      }
+      break;
+    }
+    case "answer": {
+      spinner.stop();
+      console.log(`  ${decision.response}
+`);
+      break;
+    }
+    case "queue-change": {
+      spinner.succeed("Change queued (Worker is busy)");
+      console.log(chalk8.dim("  Will apply after the current task completes.\n"));
+      break;
+    }
+    default: {
+      spinner.fail("Could not process request");
+      break;
+    }
+  }
+}
+
+// src/cli/commands/undo.ts
+import chalk9 from "chalk";
+import inquirer4 from "inquirer";
+async function undoCommand(options) {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk9.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const git = new GitManager();
+  console.log(chalk9.bold("\n  Forge Undo\n"));
+  const log = await git.getForgeLog(parseInt(options?.steps || "10", 10));
+  const forgeCommits = log.filter(
+    (c) => c.message.startsWith("feat:") || c.message.startsWith("fix:") || c.message.startsWith("docs:")
+  );
+  if (forgeCommits.length === 0) {
+    console.log(chalk9.dim("  No actions to undo.\n"));
+    return;
+  }
+  const choices = forgeCommits.map((commit) => {
+    const date = new Date(commit.date);
+    const timeStr = date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+    const hash = commit.hash.slice(0, 7);
+    return {
+      name: `  ${chalk9.dim(hash)}  ${commit.message}  ${chalk9.dim(timeStr)}`,
+      value: commit
+    };
+  });
+  const { selected } = await inquirer4.prompt([
+    {
+      type: "list",
+      name: "selected",
+      message: "Which action to undo?",
+      choices: [
+        ...choices,
+        new inquirer4.Separator(),
+        { name: chalk9.dim("  Cancel"), value: null }
+      ]
+    }
+  ]);
+  if (!selected) {
+    console.log(chalk9.dim("  Cancelled.\n"));
+    return;
+  }
+  const { confirm } = await inquirer4.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Revert "${selected.message}"? This creates a new commit that undoes those changes.`,
+      default: false
+    }
+  ]);
+  if (!confirm) {
+    console.log(chalk9.dim("  Cancelled.\n"));
+    return;
+  }
+  try {
+    await git.revertCommit(selected.hash);
+    console.log(chalk9.green(`
+  Reverted: ${selected.message}`));
+    console.log(chalk9.dim(`  Commit ${selected.hash.slice(0, 7)} has been undone.
+`));
+    await stateManager.addHistoryEntry({
+      action: "undo",
+      storyId: null,
+      details: `Reverted: ${selected.message} (${selected.hash.slice(0, 7)})`
+    });
+    const plan = await stateManager.getPlan();
+    if (plan && selected.message.startsWith("feat:")) {
+      const storyTitle = selected.message.replace("feat: ", "");
+      const story = plan.epics.flatMap((e) => e.stories).find((s) => s.title === storyTitle);
+      if (story && (story.status === "reviewing" || story.status === "done")) {
+        story.status = "planned";
+        await stateManager.savePlan(plan);
+        console.log(chalk9.dim(`  Story "${story.title}" reset to planned.
+`));
+      }
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes("conflict")) {
+      console.log(chalk9.red("\n  Revert has conflicts."));
+      console.log(chalk9.dim("  Resolve them manually, then: git revert --continue\n"));
+    } else {
+      console.log(chalk9.red(`
+  Failed to revert: ${msg}`));
+      console.log(chalk9.dim("  Try manually: " + chalk9.white(`git revert ${selected.hash.slice(0, 7)}`) + "\n"));
+    }
+  }
+}
+
+// src/cli/commands/auto.ts
+import chalk10 from "chalk";
+import inquirer5 from "inquirer";
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import path3 from "path";
+function checkClaudeAuth() {
+  try {
+    execSync("which claude", { stdio: "ignore" });
+  } catch {
+    return { ok: false, reason: "Claude Code CLI is not installed." };
+  }
+  const claudeDir = path3.join(homedir(), ".claude");
+  if (!existsSync2(claudeDir)) {
+    return { ok: false, reason: "Claude Code is installed but not logged in." };
+  }
+  return { ok: true, reason: "" };
+}
+async function autoCommand(description, options) {
+  const auth = checkClaudeAuth();
+  if (!auth.ok) {
+    console.log(chalk10.red(`
+  ${auth.reason}
+`));
+    console.log(chalk10.bold("  Forge requires Claude Code to run.\n"));
+    console.log(chalk10.dim("  Who can use it:"));
+    console.log(chalk10.dim("    Anyone with a Claude Max, Team, or Enterprise subscription.\n"));
+    console.log(chalk10.dim("  Setup:"));
+    console.log(chalk10.dim("    1. npm install -g @anthropic-ai/claude-code"));
+    console.log(chalk10.dim("    2. claude login"));
+    console.log(chalk10.dim('    3. forge auto "your app idea"\n'));
+    console.log(chalk10.dim("  Diagnose: forge doctor\n"));
+    return;
+  }
+  const rawConfig = await stateManager.getConfig();
+  if (!rawConfig) {
+    console.log(chalk10.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const config = loadAndValidateConfig(rawConfig);
+  if (!config) return;
+  const adapter = getAdapter(config.framework);
+  const skipDesign = options.skipDesign || !adapter.designSupport;
+  if (!description) {
+    const { desc } = await inquirer5.prompt([
+      {
+        type: "input",
+        name: "desc",
+        message: "What do you want to build?",
+        validate: (input) => input.length > 10 || "Please provide a more detailed description"
+      }
+    ]);
+    description = desc;
+  }
+  const allowedDomains = options.allowNetwork ? options.allowNetwork.split(",").map((d) => d.trim()) : void 0;
+  const pipeline = new AutoPipeline(config, {
+    sandbox: options.sandbox !== false,
+    quiet: options.quiet ?? false,
+    mute: options.mute ?? false,
+    deploy: options.deploy ?? false,
+    skipDesign,
+    allowedDomains
+  });
+  const result = await pipeline.run(description);
+  if (!result.success) {
+    process.exitCode = 1;
+  }
+}
+
+// src/cli/commands/resume.ts
+import chalk11 from "chalk";
+import inquirer6 from "inquirer";
+async function resumeCommand(options) {
+  let workingDir;
+  try {
+    workingDir = process.cwd();
+  } catch {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    process.chdir(home);
+    console.log(chalk11.yellow("\n  Working directory no longer exists."));
+    console.log(chalk11.dim(`  Falling back to: ${home}`));
+    console.log(chalk11.dim("  Please cd to your project directory and retry.\n"));
+    return;
+  }
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk11.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(chalk11.red("\n  No sprint plan found. Nothing to resume.\n"));
+    console.log(chalk11.dim('  Start a new sprint: forge auto "description"\n'));
+    return;
+  }
+  const state = await stateManager.getState();
+  const allStories = plan.epics.flatMap((e) => e.stories);
+  const done = allStories.filter((s) => s.status === "done").length;
+  const blocked = allStories.filter((s) => s.status === "blocked").length;
+  const remaining = allStories.filter(
+    (s) => s.status !== "done" && s.status !== "blocked"
+  );
+  if (remaining.length === 0 && blocked === 0) {
+    console.log(chalk11.green("\n  Sprint is already complete. All stories done.\n"));
+    return;
+  }
+  console.log(chalk11.bold("\n  Resuming sprint"));
+  console.log(chalk11.dim(`  ${plan.project} \xB7 ${plan.framework}`));
+  console.log(chalk11.dim(`  Phase: ${state.currentPhase}`));
+  console.log(
+    chalk11.dim(`  Progress: ${done}/${allStories.length} done`) + (blocked > 0 ? chalk11.red(` \xB7 ${blocked} blocked`) : "")
+  );
+  console.log("");
+  if (remaining.length > 0) {
+    console.log(chalk11.dim("  Remaining stories:"));
+    for (const story of remaining) {
+      const icon = story.status === "building" ? chalk11.yellow("\u25D1") : story.status === "reviewing" ? chalk11.magenta("\u25D5") : story.status === "designing" ? chalk11.blue("\u25D0") : chalk11.dim("\u25CB");
+      console.log(`    ${icon} ${story.title} ${chalk11.dim(`(${story.status})`)}`);
+    }
+    console.log("");
+  }
+  if (blocked > 0) {
+    const blockedStories = allStories.filter((s) => s.status === "blocked");
+    console.log(chalk11.red("  Blocked stories:"));
+    for (const story of blockedStories) {
+      console.log(`    ${chalk11.red("\u2715")} ${story.title}`);
+    }
+    console.log("");
+  }
+  const { action } = await inquirer6.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "What would you like to do?",
+      choices: [
+        { name: `Resume (${remaining.length} stories left)`, value: "resume" },
+        ...blocked > 0 ? [{ name: `Retry blocked stories (${blocked})`, value: "retry" }] : [],
+        { name: "Cancel", value: "cancel" }
+      ]
+    }
+  ]);
+  if (action === "cancel") {
+    console.log(chalk11.dim("  Cancelled.\n"));
+    return;
+  }
+  if (action === "retry") {
+    for (const story of allStories) {
+      if (story.status === "blocked") {
+        story.status = "planned";
+      }
+    }
+    await stateManager.savePlan(plan);
+  }
+  for (const story of allStories) {
+    if (story.status === "building") {
+      story.status = story.designApproved ? "design-approved" : "planned";
+    }
+    if (story.status === "designing") {
+      story.status = "planned";
+    }
+  }
+  await stateManager.savePlan(plan);
+  const pipeline = new AutoPipeline(config, {
+    sandbox: options.sandbox !== false,
+    quiet: options.quiet ?? false,
+    mute: options.mute ?? false,
+    skipDesign: options.skipDesign ?? false
+  });
+  const result = await pipeline.resume(plan);
+  if (!result.success) {
+    process.exitCode = 1;
+  }
+}
+
+// src/cli/commands/map.ts
+import chalk12 from "chalk";
+var STATUS_ICON = {
+  planned: chalk12.dim("\u25CB"),
+  designing: chalk12.blue("\u25D0"),
+  "design-approved": chalk12.cyan("\u25D1"),
+  building: chalk12.yellow("\u25D1"),
+  reviewing: chalk12.magenta("\u25D5"),
+  done: chalk12.green("\u25CF"),
+  blocked: chalk12.red("\u2715")
+};
+var STATUS_COLOR = {
+  planned: chalk12.dim,
+  designing: chalk12.blue,
+  "design-approved": chalk12.cyan,
+  building: chalk12.yellow,
+  reviewing: chalk12.magenta,
+  done: chalk12.green,
+  blocked: chalk12.red
+};
+async function mapCommand() {
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(chalk12.red("\n  No sprint plan found. Run: forge plan\n"));
+    return;
+  }
+  const allStories = plan.epics.flatMap((e) => e.stories);
+  const done = allStories.filter((s) => s.status === "done").length;
+  const total = allStories.length;
+  const pct = total > 0 ? Math.round(done / total * 100) : 0;
+  console.log("");
+  console.log(chalk12.bold(`  ${plan.project}`) + chalk12.dim(` \xB7 ${plan.framework}`));
+  console.log(chalk12.dim(`  ${plan.description}`));
+  console.log("");
+  const barWidth = 30;
+  const filled = Math.round(done / total * barWidth);
+  const bar = chalk12.green("\u2588".repeat(filled)) + chalk12.dim("\u2591".repeat(barWidth - filled));
+  console.log(`  ${bar} ${chalk12.bold(`${pct}%`)} ${chalk12.dim(`(${done}/${total} stories)`)}`);
+  console.log("");
+  for (const epic of plan.epics) {
+    const epicDone = epic.stories.filter((s) => s.status === "done").length;
+    const epicTotal = epic.stories.length;
+    const epicStatus = epicDone === epicTotal ? chalk12.green("done") : epicDone > 0 ? chalk12.yellow("in progress") : chalk12.dim("planned");
+    console.log(`  ${chalk12.bold(epic.title)} ${chalk12.dim(`(${epicDone}/${epicTotal})`)} ${epicStatus}`);
+    for (let i = 0; i < epic.stories.length; i++) {
+      const story = epic.stories[i];
+      const isLast = i === epic.stories.length - 1;
+      const connector = isLast ? "\u2514" : "\u251C";
+      const icon = STATUS_ICON[story.status] || chalk12.dim("?");
+      const colorFn = STATUS_COLOR[story.status] || chalk12.dim;
+      const typeTag = chalk12.dim(`[${story.type === "ui" ? "ui" : story.type === "backend" ? "api" : "full"}]`);
+      let line = `  ${chalk12.dim(connector + "\u2500")} ${icon} ${colorFn(story.title)} ${typeTag}`;
+      if (story.tags.length > 0) {
+        line += " " + chalk12.dim(story.tags[story.tags.length - 1]);
+      }
+      console.log(line);
+      if (story.dependencies.length > 0) {
+        const depPrefix = isLast ? "   " : "  \u2502";
+        const depNames = story.dependencies.map((depId) => {
+          const dep = allStories.find((s) => s.id === depId);
+          if (!dep) return chalk12.dim(depId);
+          const depIcon = STATUS_ICON[dep.status] || "?";
+          return `${depIcon} ${chalk12.dim(dep.title)}`;
+        }).join(", ");
+        console.log(chalk12.dim(`${depPrefix}  \u2190 depends on: ${depNames}`));
+      }
+    }
+    console.log("");
+  }
+  console.log(
+    chalk12.dim("  Legend: ") + `${chalk12.dim("\u25CB")} planned  ${chalk12.blue("\u25D0")} designing  ${chalk12.yellow("\u25D1")} building  ${chalk12.magenta("\u25D5")} reviewing  ${chalk12.green("\u25CF")} done  ${chalk12.red("\u2715")} blocked`
+  );
+  console.log("");
+}
+
+// src/cli/commands/diff.ts
+import chalk13 from "chalk";
+async function diffCommand(v1, v2) {
+  const git = new GitManager();
+  const resolveRef = async (ref) => {
+    const tags = await git.listTags();
+    if (tags.includes(ref)) return ref;
+    const prefixed = `forge/${ref}`;
+    if (tags.includes(prefixed)) return prefixed;
+    const match = tags.find((t) => t.includes(ref));
+    if (match) return match;
+    return ref;
+  };
+  const ref1 = await resolveRef(v1);
+  const ref2 = v2 ? await resolveRef(v2) : "HEAD";
+  console.log(chalk13.bold("\n  forge diff"));
+  console.log(chalk13.dim(`  ${ref1} \u2192 ${ref2}
+`));
+  try {
+    const diff = await git.getDiff2(ref1, ref2);
+    if (!diff.trim()) {
+      console.log(chalk13.dim("  No differences found.\n"));
+      return;
+    }
+    const lines = diff.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        console.log(chalk13.bold(chalk13.white(`  ${line}`)));
+      } else if (line.startsWith("+++") || line.startsWith("---")) {
+        console.log(chalk13.dim(`  ${line}`));
+      } else if (line.startsWith("+")) {
+        console.log(chalk13.green(`  ${line}`));
+      } else if (line.startsWith("-")) {
+        console.log(chalk13.red(`  ${line}`));
+      } else if (line.startsWith("@@")) {
+        console.log(chalk13.cyan(`  ${line}`));
+      } else {
+        console.log(chalk13.dim(`  ${line}`));
+      }
+    }
+    const filesChanged = lines.filter((l) => l.startsWith("diff --git")).length;
+    const additions = lines.filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
+    const deletions = lines.filter((l) => l.startsWith("-") && !l.startsWith("---")).length;
+    console.log("");
+    console.log(
+      chalk13.dim(`  ${filesChanged} files changed, `) + chalk13.green(`${additions} additions`) + chalk13.dim(", ") + chalk13.red(`${deletions} deletions`) + "\n"
+    );
+  } catch (err) {
+    console.log(chalk13.red(`  Could not compute diff: ${err instanceof Error ? err.message : err}`));
+    console.log(chalk13.dim("  Make sure both references exist (use forge history to see tags).\n"));
+  }
+}
+
+// src/cli/commands/doctor.ts
+import chalk14 from "chalk";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import path4 from "path";
+function checkCommand(cmd) {
+  try {
+    execSync2(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getVersion(cmd) {
+  try {
+    return execSync2(`${cmd} --version`, { encoding: "utf-8" }).trim().split("\n")[0];
+  } catch {
+    return "unknown";
+  }
+}
+async function doctorCommand() {
+  console.log(chalk14.bold("\n  forge doctor\n"));
+  const checks = [];
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1));
+  checks.push({
+    name: "Node.js",
+    status: nodeMajor >= 18 ? "pass" : "fail",
+    detail: nodeVersion,
+    fix: nodeMajor < 18 ? "Upgrade to Node.js 18+: https://nodejs.org" : void 0
+  });
+  const hasGit = checkCommand("git");
+  checks.push({
+    name: "Git",
+    status: hasGit ? "pass" : "fail",
+    detail: hasGit ? getVersion("git") : "not found",
+    fix: !hasGit ? "Install git: https://git-scm.com" : void 0
+  });
+  const hasClaude = checkCommand("claude");
+  checks.push({
+    name: "Claude Code CLI",
+    status: hasClaude ? "pass" : "fail",
+    detail: hasClaude ? "installed" : "not found",
+    fix: !hasClaude ? "npm install -g @anthropic-ai/claude-code" : void 0
+  });
+  const claudeDir = path4.join(homedir2(), ".claude");
+  const hasAuth = existsSync3(claudeDir);
+  checks.push({
+    name: "Claude auth",
+    status: hasClaude && hasAuth ? "pass" : hasClaude ? "fail" : "warn",
+    detail: hasAuth ? "logged in" : "not logged in",
+    fix: !hasAuth ? "claude login" : void 0
+  });
+  const config = await stateManager.getConfig();
+  checks.push({
+    name: "Forge project",
+    status: config ? "pass" : "warn",
+    detail: config ? `${config.framework} \xB7 ${config.model}` : "not initialized in this directory",
+    fix: !config ? "forge init" : void 0
+  });
+  const plan = await stateManager.getPlan();
+  checks.push({
+    name: "Sprint plan",
+    status: plan ? "pass" : "warn",
+    detail: plan ? `${plan.project} \xB7 ${plan.epics.flatMap((e) => e.stories).length} stories` : "no plan",
+    fix: !plan ? 'forge plan "description"' : void 0
+  });
+  if (config) {
+    const framework = config.framework;
+    if (framework === "nextjs" || framework === "react") {
+      const hasNpm = checkCommand("npm");
+      checks.push({
+        name: "npm",
+        status: hasNpm ? "pass" : "fail",
+        detail: hasNpm ? getVersion("npm").replace("npm ", "") : "not found"
+      });
+    }
+    if (framework === "django") {
+      const hasPython = checkCommand("python3");
+      checks.push({
+        name: "Python 3",
+        status: hasPython ? "pass" : "fail",
+        detail: hasPython ? getVersion("python3") : "not found",
+        fix: !hasPython ? "Install Python 3.10+: https://python.org" : void 0
+      });
+    }
+  }
+  const hasGh = checkCommand("gh");
+  checks.push({
+    name: "GitHub CLI",
+    status: hasGh ? "pass" : "warn",
+    detail: hasGh ? "installed" : "not installed (optional, for GitHub sync)",
+    fix: !hasGh ? "https://cli.github.com (optional)" : void 0
+  });
+  let hasFailure = false;
+  for (const check of checks) {
+    const icon = check.status === "pass" ? chalk14.green("OK") : check.status === "fail" ? chalk14.red("FAIL") : chalk14.yellow("WARN");
+    console.log(`  ${icon}  ${chalk14.bold(check.name)} ${chalk14.dim(check.detail)}`);
+    if (check.fix) {
+      console.log(chalk14.dim(`       fix: ${check.fix}`));
+    }
+    if (check.status === "fail") hasFailure = true;
+  }
+  console.log("");
+  console.log(chalk14.dim("  Supported frameworks:"));
+  for (const adapter of listAdapters()) {
+    console.log(chalk14.dim(`    ${adapter.name} (${adapter.language})`));
+  }
+  console.log("");
+  if (hasFailure) {
+    console.log(chalk14.red("  Some checks failed. Fix the issues above before running Forge.\n"));
+  } else {
+    console.log(chalk14.green("  All checks passed. Forge is ready.\n"));
+  }
+}
+
+// src/cli/commands/clean.ts
+import chalk15 from "chalk";
+import fs3 from "fs/promises";
+import path5 from "path";
+import inquirer7 from "inquirer";
+async function cleanCommand(options) {
+  const forgeDir = path5.join(process.cwd(), ".forge");
+  try {
+    await fs3.access(forgeDir);
+  } catch {
+    console.log(chalk15.red("\n  No .forge/ directory found. Nothing to clean.\n"));
+    return;
+  }
+  if (options.snapshots) {
+    const snapshotsDir = path5.join(forgeDir, "snapshots");
+    try {
+      const files = await fs3.readdir(snapshotsDir);
+      if (files.length === 0) {
+        console.log(chalk15.dim("\n  No snapshots to clean.\n"));
+        return;
+      }
+      for (const file of files) {
+        await fs3.unlink(path5.join(snapshotsDir, file));
+      }
+      console.log(chalk15.green(`
+  Cleaned ${files.length} snapshots.
+`));
+    } catch {
+      console.log(chalk15.dim("\n  No snapshots directory found.\n"));
+    }
+    return;
+  }
+  console.log(chalk15.bold("\n  forge clean\n"));
+  console.log(chalk15.dim("  This will remove:"));
+  console.log(chalk15.dim("    .forge/plan.json       \u2014 Sprint plan"));
+  console.log(chalk15.dim("    .forge/state.json      \u2014 Sprint state"));
+  console.log(chalk15.dim("    .forge/snapshots/      \u2014 All snapshots"));
+  console.log(chalk15.dim("    .forge/designs/        \u2014 Design metadata"));
+  console.log(chalk15.dim("\n  forge.config.json will be kept.\n"));
+  if (!options.force) {
+    const { confirm } = await inquirer7.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Reset sprint state? This cannot be undone.",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      console.log(chalk15.dim("  Cancelled.\n"));
+      return;
+    }
+  }
+  const toRemove = ["plan.json", "state.json"];
+  for (const file of toRemove) {
+    try {
+      await fs3.unlink(path5.join(forgeDir, file));
+    } catch {
+    }
+  }
+  const dirsToClean = ["snapshots", "designs"];
+  for (const dir of dirsToClean) {
+    const dirPath = path5.join(forgeDir, dir);
+    try {
+      await fs3.rm(dirPath, { recursive: true });
+      await fs3.mkdir(dirPath, { recursive: true });
+    } catch {
+    }
+  }
+  await fs3.writeFile(
+    path5.join(forgeDir, "state.json"),
+    JSON.stringify({
+      currentPhase: "init",
+      currentStory: null,
+      workerMode: null,
+      queue: [],
+      history: []
+    }, null, 2)
+  );
+  console.log(chalk15.green("  Sprint state reset. Config preserved.\n"));
+  console.log(chalk15.dim('  Start fresh: forge plan "description"\n'));
+}
+
+// src/cli/commands/export.ts
+import chalk16 from "chalk";
+import fs4 from "fs/promises";
+var STATUS_LABEL = {
+  planned: "[ ]",
+  designing: "[~]",
+  "design-approved": "[~]",
+  building: "[~]",
+  reviewing: "[~]",
+  done: "[x]",
+  blocked: "[!]"
+};
+async function exportCommand(options) {
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(chalk16.red("\n  No sprint plan found. Run: forge plan\n"));
+    return;
+  }
+  const allStories = plan.epics.flatMap((e) => e.stories);
+  const done = allStories.filter((s) => s.status === "done").length;
+  let md = `# ${plan.project}
+
+`;
+  md += `> ${plan.description}
+
+`;
+  md += `**Framework:** ${plan.framework}  
+`;
+  md += `**Created:** ${plan.created}  
+`;
+  md += `**Progress:** ${done}/${allStories.length} stories complete
+
+`;
+  md += `---
+
+`;
+  for (const epic of plan.epics) {
+    const epicDone = epic.stories.filter((s) => s.status === "done").length;
+    md += `## ${epic.title} (${epicDone}/${epic.stories.length})
+
+`;
+    for (const story of epic.stories) {
+      const check = STATUS_LABEL[story.status] || "[ ]";
+      const type = story.type === "ui" ? "UI" : story.type === "backend" ? "API" : "Full";
+      md += `- ${check} **${story.title}** \`${type}\`
+`;
+      md += `  ${story.description}
+`;
+      if (story.dependencies.length > 0) {
+        const depNames = story.dependencies.map((depId) => {
+          const dep = allStories.find((s) => s.id === depId);
+          return dep ? dep.title : depId;
+        });
+        md += `  *Depends on: ${depNames.join(", ")}*
+`;
+      }
+      if (story.tags.length > 0) {
+        md += `  Tags: ${story.tags.join(", ")}
+`;
+      }
+      md += `
+`;
+    }
+  }
+  md += `---
+
+`;
+  md += `*Exported from [ForgeAI](https://github.com/joeljohn159/forgeai)*
+`;
+  const outputPath = options.output || "sprint-plan.md";
+  await fs4.writeFile(outputPath, md);
+  console.log(chalk16.green(`
+  Exported to ${outputPath}
+`));
+}
+
+// src/cli/commands/history.ts
+import chalk17 from "chalk";
+async function historyCommand() {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk17.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const git = new GitManager();
+  const state = await stateManager.getState();
+  const plan = await stateManager.getPlan();
+  console.log(chalk17.bold("\n  Forge History\n"));
+  const tags = await git.listTags();
+  if (tags.length > 0) {
+    console.log(chalk17.bold("  Checkpoints\n"));
+    for (const tag of [...tags].reverse()) {
+      const label = tag.replace("forge/", "");
+      console.log(`    ${chalk17.cyan(tag)}  ${chalk17.dim(label)}`);
+    }
+    console.log("");
+  }
+  console.log(chalk17.bold("  Activity\n"));
+  const log = await git.getForgeLog(30);
+  if (log.length === 0) {
+    console.log(chalk17.dim("    No activity yet.\n"));
+  } else {
+    for (const entry of log) {
+      const date = new Date(entry.date);
+      const timeStr = date.toLocaleDateString() + " " + date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+      const hash = entry.hash.slice(0, 7);
+      let msgColor = chalk17.white;
+      if (entry.message.startsWith("feat:")) msgColor = chalk17.green;
+      else if (entry.message.startsWith("fix:")) msgColor = chalk17.yellow;
+      else if (entry.message.startsWith("forge:")) msgColor = chalk17.cyan;
+      else if (entry.message.startsWith("docs:")) msgColor = chalk17.blue;
+      else if (entry.message.startsWith("ci:")) msgColor = chalk17.magenta;
+      const commitTags = await git.getTagsAtCommit(entry.hash);
+      const tagStr = commitTags.length > 0 ? " " + commitTags.map((t) => chalk17.cyan(`[${t}]`)).join(" ") : "";
+      console.log(
+        chalk17.dim(`    ${hash}`) + `  ${msgColor(entry.message)}` + tagStr + chalk17.dim(`  ${timeStr}`)
+      );
+    }
+    console.log("");
+  }
+  if (plan) {
+    const allStories = plan.epics.flatMap((e) => e.stories);
+    const done = allStories.filter((s) => s.status === "done").length;
+    const blocked = allStories.filter((s) => s.status === "blocked").length;
+    const total = allStories.length;
+    console.log(chalk17.bold("  Sprint\n"));
+    console.log(chalk17.dim(`    Phase: ${state.currentPhase}`));
+    console.log(chalk17.dim(`    Stories: ${done}/${total} done${blocked > 0 ? `, ${blocked} blocked` : ""}`));
+    console.log(chalk17.dim(`    History entries: ${state.history.length}`));
+    console.log("");
+  }
+  if (tags.length > 0) {
+    console.log(chalk17.dim(`  Tip: ${chalk17.white("forge checkout <tag>")} to jump to a checkpoint
+`));
+  }
+}
+async function checkoutCommand(version) {
+  const git = new GitManager();
+  const tags = await git.listTags();
+  const match = tags.find((t) => t === version || t === `forge/${version}`);
+  if (match) {
+    await git.checkoutTag(match);
+    console.log(chalk17.green(`
+  Checked out ${match}
+`));
+    console.log(chalk17.dim("  You are in detached HEAD state."));
+    console.log(chalk17.dim("  To go back: " + chalk17.white("git checkout main") + "\n"));
+    return;
+  }
+  try {
+    await git.checkout(version);
+    console.log(chalk17.green(`
+  Checked out ${version}
+`));
+  } catch {
+    console.log(chalk17.red(`
+  Version "${version}" not found.`));
+    console.log(chalk17.dim("  Run: " + chalk17.white("forge history") + " to see available versions.\n"));
+  }
+}
+
+// src/cli/commands/start.ts
+import chalk18 from "chalk";
+import { spawn } from "child_process";
+async function startCommand() {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk18.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const adapter = getAdapter(config.framework);
+  const [cmd, ...args] = adapter.devCommand.split(" ");
+  console.log(chalk18.bold("\n  forge") + chalk18.dim(" start"));
+  console.log(chalk18.dim(`  ${adapter.name} dev server on port ${adapter.devPort}
+`));
+  console.log(chalk18.dim(`  Running: ${adapter.devCommand}
+`));
+  const child = spawn(cmd, args, {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("error", (err) => {
+    console.log(chalk18.red(`
+  Failed to start: ${err.message}`));
+    console.log(chalk18.dim(`  Try running manually: ${adapter.devCommand}
+`));
+  });
+  child.on("exit", (code) => {
+    if (code && code !== 0) {
+      console.log(chalk18.red(`
+  Dev server exited with code ${code}
+`));
+    }
+  });
+}
+
+// src/cli/commands/push.ts
+import chalk19 from "chalk";
+import ora4 from "ora";
+async function pushCommand() {
+  const config = await stateManager.getConfig();
+  if (!config) {
+    console.log(chalk19.red("\n  Forge not initialized. Run: forge init\n"));
+    return;
+  }
+  const git = new GitManager();
+  const hasRemote = await git.hasRemote();
+  if (!hasRemote) {
+    console.log(chalk19.red("\n  No remote 'origin' found."));
+    console.log(chalk19.dim("  Add one with: git remote add origin <url>\n"));
+    return;
+  }
+  const spinner = ora4({ text: "Pushing to origin...", indent: 2 }).start();
+  try {
+    const hasChanges = await git.hasUncommittedChanges();
+    if (hasChanges) {
+      await git.commitAll("forge: save progress before push");
+      spinner.text = "Committed uncommitted changes, pushing...";
+    }
+    await git.push();
+    spinner.text = "Pushing tags...";
+    await git.pushTags();
+    spinner.succeed("Pushed to origin (commits + tags)");
+    const branch = await git.getCurrentBranch();
+    console.log(chalk19.dim(`  Branch: ${branch}
+`));
+  } catch (err) {
+    spinner.fail("Push failed");
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(chalk19.red(`  ${msg}
+`));
+    console.log(chalk19.dim("  Make sure you have push access and the remote is configured.\n"));
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("forge").description(
+  chalk20.bold("Forge") + " \u2014 AI Development Orchestration Framework\n  Structured multi-agent pipeline: plan \u2192 design \u2192 build \u2192 review"
+).version("1.0.0");
+program.command("auto [description]").description("Fully autonomous mode \u2014 plan, build, and review in one command").option("--no-sandbox", "Disable sandbox (not recommended)").option("-q, --quiet", "Hide live agent output, show spinners only").option("--allow-network <domains>", "Comma-separated allowed network domains").option("--mute", "Suppress notification sounds").option("--deploy", "Configure GitHub Pages deployment after build").option("--skip-design", "Skip design phase (faster, no Storybook previews)").action(autoCommand);
+program.command("resume").description("Resume an interrupted sprint from where it left off").option("--no-sandbox", "Disable sandbox").option("-q, --quiet", "Spinners only").option("--mute", "Suppress sounds").option("--skip-design", "Skip design phase").action(resumeCommand);
+program.command("sprint [description]").description("Run full pipeline with human gates between phases").action(sprintCommand);
+program.command("init").description("Initialize Forge in the current project").option("-f, --framework <framework>", "Framework (nextjs, react, django)").option("--no-storybook", "Skip Storybook setup").action(initCommand);
+program.command("plan [description]").description("Generate a sprint plan from a project description").option("--regen", "Regenerate plan from scratch").action(planCommand);
+program.command("design").description("Generate and review design previews in Storybook").option("-s, --story <storyId>", "Design a specific story only").option("--import <path>", "Import design references (screenshots, mockups)").action(designCommand);
+program.command("build").description("Build stories sequentially with the Worker agent").option("-s, --story <storyId>", "Build a specific story only").action(buildCommand);
+program.command("review").description("Run QA review on completed stories").option("-s, --story <storyId>", "Review a specific story only").action(reviewCommand);
+program.command("start").description("Start the dev server for the current project").action(startCommand);
+program.command("push").description("Push project to GitHub (commits + tags)").action(pushCommand);
+program.command("status").description("Show current sprint state and progress").action(statusCommand);
+program.command("map").description("Visual sprint map with story status and dependencies").action(mapCommand);
+program.command("diff <v1> [v2]").description("Show changes between two versions or tags").action(diffCommand);
+program.command("fix <description>").description("Fix a bug or make a small change").option("-i, --image <path>", "Attach a screenshot for visual context").action(fixCommand);
+program.command("undo").description("Revert the last agent action").option("-n, --steps <number>", "Number of commits to show", "10").action(undoCommand);
+program.command("history").description("Show version timeline, checkpoints, and activity log").action(historyCommand);
+program.command("checkout <version>").description("Jump to a specific version or checkpoint").action(checkoutCommand);
+program.command("export").description("Export sprint plan as markdown").option("-o, --output <path>", "Output file path", "sprint-plan.md").action(exportCommand);
+program.command("clean").description("Reset sprint state (keeps config)").option("-f, --force", "Skip confirmation prompt").option("--snapshots", "Only clean snapshots").action(cleanCommand);
+program.command("doctor").description("Diagnose setup issues and check system requirements").action(doctorCommand);
+program.parse();
+//# sourceMappingURL=index.js.map