@ennamjsc/agents-scaffold 1.1.0

package/dist/index.js

@@ -0,0 +1,674 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { cac } from "cac";
+import { readFile as readFile4, access as access2 } from "fs/promises";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path7 from "path";
+import { select, isCancel as isCancel3, cancel as cancel3 } from "@clack/prompts";
+
+// src/profiles.ts
+import { fileURLToPath } from "url";
+import path from "path";
+import { existsSync } from "fs";
+var HERE = path.dirname(fileURLToPath(import.meta.url));
+var CANDIDATE_PUBLISHED = path.join(HERE, "..", "templates");
+var CANDIDATE_MONOREPO = path.join(HERE, "..", "..", "..", "templates");
+var TEMPLATES = existsSync(CANDIDATE_PUBLISHED) ? CANDIDATE_PUBLISHED : CANDIDATE_MONOREPO;
+var REGISTRY = {
+  next: {
+    name: "next",
+    description: "Next.js 16 App Router + React 19 + TS strict",
+    templateDir: path.join(TEMPLATES, "next"),
+    extraMcp: ["chrome-devtools", "figma"]
+  },
+  flutter: {
+    name: "flutter",
+    description: "Flutter 3.x + Dart + Riverpod/Bloc + dio",
+    templateDir: path.join(TEMPLATES, "flutter"),
+    extraMcp: ["figma"]
+  },
+  python: {
+    name: "python",
+    description: "Python 3.12 + FastAPI + uv + ruff + pytest",
+    templateDir: path.join(TEMPLATES, "python"),
+    extraMcp: []
+  },
+  go: {
+    name: "go",
+    description: "Go 1.24 + stdlib net/http + pgx + slog",
+    templateDir: path.join(TEMPLATES, "go"),
+    extraMcp: []
+  },
+  qa: {
+    name: "qa",
+    description: "QA workflow \u2014 test cases, evidence, chrome-devtools",
+    templateDir: path.join(TEMPLATES, "qa"),
+    extraMcp: ["chrome-devtools"]
+  },
+  "local-root": {
+    name: "local-root",
+    description: "Orchestration root \u2014 polyrepo coordinator, reads sub-platform .serena/ memories",
+    templateDir: path.join(TEMPLATES, "local-root"),
+    extraMcp: []
+  }
+};
+function getProfile(name) {
+  const p = REGISTRY[name];
+  if (!p) throw new Error(`Unknown profile: "${name}". Available: ${Object.keys(REGISTRY).join(", ")}`);
+  return p;
+}
+function listProfiles() {
+  return Object.values(REGISTRY);
+}
+function getSharedDir() {
+  return path.join(TEMPLATES, "_shared");
+}
+
+// src/enumerate.ts
+import path2 from "path";
+import fg from "fast-glob";
+
+// src/classify.ts
+var RULES = [
+  { match: (r) => r === "AGENTS.md", kind: "write-or-ask" },
+  { match: (r) => r === "CLAUDE.md", kind: "append-marker" },
+  { match: (r) => r === ".gitignore", kind: "append-lines" },
+  { match: (r) => r === ".mcp.json", kind: "json-merge" },
+  { match: (r) => r === ".claude/settings.json", kind: "json-merge" },
+  { match: (r) => r.startsWith(".claude/hooks/"), kind: "write-or-ask" },
+  { match: (r) => r.startsWith(".claude/commands/"), kind: "skip-if-exists" },
+  { match: (r) => r.startsWith(".claude/agents/"), kind: "skip-if-exists" },
+  { match: (r) => r.startsWith(".serena/"), kind: "skip-if-exists" },
+  { match: (r) => r.startsWith("docs/superpowers/"), kind: "skip-if-exists" }
+];
+function classifyFile(relPath) {
+  const norm = relPath.replace(/\\/g, "/");
+  for (const r of RULES) if (r.match(norm)) return r.kind;
+  return "write-or-ask";
+}
+
+// src/enumerate.ts
+function targetRelPath(srcRel) {
+  return srcRel.replace(/\.partial\.hbs$/, "").replace(/\.hbs$/, "").replace(/\.append$/, "");
+}
+async function collect(dir) {
+  const files = await fg("**/*", { cwd: dir, dot: true, onlyFiles: true });
+  return files.map((rel) => ({ src: path2.join(dir, rel), rel }));
+}
+async function enumerateFiles(profile) {
+  const sharedDir = getSharedDir();
+  const shared = await collect(sharedDir);
+  const profileFiles = await collect(profile.templateDir);
+  const map = /* @__PURE__ */ new Map();
+  const markerPairs = /* @__PURE__ */ new Map();
+  const collectMarker = (src, rel, isShared) => {
+    if (!rel.endsWith(".partial.hbs")) return false;
+    const target = targetRelPath(rel);
+    if (target !== "CLAUDE.md") return false;
+    const entry = markerPairs.get(target) ?? {};
+    if (isShared) entry.sharedSrc = src;
+    else entry.profileSrc = src;
+    markerPairs.set(target, entry);
+    return true;
+  };
+  for (const { src, rel } of shared) {
+    if (collectMarker(src, rel, true)) continue;
+    if (src.endsWith(".partial.hbs")) continue;
+    const target = targetRelPath(rel);
+    map.set(target, {
+      srcAbs: src,
+      relPath: target,
+      isTemplate: src.endsWith(".hbs"),
+      kind: classifyFile(target)
+    });
+  }
+  for (const { src, rel } of profileFiles) {
+    if (collectMarker(src, rel, false)) continue;
+    if (src.endsWith(".partial.hbs")) continue;
+    const target = targetRelPath(rel);
+    map.set(target, {
+      srcAbs: src,
+      relPath: target,
+      isTemplate: src.endsWith(".hbs"),
+      kind: classifyFile(target)
+    });
+  }
+  for (const [target, pair] of markerPairs) {
+    if (!pair.sharedSrc) continue;
+    map.set(target, {
+      srcAbs: pair.sharedSrc,
+      relPath: target,
+      isTemplate: true,
+      kind: "append-marker",
+      extraSrcAbs: pair.profileSrc
+    });
+  }
+  const profileMcpPartial = profileFiles.find(({ rel }) => rel === ".mcp.json.partial.hbs");
+  if (profileMcpPartial) {
+    const existing = map.get(".mcp.json");
+    if (existing) {
+      existing.extraSrcAbs = profileMcpPartial.src;
+    }
+  }
+  return [...map.values()].sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+
+// src/conflict.ts
+import { readFile, access } from "fs/promises";
+import path3 from "path";
+async function scanConflicts(cwd, relPaths, provider) {
+  const out = /* @__PURE__ */ new Map();
+  for (const rel of relPaths) {
+    const abs = path3.join(cwd, rel);
+    let exists = true;
+    try {
+      await access(abs);
+    } catch {
+      exists = false;
+    }
+    if (!exists) {
+      out.set(rel, "absent");
+      continue;
+    }
+    if (!provider) {
+      out.set(rel, "differs");
+      continue;
+    }
+    const incoming = await provider(rel);
+    if (incoming === null) {
+      out.set(rel, "differs");
+      continue;
+    }
+    const existing = await readFile(abs, "utf8");
+    out.set(rel, existing === incoming ? "identical" : "differs");
+  }
+  return out;
+}
+
+// src/plan.ts
+function buildPlan(input) {
+  const ops = [];
+  for (const e of input.entries) {
+    const state = input.conflicts.get(e.relPath) ?? "absent";
+    if (e.relPath === ".gitignore" && !input.hasGit) {
+      ops.push({
+        relPath: e.relPath,
+        src: e,
+        conflict: state,
+        op: "skip",
+        reason: "No .git detected \u2014 skipping .gitignore",
+        needsPrompt: false
+      });
+      continue;
+    }
+    if (e.kind === "append-marker") {
+      if (state === "identical") {
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "skip", reason: "identical \u2014 skip", needsPrompt: false });
+      } else {
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "merge-marker", reason: state === "absent" ? "absent \u2014 write marker block" : "differs \u2014 merge marker block", needsPrompt: false });
+      }
+      continue;
+    }
+    if (e.kind === "json-merge") {
+      if (state === "identical") {
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "skip", reason: "identical \u2014 skip", needsPrompt: false });
+      } else {
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "merge-json", reason: state === "absent" ? "absent \u2014 write json" : "differs \u2014 deep-merge (user wins)", needsPrompt: false });
+      }
+      continue;
+    }
+    if (e.kind === "append-lines") {
+      if (state === "identical") {
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "skip", reason: "identical \u2014 skip", needsPrompt: false });
+      } else {
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "merge-lines", reason: state === "absent" ? "absent \u2014 write lines" : "differs \u2014 append missing lines (dedup)", needsPrompt: false });
+      }
+      continue;
+    }
+    if (state === "absent") {
+      ops.push({ relPath: e.relPath, src: e, conflict: state, op: "write", reason: "absent \u2014 write", needsPrompt: false });
+      continue;
+    }
+    if (state === "identical") {
+      ops.push({ relPath: e.relPath, src: e, conflict: state, op: "skip", reason: "identical \u2014 skip", needsPrompt: false });
+      continue;
+    }
+    if (e.kind === "skip-if-exists") {
+      ops.push({ relPath: e.relPath, src: e, conflict: state, op: "skip", reason: "skip-if-exists kind", needsPrompt: false });
+      continue;
+    }
+    if (e.kind === "mkdir-only") {
+      ops.push({ relPath: e.relPath, src: e, conflict: state, op: "mkdir", reason: "mkdir-only kind", needsPrompt: false });
+      continue;
+    }
+    switch (input.strategy) {
+      case "overwrite":
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "write", reason: "differs \u2014 overwrite (--merge-strategy=overwrite)", needsPrompt: false });
+        break;
+      case "skip":
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "skip", reason: "differs \u2014 keep existing (--merge-strategy=skip)", needsPrompt: false });
+        break;
+      case "ask":
+      default:
+        ops.push({ relPath: e.relPath, src: e, conflict: state, op: "write", reason: "differs \u2014 will prompt at execute time", needsPrompt: true });
+        break;
+    }
+  }
+  return ops;
+}
+
+// src/execute.ts
+import { readFile as readFile3, writeFile, mkdir as mkdir2 } from "fs/promises";
+import path6 from "path";
+import { confirm, isCancel, cancel } from "@clack/prompts";
+
+// src/render.ts
+import path4 from "path";
+import { readFile as readFile2 } from "fs/promises";
+import Handlebars from "handlebars";
+
+// src/merge/json.ts
+function mergeJson(user, scaffold) {
+  const out = { ...user };
+  for (const key of Object.keys(scaffold)) {
+    if (!(key in user)) {
+      out[key] = deepClone(scaffold[key]);
+      continue;
+    }
+    const u = user[key];
+    const s = scaffold[key];
+    if (isPlainObject(u) && isPlainObject(s)) {
+      out[key] = mergeJson(u, s);
+    } else {
+      out[key] = deepClone(u);
+    }
+  }
+  return out;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepClone(v) {
+  return JSON.parse(JSON.stringify(v));
+}
+
+// src/render.ts
+function buildContext(opts) {
+  const now = /* @__PURE__ */ new Date();
+  const date = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}-${String(now.getUTCDate()).padStart(2, "0")}`;
+  return {
+    scaffoldVersion: opts.version,
+    profile: opts.profile,
+    cwd: opts.cwd,
+    projectName: path4.basename(opts.cwd),
+    year: now.getUTCFullYear(),
+    date,
+    isWindows: process.platform === "win32"
+  };
+}
+Handlebars.registerHelper("json", (value) => {
+  return JSON.stringify(value);
+});
+function renderString(template, ctx) {
+  return Handlebars.compile(template, { noEscape: true })(ctx);
+}
+async function renderFileEntry(entry, ctx) {
+  const raw = await readFile2(entry.srcAbs, "utf8");
+  if (!entry.extraSrcAbs) {
+    return entry.isTemplate ? renderString(raw, ctx) : raw;
+  }
+  const profileRaw = await readFile2(entry.extraSrcAbs, "utf8");
+  const profileRendered = renderString(profileRaw, ctx);
+  const extendedCtx = { ...ctx, profileSection: profileRendered };
+  return renderString(raw, extendedCtx);
+}
+async function renderJsonContent(entry, ctx) {
+  const sharedRaw = await readFile2(entry.srcAbs, "utf8");
+  const sharedObj = JSON.parse(renderString(sharedRaw, ctx));
+  if (!entry.extraSrcAbs) return sharedObj;
+  const profileRaw = await readFile2(entry.extraSrcAbs, "utf8");
+  const profileObj = JSON.parse(renderString(profileRaw, ctx));
+  return mergeJson(
+    profileObj,
+    sharedObj
+  );
+}
+
+// src/merge/marker.ts
+var BEGIN_RE = /<!--\s*ennam-agents-scaffold:begin v[^\s>]*\s*-->/;
+var BEGIN_RE_GLOBAL = /<!--\s*ennam-agents-scaffold:begin v[^\s>]*\s*-->/g;
+var END_MARKER = "<!-- ennam-agents-scaffold:end -->";
+function mergeMarker(existing, block) {
+  if (existing.length === 0) {
+    return block.endsWith("\n") ? block : block + "\n";
+  }
+  const allBegins = existing.match(BEGIN_RE_GLOBAL);
+  if (allBegins && allBegins.length > 1) {
+    throw new Error(
+      "Multiple ennam-agents-scaffold begin markers found; refusing to merge. Please consolidate to a single managed block before re-running the scaffold."
+    );
+  }
+  const beginMatch = existing.match(BEGIN_RE);
+  if (!beginMatch) {
+    const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+    const trailing = block.endsWith("\n") ? "" : "\n";
+    return existing + sep + block + trailing;
+  }
+  const beginStart = beginMatch.index;
+  const afterBegin = beginStart + beginMatch[0].length;
+  const endIndex = existing.indexOf(END_MARKER, afterBegin);
+  if (endIndex === -1) {
+    throw new Error("Marker block malformed: begin marker found but end marker not found");
+  }
+  const afterEnd = endIndex + END_MARKER.length;
+  const before = existing.slice(0, beginStart);
+  const after = existing.slice(afterEnd);
+  return before + block + after;
+}
+
+// src/merge/lines.ts
+function mergeLines(user, incoming) {
+  const userLines = user.split("\n");
+  if (userLines.length > 0 && userLines[userLines.length - 1] === "") {
+    userLines.pop();
+  }
+  const userSet = new Set(userLines.map((l) => l.trim()));
+  const incomingLines = incoming.split("\n");
+  if (incomingLines.length > 0 && incomingLines[incomingLines.length - 1] === "") {
+    incomingLines.pop();
+  }
+  const toAppend = [];
+  for (const line of incomingLines) {
+    if (userSet.has(line.trim())) continue;
+    toAppend.push(line);
+    userSet.add(line.trim());
+  }
+  const all = [...userLines, ...toAppend];
+  return all.join("\n") + "\n";
+}
+
+// src/backup.ts
+import { cp, mkdir, readdir, rm } from "fs/promises";
+import path5 from "path";
+var BACKUP_DIR = ".ennam-scaffold-backup";
+async function backupFile(cwd, relPath, session) {
+  const sessionDir = session ?? (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const dest = path5.join(cwd, BACKUP_DIR, sessionDir, relPath);
+  await mkdir(path5.dirname(dest), { recursive: true });
+  await cp(path5.join(cwd, relPath), dest);
+  return dest;
+}
+async function rotateBackups(cwd, keep) {
+  const root = path5.join(cwd, BACKUP_DIR);
+  let entries;
+  try {
+    entries = await readdir(root);
+  } catch {
+    return;
+  }
+  const sorted = entries.sort();
+  const toRemove = sorted.slice(0, Math.max(0, sorted.length - keep));
+  for (const name of toRemove) {
+    await rm(path5.join(root, name), { recursive: true, force: true });
+  }
+}
+function newSessionId() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+
+// src/execute.ts
+async function maybeRender(op, ctx) {
+  const raw = await readFile3(op.src.srcAbs, "utf8");
+  if (!op.src.extraSrcAbs) {
+    return op.src.isTemplate ? renderString(raw, ctx) : raw;
+  }
+  const profileRaw = await readFile3(op.src.extraSrcAbs, "utf8");
+  const profileRendered = renderString(profileRaw, ctx);
+  const extendedCtx = { ...ctx, profileSection: profileRendered };
+  return renderString(raw, extendedCtx);
+}
+async function promptOverwrite(relPath) {
+  const ans = await confirm({
+    message: `File exists and differs: ${relPath}. Overwrite?`,
+    initialValue: false
+  });
+  if (isCancel(ans)) {
+    cancel("Aborted by user.");
+    process.exit(1);
+  }
+  return ans === true;
+}
+async function executeOps(input) {
+  const result = { written: 0, skipped: 0, mkdirs: 0 };
+  const session = newSessionId();
+  for (const op of input.ops) {
+    const target = path6.join(input.cwd, op.relPath);
+    if (op.op === "skip") {
+      result.skipped++;
+      continue;
+    }
+    if (op.op === "mkdir") {
+      await mkdir2(target, { recursive: true });
+      result.mkdirs++;
+      continue;
+    }
+    if (op.op === "merge-marker") {
+      await mkdir2(path6.dirname(target), { recursive: true });
+      let existing = "";
+      try {
+        existing = await readFile3(target, "utf8");
+        if (existing.length > 0) await backupFile(input.cwd, op.relPath, session);
+      } catch {
+      }
+      const block = (await maybeRender(op, input.ctx)).replace(/\n$/, "");
+      const merged = mergeMarker(existing, block);
+      await writeFile(target, merged, "utf8");
+      result.written++;
+      continue;
+    }
+    if (op.op === "merge-json") {
+      await mkdir2(path6.dirname(target), { recursive: true });
+      let existingObj = {};
+      let existed = false;
+      try {
+        const existingText = await readFile3(target, "utf8");
+        if (existingText.trim().length > 0) {
+          existingObj = JSON.parse(existingText);
+          existed = true;
+        }
+      } catch {
+      }
+      if (existed) await backupFile(input.cwd, op.relPath, session);
+      const scaffoldObj = await renderJsonContent(op.src, input.ctx);
+      const merged = mergeJson(
+        existingObj,
+        scaffoldObj
+      );
+      await writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+      result.written++;
+      continue;
+    }
+    if (op.op === "merge-lines") {
+      await mkdir2(path6.dirname(target), { recursive: true });
+      let existing = "";
+      try {
+        existing = await readFile3(target, "utf8");
+        if (existing.length > 0) await backupFile(input.cwd, op.relPath, session);
+      } catch {
+      }
+      const incoming = await maybeRender(op, input.ctx);
+      const merged = mergeLines(existing, incoming);
+      await writeFile(target, merged, "utf8");
+      result.written++;
+      continue;
+    }
+    if (op.needsPrompt) {
+      if (input.interactive) {
+        const yes = await promptOverwrite(op.relPath);
+        if (!yes) {
+          result.skipped++;
+          continue;
+        }
+      } else {
+        console.error(
+          `Error: ${op.relPath} differs from scaffold and --merge-strategy=ask is not safe in non-interactive mode.
+       Re-run with --merge-strategy=overwrite (or --force) to replace, or --merge-strategy=skip to keep the existing file.`
+        );
+        process.exit(2);
+      }
+    }
+    await mkdir2(path6.dirname(target), { recursive: true });
+    const content = await maybeRender(op, input.ctx);
+    await writeFile(target, content, "utf8");
+    result.written++;
+  }
+  await rotateBackups(input.cwd, 3);
+  return result;
+}
+
+// src/ux.ts
+import pc from "picocolors";
+import { intro, outro, log, confirm as confirm2, isCancel as isCancel2, cancel as cancel2 } from "@clack/prompts";
+function printIntro(version) {
+  intro(pc.cyan(`Ennam Agents Scaffold v${version}`));
+}
+function printPlan(plan) {
+  const lines = [];
+  for (const op of plan.ops) {
+    const marker = op.op === "write" ? pc.green("+ write ") : op.op === "mkdir" ? pc.blue("+ mkdir ") : op.op === "merge-json" || op.op === "merge-marker" || op.op === "merge-lines" ? pc.yellow("~ merge ") : pc.gray("  skip  ");
+    lines.push(`${marker} ${op.relPath}  ${pc.dim(`(${op.reason})`)}`);
+  }
+  log.step(`Plan (${plan.ops.length} ops):
+  ${lines.join("\n  ")}`);
+}
+async function confirmProceed() {
+  const yes = await confirm2({ message: "Proceed?", initialValue: true });
+  if (isCancel2(yes)) {
+    cancel2("Aborted.");
+    return false;
+  }
+  return yes === true;
+}
+function printNextSteps(profile, result, hasGit) {
+  const envVars = ["JIRA_URL", "JIRA_TOKEN"];
+  if (profile.extraMcp.includes("figma")) envVars.push("FIGMA_TOKEN");
+  const steps = [];
+  if (hasGit) {
+    steps.push("Review changes: git diff");
+  } else {
+    steps.push("Inspect changes in your editor (no .git detected \u2014 run `git init` first if you want diff/version tracking)");
+  }
+  steps.push(`Set env vars in .env.local: ${envVars.join(", ")}`);
+  steps.push("Start Claude Code: claude");
+  steps.push("Inside Claude: run /boot");
+  outro(
+    pc.cyan(`Done.`) + `
+  Profile: ${pc.bold(profile.name)}
+  Written: ${result.written}  Skipped: ${result.skipped}  Mkdir: ${result.mkdirs}`
+  );
+  console.log();
+  steps.forEach((s, i) => console.log(`    ${i + 1}. ${s}`));
+}
+
+// src/index.ts
+var HERE2 = path7.dirname(fileURLToPath2(import.meta.url));
+var PKG = JSON.parse(await readFile4(path7.join(HERE2, "..", "package.json"), "utf8"));
+var cli = cac("ennam-agents-scaffold");
+cli.command("[profile]", "Install Claude Code config into the current directory").option("--dry-run", "Print the plan without writing anything").option("--force", "Overwrite all conflicts without prompting (alias for --merge-strategy=overwrite)").option("--merge-strategy <s>", "ask | skip | overwrite (default: ask)", { default: "ask" }).option("--no-prompts", "Fail on missing info instead of prompting (CI mode)").option("--verbose", "Verbose output").action(async (profileArg, flags) => {
+  printIntro(PKG.version);
+  const interactive = flags.prompts !== false;
+  let profileName = profileArg;
+  if (!profileName) {
+    if (!interactive) {
+      console.error("Error: profile is required in --no-prompts mode");
+      process.exit(2);
+    }
+    const choices = listProfiles().map((p) => ({ value: p.name, label: `${p.name} \u2014 ${p.description}` }));
+    const picked = await select({ message: "Choose a profile:", options: choices });
+    if (isCancel3(picked)) {
+      cancel3("Aborted.");
+      process.exit(1);
+    }
+    profileName = picked;
+  }
+  let profile;
+  try {
+    profile = getProfile(profileName);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(2);
+  }
+  const cwd = process.cwd();
+  let hasGit = true;
+  try {
+    await access2(path7.join(cwd, ".git"));
+  } catch {
+    hasGit = false;
+  }
+  const strategy = (flags.force ? "overwrite" : flags.mergeStrategy) ?? "ask";
+  const entries = await enumerateFiles(profile);
+  const ctx = buildContext({ profile: profileName, cwd, version: PKG.version });
+  const byRel = new Map(entries.map((e) => [e.relPath, e]));
+  const provider = async (rel) => {
+    const entry = byRel.get(rel);
+    if (!entry) return null;
+    if (entry.kind === "append-marker") {
+      const block = (await renderFileEntry(entry, ctx)).replace(/\n$/, "");
+      const abs = path7.join(cwd, rel);
+      let existing = "";
+      try {
+        existing = await readFile4(abs, "utf8");
+      } catch {
+        return null;
+      }
+      return mergeMarker(existing, block);
+    }
+    if (entry.kind === "json-merge") {
+      let existingObj = {};
+      try {
+        const existingText = await readFile4(path7.join(cwd, rel), "utf8");
+        if (existingText.trim().length > 0) {
+          existingObj = JSON.parse(existingText);
+        }
+      } catch {
+        return null;
+      }
+      const scaffoldObj = await renderJsonContent(entry, ctx);
+      const merged = mergeJson(
+        existingObj,
+        scaffoldObj
+      );
+      return JSON.stringify(merged, null, 2) + "\n";
+    }
+    if (entry.kind === "append-lines") {
+      let existing = "";
+      try {
+        existing = await readFile4(path7.join(cwd, rel), "utf8");
+      } catch {
+        return null;
+      }
+      const incoming = await renderFileEntry(entry, ctx);
+      return mergeLines(existing, incoming);
+    }
+    return renderFileEntry(entry, ctx);
+  };
+  const conflicts = await scanConflicts(cwd, entries.map((e) => e.relPath), provider);
+  const ops = buildPlan({ entries, conflicts, strategy, hasGit });
+  const plan = { cwd, profile, ops, hasGit };
+  printPlan(plan);
+  if (flags.dryRun) {
+    console.log("\n(dry-run \u2014 no files written)");
+    process.exit(0);
+  }
+  if (interactive) {
+    const proceed = await confirmProceed();
+    if (!proceed) process.exit(1);
+  }
+  const result = await executeOps({ cwd, ops, ctx, interactive });
+  printNextSteps(profile, result, hasGit);
+});
+cli.help();
+cli.version(PKG.version);
+cli.parse();
+//# sourceMappingURL=index.js.map