react-detective 0.0.0-stage → 0.1.1

package/dist/init-JUCWNJPS.js

@@ -0,0 +1,630 @@
+import {
+  findApiKey
+} from "./chunk-E23QXCCY.js";
+
+// src/init/index.ts
+import { execFileSync, spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { parseArgs } from "util";
+import readline from "readline/promises";
+import { structuredPatch } from "diff";
+
+// src/init/edits.ts
+import { parse } from "@babel/parser";
+import MagicString from "magic-string";
+var changed = (code) => ({ status: "changed", code });
+var manual = (reason) => ({ status: "manual", reason });
+function parseModule(code, filename) {
+  const isTs = /\.[cm]?tsx?$/.test(filename);
+  const plugins = isTs ? filename.endsWith("x") ? ["typescript", "jsx"] : ["typescript"] : ["jsx"];
+  try {
+    return parse(code, { sourceType: "unambiguous", plugins });
+  } catch {
+    return null;
+  }
+}
+function optionsLiteral(opts = {}) {
+  return opts.model && opts.model !== "sonnet" ? `{ model: ${JSON.stringify(opts.model)} }` : "";
+}
+function insertImport(s, ast, line) {
+  let last;
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration" || isRequireDeclaration(stmt)) last = stmt;
+  }
+  if (last) s.appendLeft(last.end, `
+${line}`);
+  else {
+    const directive = ast.program.directives.at(-1);
+    if (directive) s.appendLeft(directive.end, `
+${line}`);
+    else s.prepend(`${line}
+`);
+  }
+}
+function isRequireDeclaration(stmt) {
+  if (stmt.type !== "VariableDeclaration") return false;
+  return stmt.declarations.some((d) => d.init?.type === "CallExpression" && d.init.callee.type === "Identifier" && d.init.callee.name === "require");
+}
+function findVariable(ast, name) {
+  for (const stmt of ast.program.body) {
+    const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+    if (decl?.type !== "VariableDeclaration") continue;
+    for (const d of decl.declarations) {
+      if (d.id.type === "Identifier" && d.id.name === name && d.init) return d.init;
+    }
+  }
+  return null;
+}
+function findFunction(ast, name) {
+  for (const stmt of ast.program.body) {
+    const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+    if (decl?.type === "FunctionDeclaration" && decl.id?.name === name) return decl;
+  }
+  return null;
+}
+function returnedExpression(fn) {
+  if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression" && fn.type !== "FunctionDeclaration") return null;
+  if (fn.body.type !== "BlockStatement") return fn.body;
+  const ret = [...fn.body.body].reverse().find((s) => s.type === "ReturnStatement");
+  return ret?.argument ?? null;
+}
+function unwrapTs(node) {
+  while (node.type === "TSSatisfiesExpression" || node.type === "TSAsExpression" || node.type === "TSNonNullExpression") node = node.expression;
+  return node;
+}
+function defaultExport(ast) {
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ExportDefaultDeclaration") return stmt.declaration;
+  }
+  return null;
+}
+function moduleExports(ast) {
+  for (const stmt of ast.program.body) {
+    if (stmt.type !== "ExpressionStatement" || stmt.expression.type !== "AssignmentExpression") continue;
+    const left = stmt.expression.left;
+    if (left.type === "MemberExpression" && left.object.type === "Identifier" && left.object.name === "module" && left.property.type === "Identifier" && left.property.name === "exports")
+      return stmt.expression;
+  }
+  return null;
+}
+function indentBefore(code, pos) {
+  const lineStart = code.lastIndexOf("\n", pos - 1) + 1;
+  const prefix = code.slice(lineStart, pos);
+  return /^[ \t]*$/.test(prefix) ? prefix : null;
+}
+function insertBeforeClosing(s, code, closingStart, child) {
+  const indent = indentBefore(code, closingStart);
+  if (indent === null) s.appendLeft(closingStart, child);
+  else s.appendLeft(closingStart, `${indent.includes("	") ? "	" : "  "}${child}
+${indent}`);
+}
+function resolveConfigObject(ast, node, depth = 0) {
+  if (!node || depth > 8) return null;
+  node = unwrapTs(node);
+  switch (node.type) {
+    case "ObjectExpression":
+      return node;
+    case "CallExpression":
+      for (const arg of node.arguments) {
+        const found = resolveConfigObject(ast, arg, depth + 1);
+        if (found) return found;
+      }
+      return null;
+    case "ArrowFunctionExpression":
+    case "FunctionExpression":
+    case "FunctionDeclaration":
+      return resolveConfigObject(ast, returnedExpression(node), depth + 1);
+    case "Identifier":
+      return resolveConfigObject(ast, findVariable(ast, node.name) ?? findFunction(ast, node.name), depth + 1);
+    default:
+      return null;
+  }
+}
+function propertyNamed(obj, name) {
+  for (const p of obj.properties) {
+    if (p.type !== "ObjectProperty") continue;
+    const key = p.key;
+    if (key.type === "Identifier" && key.name === name || key.type === "StringLiteral" && key.value === name) return p;
+  }
+  return null;
+}
+function addVitePlugin(code, filename, opts = {}) {
+  if (code.includes("react-detective/vite")) return { status: "already" };
+  const ast = parseModule(code, filename);
+  if (!ast) return manual(`couldn't parse ${filename}`);
+  const exported = defaultExport(ast) ?? moduleExports(ast)?.right;
+  const config = resolveConfigObject(ast, exported);
+  if (!config) return manual(`couldn't find the config object exported by ${filename}`);
+  const name = /\bdetective\b/.test(code) ? "reactDetective" : "detective";
+  const call = `${name}(${optionsLiteral(opts)})`;
+  const s = new MagicString(code);
+  const plugins = propertyNamed(config, "plugins");
+  if (plugins) {
+    const arr = unwrapTs(plugins.value);
+    if (arr.type !== "ArrayExpression") return manual(`\`plugins\` in ${filename} isn't an array literal`);
+    const first = arr.elements.find((e) => e);
+    if (!first) s.appendLeft(arr.start + 1, call);
+    else {
+      const indent = indentBefore(code, first.start);
+      s.appendLeft(first.start, indent === null ? `${call}, ` : `${call},
+${indent}`);
+    }
+  } else {
+    const first = config.properties[0];
+    if (!first) s.appendLeft(config.start + 1, ` plugins: [${call}] `);
+    else {
+      const indent = indentBefore(code, first.start);
+      s.appendLeft(first.start, indent === null ? `plugins: [${call}], ` : `plugins: [${call}],
+${indent}`);
+    }
+  }
+  insertImport(s, ast, isCommonJs(ast) ? `const ${name} = require("react-detective/vite").default;` : `import ${name} from "react-detective/vite";`);
+  return changed(s.toString());
+}
+function isCommonJs(ast) {
+  return !ast.program.body.some((s) => s.type === "ImportDeclaration" || s.type === "ExportDefaultDeclaration" || s.type === "ExportNamedDeclaration") && !!moduleExports(ast);
+}
+function wrapNextConfig(code, filename, opts = {}) {
+  if (code.includes("react-detective/next")) return { status: "already" };
+  const ast = parseModule(code, filename);
+  if (!ast) return manual(`couldn't parse ${filename}`);
+  const extra = optionsLiteral(opts);
+  const close = extra ? `, ${extra})` : ")";
+  const s = new MagicString(code);
+  const exported = defaultExport(ast);
+  if (exported) {
+    if (exported.type === "ClassDeclaration" || exported.type === "TSInterfaceDeclaration" || exported.type === "TSDeclareFunction") {
+      return manual(`${filename} doesn't export a config`);
+    }
+    s.appendLeft(exported.start, "withDetective(");
+    s.appendRight(exported.end, close);
+    insertImport(s, ast, `import { withDetective } from "react-detective/next";`);
+    return changed(s.toString());
+  }
+  const assignment = moduleExports(ast);
+  if (assignment) {
+    s.appendLeft(assignment.right.start, "withDetective(");
+    s.appendRight(assignment.right.end, close);
+    insertImport(s, ast, `const { withDetective } = require("react-detective/next");`);
+    return changed(s.toString());
+  }
+  return manual(`couldn't find \`export default\` or \`module.exports\` in ${filename}`);
+}
+var DETECTIVE_IMPORT = `import { Detective } from "react-detective/react";`;
+function findJsxElement(node, tag) {
+  if (node.type === "JSXElement") {
+    const name = node.openingElement.name;
+    if (name.type === "JSXIdentifier" && name.name === tag) return node;
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+    const value = node[key];
+    const children = Array.isArray(value) ? value : [value];
+    for (const child of children) {
+      if (child && typeof child === "object" && typeof child.type === "string") {
+        const found = findJsxElement(child, tag);
+        if (found) return found;
+      }
+    }
+  }
+  return null;
+}
+function addToLayout(code, filename) {
+  if (code.includes("react-detective/react")) return { status: "already" };
+  const ast = parseModule(code, filename);
+  if (!ast) return manual(`couldn't parse ${filename}`);
+  const body = findJsxElement(ast.program, "body");
+  if (!body?.closingElement) return manual(`couldn't find <body>\u2026</body> in ${filename}`);
+  const s = new MagicString(code);
+  insertBeforeClosing(s, code, body.closingElement.start, "<Detective />");
+  insertImport(s, ast, DETECTIVE_IMPORT);
+  return changed(s.toString());
+}
+function addToApp(code, filename) {
+  if (code.includes("react-detective/react")) return { status: "already" };
+  const ast = parseModule(code, filename);
+  if (!ast) return manual(`couldn't parse ${filename}`);
+  let exported = defaultExport(ast);
+  if (exported) exported = unwrapTs(exported);
+  if (exported?.type === "Identifier") exported = findVariable(ast, exported.name) ?? findFunction(ast, exported.name);
+  const rendered = exported && returnedExpression(exported);
+  if (!rendered) return manual(`couldn't find what the default export of ${filename} renders`);
+  const s = new MagicString(code);
+  if (rendered.type === "JSXFragment") insertBeforeClosing(s, code, rendered.closingFragment.start, "<Detective />");
+  else if (rendered.type === "JSXElement") {
+    s.appendLeft(rendered.start, "<>");
+    s.appendRight(rendered.end, "<Detective /></>");
+  } else return manual(`the default export of ${filename} doesn't return JSX directly`);
+  insertImport(s, ast, DETECTIVE_IMPORT);
+  return changed(s.toString());
+}
+function newAppFile(typescript) {
+  return typescript ? `import type { AppProps } from "next/app";
+${DETECTIVE_IMPORT}
+
+export default function App({ Component, pageProps }: AppProps) {
+  return (
+    <>
+      <Component {...pageProps} />
+      <Detective />
+    </>
+  );
+}
+` : `${DETECTIVE_IMPORT}
+
+export default function App({ Component, pageProps }) {
+  return (
+    <>
+      <Component {...pageProps} />
+      <Detective />
+    </>
+  );
+}
+`;
+}
+function setEnvVar(text, key, value) {
+  const line = `${key}=${value}`;
+  const re = new RegExp(`^[ \\t]*(?:export[ \\t]+)?${key}[ \\t]*=.*$`, "m");
+  if (re.test(text)) return text.replace(re, line);
+  if (!text) return `${line}
+`;
+  return `${text}${text.endsWith("\n") ? "" : "\n"}${line}
+`;
+}
+function isGitIgnored(gitignore, file) {
+  let ignored = false;
+  for (const raw of gitignore.split(/\r?\n/)) {
+    let pattern = raw.trim();
+    if (!pattern || pattern.startsWith("#")) continue;
+    const negate = pattern.startsWith("!");
+    if (negate) pattern = pattern.slice(1);
+    if (pattern.endsWith("/")) continue;
+    pattern = pattern.replace(/^\//, "").replace(/^\*\*\//, "");
+    if (pattern.includes("/")) continue;
+    const re = new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")}$`);
+    if (re.test(file)) ignored = !negate;
+  }
+  return ignored;
+}
+function addGitIgnore(text, entry) {
+  if (!text) return `${entry}
+`;
+  return `${text}${text.endsWith("\n") ? "" : "\n"}${entry}
+`;
+}
+
+// src/init/index.ts
+var ENV_FILE = ".env.local";
+var MODELS = ["sonnet", "haiku", "opus"];
+var JS_EXTS = [".ts", ".mts", ".js", ".mjs", ".cjs", ".tsx", ".jsx"];
+var color = process.stdout.isTTY && !process.env.NO_COLOR;
+var paint = (code) => (s) => color ? `\x1B[${code}m${s}\x1B[0m` : s;
+var bold = paint(1);
+var dim = paint(2);
+var red = paint(31);
+var green = paint(32);
+var yellow = paint(33);
+var cyan = paint(36);
+async function runInit(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      root: { type: "string", short: "r" },
+      model: { type: "string", short: "m" },
+      yes: { type: "boolean", short: "y" },
+      "skip-install": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) {
+    console.log(`Usage: react-detective init [--root .] [--model sonnet|haiku|opus|<id>] [--yes] [--skip-install]
+
+Sets up React Detective in a Vite or Next.js project: installs it, adds it to your config,
+and saves your Anthropic API key to ${ENV_FILE}. Shows every change before writing it.
+
+  --yes, -y        accept the defaults and apply without asking (no API key is asked for)
+  --skip-install   don't install the package`);
+    return;
+  }
+  const root = path.resolve(values.root ?? process.cwd());
+  const pkg = readJson(path.join(root, "package.json"));
+  if (!pkg) fail(`No package.json in ${root}. Run this from your project's folder, or pass --root.`);
+  console.log(`
+${bold("React Detective setup")} ${dim(root)}
+`);
+  const framework = detectFramework(root, pkg);
+  if (!framework) {
+    console.log(`Couldn't find Vite or Next.js in this project. React Detective works with those two for now.
+Using something else? Open an issue so we know to support it.`);
+    return;
+  }
+  console.log(`${green("\u2713")} Found ${framework === "next" ? "Next.js" : "Vite"}`);
+  const prompt = values.yes ? null : new Prompt();
+  try {
+    const model = values.model ?? (prompt ? await prompt.choose("Model for explanations and questions", MODELS, "sonnet") : "sonnet");
+    const opts = { model };
+    const changes = [];
+    const manual2 = [];
+    if (framework === "vite") planVite(root, opts, changes, manual2);
+    else planNext(root, opts, changes, manual2);
+    const pm = detectPackageManager(root);
+    const installed = !!(pkg.dependencies?.["react-detective"] || pkg.devDependencies?.["react-detective"]);
+    const install = installed || values["skip-install"] ? null : installCommand(pm);
+    let installFailed = false;
+    if (!changes.length && !install && !manual2.length) console.log(`${green("\u2713")} Already set up`);
+    else {
+      console.log(`
+${bold("Changes")}`);
+      if (install) console.log(`
+${cyan("$")} ${install.join(" ")}`);
+      for (const change of changes) printChange(change);
+      if (!changes.length && !install) console.log(dim("\nNothing to change automatically."));
+      if (changes.length || install) {
+        const ok = prompt ? await prompt.confirm("\nApply these changes?", true) : true;
+        if (!ok) {
+          console.log("Nothing was changed.");
+          return;
+        }
+      }
+      for (const change of changes) writeChange(root, change);
+      if (install) {
+        console.log(`
+${cyan("$")} ${install.join(" ")}`);
+        const result = spawnSync(install[0], install.slice(1), { cwd: root, stdio: "inherit", shell: process.platform === "win32" });
+        installFailed = result.status !== 0;
+        if (installFailed) console.log(red(`
+Install failed. Run it yourself: ${install.join(" ")}`));
+      }
+      for (const step of manual2) {
+        console.log(`
+${yellow("!")} ${bold(step.file)}: ${step.reason}. Add this yourself:
+
+${step.snippet}`);
+      }
+    }
+    const hasKey = await askForApiKey(root, prompt);
+    console.log(`
+${bold("Next")}`);
+    if (!hasKey) console.log(`  \u2022 Add ANTHROPIC_API_KEY=sk-ant-... to ${ENV_FILE} when you're ready (make sure it's in .gitignore). No restart needed.`);
+    console.log(`  \u2022 Start your dev server as usual, then press ${bold("Alt")} (or click the Detective badge) and click a component`);
+    console.log(`  \u2022 Commit the ${bold(".react-detective/")} folder once it appears so your team shares explanations`);
+    if (installFailed || manual2.length) process.exitCode = 1;
+  } finally {
+    prompt?.close();
+  }
+}
+function planVite(root, opts, changes, manual2) {
+  const file = findFile(root, ["vite.config"], [".ts", ".mts", ".js", ".mjs", ".cjs"]);
+  const snippet = `  import detective from "react-detective/vite";
+
+  plugins: [detective(${optionsLiteral(opts)}), react()],`;
+  if (!file) {
+    manual2.push({ file: "vite.config.ts", reason: "no Vite config found", snippet });
+    return;
+  }
+  apply(root, file, addVitePlugin, opts, changes, manual2, snippet);
+}
+function planNext(root, opts, changes, manual2) {
+  const configFile = findFile(root, ["next.config"], [".ts", ".mts", ".js", ".mjs", ".cjs"]);
+  const extra = optionsLiteral(opts);
+  const configSnippet = `  import { withDetective } from "react-detective/next";
+
+  export default withDetective(nextConfig${extra ? `, ${extra}` : ""});`;
+  if (configFile) apply(root, configFile, wrapNextConfig, opts, changes, manual2, configSnippet);
+  else changes.push({ file: "next.config.mjs", before: null, after: `import { withDetective } from "react-detective/next";
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {};
+
+export default withDetective(nextConfig${extra ? `, ${extra}` : ""});
+` });
+  const appDir = ["app", "src/app"].find((d) => isDir(path.join(root, d)));
+  const pagesDir = ["pages", "src/pages"].find((d) => isDir(path.join(root, d)));
+  const layoutSnippet = `  import { Detective } from "react-detective/react";
+
+  <body>
+    {children}
+    <Detective />
+  </body>`;
+  const appSnippet = `  import { Detective } from "react-detective/react";
+
+  return (
+    <>
+      <Component {...pageProps} />
+      <Detective />
+    </>
+  );`;
+  if (appDir) {
+    const layout = findFile(root, [`${appDir}/layout`], JS_EXTS);
+    if (layout) apply(root, layout, (code, name) => addToLayout(code, name), opts, changes, manual2, layoutSnippet);
+    else manual2.push({ file: `${appDir}/layout.tsx`, reason: "no root layout found", snippet: layoutSnippet });
+  }
+  if (pagesDir && (!appDir || hasPages(path.join(root, pagesDir)))) {
+    const app = findFile(root, [`${pagesDir}/_app`], JS_EXTS);
+    if (app) apply(root, app, (code, name) => addToApp(code, name), opts, changes, manual2, appSnippet);
+    else {
+      const ts = fs.existsSync(path.join(root, "tsconfig.json"));
+      changes.push({ file: `${pagesDir}/_app.${ts ? "tsx" : "jsx"}`, before: null, after: newAppFile(ts) });
+    }
+  }
+  if (!appDir && !pagesDir) manual2.push({ file: "app/layout.tsx", reason: "no app/ or pages/ folder found", snippet: layoutSnippet });
+}
+function apply(root, file, edit, opts, changes, manual2, snippet) {
+  const before = fs.readFileSync(path.join(root, file), "utf8");
+  const result = edit(before, file, opts);
+  if (result.status === "changed") changes.push({ file, before, after: result.code });
+  else if (result.status === "already") console.log(`${green("\u2713")} ${file} already set up`);
+  else manual2.push({ file, reason: result.reason, snippet });
+}
+function writeChange(root, change) {
+  fs.mkdirSync(path.dirname(path.join(root, change.file)), { recursive: true });
+  fs.writeFileSync(path.join(root, change.file), change.after);
+  console.log(`${green("\u2713")} ${change.before === null ? "Created" : "Updated"} ${change.file}${change.summary ? dim(` (${change.summary})`) : ""}`);
+}
+async function askForApiKey(root, prompt) {
+  if (findApiKey(root)) {
+    console.log(`${green("\u2713")} Anthropic API key already set`);
+    return true;
+  }
+  if (!prompt) return false;
+  console.log(`
+${bold("API key")} ${dim("(optional)")}`);
+  console.log(`New explanations are written by Claude using your own Anthropic API key. Saved ones work without it.`);
+  console.log(dim(`Get one at https://console.anthropic.com/settings/keys. Leave blank to add it later.`));
+  const key = await prompt.secret("API key");
+  if (!key) return false;
+  if (!key.startsWith("sk-ant-")) console.log(yellow(`  That doesn't look like an Anthropic key (they start with sk-ant-), saving it anyway.`));
+  const changes = [];
+  planApiKey(root, key, changes);
+  for (const change of changes) writeChange(root, change);
+  return true;
+}
+function planApiKey(root, key, changes) {
+  const envPath = path.join(root, ENV_FILE);
+  const before = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : null;
+  changes.push({ file: ENV_FILE, before, after: setEnvVar(before ?? "", "ANTHROPIC_API_KEY", key), summary: `ANTHROPIC_API_KEY=${mask(key)}` });
+  if (gitIgnores(root, ENV_FILE)) return;
+  const gitignorePath = path.join(root, ".gitignore");
+  const gi = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf8") : null;
+  changes.push({ file: ".gitignore", before: gi, after: addGitIgnore(gi ?? "", ENV_FILE) });
+}
+function gitIgnores(root, file) {
+  try {
+    execFileSync("git", ["check-ignore", "-q", file], { cwd: root, stdio: "ignore" });
+    return true;
+  } catch (err) {
+    if (err?.status === 1) return false;
+  }
+  try {
+    return isGitIgnored(fs.readFileSync(path.join(root, ".gitignore"), "utf8"), file);
+  } catch {
+    return false;
+  }
+}
+var mask = (key) => key.length > 14 ? `${key.slice(0, 7)}\u2026${key.slice(-4)}` : "\u2026";
+function detectFramework(root, pkg) {
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deps.next || findFile(root, ["next.config"], JS_EXTS)) return "next";
+  if (deps.vite || findFile(root, ["vite.config"], JS_EXTS)) return "vite";
+  return null;
+}
+function detectPackageManager(root) {
+  const lockfiles = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["package-lock.json", "npm"]
+  ];
+  for (let dir = root; ; dir = path.dirname(dir)) {
+    for (const [file, pm] of lockfiles) if (fs.existsSync(path.join(dir, file))) return pm;
+    if (path.dirname(dir) === dir) break;
+  }
+  const agent = process.env.npm_config_user_agent ?? "";
+  return ["pnpm", "yarn", "bun"].find((pm) => agent.startsWith(pm)) ?? "npm";
+}
+function installCommand(pm) {
+  if (pm === "npm") return ["npm", "install", "--save-dev", "react-detective"];
+  return [pm, "add", pm === "bun" ? "-d" : "-D", "react-detective"];
+}
+function findFile(root, bases, exts) {
+  for (const base of bases) for (const ext of exts) if (fs.existsSync(path.join(root, base + ext))) return base + ext;
+  return null;
+}
+function hasPages(dir) {
+  return fs.readdirSync(dir).some((name) => name !== "api" && !name.startsWith("_"));
+}
+var isDir = (p) => fs.statSync(p, { throwIfNoEntry: false })?.isDirectory() ?? false;
+function readJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function fail(message) {
+  console.error(red(message));
+  process.exit(1);
+}
+function printChange(change) {
+  const label = change.before === null ? green("new") : yellow("edit");
+  console.log(`
+${label} ${bold(change.file)}`);
+  if (change.summary) {
+    console.log(`  ${green(`+ ${change.summary}`)}`);
+    return;
+  }
+  const patch = structuredPatch(change.file, change.file, change.before ?? "", change.after, "", "", { context: 2 });
+  for (const hunk of patch.hunks) {
+    console.log(dim(`  @@ line ${hunk.newStart}`));
+    for (const line of hunk.lines) {
+      if (line.startsWith("\\")) continue;
+      const text = `  ${line[0]} ${line.slice(1)}`;
+      console.log(line[0] === "+" ? green(text) : line[0] === "-" ? red(text) : dim(text));
+    }
+  }
+}
+var Prompt = class {
+  rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: !!process.stdin.isTTY });
+  lines = [];
+  waiting = null;
+  closed = false;
+  muted = false;
+  constructor() {
+    this.rl.on("line", (line) => {
+      if (this.waiting) this.take(line);
+      else this.lines.push(line);
+    });
+    this.rl.on("close", () => {
+      this.closed = true;
+      this.take(null);
+    });
+    const rl = this.rl;
+    const write = rl._writeToOutput?.bind(rl);
+    if (write) {
+      rl._writeToOutput = (s) => {
+        if (!this.muted) write(s);
+        else if (s.includes("\n")) write("\n");
+        else if (s.length === 1) write("*");
+      };
+    }
+  }
+  take(line) {
+    const resolve = this.waiting;
+    this.waiting = null;
+    resolve?.(line);
+  }
+  async ask(question, muted = false) {
+    this.rl.setPrompt(question);
+    this.rl.prompt();
+    let line;
+    if (this.lines.length) line = this.lines.shift();
+    else if (this.closed) line = null;
+    else {
+      this.muted = muted;
+      line = await new Promise((resolve) => this.waiting = resolve);
+      this.muted = false;
+    }
+    if (!process.stdin.isTTY) process.stdout.write(`${line === null ? "" : muted ? "*".repeat(line.length) : line}
+`);
+    return (line ?? "").trim();
+  }
+  async choose(question, options, fallback) {
+    const list = options.map((o) => o === fallback ? bold(o) : o).join(" / ");
+    return await this.ask(`${cyan("?")} ${question} (${list}, or a model ID) ${dim(fallback)} `) || fallback;
+  }
+  async confirm(question, fallback) {
+    const answer = (await this.ask(`${question} ${dim(fallback ? "(Y/n)" : "(y/N)")} `)).toLowerCase();
+    return answer ? answer.startsWith("y") : fallback;
+  }
+  secret(question) {
+    return this.ask(`${cyan("?")} ${question}: `, true);
+  }
+  close() {
+    this.rl.close();
+  }
+};
+export {
+  runInit
+};