schub 0.1.0 → 0.1.2

package/src/commands/adr.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const decoder = new TextDecoder();
+
+const runCli = (schubCwd: string, args: string[]) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const createRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-adr-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  const schubRoot = join(repoRoot, ".schub");
+  mkdirSync(cwd, { recursive: true });
+  mkdirSync(schubRoot, { recursive: true });
+  return { cwd, schubRoot };
+};
+
+const seedChange = (schubRoot: string, changeId: string, title: string) => {
+  const changeDir = join(schubRoot, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  const proposal = [
+    `# Proposal - ${title}`,
+    "",
+    `**Change ID**: \`${changeId}\``,
+    "**Created**: 2024-01-01",
+    "**Status**: Draft",
+    "",
+  ].join("\n");
+  writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
+};
+
+test("adr create scaffolds ADR file", () => {
+  const { cwd, schubRoot } = createRepo();
+  const changeId = "C003_new-adr";
+  const changeTitle = "New ADR";
+  seedChange(schubRoot, changeId, changeTitle);
+
+  const adrTitle = "Decision Record";
+  const { result } = runCli(cwd, ["adr", "create", "--change-id", changeId, "--title", adrTitle]);
+  expect(result.exitCode).toBe(0);
+
+  const adrPath = join(schubRoot, "changes", changeId, "adr.md");
+  expect(existsSync(adrPath)).toBe(true);
+
+  const templatePath = join(cliDir, "templates", "create-proposal", "adr-template.md");
+  const template = readFileSync(templatePath, "utf8");
+  const today = new Date().toISOString().split("T")[0];
+  const expected = template.split("[TITLE]").join(adrTitle).split("[YYYY-MM-DD]").join(today);
+
+  expect(readFileSync(adrPath, "utf8")).toBe(expected);
+});

package/src/commands/adr.ts

@@ -0,0 +1,107 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readChangeSummary, resolveChangeRoot } from "../changes";
+import { resolveTemplatePath } from "../templates";
+
+const BUNDLED_ADR_TEMPLATE_PATH = fileURLToPath(
+  new URL("../../templates/create-proposal/adr-template.md", import.meta.url),
+);
+
+type AdrCreateOptions = {
+  changeId: string;
+  title?: string;
+  overwrite: boolean;
+};
+
+const parseAdrCreateOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let title: string | undefined;
+  let overwrite = false;
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--overwrite") {
+      overwrite = true;
+      continue;
+    }
+    if (arg === "--change-id") {
+      changeId = args[index + 1];
+      if (changeId === undefined) {
+        throw new Error("Missing value for --change-id.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--change-id=")) {
+      changeId = arg.slice("--change-id=".length);
+      continue;
+    }
+    if (arg === "--title") {
+      title = args[index + 1];
+      if (title === undefined) {
+        throw new Error("Missing value for --title.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--title=")) {
+      title = arg.slice("--title=".length);
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  if (!changeId) {
+    throw new Error("Provide --change-id.");
+  }
+
+  return { changeId, title, overwrite };
+};
+
+const renderAdrTemplate = (template: string, title: string) => {
+  const today = new Date().toISOString().split("T")[0];
+  return template.split("[TITLE]").join(title).split("[YYYY-MM-DD]").join(today);
+};
+
+export const runAdrCreate = (args: string[], startDir: string) => {
+  const options: AdrCreateOptions = parseAdrCreateOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const summary = readChangeSummary(schubDir, options.changeId);
+  const adrTitle = options.title?.trim() || summary.changeTitle;
+  const outputPath = join(summary.changeDir, "adr.md");
+
+  if (existsSync(outputPath) && !options.overwrite) {
+    throw new Error(`Refusing to overwrite existing file: ${outputPath}`);
+  }
+
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("create-proposal", "adr-template.md"),
+    BUNDLED_ADR_TEMPLATE_PATH,
+  );
+  const template = readFileSync(templatePath, "utf8");
+  const rendered = renderAdrTemplate(template, adrTitle || summary.changeId);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, rendered, "utf8");
+
+  process.stdout.write(`[OK] Wrote ADR: ${outputPath}\n`);
+};

