forgecraft 1.4.0 → 2.0.0

package/dist/cli/index.js

@@ -6,18 +6,26 @@ import {
   Pipeline,
   Worker,
   buildAttachmentPrompt,
+  estimateCost,
   formatAttachmentList,
+  formatCostEstimate,
+  generateGitHubActions,
+  generateGitLabCI,
+  generateVisualization,
   getAdapter,
+  getTemplate,
   listAdapters,
+  listTemplates,
   loadAndValidateConfig,
   parseAttachments,
+  refreshAdapters,
   stageAttachments,
   stateManager
-} from "../chunk-NYOV5D5J.js";
+} from "../chunk-U6CZUA5R.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import chalk21 from "chalk";
+import chalk27 from "chalk";
 
 // src/cli/commands/init.ts
 import fs from "fs/promises";
@@ -67,8 +75,11 @@ async function initCommand(options) {
       choices: [
         { name: "Next.js (TypeScript + Tailwind + App Router)", value: "nextjs" },
         { name: "React + Vite (TypeScript SPA)", value: "react" },
+        { name: "Vue 3 + Nuxt 3 (Composition API + Tailwind)", value: "vue" },
+        { name: "SvelteKit (Svelte 5 + Tailwind)", value: "svelte" },
         { name: "Django (Python + DRF)", value: "django" },
-        { name: "Other (Express, Vue, Svelte, Go, Rust, etc.)", value: "generic" }
+        { name: "Flutter (Dart + Material Design 3)", value: "flutter" },
+        { name: "Other (Express, Go, Rust, etc.)", value: "generic" }
       ],
       default: options.framework || "nextjs"
     },
