@forgelore/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1652 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import ora from "ora";
+import { mkdir } from "fs/promises";
+import { resolve } from "path";
+import {
+  createDefaultConfig,
+  writeConfig,
+  configExists,
+  getForgeloreDir
+} from "@forgelore/core";
+import { scaffoldSpecDirs } from "@forgelore/core";
+import { scaffoldKnowledge } from "@forgelore/core";
+
+// src/ui/banner.ts
+import boxen from "boxen";
+import chalk2 from "chalk";
+import gradient2 from "gradient-string";
+
+// src/ui/theme.ts
+import chalk from "chalk";
+import gradient from "gradient-string";
+var colors = {
+  primary: chalk.hex("#FF6B35"),
+  // forge orange
+  secondary: chalk.hex("#06B6D4"),
+  // lore cyan
+  accent: chalk.hex("#FFD700"),
+  // spark gold
+  lore: chalk.hex("#7C3AED"),
+  // lore violet
+  success: chalk.hex("#10B981"),
+  // emerald
+  warning: chalk.hex("#F97316"),
+  // orange
+  error: chalk.hex("#EF4444"),
+  // red
+  muted: chalk.hex("#6B7280"),
+  // gray
+  dim: chalk.dim,
+  bold: chalk.bold,
+  white: chalk.white
+};
+var gradients = {
+  brand: gradient(["#FF6B35", "#FFD700", "#7C3AED", "#06B6D4"]),
+  forge: gradient(["#FF6B35", "#FFD700"]),
+  lore: gradient(["#7C3AED", "#06B6D4"]),
+  warm: gradient(["#F59E0B", "#EF4444"]),
+  cool: gradient(["#06B6D4", "#7C3AED"]),
+  success: gradient(["#10B981", "#06B6D4"]),
+  sunset: gradient(["#F97316", "#EF4444", "#7C3AED"])
+};
+var icons = {
+  success: colors.success("\u2713"),
+  error: colors.error("\u2717"),
+  warning: colors.warning("\u26A0"),
+  info: colors.secondary("\u25C6"),
+  pending: colors.muted("\u25CB"),
+  inProgress: colors.accent("\u25CF"),
+  arrow: colors.primary("\u2192"),
+  bullet: colors.muted("\u2022"),
+  star: colors.accent("\u2605"),
+  spark: colors.accent("\u2726"),
+  anvil: colors.primary("\u2692")
+};
+function statusColor(status) {
+  switch (status) {
+    case "passed":
+    case "validated":
+    case "archived":
+      return colors.success(status);
+    case "failed":
+      return colors.error(status);
+    case "in-progress":
+    case "claimed":
+    case "implementing":
+    case "validating":
+      return colors.accent(status);
+    case "blocked":
+      return colors.error(status);
+    case "pending":
+    case "proposed":
+    case "planning":
+      return colors.muted(status);
+    default:
+      return colors.white(status);
+  }
+}
+function progressBar(percent, width = 20) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  const bar = colors.success("\u2588".repeat(filled)) + colors.muted("\u2591".repeat(empty));
+  return `${bar} ${percent}%`;
+}
+
+// src/ui/banner.ts
+var forgeGradient = gradient2(["#FF6B35", "#FFD700"]);
+var loreGradient = gradient2(["#7C3AED", "#06B6D4"]);
+var brandGradient = gradient2(["#FF6B35", "#FFD700", "#7C3AED", "#06B6D4"]);
+var sparkColor = chalk2.hex("#FFD700");
+var emberColor = chalk2.hex("#FF6B35");
+var TITLE_GRADIENT = [
+  "#FF6B35",
+  // F - forge orange
+  "#FF8E3C",
+  // O
+  "#FFB347",
+  // R
+  "#FFD700",
+  // G - spark gold
+  "#C9A832",
+  // E
+  "#9B6FC0",
+  // L - transitioning
+  "#7C3AED",
+  // O - lore violet
+  "#4196CB",
+  // R
+  "#06B6D4"
+  // E - lore cyan
+];
+var BOOK_LINES = [
+  "         .\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500.",
+  "        \u2571 \u2261 \u2261 \u2261 \u2261 \u2261 \u2571\u2502",
+  "       \u2571 \u2261 \u2261 \u2261 \u2261 \u2261 \u2571 \u2502",
+  "      \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524  \u2502",
+  "      \u2502 \u2261 \u2261 \u2261 \u2261 \u2261 \u2502  \u2502",
+  "      \u2502 \u2261 \u2261 \u2261 \u2261 \u2261 \u2502 \u2571",
+  "      \u2502 \u2261 \u2261 \u2261 \u2261 \u2261 \u2502\u2571",
+  "      \u2514\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2518"
+];
+var ANVIL_LINES = [
+  "        \u2554\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u2550\u2557",
+  "   \u2501\u2501\u2501\u2501\u2501\u2563\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2560\u2501\u2501\u2501\u2501\u2501",
+  "        \u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551",
+  "        \u255A\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2550\u255D",
+  "       \u2588\u2588\u2588\u2588\u2588\u2567\u2588\u2588\u2588\u2588\u2588\u2588",
+  "      \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588"
+];
+var SPARK_CHARS = ["\u2726", "\u2727", "\xB7", "\u2736", "\u2217"];
+function getColoredBook() {
+  return BOOK_LINES.map((l) => loreGradient(l));
+}
+function getColoredAnvil() {
+  return ANVIL_LINES.map((l) => forgeGradient(l));
+}
+function getTitle() {
+  return "FORGELORE".split("").map((ch, i) => chalk2.bold(chalk2.hex(TITLE_GRADIENT[i])(ch))).join("");
+}
+function randomSpark() {
+  return sparkColor(
+    SPARK_CHARS[Math.floor(Math.random() * SPARK_CHARS.length)]
+  );
+}
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var CLEAR_LINE = "\x1B[2K";
+function moveUp(n) {
+  return n > 0 ? `\x1B[${n}A` : "";
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function renderBanner() {
+  const book = getColoredBook().join("\n");
+  const anvil = getColoredAnvil().join("\n");
+  const title = `  ${getTitle()}`;
+  const tagline = colors.muted("  forge knowledge, shape code");
+  const version = chalk2.dim("  v0.1.0");
+  return `
+${book}
+${anvil}
+
+${title}
+${tagline}${version}
+`;
+}
+async function renderAnimatedBanner() {
+  if (!process.stdout.isTTY) {
+    console.log(renderBanner());
+    return;
+  }
+  const bookColored = getColoredBook();
+  const anvilColored = getColoredAnvil();
+  const allLines = [...bookColored, ...anvilColored];
+  const totalHeight = allLines.length;
+  process.stdout.write(HIDE_CURSOR);
+  try {
+    console.log("");
+    for (let i = anvilColored.length - 1; i >= 0; i--) {
+      const visible = anvilColored.slice(i);
+      for (const line of visible) {
+        process.stdout.write(CLEAR_LINE + line + "\n");
+      }
+      await sleep(45);
+      if (i > 0) {
+        process.stdout.write(moveUp(visible.length));
+      }
+    }
+    const anvilHeight = anvilColored.length;
+    process.stdout.write(moveUp(anvilHeight));
+    for (let i = bookColored.length - 1; i >= 0; i--) {
+      const visibleBook = bookColored.slice(i);
+      const frame = [...visibleBook, ...anvilColored];
+      for (const line of frame) {
+        process.stdout.write(CLEAR_LINE + line + "\n");
+      }
+      await sleep(35);
+      process.stdout.write(moveUp(frame.length));
+    }
+    for (const line of allLines) {
+      process.stdout.write(CLEAR_LINE + line + "\n");
+    }
+    for (let cycle = 0; cycle < 5; cycle++) {
+      await sleep(90);
+      process.stdout.write(moveUp(totalHeight));
+      for (let i = 0; i < totalHeight; i++) {
+        const line = allLines[i];
+        let spark = "";
+        if (i >= bookColored.length - 2 && i <= bookColored.length + 2) {
+          if (Math.random() > 0.3) {
+            spark = "  " + randomSpark();
+            if (Math.random() > 0.5) spark += " " + randomSpark();
+          }
+        } else if (Math.random() > 0.7) {
+          spark = "  " + randomSpark();
+        }
+        process.stdout.write(CLEAR_LINE + line + spark + "\n");
+      }
+    }
+    process.stdout.write(moveUp(totalHeight));
+    for (const line of allLines) {
+      process.stdout.write(CLEAR_LINE + line + "\n");
+    }
+    console.log("");
+    process.stdout.write("  ");
+    const title = "FORGELORE";
+    for (let i = 0; i < title.length; i++) {
+      process.stdout.write(emberColor("\u2588"));
+      await sleep(35);
+      process.stdout.write("\b" + chalk2.bold(chalk2.hex(TITLE_GRADIENT[i])(title[i])));
+      await sleep(50);
+    }
+    console.log("");
+    await sleep(200);
+    console.log(colors.muted("  forge knowledge, shape code") + chalk2.dim("  v0.1.0"));
+    console.log("");
+  } finally {
+    process.stdout.write(SHOW_CURSOR);
+  }
+}
+function renderBox(content, title, borderColor = "#FF6B35") {
+  return boxen(content, {
+    padding: 1,
+    margin: { top: 0, bottom: 1, left: 0, right: 0 },
+    borderStyle: "round",
+    borderColor,
+    title,
+    titleAlignment: "left"
+  });
+}
+function renderSection(title, content) {
+  return `
+${brandGradient(` ${title} `)}
+${content}
+`;
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  const projectRoot = resolve(options.cwd || process.cwd());
+  console.log(renderBanner());
+  if (await configExists(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.warning} forgelore is already initialized in this project.
+${colors.muted("Run")} ${colors.primary("forgelore status")} ${colors.muted("to see current state.")}`,
+        "Already Initialized"
+      )
+    );
+    return;
+  }
+  p.intro(gradients.brand(" forgelore init "));
+  const mode = await p.select({
+    message: "How do you want to manage specs?",
+    options: [
+      {
+        value: "local",
+        label: "Local only",
+        hint: "Specs live in this repo only"
+      },
+      {
+        value: "local+global",
+        label: "Local + Global",
+        hint: "Local specs + a shared company spec repo"
+      },
+      {
+        value: "global",
+        label: "Global only",
+        hint: "Reference a shared spec repo"
+      }
+    ]
+  });
+  if (p.isCancel(mode)) {
+    p.cancel("Init cancelled.");
+    process.exit(0);
+  }
+  let globalSource;
+  if (mode === "local+global" || mode === "global") {
+    const source = await p.text({
+      message: "Global spec source (filesystem path or GitHub URL):",
+      placeholder: "/path/to/company-specs or https://github.com/org/specs",
+      validate: (val) => {
+        if (!val) return "Please enter a path or URL";
+        return void 0;
+      }
+    });
+    if (p.isCancel(source)) {
+      p.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    globalSource = source;
+  }
+  const config = createDefaultConfig(mode);
+  if (globalSource) {
+    const isUrl = globalSource.startsWith("http://") || globalSource.startsWith("https://");
+    config.global = {
+      source: globalSource,
+      path: isUrl ? `~/.cache/forgelore/global/${globalSource.split("/").pop()}` : globalSource,
+      autoSync: true
+    };
+  }
+  const spinner = ora({
+    text: "Scaffolding forgelore...",
+    color: "magenta"
+  }).start();
+  try {
+    const forgeloreDir = getForgeloreDir(projectRoot);
+    await mkdir(forgeloreDir, { recursive: true });
+    spinner.text = "Creating directory structure...";
+    await scaffoldSpecDirs(projectRoot);
+    spinner.text = "Setting up knowledge base...";
+    await scaffoldKnowledge(projectRoot);
+    spinner.text = "Writing config...";
+    await writeConfig(projectRoot, config);
+    spinner.succeed(colors.success("forgelore initialized"));
+  } catch (err) {
+    spinner.fail(colors.error("Failed to initialize forgelore"));
+    console.error(err);
+    process.exit(1);
+  }
+  const summary = [
+    `${icons.success} ${colors.white("Created:")}`,
+    `  ${icons.bullet} ${colors.muted("forgelore/forgelore.json")}`,
+    `  ${icons.bullet} ${colors.muted("forgelore/changes/")}`,
+    `  ${icons.bullet} ${colors.muted("forgelore/knowledge/architecture.md")}`,
+    `  ${icons.bullet} ${colors.muted("forgelore/knowledge/patterns.md")}`,
+    `  ${icons.bullet} ${colors.muted("forgelore/knowledge/glossary.md")}`,
+    `  ${icons.bullet} ${colors.muted("forgelore/knowledge/capabilities/")}`,
+    `  ${icons.bullet} ${colors.muted("forgelore/knowledge/decisions/")}`,
+    "",
+    `${icons.info} Mode: ${colors.primary(mode)}`
+  ];
+  if (globalSource) {
+    summary.push(`${icons.info} Global: ${colors.secondary(globalSource)}`);
+  }
+  console.log(renderBox(summary.join("\n"), "Setup Complete", "#10B981"));
+  p.outro(
+    `Run ${colors.primary("forgelore propose")} ${colors.muted('"your idea"')} to create your first spec.`
+  );
+}
+
+// src/commands/propose.ts
+import * as p2 from "@clack/prompts";
+import ora2 from "ora";
+import { resolve as resolve2 } from "path";
+import {
+  configExists as configExists2,
+  createChange
+} from "@forgelore/core";
+function slugify(text3) {
+  return text3.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+async function proposeCommand(idea, options) {
+  const projectRoot = resolve2(options?.cwd || process.cwd());
+  if (!await configExists2(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  p2.intro(gradients.brand(" forgelore propose "));
+  let ideaText = idea;
+  if (!ideaText) {
+    const input = await p2.text({
+      message: "What do you want to build?",
+      placeholder: "e.g., Add dark mode toggle to settings",
+      validate: (val) => {
+        if (!val) return "Please describe your idea";
+        return void 0;
+      }
+    });
+    if (p2.isCancel(input)) {
+      p2.cancel("Propose cancelled.");
+      process.exit(0);
+    }
+    ideaText = input;
+  }
+  const suggestedName = slugify(ideaText).slice(0, 50);
+  const nameInput = await p2.text({
+    message: "Change name (used as folder name):",
+    placeholder: suggestedName,
+    defaultValue: suggestedName,
+    validate: (val) => {
+      if (!val) return "Please enter a name";
+      if (!/^[a-z0-9-]+$/.test(val))
+        return "Use lowercase letters, numbers, and hyphens only";
+      return void 0;
+    }
+  });
+  if (p2.isCancel(nameInput)) {
+    p2.cancel("Propose cancelled.");
+    process.exit(0);
+  }
+  const changeName = nameInput || suggestedName;
+  const proposalContent = `# Proposal: ${ideaText}
+
+## Motivation
+
+<!-- Why are we doing this? What problem does it solve? -->
+
+
+## Scope
+
+<!-- What is included and excluded from this change? -->
+
+### In Scope
+
+
+### Out of Scope
+
+
+## Context
+
+<!-- Any relevant context, links, or references -->
+
+
+## Success Criteria
+
+<!-- How do we know this is done? -->
+
+1. 
+
+---
+
+*Proposed: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}*
+`;
+  const spinner = ora2({
+    text: "Creating change...",
+    color: "magenta"
+  }).start();
+  try {
+    const change = await createChange(projectRoot, changeName, proposalContent);
+    spinner.succeed(colors.success(`Created change: ${changeName}`));
+    const files = [
+      `forgelore/changes/${changeName}/proposal.md`,
+      `forgelore/changes/${changeName}/specs/requirements.md`,
+      `forgelore/changes/${changeName}/specs/scenarios.md`,
+      `forgelore/changes/${changeName}/design.md`,
+      `forgelore/changes/${changeName}/tasks.md`
+    ];
+    const summary = [
+      `${icons.success} ${colors.white("Change created:")} ${colors.primary(changeName)}`,
+      "",
+      `${colors.white("Files:")}`,
+      ...files.map((f) => `  ${icons.bullet} ${colors.muted(f)}`),
+      "",
+      `${colors.muted("Next steps:")}`,
+      `  1. Fill in ${colors.primary("proposal.md")} with motivation and scope`,
+      `  2. Define requirements in ${colors.primary("specs/requirements.md")}`,
+      `  3. Add scenarios in ${colors.primary("specs/scenarios.md")}`,
+      `  4. Describe approach in ${colors.primary("design.md")}`,
+      `  5. Break into tasks in ${colors.primary("tasks.md")}`
+    ];
+    console.log(renderBox(summary.join("\n"), "Proposed", "#7C3AED"));
+  } catch (err) {
+    spinner.fail(colors.error("Failed to create change"));
+    if (err instanceof Error) {
+      console.error(colors.muted(err.message));
+    }
+    process.exit(1);
+  }
+  p2.outro(
+    `Run ${colors.primary("forgelore clarify")} ${colors.muted(changeName)} to refine requirements.`
+  );
+}
+
+// src/commands/status.ts
+import { resolve as resolve3 } from "path";
+import Table from "cli-table3";
+import {
+  configExists as configExists3,
+  readConfig,
+  listCapabilities,
+  getProjectSummary
+} from "@forgelore/core";
+async function statusCommand(options) {
+  const projectRoot = resolve3(options?.cwd || process.cwd());
+  if (!await configExists3(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  console.log(renderBanner());
+  const config = await readConfig(projectRoot);
+  const summary = await getProjectSummary(projectRoot);
+  const capabilities = await listCapabilities(projectRoot);
+  const statsLine = [
+    `${colors.primary(String(summary.activeChanges))} active`,
+    `${colors.success(String(summary.archivedChanges))} archived`,
+    `${colors.secondary(String(summary.totalCapabilities))} capabilities`,
+    `${colors.muted("mode:")} ${colors.accent(config.mode)}`
+  ].join(colors.muted("  \u2502  "));
+  console.log(renderBox(statsLine, "forgelore status", "#7C3AED"));
+  if (summary.changes.length > 0) {
+    const table = new Table({
+      head: [
+        colors.bold("Change"),
+        colors.bold("Status"),
+        colors.bold("Tasks"),
+        colors.bold("Progress")
+      ].map(String),
+      style: { head: [], border: ["gray"] },
+      colWidths: [30, 14, 10, 30]
+    });
+    for (const change of summary.changes) {
+      const ts = change.taskSummary;
+      const taskStr = ts.total > 0 ? `${ts.passed}/${ts.total}` : colors.muted("none");
+      const progress = ts.total > 0 ? progressBar(ts.completionPercent) : colors.muted("--");
+      table.push([
+        colors.white(change.name),
+        statusColor(change.status),
+        taskStr,
+        progress
+      ]);
+    }
+    console.log(renderSection("Active Changes", table.toString()));
+  } else {
+    console.log(
+      renderSection(
+        "Active Changes",
+        `  ${colors.muted("No active changes.")} Run ${colors.primary("forgelore propose")} to create one.`
+      )
+    );
+  }
+  if (capabilities.length > 0) {
+    const capTable = new Table({
+      head: [
+        colors.bold("Capability"),
+        colors.bold("Source"),
+        colors.bold("Archived")
+      ].map(String),
+      style: { head: [], border: ["gray"] },
+      colWidths: [30, 25, 16]
+    });
+    for (const cap of capabilities.slice(0, 10)) {
+      capTable.push([
+        colors.white(cap.name),
+        colors.muted(cap.sourceChange),
+        colors.dim(cap.archivedAt.slice(0, 10))
+      ]);
+    }
+    const moreText = capabilities.length > 10 ? `
+  ${colors.muted(`...and ${capabilities.length - 10} more. Run`)} ${colors.primary("forgelore capabilities")} ${colors.muted("to see all.")}` : "";
+    console.log(
+      renderSection("Capabilities", capTable.toString() + moreText)
+    );
+  } else {
+    console.log(
+      renderSection(
+        "Capabilities",
+        `  ${colors.muted("No capabilities yet.")} Archive a completed change to start building the knowledge base.`
+      )
+    );
+  }
+  if (config.mode === "local+global" || config.mode === "global") {
+    const globalInfo = config.global ? `  ${icons.info} Source: ${colors.secondary(config.global.source)}
+  ${icons.info} Path: ${colors.muted(config.global.path)}
+  ${icons.info} Auto-sync: ${config.global.autoSync ? colors.success("enabled") : colors.muted("disabled")}` : `  ${colors.warning("Global spec repo not configured.")}`;
+    console.log(renderSection("Global Specs", globalInfo));
+  }
+}
+
+// src/commands/clarify.ts
+import * as p3 from "@clack/prompts";
+import { resolve as resolve4 } from "path";
+import {
+  configExists as configExists4,
+  readChange,
+  readChangeFile,
+  updateChangeStatus
+} from "@forgelore/core";
+async function clarifyCommand(changeName, options) {
+  const projectRoot = resolve4(options?.cwd || process.cwd());
+  if (!await configExists4(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  p3.intro(gradients.brand(" forgelore clarify "));
+  let change;
+  try {
+    change = await readChange(projectRoot, changeName);
+  } catch {
+    console.log(
+      renderBox(
+        `${icons.error} Change ${colors.primary(changeName)} not found.
+Run ${colors.primary("forgelore list")} to see available changes.`,
+        "Not Found",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  const proposal = await readChangeFile(projectRoot, changeName, "proposal.md");
+  let requirements;
+  try {
+    requirements = await readChangeFile(projectRoot, changeName, "specs/requirements.md");
+  } catch {
+    requirements = "(not yet defined)";
+  }
+  let scenarios;
+  try {
+    scenarios = await readChangeFile(projectRoot, changeName, "specs/scenarios.md");
+  } catch {
+    scenarios = "(not yet defined)";
+  }
+  console.log(
+    renderBox(
+      [
+        `${icons.info} Change: ${colors.primary(changeName)}`,
+        `${icons.info} Status: ${colors.accent(change.status)}`,
+        `${icons.info} Created: ${colors.muted(change.createdAt.slice(0, 10))}`
+      ].join("\n"),
+      "Change Details"
+    )
+  );
+  console.log(renderSection("Proposal", colors.muted(proposal.slice(0, 500))));
+  console.log(renderSection("Requirements", colors.muted(requirements.slice(0, 500))));
+  console.log(renderSection("Scenarios", colors.muted(scenarios.slice(0, 500))));
+  const checks = await p3.group({
+    proposalComplete: () => p3.confirm({
+      message: "Is the proposal well-defined with clear motivation and scope?",
+      initialValue: false
+    }),
+    requirementsDefined: () => p3.confirm({
+      message: "Are functional and non-functional requirements specified?",
+      initialValue: false
+    }),
+    scenariosCovered: () => p3.confirm({
+      message: "Are happy path, edge cases, and error scenarios defined?",
+      initialValue: false
+    }),
+    readyForDesign: () => p3.confirm({
+      message: "Is this change ready for design and task breakdown?",
+      initialValue: false
+    })
+  });
+  if (p3.isCancel(checks)) {
+    p3.cancel("Clarify cancelled.");
+    process.exit(0);
+  }
+  const allReady = checks.proposalComplete && checks.requirementsDefined && checks.scenariosCovered && checks.readyForDesign;
+  if (allReady) {
+    await updateChangeStatus(projectRoot, changeName, "planning");
+    console.log(
+      renderBox(
+        `${icons.success} Change ${colors.primary(changeName)} is ready for design.
+Status updated to ${colors.accent("planning")}.
+
+Next: Fill in ${colors.primary("design.md")} and ${colors.primary("tasks.md")}`,
+        "Ready",
+        "#10B981"
+      )
+    );
+  } else {
+    const incomplete = [];
+    if (!checks.proposalComplete) incomplete.push(`  ${icons.pending} Proposal needs refinement`);
+    if (!checks.requirementsDefined) incomplete.push(`  ${icons.pending} Requirements need specification`);
+    if (!checks.scenariosCovered) incomplete.push(`  ${icons.pending} Scenarios need coverage`);
+    console.log(
+      renderBox(
+        `${icons.warning} Change ${colors.primary(changeName)} needs more clarification:
+
+` + incomplete.join("\n") + `
+
+${colors.muted("Edit the spec files and run")} ${colors.primary("forgelore clarify " + changeName)} ${colors.muted("again.")}`,
+        "Needs Work",
+        "#F59E0B"
+      )
+    );
+  }
+  p3.outro(colors.muted("Specs are the foundation. Take the time to get them right."));
+}
+
+// src/commands/list.ts
+import { resolve as resolve5 } from "path";
+import Table2 from "cli-table3";
+import {
+  configExists as configExists5,
+  listChanges
+} from "@forgelore/core";
+import { summarizeTasks } from "@forgelore/core";
+async function listCommand(options) {
+  const projectRoot = resolve5(options?.cwd || process.cwd());
+  if (!await configExists5(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  let changes = await listChanges(projectRoot, options?.archived ?? false);
+  if (options?.status) {
+    changes = changes.filter((c) => c.status === options.status);
+  }
+  if (changes.length === 0) {
+    const msg = options?.status ? `No changes with status "${options.status}".` : "No changes found.";
+    console.log(
+      renderBox(
+        `${icons.info} ${msg}
+Run ${colors.primary("forgelore propose")} to create one.`,
+        "Changes"
+      )
+    );
+    return;
+  }
+  const table = new Table2({
+    head: [
+      colors.bold("Name"),
+      colors.bold("Status"),
+      colors.bold("Tasks"),
+      colors.bold("Progress"),
+      colors.bold("Updated")
+    ].map(String),
+    style: { head: [], border: ["gray"] },
+    colWidths: [28, 14, 10, 26, 14]
+  });
+  for (const change of changes) {
+    const ts = summarizeTasks(change.tasks);
+    const taskStr = ts.total > 0 ? `${ts.passed}/${ts.total}` : colors.muted("--");
+    const progress = ts.total > 0 ? progressBar(ts.completionPercent) : colors.muted("--");
+    const updated = colors.dim(change.updatedAt.slice(0, 10));
+    table.push([
+      colors.white(change.name),
+      statusColor(change.status),
+      taskStr,
+      progress,
+      updated
+    ]);
+  }
+  const title = options?.archived ? "All Changes (including archived)" : "Active Changes";
+  console.log(renderSection(title, table.toString()));
+  console.log(
+    colors.muted(`  ${changes.length} change${changes.length === 1 ? "" : "s"} found`)
+  );
+}
+
+// src/commands/verify.ts
+import { resolve as resolve6 } from "path";
+import {
+  configExists as configExists6,
+  readChangeFile as readChangeFile2,
+  listChanges as listChanges2,
+  getChangePath as getChangePath2
+} from "@forgelore/core";
+async function verifyChange(projectRoot, changeName) {
+  const checks = [];
+  const changePath = getChangePath2(projectRoot, changeName);
+  try {
+    const proposal = await readChangeFile2(projectRoot, changeName, "proposal.md");
+    const hasContent = proposal.replace(/<!--.*?-->/gs, "").trim().length > 50;
+    checks.push({
+      name: "Proposal",
+      passed: hasContent,
+      message: hasContent ? "proposal.md has content" : "proposal.md is mostly empty \u2014 fill in motivation and scope"
+    });
+  } catch {
+    checks.push({
+      name: "Proposal",
+      passed: false,
+      message: "proposal.md is missing"
+    });
+  }
+  try {
+    const reqs = await readChangeFile2(projectRoot, changeName, "specs/requirements.md");
+    const hasContent = reqs.replace(/<!--.*?-->/gs, "").trim().length > 50;
+    checks.push({
+      name: "Requirements",
+      passed: hasContent,
+      message: hasContent ? "requirements.md has content" : "requirements.md is mostly empty \u2014 define functional and non-functional requirements"
+    });
+  } catch {
+    checks.push({
+      name: "Requirements",
+      passed: false,
+      message: "specs/requirements.md is missing"
+    });
+  }
+  try {
+    const scenarios = await readChangeFile2(projectRoot, changeName, "specs/scenarios.md");
+    const hasContent = scenarios.replace(/<!--.*?-->/gs, "").trim().length > 50;
+    checks.push({
+      name: "Scenarios",
+      passed: hasContent,
+      message: hasContent ? "scenarios.md has content" : "scenarios.md is mostly empty \u2014 define happy path, edge cases, error cases"
+    });
+  } catch {
+    checks.push({
+      name: "Scenarios",
+      passed: false,
+      message: "specs/scenarios.md is missing"
+    });
+  }
+  try {
+    const design = await readChangeFile2(projectRoot, changeName, "design.md");
+    const hasContent = design.replace(/<!--.*?-->/gs, "").trim().length > 50;
+    checks.push({
+      name: "Design",
+      passed: hasContent,
+      message: hasContent ? "design.md has content" : "design.md is mostly empty \u2014 describe technical approach"
+    });
+  } catch {
+    checks.push({
+      name: "Design",
+      passed: false,
+      message: "design.md is missing"
+    });
+  }
+  try {
+    const tasks = await readChangeFile2(projectRoot, changeName, "tasks.md");
+    const hasContent = tasks.replace(/<!--.*?-->/gs, "").trim().length > 50;
+    checks.push({
+      name: "Tasks",
+      passed: hasContent,
+      message: hasContent ? "tasks.md has content" : "tasks.md is mostly empty \u2014 break down implementation into tasks"
+    });
+  } catch {
+    checks.push({
+      name: "Tasks",
+      passed: false,
+      message: "tasks.md is missing"
+    });
+  }
+  return checks;
+}
+async function verifyCommand(changeName, options) {
+  const projectRoot = resolve6(options?.cwd || process.cwd());
+  if (!await configExists6(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  const changesToVerify = [];
+  if (changeName) {
+    changesToVerify.push(changeName);
+  } else {
+    const changes = await listChanges2(projectRoot, false);
+    if (changes.length === 0) {
+      console.log(
+        renderBox(
+          `${icons.info} No active changes to verify.
+Run ${colors.primary("forgelore propose")} to create one.`,
+          "Nothing to Verify"
+        )
+      );
+      return;
+    }
+    changesToVerify.push(...changes.map((c) => c.name));
+  }
+  let totalPassed = 0;
+  let totalChecks = 0;
+  for (const name of changesToVerify) {
+    try {
+      const checks = await verifyChange(projectRoot, name);
+      const passed = checks.filter((c) => c.passed).length;
+      totalPassed += passed;
+      totalChecks += checks.length;
+      const lines = checks.map(
+        (c) => `  ${c.passed ? icons.success : icons.error} ${colors.white(c.name)}: ${c.passed ? colors.muted(c.message) : colors.warning(c.message)}`
+      );
+      const allPassed = passed === checks.length;
+      const borderColor = allPassed ? "#10B981" : "#F59E0B";
+      console.log(
+        renderBox(
+          `${allPassed ? icons.success : icons.warning} ${passed}/${checks.length} checks passed
+
+${lines.join("\n")}`,
+          name,
+          borderColor
+        )
+      );
+    } catch {
+      console.log(
+        renderBox(
+          `${icons.error} Change ${colors.primary(name)} not found.`,
+          name,
+          "#EF4444"
+        )
+      );
+    }
+  }
+  if (changesToVerify.length > 1) {
+    const allPassed = totalPassed === totalChecks;
+    console.log(
+      renderBox(
+        `${allPassed ? icons.success : icons.warning} ${totalPassed}/${totalChecks} total checks passed across ${changesToVerify.length} changes`,
+        "Summary",
+        allPassed ? "#10B981" : "#F59E0B"
+      )
+    );
+  }
+}
+
+// src/commands/archive.ts
+import * as p4 from "@clack/prompts";
+import ora3 from "ora";
+import { resolve as resolve7 } from "path";
+import {
+  configExists as configExists7,
+  readChange as readChange3,
+  archiveChange,
+  readOutcome,
+  writeOutcome,
+  getChangePath as getChangePath3
+} from "@forgelore/core";
+async function archiveCommand(changeName, options) {
+  const projectRoot = resolve7(options?.cwd || process.cwd());
+  if (!await configExists7(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  p4.intro(gradients.brand(" forgelore archive "));
+  let change;
+  try {
+    change = await readChange3(projectRoot, changeName);
+  } catch {
+    console.log(
+      renderBox(
+        `${icons.error} Change ${colors.primary(changeName)} not found.`,
+        "Not Found",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  const changePath = getChangePath3(projectRoot, changeName);
+  const existingOutcome = await readOutcome(changePath);
+  if (!existingOutcome && !options?.skipOutcome) {
+    console.log(
+      renderBox(
+        [
+          `${icons.info} Before archiving, an ${colors.primary("outcome.md")} should be created.`,
+          "",
+          `This file captures:`,
+          `  ${icons.bullet} What was built and the final state`,
+          `  ${icons.bullet} Capabilities that emerged from this change`,
+          `  ${icons.bullet} Lessons learned and patterns established`,
+          "",
+          `${colors.muted("An AI agent can generate this, or you can write it manually.")}`,
+          `${colors.muted("Create")} ${colors.primary(`forgelore/changes/${changeName}/outcome.md`)} ${colors.muted("and run archive again.")}`
+        ].join("\n"),
+        "Step 1: Outcome",
+        "#F59E0B"
+      )
+    );
+    const proceed = await p4.confirm({
+      message: "Create a placeholder outcome.md and continue archiving?",
+      initialValue: false
+    });
+    if (p4.isCancel(proceed) || !proceed) {
+      p4.cancel("Archive paused. Create outcome.md and run archive again.");
+      process.exit(0);
+    }
+    const placeholderOutcome = `# Outcome: ${changeName}
+
+## What Was Built
+
+<!-- Summary of what was implemented -->
+
+
+## Capabilities
+
+<!-- List capabilities that emerged from this change -->
+<!-- Format: - **Capability Name**: Description -->
+
+- 
+
+## Lessons Learned
+
+<!-- What did we learn? Any patterns to document? -->
+
+
+## Files Changed
+
+<!-- Key files that were created or modified -->
+
+- 
+
+---
+
+*Archived: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}*
+`;
+    await writeOutcome(changePath, placeholderOutcome);
+    console.log(`  ${icons.success} Created placeholder outcome.md`);
+  }
+  const confirmArchive = await p4.confirm({
+    message: `Archive "${changeName}"? This will move it to forgelore/changes/archive/`,
+    initialValue: true
+  });
+  if (p4.isCancel(confirmArchive) || !confirmArchive) {
+    p4.cancel("Archive cancelled.");
+    process.exit(0);
+  }
+  const spinner = ora3({
+    text: "Archiving change...",
+    color: "magenta"
+  }).start();
+  try {
+    const archivePath = await archiveChange(projectRoot, changeName);
+    spinner.succeed(colors.success("Change archived"));
+    console.log(
+      renderBox(
+        [
+          `${icons.success} ${colors.white("Archived:")} ${colors.primary(changeName)}`,
+          `${icons.arrow} ${colors.muted(archivePath)}`,
+          "",
+          `${colors.muted("Next steps:")}`,
+          `  1. Review ${colors.primary("outcome.md")} and extract capabilities`,
+          `  2. Run ${colors.primary("forgelore capabilities")} to view the knowledge base`,
+          `  3. Update ${colors.primary("forgelore/knowledge/architecture.md")} if needed`
+        ].join("\n"),
+        "Archived",
+        "#10B981"
+      )
+    );
+  } catch (err) {
+    spinner.fail(colors.error("Failed to archive"));
+    if (err instanceof Error) {
+      console.error(colors.muted(err.message));
+    }
+    process.exit(1);
+  }
+  p4.outro(colors.muted("Knowledge captured. The spec lives on."));
+}
+
+// src/commands/sync.ts
+import ora4 from "ora";
+import { resolve as resolve8 } from "path";
+import { execSync } from "child_process";
+import { existsSync, mkdirSync } from "fs";
+import {
+  configExists as configExists8,
+  readConfig as readConfig2
+} from "@forgelore/core";
+async function syncCommand(options) {
+  const projectRoot = resolve8(options?.cwd || process.cwd());
+  if (!await configExists8(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  const config = await readConfig2(projectRoot);
+  if (config.mode === "local") {
+    console.log(
+      renderBox(
+        `${icons.info} Spec mode is ${colors.primary("local")}. No global repo to sync.
+Run ${colors.primary("forgelore config mode local+global")} to enable global specs.`,
+        "No Sync Needed"
+      )
+    );
+    return;
+  }
+  if (!config.global?.source) {
+    console.log(
+      renderBox(
+        `${icons.error} Global spec source not configured.
+Run ${colors.primary("forgelore config global.source <path-or-url>")} to set it.`,
+        "Not Configured",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  const source = config.global.source;
+  const isGitUrl = source.startsWith("http://") || source.startsWith("https://") || source.startsWith("git@");
+  const targetPath = config.global.path;
+  const spinner = ora4({
+    text: `Syncing from ${source}...`,
+    color: "magenta"
+  }).start();
+  try {
+    if (isGitUrl) {
+      if (existsSync(targetPath)) {
+        spinner.text = "Pulling latest changes...";
+        execSync("git pull --ff-only", { cwd: targetPath, stdio: "pipe" });
+        spinner.succeed(colors.success("Global specs updated (git pull)"));
+      } else {
+        spinner.text = "Cloning global spec repo...";
+        mkdirSync(targetPath, { recursive: true });
+        execSync(`git clone ${source} ${targetPath}`, { stdio: "pipe" });
+        spinner.succeed(colors.success("Global specs cloned"));
+      }
+    } else {
+      if (existsSync(source)) {
+        spinner.succeed(
+          colors.success(`Global specs linked: ${colors.muted(source)}`)
+        );
+      } else {
+        spinner.fail(
+          colors.error(`Global spec path not found: ${source}`)
+        );
+        process.exit(1);
+      }
+    }
+    console.log(
+      renderBox(
+        [
+          `${icons.success} Global specs synced`,
+          `${icons.info} Source: ${colors.secondary(source)}`,
+          `${icons.info} Path: ${colors.muted(targetPath)}`
+        ].join("\n"),
+        "Sync Complete",
+        "#10B981"
+      )
+    );
+  } catch (err) {
+    spinner.fail(colors.error("Sync failed"));
+    if (err instanceof Error) {
+      console.error(colors.muted(err.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/doctor.ts
+import { resolve as resolve9, join } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+import {
+  configExists as configExists9,
+  readConfig as readConfig3,
+  fileExists as fileExists2,
+  getForgeloreDir as getForgeloreDir2,
+  listChanges as listChanges3
+} from "@forgelore/core";
+async function doctorCommand(options) {
+  const projectRoot = resolve9(options?.cwd || process.cwd());
+  const forgeloreDir = getForgeloreDir2(projectRoot);
+  const checks = [];
+  console.log(
+    renderBox(
+      `${icons.info} Running health checks...`,
+      "forgelore doctor"
+    )
+  );
+  const hasConfig = await configExists9(projectRoot);
+  checks.push({
+    name: "Configuration",
+    passed: hasConfig,
+    message: hasConfig ? "forgelore.json found" : "forgelore.json not found \u2014 run forgelore init"
+  });
+  if (!hasConfig) {
+    printResults(checks);
+    return;
+  }
+  let config;
+  try {
+    config = await readConfig3(projectRoot);
+    checks.push({
+      name: "Config Valid",
+      passed: true,
+      message: `Config parsed (v${config.version}, mode: ${config.mode})`
+    });
+  } catch (err) {
+    checks.push({
+      name: "Config Valid",
+      passed: false,
+      message: `Config parse error: ${err instanceof Error ? err.message : String(err)}`
+    });
+    printResults(checks);
+    return;
+  }
+  const dirs = [
+    { path: join(forgeloreDir, "changes"), name: "changes/" },
+    { path: join(forgeloreDir, "changes", "archive"), name: "changes/archive/" },
+    { path: join(forgeloreDir, "knowledge"), name: "knowledge/" },
+    { path: join(forgeloreDir, "knowledge", "capabilities"), name: "knowledge/capabilities/" },
+    { path: join(forgeloreDir, "knowledge", "decisions"), name: "knowledge/decisions/" }
+  ];
+  for (const dir of dirs) {
+    const exists = await fileExists2(dir.path);
+    checks.push({
+      name: `Dir: ${dir.name}`,
+      passed: exists,
+      message: exists ? `${dir.name} exists` : `${dir.name} missing`,
+      fixable: true
+    });
+    if (!exists && options?.fix) {
+      await mkdir2(dir.path, { recursive: true });
+    }
+  }
+  const knowledgeFiles = [
+    { path: join(forgeloreDir, "knowledge", "architecture.md"), name: "architecture.md" },
+    { path: join(forgeloreDir, "knowledge", "patterns.md"), name: "patterns.md" },
+    { path: join(forgeloreDir, "knowledge", "glossary.md"), name: "glossary.md" }
+  ];
+  for (const file of knowledgeFiles) {
+    const exists = await fileExists2(file.path);
+    checks.push({
+      name: `KB: ${file.name}`,
+      passed: exists,
+      message: exists ? `${file.name} present` : `${file.name} missing`
+    });
+  }
+  try {
+    const changes = await listChanges3(projectRoot, false);
+    checks.push({
+      name: "Active Changes",
+      passed: true,
+      message: `${changes.length} active change${changes.length === 1 ? "" : "s"}`
+    });
+    for (const change of changes) {
+      const hasProposal = await fileExists2(join(change.path, "proposal.md"));
+      if (!hasProposal) {
+        checks.push({
+          name: `Change: ${change.name}`,
+          passed: false,
+          message: `${change.name} has metadata but missing proposal.md`
+        });
+      }
+    }
+  } catch {
+    checks.push({
+      name: "Active Changes",
+      passed: false,
+      message: "Could not read changes directory"
+    });
+  }
+  if (config.mode !== "local" && config.global) {
+    const globalExists = await fileExists2(config.global.path);
+    checks.push({
+      name: "Global Repo",
+      passed: globalExists,
+      message: globalExists ? `Global specs available at ${config.global.path}` : `Global specs not found at ${config.global.path} \u2014 run forgelore sync`
+    });
+  }
+  printResults(checks, options?.fix);
+}
+function printResults(checks, didFix) {
+  const passed = checks.filter((c) => c.passed).length;
+  const total = checks.length;
+  const allPassed = passed === total;
+  const lines = checks.map(
+    (c) => `  ${c.passed ? icons.success : icons.error} ${colors.white(c.name)}: ${c.passed ? colors.muted(c.message) : colors.warning(c.message)}${!c.passed && c.fixable && didFix ? colors.success(" (fixed)") : ""}`
+  );
+  const borderColor = allPassed ? "#10B981" : passed > total / 2 ? "#F59E0B" : "#EF4444";
+  console.log(
+    renderBox(
+      `${allPassed ? icons.success : icons.warning} ${passed}/${total} checks passed
+
+${lines.join("\n")}`,
+      "Results",
+      borderColor
+    )
+  );
+  if (!allPassed && !didFix) {
+    const fixable = checks.filter((c) => !c.passed && c.fixable).length;
+    if (fixable > 0) {
+      console.log(
+        colors.muted(`  Run ${colors.primary("forgelore doctor --fix")} to auto-fix ${fixable} issue${fixable === 1 ? "" : "s"}.`)
+      );
+    }
+  }
+}
+
+// src/commands/capabilities.ts
+import { resolve as resolve10 } from "path";
+import Table3 from "cli-table3";
+import {
+  configExists as configExists10,
+  listCapabilities as listCapabilities3
+} from "@forgelore/core";
+async function capabilitiesCommand(options) {
+  const projectRoot = resolve10(options?.cwd || process.cwd());
+  if (!await configExists10(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  const capabilities = await listCapabilities3(projectRoot);
+  if (capabilities.length === 0) {
+    console.log(
+      renderBox(
+        `${icons.info} No capabilities registered yet.
+
+Capabilities are extracted when changes are archived.
+Archive a completed change with ${colors.primary("forgelore archive <change>")} to start building
+your knowledge base.`,
+        "Capabilities"
+      )
+    );
+    return;
+  }
+  if (options?.json) {
+    console.log(JSON.stringify(capabilities, null, 2));
+    return;
+  }
+  const table = new Table3({
+    head: [
+      colors.bold("Name"),
+      colors.bold("Description"),
+      colors.bold("Source"),
+      colors.bold("Archived"),
+      colors.bold("Tags")
+    ].map(String),
+    style: { head: [], border: ["gray"] },
+    colWidths: [22, 30, 18, 14, 16],
+    wordWrap: true
+  });
+  for (const cap of capabilities) {
+    table.push([
+      colors.white(cap.name),
+      colors.muted(cap.description.slice(0, 60)),
+      colors.secondary(cap.sourceChange),
+      colors.dim(cap.archivedAt.slice(0, 10)),
+      cap.tags?.length ? colors.accent(cap.tags.join(", ")) : colors.muted("--")
+    ]);
+  }
+  console.log(renderSection("Capabilities", table.toString()));
+  console.log(
+    colors.muted(
+      `  ${capabilities.length} capabilit${capabilities.length === 1 ? "y" : "ies"} registered`
+    )
+  );
+}
+
+// src/commands/config.ts
+import { resolve as resolve11 } from "path";
+import {
+  configExists as configExists11,
+  readConfig as readConfig4,
+  getConfigValue,
+  setConfigValue
+} from "@forgelore/core";
+async function configCommand(key, value, options) {
+  const projectRoot = resolve11(options?.cwd || process.cwd());
+  if (!await configExists11(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  if (options?.list || !key && !value) {
+    const config = await readConfig4(projectRoot);
+    const lines = formatObject(config, "");
+    console.log(
+      renderSection("Configuration", lines.join("\n"))
+    );
+    return;
+  }
+  if (key && !value) {
+    const val = await getConfigValue(projectRoot, key);
+    if (val === void 0) {
+      console.log(
+        `  ${icons.error} Key ${colors.primary(key)} not found in config.`
+      );
+      process.exit(1);
+    }
+    if (typeof val === "object" && val !== null) {
+      const lines = formatObject(val, "");
+      console.log(renderSection(key, lines.join("\n")));
+    } else {
+      console.log(`  ${colors.primary(key)} ${colors.muted("=")} ${colors.white(String(val))}`);
+    }
+    return;
+  }
+  if (key && value) {
+    let parsed = value;
+    if (value === "true") parsed = true;
+    else if (value === "false") parsed = false;
+    else if (/^\d+$/.test(value)) parsed = parseInt(value, 10);
+    else {
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+      }
+    }
+    await setConfigValue(projectRoot, key, parsed);
+    console.log(
+      `  ${icons.success} Set ${colors.primary(key)} ${colors.muted("=")} ${colors.white(String(parsed))}`
+    );
+  }
+}
+function formatObject(obj, prefix) {
+  const lines = [];
+  for (const [k, v] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${k}` : k;
+    if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+      lines.push(`  ${colors.muted(fullKey + ":")}`);
+      lines.push(...formatObject(v, fullKey));
+    } else {
+      lines.push(
+        `  ${colors.primary(fullKey)} ${colors.muted("=")} ${colors.white(String(v))}`
+      );
+    }
+  }
+  return lines;
+}
+
+// src/commands/diff.ts
+import { resolve as resolve12 } from "path";
+import Table4 from "cli-table3";
+import {
+  configExists as configExists12,
+  listChanges as listChanges4,
+  readChange as readChange4,
+  readChangeFile as readChangeFile3
+} from "@forgelore/core";
+async function diffCommand(changeName, options) {
+  const projectRoot = resolve12(options?.cwd || process.cwd());
+  if (!await configExists12(projectRoot)) {
+    console.log(
+      renderBox(
+        `${icons.error} forgelore is not initialized.
+Run ${colors.primary("forgelore init")} first.`,
+        "Not Initialized",
+        "#EF4444"
+      )
+    );
+    process.exit(1);
+  }
+  const driftItems = [];
+  if (changeName) {
+    try {
+      const change = await readChange4(projectRoot, changeName);
+      await analyzeChangeDrift(projectRoot, changeName, driftItems);
+    } catch {
+      console.log(
+        renderBox(
+          `${icons.error} Change ${colors.primary(changeName)} not found.`,
+          "Not Found",
+          "#EF4444"
+        )
+      );
+      process.exit(1);
+    }
+  } else {
+    const changes = await listChanges4(projectRoot, false);
+    if (changes.length === 0) {
+      console.log(
+        renderBox(
+          `${icons.info} No active changes to analyze.
+Run ${colors.primary("forgelore propose")} to create one.`,
+          "No Changes"
+        )
+      );
+      return;
+    }
+    for (const change of changes) {
+      await analyzeChangeDrift(projectRoot, change.name, driftItems);
+    }
+  }
+  if (driftItems.length === 0) {
+    console.log(
+      renderBox(
+        `${icons.success} No drift detected. Specs and implementation are in sync.`,
+        "All Clear",
+        "#10B981"
+      )
+    );
+    return;
+  }
+  const table = new Table4({
+    head: [
+      colors.bold("Severity"),
+      colors.bold("Type"),
+      colors.bold("Message")
+    ].map(String),
+    style: { head: [], border: ["gray"] },
+    colWidths: [12, 20, 55],
+    wordWrap: true
+  });
+  for (const item of driftItems) {
+    const sevColor = item.severity === "critical" ? colors.error : item.severity === "warning" ? colors.warning : colors.muted;
+    table.push([
+      sevColor(item.severity),
+      colors.white(item.type),
+      colors.muted(item.message)
+    ]);
+  }
+  const critical = driftItems.filter((d) => d.severity === "critical").length;
+  const warnings = driftItems.filter((d) => d.severity === "warning").length;
+  const info = driftItems.filter((d) => d.severity === "info").length;
+  const summaryParts = [];
+  if (critical > 0) summaryParts.push(colors.error(`${critical} critical`));
+  if (warnings > 0) summaryParts.push(colors.warning(`${warnings} warnings`));
+  if (info > 0) summaryParts.push(colors.muted(`${info} info`));
+  console.log(
+    renderSection("Drift Report", table.toString())
+  );
+  console.log(
+    renderBox(
+      `${critical > 0 ? icons.error : icons.warning} ${summaryParts.join(", ")}`,
+      "Summary",
+      critical > 0 ? "#EF4444" : "#F59E0B"
+    )
+  );
+}
+async function analyzeChangeDrift(projectRoot, changeName, items) {
+  try {
+    const change = await readChange4(projectRoot, changeName);
+    const updatedAt = new Date(change.updatedAt);
+    const daysSince = Math.floor(
+      (Date.now() - updatedAt.getTime()) / (1e3 * 60 * 60 * 24)
+    );
+    if (daysSince > 14 && change.status === "proposed") {
+      items.push({
+        type: "stale-proposal",
+        severity: "warning",
+        message: `"${changeName}" proposed ${daysSince} days ago with no progress`
+      });
+    }
+    if (daysSince > 7 && change.status === "in-progress") {
+      items.push({
+        type: "stale-progress",
+        severity: "info",
+        message: `"${changeName}" in progress for ${daysSince} days since last update`
+      });
+    }
+    const specFiles = ["proposal.md", "specs/requirements.md", "specs/scenarios.md", "design.md", "tasks.md"];
+    for (const file of specFiles) {
+      try {
+        const content = await readChangeFile3(projectRoot, changeName, file);
+        const stripped = content.replace(/<!--.*?-->/gs, "").trim();
+        if (stripped.length < 30) {
+          items.push({
+            type: "empty-spec",
+            severity: change.status === "in-progress" ? "warning" : "info",
+            message: `"${changeName}/${file}" has minimal content`
+          });
+        }
+      } catch {
+        items.push({
+          type: "missing-file",
+          severity: "critical",
+          message: `"${changeName}/${file}" is missing`
+        });
+      }
+    }
+    if (change.status === "in-progress" && change.tasks.length > 0 && change.tasks.every((t) => t.status === "pending")) {
+      items.push({
+        type: "no-task-progress",
+        severity: "warning",
+        message: `"${changeName}" is in-progress but all ${change.tasks.length} tasks are still pending`
+      });
+    }
+  } catch {
+    items.push({
+      type: "read-error",
+      severity: "critical",
+      message: `Could not read change "${changeName}"`
+    });
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("forgelore").description("Spec-driven development for AI-assisted teams \u2014 forge knowledge, shape code").version("0.1.0");
+program.command("init").description("Initialize forgelore in the current project").option("-C, --cwd <path>", "Working directory").action((opts) => initCommand({ cwd: opts.cwd }));
+program.command("propose [idea]").description("Create a new change proposal").option("-C, --cwd <path>", "Working directory").action((idea, opts) => proposeCommand(idea, { cwd: opts.cwd }));
+program.command("clarify <change>").description("Review and refine requirements for a change").option("-C, --cwd <path>", "Working directory").action((change, opts) => clarifyCommand(change, { cwd: opts.cwd }));
+program.command("status").description("Show project status dashboard").option("-C, --cwd <path>", "Working directory").action((opts) => statusCommand({ cwd: opts.cwd }));
+program.command("list").description("List all changes").option("-a, --archived", "Include archived changes").option("-s, --status <status>", "Filter by status").option("-C, --cwd <path>", "Working directory").action((opts) => listCommand({ archived: opts.archived, status: opts.status, cwd: opts.cwd }));
+program.command("verify [change]").description("Verify a change against its specs (structural check)").option("-C, --cwd <path>", "Working directory").action((change, opts) => verifyCommand(change, { cwd: opts.cwd }));
+program.command("archive <change>").description("Archive a completed change and extract capabilities").option("--skip-outcome", "Skip outcome.md generation step").option("-C, --cwd <path>", "Working directory").action((change, opts) => archiveCommand(change, { skipOutcome: opts.skipOutcome, cwd: opts.cwd }));
+program.command("sync").description("Sync with the global spec repository").option("--force", "Force sync even if local changes exist").option("-C, --cwd <path>", "Working directory").action((opts) => syncCommand({ force: opts.force, cwd: opts.cwd }));
+program.command("doctor").description("Check forgelore health and diagnose issues").option("--fix", "Attempt to fix detected issues").option("-C, --cwd <path>", "Working directory").action((opts) => doctorCommand({ fix: opts.fix, cwd: opts.cwd }));
+program.command("capabilities").alias("caps").description("List all registered capabilities").option("--json", "Output as JSON").option("-C, --cwd <path>", "Working directory").action((opts) => capabilitiesCommand({ json: opts.json, cwd: opts.cwd }));
+program.command("config [key] [value]").description("Get or set configuration values").option("--list", "List all config values").option("-C, --cwd <path>", "Working directory").action((key, value, opts) => configCommand(key, value, { list: opts.list, cwd: opts.cwd }));
+program.command("diff [change]").description("Show drift between specs and implementation").option("-C, --cwd <path>", "Working directory").action((change, opts) => diffCommand(change, { cwd: opts.cwd }));
+program.action(async () => {
+  await renderAnimatedBanner();
+  program.outputHelp();
+});
+program.parse();
+//# sourceMappingURL=index.js.map