package/src/commands/changes.test.ts

@@ -0,0 +1,171 @@
+import { expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const proposalTemplatePath = join(cliDir, "templates", "create-proposal", "proposal-template.md");
+const decoder = new TextDecoder();
+
+const runChangesCreate = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "changes", "create", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const runChangesStatus = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "changes", "status", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const createRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-changes-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  mkdirSync(cwd, { recursive: true });
+  return { repoRoot, cwd };
+};
+
+const seedChange = (schubRoot: string, changeId: string) => {
+  const changeDir = join(schubRoot, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(join(changeDir, "proposal.md"), "# Proposal - Seed\n", "utf8");
+};
+
+const seedProposal = (schubRoot: string, changeId: string, status: string) => {
+  const changeDir = join(schubRoot, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  const proposal = `# Proposal - Seed\n**Status**: ${status}\n`;
+  writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
+};
+
+test("changes create scaffolds proposal with prefixed id", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedChange(schubRoot, "C002_existing-change");
+
+  const title = "Update CLI scaffolding";
+  const input = "user prompt";
+  const { result } = runChangesCreate(cwd, [
+    "--change-id",
+    "update-cli-scaffolding",
+    "--title",
+    title,
+    "--input",
+    input,
+  ]);
+
+  expect(result.exitCode).toBe(0);
+
+  const changeId = "C003_update-cli-scaffolding";
+  const proposalPath = join(schubRoot, "changes", changeId, "proposal.md");
+  expect(existsSync(proposalPath)).toBe(true);
+
+  const content = readFileSync(proposalPath, "utf8");
+  const template = readFileSync(proposalTemplatePath, "utf8");
+  const today = new Date().toISOString().split("T")[0];
+  const expected = template
+    .replace("{{CHANGE_TITLE}}", title)
+    .replace("{{CHANGE_ID}}", changeId)
+    .replace("{{DATE}}", today)
+    .replace("{{INPUT}}", input)
+    .replace("{{AGENT_ROOT}}", schubRoot);
+
+  expect(content).toBe(expected);
+});
+
+test("changes create rejects invalid change id", () => {
+  const { cwd } = createRepo();
+  const { result, stderr } = runChangesCreate(cwd, ["--change-id", "bad id"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Invalid change-id");
+  expect(existsSync(join(cwd, ".schub"))).toBe(false);
+});
+
+test("changes create requires change id or title", () => {
+  const { cwd } = createRepo();
+  const { result, stderr } = runChangesCreate(cwd);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Provide --change-id or --title.");
+  expect(existsSync(join(cwd, ".schub"))).toBe(false);
+});
+
+test("changes create respects overwrite", () => {
+  const { cwd } = createRepo();
+  const schubRoot = join(cwd, ".schub");
+  const changeId = "C001_repeatable-change";
+
+  const first = runChangesCreate(cwd, ["--change-id", changeId, "--title", "First"]);
+  expect(first.result.exitCode).toBe(0);
+
+  const proposalPath = join(schubRoot, "changes", changeId, "proposal.md");
+  expect(readFileSync(proposalPath, "utf8")).toContain("# Proposal - First");
+
+  const second = runChangesCreate(cwd, ["--change-id", changeId, "--title", "Second"]);
+  expect(second.result.exitCode).not.toBe(0);
+  expect(second.stderr).toContain("already exists");
+
+  const third = runChangesCreate(cwd, ["--change-id", changeId, "--title", "Overwrite", "--overwrite"]);
+  expect(third.result.exitCode).toBe(0);
+  expect(readFileSync(proposalPath, "utf8")).toContain("# Proposal - Overwrite");
+});
+
+test("changes create rejects schub root flags", () => {
+  const { cwd } = createRepo();
+  const { result, stderr } = runChangesCreate(cwd, ["--schub-root", "/tmp", "--change-id", "valid-slug"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Unsupported option: --schub-root.");
+});
+
+test("changes status updates accepted proposals", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C001_update-cli", "Accepted");
+
+  const { result, stdout } = runChangesStatus(cwd, ["--change-id", "C001_update-cli", "--status", "Done"]);
+
+  expect(result.exitCode).toBe(0);
+
+  const proposalPath = join(schubRoot, "changes", "C001_update-cli", "proposal.md");
+  const updated = readFileSync(proposalPath, "utf8");
+  expect(updated).toContain("**Status**: Done");
+  expect(stdout).toContain("[OK] Updated status");
+});
+
+test("changes status updates WIP proposals", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C001_update-cli", "WIP");
+
+  const { result, stdout } = runChangesStatus(cwd, ["--change-id", "C001_update-cli", "--status", "Done"]);
+
+  expect(result.exitCode).toBe(0);
+
+  const proposalPath = join(schubRoot, "changes", "C001_update-cli", "proposal.md");
+  const updated = readFileSync(proposalPath, "utf8");
+  expect(updated).toContain("**Status**: Done");
+  expect(stdout).toContain("[OK] Updated status");
+});

package/src/commands/changes.ts

@@ -0,0 +1,163 @@
+import { createChange, resolveChangeRoot, updateChangeStatus } from "../changes";
+
+type ChangeCreateOptions = {
+  changeId?: string;
+  title?: string;
+  input?: string;
+  overwrite: boolean;
+};
+
+type ChangeStatusOptions = {
+  changeId: string;
+  status: string;
+};
+
+const parseChangeCreateOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let title: string | undefined;
+  let input: string | undefined;
+  let overwrite = false;
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--overwrite") {
+      overwrite = true;
+      continue;
+    }
+    if (arg === "--change-id") {
+      changeId = args[index + 1];
+      if (changeId === undefined) {
+        throw new Error("Missing value for --change-id.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--change-id=")) {
+      changeId = arg.slice("--change-id=".length);
+      continue;
+    }
+    if (arg === "--title") {
+      title = args[index + 1];
+      if (title === undefined) {
+        throw new Error("Missing value for --title.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--title=")) {
+      title = arg.slice("--title=".length);
+      continue;
+    }
+    if (arg === "--input") {
+      input = args[index + 1];
+      if (input === undefined) {
+        throw new Error("Missing value for --input.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--input=")) {
+      input = arg.slice("--input=".length);
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  const options: ChangeCreateOptions = { changeId, title, input, overwrite };
+  return options;
+};
+
+const parseChangeStatusOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let status: string | undefined;
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--change-id") {
+      changeId = args[index + 1];
+      if (changeId === undefined) {
+        throw new Error("Missing value for --change-id.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--change-id=")) {
+      changeId = arg.slice("--change-id=".length);
+      continue;
+    }
+    if (arg === "--status") {
+      status = args[index + 1];
+      if (status === undefined) {
+        throw new Error("Missing value for --status.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--status=")) {
+      status = arg.slice("--status=".length);
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  if (!changeId) {
+    throw new Error("Provide --change-id.");
+  }
+
+  if (!status || !status.trim()) {
+    throw new Error("Provide --status.");
+  }
+
+  const options: ChangeStatusOptions = { changeId, status };
+  return options;
+};
+
+export const runChangesCreate = (args: string[], startDir: string) => {
+  const options = parseChangeCreateOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const proposalPath = createChange(schubDir, options);
+  process.stdout.write(`[OK] Wrote proposal: ${proposalPath}\n`);
+};
+
+export const runChangesStatus = (args: string[], startDir: string) => {
+  const options = parseChangeStatusOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const updated = updateChangeStatus(schubDir, options.changeId, options.status);
+  process.stdout.write(`[OK] Updated status for ${updated.changeId}: ${updated.previousStatus} -> ${updated.status}\n`);
+};

package/src/commands/cookbook.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const decoder = new TextDecoder();
+
+const runCli = (schubCwd: string, args: string[]) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const createRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-cookbook-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  const schubRoot = join(repoRoot, ".schub");
+  mkdirSync(cwd, { recursive: true });
+  mkdirSync(schubRoot, { recursive: true });
+  return { cwd, schubRoot };
+};
+
+const seedChange = (schubRoot: string, changeId: string, title: string) => {
+  const changeDir = join(schubRoot, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  const proposal = [
+    `# Proposal - ${title}`,
+    "",
+    `**Change ID**: \`${changeId}\``,
+    "**Created**: 2024-01-01",
+    "**Status**: Draft",
+    "",
+  ].join("\n");
+  writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
+};
+
+test("cookbook create scaffolds cookbook file", () => {
+  const { cwd, schubRoot } = createRepo();
+  const changeId = "C004_new-cookbook";
+  const changeTitle = "New Cookbook";
+  seedChange(schubRoot, changeId, changeTitle);
+
+  const { result } = runCli(cwd, ["cookbook", "create", "--change-id", changeId]);
+  expect(result.exitCode).toBe(0);
+
+  const cookbookPath = join(schubRoot, "changes", changeId, "cookbook.md");
+  expect(existsSync(cookbookPath)).toBe(true);
+
+  const templatePath = join(cliDir, "templates", "create-proposal", "cookbook-template.md");
+  const template = readFileSync(templatePath, "utf8");
+  const today = new Date().toISOString().split("T")[0];
+  const expected = template
+    .replace("{{CHANGE_TITLE}}", changeTitle)
+    .replace("{{CHANGE_ID}}", changeId)
+    .replace("{{DATE}}", today);
+
+  expect(readFileSync(cookbookPath, "utf8")).toBe(expected);
+});

package/src/commands/cookbook.ts

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readChangeSummary, resolveChangeRoot } from "../changes";
+import { resolveTemplatePath } from "../templates";
+
+const BUNDLED_COOKBOOK_TEMPLATE_PATH = fileURLToPath(
+  new URL("../../templates/create-proposal/cookbook-template.md", import.meta.url),
+);
+
+type CookbookCreateOptions = {
+  changeId: string;
+  overwrite: boolean;
+};
+
+const parseCookbookCreateOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let overwrite = false;
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--overwrite") {
+      overwrite = true;
+      continue;
+    }
+    if (arg === "--change-id") {
+      changeId = args[index + 1];
+      if (changeId === undefined) {
+        throw new Error("Missing value for --change-id.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--change-id=")) {
+      changeId = arg.slice("--change-id=".length);
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  if (!changeId) {
+    throw new Error("Provide --change-id.");
+  }
+
+  return { changeId, overwrite };
+};
+
+const renderCookbookTemplate = (template: string, changeTitle: string, changeId: string) => {
+  const today = new Date().toISOString().split("T")[0];
+  return template
+    .replace("{{CHANGE_TITLE}}", changeTitle)
+    .replace("{{CHANGE_ID}}", changeId)
+    .replace("{{DATE}}", today);
+};
+
+export const runCookbookCreate = (args: string[], startDir: string) => {
+  const options: CookbookCreateOptions = parseCookbookCreateOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const summary = readChangeSummary(schubDir, options.changeId);
+  const outputPath = join(summary.changeDir, "cookbook.md");
+
+  if (existsSync(outputPath) && !options.overwrite) {
+    throw new Error(`Refusing to overwrite existing file: ${outputPath}`);
+  }
+
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("create-proposal", "cookbook-template.md"),
+    BUNDLED_COOKBOOK_TEMPLATE_PATH,
+  );
+  const template = readFileSync(templatePath, "utf8");
+  const rendered = renderCookbookTemplate(template, summary.changeTitle, summary.changeId);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, rendered, "utf8");
+
+  process.stdout.write(`[OK] Wrote cookbook: ${outputPath}\n`);
+};