@@ -114,6 +125,7 @@ async function initCommand(options) {
     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.mkdir(path.join(forgeDir, "adapters"), { recursive: true });
     await fs.writeFile(
       path.join(process.cwd(), "forge.config.json"),
       JSON.stringify(config, null, 2)
@@ -148,6 +160,7 @@ async function initCommand(options) {
     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/adapters/         \u2014 Custom framework adapters"));
     console.log(chalk.dim("    forge.config.json        \u2014 Project config"));
     if (answers.githubSync) {
       console.log(
@@ -433,16 +446,25 @@ async function fixCommand(description, options) {
     console.log(chalk8.red('\n  Please describe the fix: forge fix "description"\n'));
     return;
   }
-  if (options?.image && !existsSync(options.image)) {
-    console.log(chalk8.red(`
+  if (options?.image) {
+    const { resolve } = await import("path");
+    const imgPath = resolve(options.image);
+    if (!existsSync(imgPath)) {
+      console.log(chalk8.red(`
   Image not found: ${options.image}
 `));
-    return;
+      return;
+    }
+    options.image = imgPath;
   }
-  const parsed = parseAttachments(description);
-  if (parsed.attachments.length > 0) {
-    description = parsed.description;
-    stageAttachments(parsed.attachments);
+  let parsed = { description, attachments: [] };
+  try {
+    parsed = parseAttachments(description);
+    if (parsed.attachments.length > 0) {
+      description = parsed.description;
+      stageAttachments(parsed.attachments);
+    }
+  } catch {
   }
   console.log(chalk8.bold("\n  forge fix\n"));
   console.log(chalk8.dim(`  "${description}"`));
@@ -457,15 +479,26 @@ async function fixCommand(description, options) {
   const orchestrator = new Orchestrator(config);
   const worker = new Worker(config, {});
   const git = new GitManager();
-  const state = await stateManager.getState();
+  let state;
+  try {
+    state = await stateManager.getState();
+  } catch {
+    state = { currentPhase: "init", currentStory: null, workerMode: null, queue: [], history: [] };
+  }
   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;
+    const errMsg = err instanceof Error ? err.message : String(err);
+    if (errMsg.includes("JSON") || errMsg.includes("parse") || errMsg.includes("Unexpected token")) {
+      spinner.warn("AI response parsing failed \u2014 falling back to direct fix mode");
+      decision = { action: "route-to-worker", workerMode: "fix", prompt: description };
+    } else {
+      spinner.fail("Failed to analyze request");
+      console.log(chalk8.red(`  ${errMsg}`));
+      return;
+    }
   }
   switch (decision.action) {
     case "route-to-worker": {
@@ -519,28 +552,33 @@ Read this image file to see the visual issue the user is referring to.`;
     }
     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.
+      try {
+        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"));
+        }
+      } catch (err) {
+        console.log(chalk8.red(`  Failed to add story: ${err instanceof Error ? err.message : err}
 `));
-      } else {
-        console.log(chalk8.yellow("  No plan found. Run forge plan first to create a sprint plan.\n"));
       }
       break;
     }
@@ -689,13 +727,52 @@ async function autoCommand(description, options) {
     console.log(chalk10.dim("  Diagnose: forge doctor\n"));
     return;
   }
-  const rawConfig = await stateManager.getConfig();
+  let rawConfig = await stateManager.getConfig();
   if (!rawConfig) {
-    console.log(chalk10.red("\n  Forge not initialized. Run: forge init\n"));
-    return;
+    const hasPackageJson = existsSync2("package.json");
+    const hasManagePy = existsSync2("manage.py");
+    const hasPubspec = existsSync2("pubspec.yaml");
+    const hasCargo = existsSync2("Cargo.toml");
+    if (hasPackageJson || hasManagePy || hasPubspec || hasCargo) {
+      console.log(chalk10.dim("\n  Existing project detected \u2014 auto-initializing Forge...\n"));
+      let framework = "other";
+      if (hasPackageJson) {
+        try {
+          const { readFileSync: readFileSync2 } = await import("fs");
+          const pkg = JSON.parse(readFileSync2("package.json", "utf-8"));
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          if (deps["next"]) framework = "nextjs";
+          else if (deps["nuxt"]) framework = "nuxt";
+          else if (deps["@sveltejs/kit"]) framework = "sveltekit";
+          else if (deps["vue"]) framework = "vue";
+          else if (deps["react"]) framework = "react";
+        } catch {
+        }
+      } else if (hasManagePy) {
+        framework = "django";
+      } else if (hasPubspec) {
+        framework = "flutter";
+      }
+      rawConfig = {
+        framework,
+        model: "sonnet",
+        designPreview: "storybook",
+        githubSync: false,
+        githubRepo: null,
+        autoCommit: true,
+        storybook: { port: 6006 }
+      };
+      await stateManager.saveConfig(rawConfig);
+      console.log(chalk10.dim(`  Framework: ${framework}
+`));
+    } else {
+      console.log(chalk10.red("\n  Forge not initialized. Run: forge init\n"));
+      return;
+    }
   }
   const config = loadAndValidateConfig(rawConfig);
   if (!config) return;
+  await refreshAdapters();
   const adapter = getAdapter(config.framework);
   const skipDesign = options.skipDesign || !adapter.designSupport;
   if (!description) {
@@ -728,6 +805,7 @@ async function autoCommand(description, options) {
     mute: options.mute ?? false,
     deploy: options.deploy ?? false,
     skipDesign,
+    skipTests: options.skipTests ?? false,
     allowedDomains,
     attachments
   });
@@ -1342,43 +1420,73 @@ async function checkoutCommand(version) {
 // src/cli/commands/start.ts
 import chalk18 from "chalk";
 import { spawn } from "child_process";
+import { existsSync as existsSync4, readFileSync } from "fs";
+import path6 from "path";
 async function startCommand() {
+  console.log(chalk18.bold("\n  forge") + chalk18.dim(" start\n"));
+  let devCommand = null;
+  let label = "Project";
   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);
-  let devCommand = adapter.devCommand;
-  if (adapter.id === "generic") {
+  if (config) {
     try {
-      const { readFileSync } = await import("fs");
-      const pkg = JSON.parse(readFileSync("package.json", "utf-8"));
-      if (pkg.scripts?.dev) {
-        devCommand = "npm run dev";
-      } else if (pkg.scripts?.start) {
-        devCommand = "npm start";
-      } else if (pkg.scripts?.serve) {
-        devCommand = "npm run serve";
-      }
+      await refreshAdapters();
+      const adapter = getAdapter(config.framework);
+      devCommand = adapter.devCommand;
+      label = adapter.id === "generic" ? "Custom stack" : adapter.name;
     } catch {
-      const { existsSync: existsSync4 } = await import("fs");
-      if (existsSync4("manage.py")) {
-        devCommand = "python manage.py runserver";
-      } else if (existsSync4("Cargo.toml")) {
-        devCommand = "cargo run";
-      } else if (existsSync4("go.mod")) {
-        devCommand = "go run .";
+    }
+  }
+  const detected = detectDevCommand();
+  if (detected) {
+    devCommand = detected;
+  } else if (devCommand) {
+    const npmMatch = devCommand.match(/^npm run (\S+)$/);
+    if (npmMatch) {
+      const scriptName = npmMatch[1];
+      const pkgPath = path6.join(process.cwd(), "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (!pkg.scripts?.[scriptName]) {
+          devCommand = null;
+        }
+      } catch {
+        devCommand = null;
       }
     }
   }
-  const [cmd, ...args] = devCommand.split(" ");
-  console.log(chalk18.bold("\n  forge") + chalk18.dim(" start"));
-  console.log(chalk18.dim(`  ${adapter.id === "generic" ? "Custom stack" : adapter.name} dev server
-`));
+  if (!config && detected) {
+    label = detectProjectType();
+  }
+  if (!devCommand) {
+    console.log(chalk18.red("  Could not detect how to start this project.\n"));
+    const pkgPath = path6.join(process.cwd(), "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const scripts = Object.keys(pkg.scripts || {});
+        if (scripts.length > 0) {
+          console.log(chalk18.dim("  Available scripts in package.json:"));
+          for (const s of scripts) {
+            console.log(chalk18.white(`    npm run ${s}`));
+          }
+          console.log("");
+          return;
+        }
+      } catch {
+      }
+    }
+    console.log(chalk18.dim("  Expected one of:"));
+    console.log(chalk18.dim("    - package.json with dev/start/serve script"));
+    console.log(chalk18.dim("    - manage.py (Django)"));
+    console.log(chalk18.dim("    - Cargo.toml (Rust)"));
+    console.log(chalk18.dim("    - go.mod (Go)"));
+    console.log(chalk18.dim("    - pubspec.yaml (Flutter)\n"));
+    return;
+  }
+  console.log(chalk18.dim(`  ${label} dev server`));
   console.log(chalk18.dim(`  Running: ${devCommand}
 `));
-  const child = spawn(cmd, args, {
+  const child = spawn(devCommand, {
     cwd: process.cwd(),
     stdio: "inherit",
     shell: true
@@ -1397,6 +1505,48 @@ async function startCommand() {
     }
   });
 }
+function detectDevCommand() {
+  const pkgPath = path6.join(process.cwd(), "package.json");
+  if (existsSync4(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const scripts = pkg.scripts || {};
+      if (scripts.dev) return "npm run dev";
+      if (scripts.start) return "npm start";
+      if (scripts.serve) return "npm run serve";
+    } catch {
+    }
+  }
+  if (existsSync4(path6.join(process.cwd(), "manage.py"))) {
+    return "python manage.py runserver";
+  }
+  if (existsSync4(path6.join(process.cwd(), "Cargo.toml"))) {
+    return "cargo run";
+  }
+  if (existsSync4(path6.join(process.cwd(), "go.mod"))) {
+    return "go run .";
+  }
+  if (existsSync4(path6.join(process.cwd(), "pubspec.yaml"))) {
+    return "flutter run";
+  }
+  if (existsSync4(path6.join(process.cwd(), "Gemfile"))) {
+    if (existsSync4(path6.join(process.cwd(), "bin", "rails"))) {
+      return "bundle exec rails server";
+    }
+    return "bundle exec ruby app.rb";
+  }
+  return null;
+}
+function detectProjectType() {
+  if (existsSync4(path6.join(process.cwd(), "next.config.ts")) || existsSync4(path6.join(process.cwd(), "next.config.js")) || existsSync4(path6.join(process.cwd(), "next.config.mjs"))) return "Next.js";
+  if (existsSync4(path6.join(process.cwd(), "nuxt.config.ts"))) return "Nuxt";
+  if (existsSync4(path6.join(process.cwd(), "svelte.config.js"))) return "SvelteKit";
+  if (existsSync4(path6.join(process.cwd(), "manage.py"))) return "Django";
+  if (existsSync4(path6.join(process.cwd(), "Cargo.toml"))) return "Rust";
+  if (existsSync4(path6.join(process.cwd(), "go.mod"))) return "Go";
+  if (existsSync4(path6.join(process.cwd(), "pubspec.yaml"))) return "Flutter";
+  return "Project";
+}
 
 // src/cli/commands/push.ts
 import chalk19 from "chalk";
@@ -1497,12 +1647,331 @@ function getCurrentVersion() {
   }
 }
 
+// src/cli/commands/test.ts
+import chalk21 from "chalk";
+import ora6 from "ora";
+import fs5 from "fs/promises";
+import path7 from "path";
+async function testCommand(options) {
+  console.log(chalk21.bold("\n  forge") + chalk21.dim(" test\n"));
+  const configPath = path7.join(process.cwd(), "forge.config.json");
+  let config;
+  try {
+    const raw = await fs5.readFile(configPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    console.log(chalk21.red("  No forge.config.json found. Run: forge init\n"));
+    return;
+  }
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(chalk21.red("  No sprint plan found. Run: forge plan\n"));
+    return;
+  }
+  await refreshAdapters();
+  let adapter = null;
+  try {
+    adapter = getAdapter(config.framework);
+  } catch {
+  }
+  const worker = new Worker(config, { sandbox: false, yes: true });
+  const git = new GitManager();
+  const allStories = plan.epics.flatMap((e) => e.stories);
+  let testable = allStories.filter(
+    (s) => s.status === "reviewing" || s.status === "testing" || s.status === "done"
+  );
+  if (options.story) {
+    testable = testable.filter((s) => s.id === options.story);
+    if (testable.length === 0) {
+      console.log(chalk21.red(`  Story "${options.story}" not found or not built yet.
+`));
+      return;
+    }
+  }
+  if (testable.length === 0) {
+    console.log(chalk21.yellow("  No built stories to test. Run: forge build\n"));
+    return;
+  }
+  console.log(chalk21.dim(`  ${testable.length} stories to test
+`));
+  for (let i = 0; i < testable.length; i++) {
+    const story = testable[i];
+    const label = `[${i + 1}/${testable.length}] ${story.title}`;
+    const spinner = ora6({ text: label, indent: 2 }).start();
+    const isGeneric = !adapter || adapter.id === "generic";
+    const testInfo = isGeneric ? "Detect the test framework from config files. Install test dependencies if needed." : `Test framework: ${adapter.testFramework || "Vitest"}
+Test command: ${adapter.testCommand || "npm test"}`;
+    const prompt = `
+      Generate tests for: "${story.title}"
+      Description: ${story.description}
+      App: ${plan.project} (${plan.framework})
+
+      ${testInfo}
+
+      1. Read the source files to understand what was built
+      2. Create test files co-located with the source
+      3. Write meaningful tests (happy path, errors, edge cases)
+      4. Run the test suite \u2014 all tests must pass
+    `;
+    const result = await worker.run("test", prompt);
+    if (result.success) {
+      await git.commitAll(`test: ${story.title}`);
+      spinner.succeed(`${label}` + chalk21.dim(` \xB7 ${result.filesCreated.length} test files`));
+    } else {
+      spinner.warn(`${label}` + chalk21.dim(" tests incomplete"));
+      for (const err of result.errors) {
+        console.log(chalk21.red(`    ${err}`));
+      }
+    }
+  }
+  console.log(chalk21.green("\n  Test generation complete.\n"));
+}
+
+// src/cli/commands/template.ts
+import chalk22 from "chalk";
+import inquirer8 from "inquirer";
+async function templateCommand(options) {
+  const templates = listTemplates();
+  if (options.list) {
+    console.log(chalk22.bold("\n  Forge Templates\n"));
+    for (const t of templates) {
+      console.log(`  ${chalk22.cyan(t.id.padEnd(16))} ${t.name}`);
+      console.log(chalk22.dim(`  ${"".padEnd(16)} ${t.description}`));
+      console.log(chalk22.dim(`  ${"".padEnd(16)} Frameworks: ${t.suggestedFrameworks.join(", ")}
+`));
+    }
+    return;
+  }
+  console.log(chalk22.bold("\n  forge") + chalk22.dim(" template\n"));
+  let templateId;
+  try {
+    const answer = await inquirer8.prompt([
+      {
+        type: "list",
+        name: "templateId",
+        message: "Choose a starter template:",
+        choices: templates.map((t) => ({
+          name: `${t.name} \u2014 ${t.description}`,
+          value: t.id
+        }))
+      }
+    ]);
+    templateId = answer.templateId;
+  } catch {
+    console.log(chalk22.dim("\n  Cancelled.\n"));
+    return;
+  }
+  const template = getTemplate(templateId);
+  if (!template) {
+    console.log(chalk22.red("  Template not found.\n"));
+    return;
+  }
+  console.log(chalk22.green(`
+  Selected: ${template.name}`));
+  console.log(chalk22.dim(`  ${template.description}
+`));
+  console.log(chalk22.dim("  Suggested frameworks: " + template.suggestedFrameworks.join(", ")));
+  console.log(chalk22.bold("\n  To use this template, run:"));
+  console.log(chalk22.cyan(`    forge auto "${template.planDescription.split("\n")[0].trim()}"
+`));
+  console.log(chalk22.dim("  Or copy the full description:\n"));
+  const lines = template.planDescription.split("\n");
+  for (const line of lines) {
+    console.log(chalk22.dim(`    ${line}`));
+  }
+  console.log("");
+}
+
+// src/cli/commands/estimate.ts
+import chalk23 from "chalk";
+import fs6 from "fs/promises";
+import path8 from "path";
+async function estimateCommand() {
+  console.log(chalk23.bold("\n  forge") + chalk23.dim(" estimate\n"));
+  const configPath = path8.join(process.cwd(), "forge.config.json");
+  let config;
+  try {
+    const raw = await fs6.readFile(configPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    console.log(chalk23.red("  No forge.config.json found. Run: forge init\n"));
+    return;
+  }
+  const plan = await stateManager.getPlan();
+  if (!plan) {
+    console.log(chalk23.red("  No sprint plan found. Run: forge plan\n"));
+    return;
+  }
+  const estimate = estimateCost(plan, config.model);
+  console.log(formatCostEstimate(estimate));
+  console.log("");
+}
+
+// src/cli/commands/cicd.ts
+import chalk24 from "chalk";
+import inquirer9 from "inquirer";
+import fs7 from "fs/promises";
+import path9 from "path";
+async function cicdCommand(options) {
+  console.log(chalk24.bold("\n  forge") + chalk24.dim(" cicd\n"));
+  const configPath = path9.join(process.cwd(), "forge.config.json");
+  let config;
+  try {
+    const raw = await fs7.readFile(configPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    console.log(chalk24.red("  No forge.config.json found. Run: forge init\n"));
+    return;
+  }
+  let provider = options.provider || "github";
+  if (!options.provider) {
+    try {
+      const { selectedProvider } = await inquirer9.prompt([
+        {
+          type: "list",
+          name: "selectedProvider",
+          message: "CI/CD provider:",
+          choices: [
+            { name: "GitHub Actions", value: "github" },
+            { name: "GitLab CI", value: "gitlab" }
+          ]
+        }
+      ]);
+      provider = selectedProvider;
+    } catch {
+      console.log(chalk24.dim("\n  Cancelled.\n"));
+      return;
+    }
+  }
+  await refreshAdapters();
+  const adapter = getAdapter(config.framework);
+  let content;
+  let filePath;
+  if (provider === "github") {
+    content = generateGitHubActions(adapter);
+    filePath = path9.join(process.cwd(), ".github", "workflows", "ci.yml");
+    await fs7.mkdir(path9.dirname(filePath), { recursive: true });
+  } else {
+    content = generateGitLabCI(adapter);
+    filePath = path9.join(process.cwd(), ".gitlab-ci.yml");
+  }
+  await fs7.writeFile(filePath, content);
+  const relative = path9.relative(process.cwd(), filePath);
+  console.log(chalk24.green(`  Created: ${relative}`));
+  console.log(chalk24.dim(`  Framework: ${adapter.name}`));
+  console.log(chalk24.dim(`  Provider: ${provider === "github" ? "GitHub Actions" : "GitLab CI"}
+`));
+}
+
+// src/cli/commands/viz.ts
+import chalk25 from "chalk";
+import ora7 from "ora";
+async function vizCommand(targetPath, options) {
+  console.log(chalk25.bold("\n  forge") + chalk25.dim(" viz\n"));
+  const spinner = ora7({ text: "Scanning project...", indent: 2 }).start();
+  try {
+    const shouldOpen = options.open !== false;
+    const { outputPath, graph } = await generateVisualization({
+      workingDir: targetPath || void 0,
+      outputPath: options.output,
+      open: shouldOpen
+    });
+    spinner.succeed(
+      `Scanned ${graph.totalFiles} files (${formatLines(graph.totalLines)} lines)`
+    );
+    const categories = {};
+    for (const f of graph.files) {
+      categories[f.category] = (categories[f.category] || 0) + 1;
+    }
+    console.log(chalk25.dim(`
+  Framework: ${graph.framework}`));
+    console.log(chalk25.dim(`  Languages: ${Object.keys(graph.languages).join(", ")}`));
+    if (graph.apiRoutes.length > 0) {
+      console.log(chalk25.dim(`  API routes: ${graph.apiRoutes.length}`));
+    }
+    console.log(chalk25.dim(`
+  Dashboard: ${outputPath}`));
+    if (shouldOpen) {
+      console.log(chalk25.green("  Opened in browser\n"));
+    } else {
+      console.log(chalk25.dim("  Open the file in your browser to view.\n"));
+    }
+  } catch (err) {
+    spinner.fail("Failed to generate visualization");
+    console.log(chalk25.red(`  ${err instanceof Error ? err.message : err}
+`));
+  }
+}
+function formatLines(n) {
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
+  return String(n);
+}
+
+// src/cli/commands/claude.ts
+import chalk26 from "chalk";
+import { spawn as spawn2 } from "child_process";
+async function claudeCommand() {
+  console.log(chalk26.bold("\n  forge") + chalk26.dim(" claude\n"));
+  const cmd = await findClaudeCLI();
+  if (!cmd) {
+    console.log(chalk26.red("  Claude Code CLI not found.\n"));
+    console.log(chalk26.dim("  Install it with:"));
+    console.log(chalk26.white("    npm install -g @anthropic-ai/claude-code"));
+    console.log(chalk26.dim("  Then log in:"));
+    console.log(chalk26.white("    claude login\n"));
+    return;
+  }
+  console.log(chalk26.dim(`  Starting Claude Code...
+`));
+  const isWindows = process.platform === "win32";
+  const child = spawn2(cmd.cmd, cmd.args, {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    shell: isWindows
+    // On Windows, use shell mode to resolve commands from PATH
+  });
+  child.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      console.log(chalk26.red("\n  Claude Code CLI not found in PATH."));
+      console.log(chalk26.dim("  Install: npm install -g @anthropic-ai/claude-code\n"));
+    } else {
+      console.log(chalk26.red(`
+  Failed to start Claude: ${err.message}
+`));
+    }
+  });
+  child.on("exit", (code) => {
+    if (code && code !== 0) {
+      console.log(chalk26.dim(`
+  Claude exited with code ${code}
+`));
+    }
+  });
+}
+async function findClaudeCLI() {
+  const { execSync: execSync4 } = await import("child_process");
+  const isWindows = process.platform === "win32";
+  try {
+    const whichCmd = isWindows ? "where claude" : "which claude";
+    execSync4(whichCmd, { stdio: "ignore" });
+    return { cmd: "claude", args: [] };
+  } catch {
+  }
+  try {
+    const whichCmd = isWindows ? "where npx" : "which npx";
+    execSync4(whichCmd, { stdio: "ignore" });
+    return { cmd: "npx", args: ["@anthropic-ai/claude-code"] };
+  } catch {
+  }
+  return null;
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("forge").description(
-  chalk21.bold("Forge") + " \u2014 AI Development Orchestration Framework\n  Structured multi-agent pipeline: plan \u2192 design \u2192 build \u2192 review"
-).version("1.4.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("-y, --yes", "Skip all confirmation prompts (auto-approve everything)").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);
+  chalk27.bold("Forge") + " \u2014 AI Development Orchestration Framework\n  Structured multi-agent pipeline: plan \u2192 design \u2192 build \u2192 review"
+).version("2.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("-y, --yes", "Skip all confirmation prompts (auto-approve everything)").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)").option("--skip-tests", "Skip test generation phase").action(autoCommand);
 program.command("resume").description("Resume an interrupted sprint from where it left off").option("--no-sandbox", "Disable sandbox").option("-y, --yes", "Skip all confirmation prompts (auto-approve everything)").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);
@@ -1510,8 +1979,10 @@ program.command("plan [description]").description("Generate a sprint plan from a
 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("test").description("Generate and run tests for built stories").option("-s, --story <storyId>", "Test a specific story only").action(testCommand);
 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("claude").description("Launch Claude Code CLI in the current project").action(claudeCommand);
 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);
@@ -1521,7 +1992,11 @@ program.command("history").description("Show version timeline, checkpoints, and
 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("viz [path]").description("Interactive project map \u2014 visualize files, dependencies, and data flow").option("-o, --output <path>", "Output HTML file path").option("--no-open", "Don't auto-open in browser").action(vizCommand);
 program.command("doctor").description("Diagnose setup issues and check system requirements").action(doctorCommand);
+program.command("estimate").description("Estimate token usage and cost for the current sprint plan").action(estimateCommand);
+program.command("cicd").description("Generate CI/CD pipeline configuration").option("-p, --provider <provider>", "CI provider (github, gitlab)").action(cicdCommand);
+program.command("template").description("Browse and use starter app templates").option("-l, --list", "List all available templates").action(templateCommand);
 program.command("upgrade").description("Upgrade Forge to the latest version").action(upgradeCommand);
 program.parse();
 //# sourceMappingURL=index.js.map