@blzsky/variant 0.2.1 → 0.3.0-canary.0

package/dist/init-VNK5E4H3.js

@@ -0,0 +1,777 @@
+import {
+  discoverRepository,
+  pullRequestWorkflow,
+  withFullHistory,
+  workflowStyle
+} from "./chunk-SGP5JX6I.js";
+import {
+  CLEAR_LINE,
+  HIDE_CURSOR,
+  SHOW_CURSOR
+} from "./chunk-IHXJ72XA.js";
+import {
+  detectProject
+} from "./chunk-V5CTGXMM.js";
+import {
+  findVariantConfigPath
+} from "./chunk-RJBFCURK.js";
+import {
+  plural
+} from "./chunk-CXNXZLDG.js";
+import "./chunk-3E5LBU3O.js";
+import {
+  getColors
+} from "./chunk-YYGCSKIQ.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-EISTWXDW.js";
+import "./chunk-RSIOYQOQ.js";
+import "./chunk-ACTY42RE.js";
+
+// src/cli/commands/init.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
+import { createInterface as createInterface2 } from "readline/promises";
+
+// src/core/scaffold/config-template.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var DEFAULT_TASK_INPUTS = {
+  build: ["src/**/*", "package.json"],
+  lint: ["src/**/*", "*.config.*"],
+  test: ["src/**/*", "**/__tests__/**/*"],
+  typecheck: ["src/**/*", "tsconfig*.json"],
+  format: ["src/**/*"]
+};
+var TASK_ORDER = ["build", "lint", "test", "typecheck", "format"];
+var FALLBACK_TASKS = ["build", "lint", "test"];
+function inputsFor(task) {
+  return DEFAULT_TASK_INPUTS[task] ?? DEFAULT_TASK_INPUTS["build"] ?? [];
+}
+function runPrefix(pm) {
+  return pm === "pnpm" || pm === "yarn" ? pm : "npm run";
+}
+function binaryRunner(pm) {
+  if (pm === "pnpm") return "pnpm";
+  if (pm === "yarn") return "yarn";
+  return "npx";
+}
+function defaultCommandFor(pm, task, framework) {
+  if (task === "build" && framework === "next") {
+    return `${binaryRunner(pm)} next build`;
+  }
+  if (task === "build" && framework === "vite") {
+    return `${binaryRunner(pm)} vite build`;
+  }
+  return `${runPrefix(pm)} ${task}`;
+}
+async function detectScriptTasks(cwd) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(path.join(cwd, "package.json"), "utf8")
+    );
+    const present = new Set(Object.keys(manifest.scripts ?? {}));
+    const ordered = TASK_ORDER.filter((task) => present.has(task));
+    return ordered.length > 0 ? ordered : [...FALLBACK_TASKS];
+  } catch {
+    return [...FALLBACK_TASKS];
+  }
+}
+function renderConfigTemplate(tasks) {
+  const taskLines = tasks.map(
+    ({ name, command, inputs }) => `    ${name}: {
+      command: "${command}",
+      inputs: [${inputs.map((i) => `"${i}"`).join(", ")}],
+    }`
+  ).join(",\n");
+  return `import { defineConfig } from "@blzsky/variant";
+
+export default defineConfig({
+  strategy: "adaptive",
+  tasks: {
+${taskLines},
+  },
+});
+`;
+}
+
+// src/core/setup/apply.ts
+import { mkdir, writeFile } from "fs/promises";
+import path2 from "path";
+async function runCommand(command, cwd) {
+  const [file, ...args] = command;
+  if (file === void 0) return;
+  const { execa } = await import("execa");
+  await execa(file, args, { cwd, stdio: "inherit" });
+}
+async function applySetup(cwd, actions, deps = { run: runCommand }) {
+  const result = { written: [], installed: false };
+  for (const action of actions) {
+    if (action.kind !== "write") continue;
+    const target = path2.join(cwd, action.file);
+    await mkdir(path2.dirname(target), { recursive: true });
+    await writeFile(target, action.after);
+    result.written.push(action.file);
+  }
+  for (const action of actions) {
+    if (action.kind !== "install") continue;
+    try {
+      await deps.run(action.command, cwd);
+      result.installed = true;
+    } catch (error) {
+      result.installError = (error instanceof Error ? error.message : String(error)).split(
+        "\n"
+      )[0] ?? "the install command failed";
+    }
+  }
+  return result;
+}
+
+// src/core/setup/plan.ts
+import { readFile as readFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/core/setup/vitest-config.ts
+var ADAPTER_MODULE = "@blzsky/variant/vitest";
+var WRAPPERS = /* @__PURE__ */ new Set(["defineConfig", "defineProject", "mergeConfig"]);
+function indentationOf(source) {
+  const indented = /^([ \t]+)\S/m.exec(source);
+  if (indented === null) return "	";
+  return indented[1]?.startsWith("	") ? "	" : indented[1] ?? "	";
+}
+function configObject(node, tsm, hops = 0) {
+  if (node === void 0 || hops > 4) return void 0;
+  const { Node: N } = tsm;
+  if (N.isObjectLiteralExpression(node)) return node;
+  if (N.isParenthesizedExpression(node) || N.isAsExpression(node)) {
+    return configObject(node.getExpression(), tsm, hops + 1);
+  }
+  if (N.isSatisfiesExpression(node)) {
+    return configObject(node.getExpression(), tsm, hops + 1);
+  }
+  if (N.isCallExpression(node)) {
+    if (!WRAPPERS.has(node.getExpression().getText())) return void 0;
+    return configObject(node.getArguments().at(-1), tsm, hops + 1);
+  }
+  if (N.isArrowFunction(node)) {
+    const body = node.getBody();
+    return N.isBlock(body) ? void 0 : configObject(body, tsm, hops + 1);
+  }
+  if (N.isIdentifier(node)) {
+    const declaration = node.getSourceFile().getVariableDeclaration(node.getText());
+    return configObject(declaration?.getInitializer(), tsm, hops + 1);
+  }
+  return void 0;
+}
+function objectProperty(object, name, tsm) {
+  const property = object.getProperty(name);
+  if (property === void 0) return void 0;
+  return tsm.Node.isPropertyAssignment(property) ? property.getInitializer() : "unreadable";
+}
+function addImport(file, name, isDefault) {
+  file.addImportDeclaration({
+    moduleSpecifier: ADAPTER_MODULE,
+    ...isDefault ? { defaultImport: name } : { namedImports: [name] }
+  });
+}
+var WITH_DEFAULTS = "variantReporters";
+function newConfig() {
+  return `import { ${WITH_DEFAULTS} } from "${ADAPTER_MODULE}";
+
+export default {
+	test: {
+		reporters: ${WITH_DEFAULTS}(),
+	},
+};
+`;
+}
+async function withAdapter(source, fileName) {
+  if (source.includes(ADAPTER_MODULE)) return { kind: "present" };
+  if (/\.cjs$/.test(fileName) || /\bmodule\.exports\b/.test(source)) {
+    return { kind: "manual", reason: "it is a CommonJS config" };
+  }
+  const tsm = await import("ts-morph");
+  const project = new tsm.Project({
+    useInMemoryFileSystem: true,
+    manipulationSettings: {
+      indentationText: indentationOf(source),
+      quoteKind: /from\s+'/.test(source) ? tsm.QuoteKind.Single : tsm.QuoteKind.Double,
+      useTrailingCommas: true
+    }
+  });
+  const file = project.createSourceFile(
+    `config${extensionOf(fileName)}`,
+    source
+  );
+  const exported = file.getExportAssignment((assignment) => !assignment.isExportEquals())?.getExpression();
+  const config = configObject(exported, tsm);
+  if (config === void 0) {
+    return {
+      kind: "manual",
+      reason: "its default export is not a plain config object"
+    };
+  }
+  const clash = file.getLocals().some((local) => local.getName() === "variant");
+  const name = clash ? "variantReporter" : "variant";
+  const test = objectProperty(config, "test", tsm);
+  if (test === "unreadable") {
+    return {
+      kind: "manual",
+      reason: "its `test` option is not written inline"
+    };
+  }
+  if (test === void 0) {
+    config.addPropertyAssignment({
+      name: "test",
+      initializer: (writer) => writer.block(() => writer.write(`reporters: ${WITH_DEFAULTS}(),`))
+    });
+    addImport(file, WITH_DEFAULTS, false);
+    return { kind: "edited", text: file.getFullText() };
+  }
+  if (!tsm.Node.isObjectLiteralExpression(test)) {
+    return {
+      kind: "manual",
+      reason: "its `test` option is not an object literal"
+    };
+  }
+  const existing = objectProperty(test, "reporters", tsm);
+  if (existing === "unreadable") {
+    return {
+      kind: "manual",
+      reason: "its `reporters` are not written inline"
+    };
+  }
+  if (existing === void 0) {
+    test.insertPropertyAssignment(0, {
+      name: "reporters",
+      initializer: `${WITH_DEFAULTS}()`
+    });
+    addImport(file, WITH_DEFAULTS, false);
+    return { kind: "edited", text: file.getFullText() };
+  }
+  if (!tsm.Node.isArrayLiteralExpression(existing)) {
+    return {
+      kind: "manual",
+      reason: "its `reporters` option is not an array literal"
+    };
+  }
+  existing.addElement(`${name}()`);
+  addImport(file, name, !clash);
+  return { kind: "edited", text: file.getFullText() };
+}
+function extensionOf(fileName) {
+  return /\.[cm]?[jt]s$/.exec(fileName)?.[0] ?? ".ts";
+}
+function manualInstructions(file) {
+  return [
+    `Add the adapter to ${file} yourself:`,
+    `  import { ${WITH_DEFAULTS} } from "${ADAPTER_MODULE}";`,
+    `  test: { reporters: ${WITH_DEFAULTS}() }`,
+    "If the config already lists reporters, import the default export as `variant` and add `variant()` to that list instead."
+  ];
+}
+
+// src/core/setup/plan.ts
+var PACKAGE_NAME = "@blzsky/variant";
+var NEW_CONFIG = "vitest.config.mts";
+var PULL_REQUEST_WORKFLOW = ".github/workflows/variant.yml";
+var ADD_DEV = {
+  npm: ["npm", "install", "--save-dev"],
+  pnpm: ["pnpm", "add", "--save-dev"],
+  yarn: ["yarn", "add", "--dev"],
+  bun: ["bun", "add", "--dev"]
+};
+var WORKSPACE_ROOT_FLAG = {
+  pnpm: "--workspace-root",
+  yarn: "--ignore-workspace-root-check"
+};
+function installCommand(facts, packageSpec = PACKAGE_NAME) {
+  const packageManager = facts.packageManager ?? "npm";
+  const rootFlag = facts.workspacePackages > 0 ? WORKSPACE_ROOT_FLAG[packageManager] : void 0;
+  return [
+    ...ADD_DEV[packageManager],
+    ...rootFlag === void 0 ? [] : [rootFlag],
+    packageSpec
+  ];
+}
+function withIgnoreEntry(gitignore) {
+  if (gitignore === null || gitignore === "") return ".variant/\n";
+  return `${gitignore}${gitignore.endsWith("\n") ? "" : "\n"}.variant/
+`;
+}
+async function readText(file) {
+  try {
+    return await readFile2(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function planSetup(cwd, facts, options = {}) {
+  const actions = [];
+  if (!facts.hasManifest) {
+    return [
+      {
+        kind: "note",
+        lines: [
+          "No package.json here. Run `variant init` in the directory that has one."
+        ]
+      }
+    ];
+  }
+  const observed = facts.vitestConfigs.length > 0 || facts.vitestWithoutConfig.length > 0;
+  if (!facts.installed && options.install !== false) {
+    actions.push({
+      kind: "install",
+      command: installCommand(facts, options.packageSpec),
+      reason: observed ? "the adapter is imported from your test config" : "the pull-request workflow runs it"
+    });
+  } else if (!facts.installed) {
+    actions.push({
+      kind: "note",
+      lines: [
+        `${PACKAGE_NAME} is not installed. The adapter needs it: ${installCommand(facts, options.packageSpec).join(" ")}`
+      ]
+    });
+  }
+  for (const file of facts.vitestConfigs) {
+    const before = await readText(path3.join(cwd, file));
+    if (before === null) continue;
+    const edit = await withAdapter(before, file);
+    if (edit.kind === "edited") {
+      actions.push({
+        kind: "write",
+        file,
+        before,
+        after: edit.text,
+        reason: "predict and check on every CI test run"
+      });
+    } else if (edit.kind === "manual") {
+      actions.push({
+        kind: "note",
+        lines: [
+          `${file} was left alone: ${edit.reason}.`,
+          ...manualInstructions(file)
+        ]
+      });
+    }
+  }
+  for (const dir of facts.vitestWithoutConfig) {
+    const file = dir === "" ? NEW_CONFIG : `${dir}/${NEW_CONFIG}`;
+    actions.push({
+      kind: "write",
+      file,
+      before: null,
+      after: newConfig(),
+      reason: "Vitest runs here without a config, and the adapter needs one to be in; this sets nothing else"
+    });
+  }
+  for (const file of facts.viteConfigs) {
+    actions.push({
+      kind: "note",
+      gap: true,
+      lines: [
+        `${file} was left alone: Vitest reads its settings from it, and a separate Vitest config would replace it.`,
+        ...manualInstructions(file)
+      ]
+    });
+  }
+  for (const file of facts.reporterFlags) {
+    actions.push({
+      kind: "note",
+      lines: [
+        `A script in ${file} passes --reporter to Vitest. That replaces the reporters in the config, the adapter with them: remove the flag, or the adapter will not load.`
+      ]
+    });
+  }
+  if (observed && facts.taskRunner === "turborepo") {
+    actions.push({
+      kind: "note",
+      lines: [
+        "Turborepo passes a task only the environment variables it is told about.",
+        'To switch the adapter with VARIANT_SHADOW, or point it with VARIANT_BASE, add "VARIANT_*" to `globalPassThroughEnv` in turbo.json.'
+      ]
+    });
+  }
+  if (!observed && facts.viteConfigs.length === 0 && facts.jestConfigs.length === 0) {
+    actions.push({
+      kind: "note",
+      gap: true,
+      lines: [
+        "No package here runs Vitest, so no adapter was added.",
+        ...manualInstructions("your Vitest config")
+      ]
+    });
+  }
+  if (facts.jestConfigs.length > 0) {
+    actions.push({
+      kind: "note",
+      gap: true,
+      lines: [
+        `Jest found (${facts.jestConfigs.join(", ")}). There is no Jest adapter yet, so Jest runs are not checked.`
+      ]
+    });
+  }
+  if (!facts.ignoresVariantDir) {
+    const before = await readText(path3.join(cwd, ".gitignore"));
+    actions.push({
+      kind: "write",
+      file: ".gitignore",
+      before,
+      after: withIgnoreEntry(before),
+      reason: "variant keeps its index and history in .variant/"
+    });
+  }
+  for (const workflow of facts.workflows) {
+    if (!observed || !workflow.runsTests || !workflow.shallow) continue;
+    const after = withFullHistory(workflow.content);
+    if (after === null) continue;
+    actions.push({
+      kind: "write",
+      file: workflow.file,
+      before: workflow.content,
+      after,
+      reason: "the adapter compares against an earlier commit, and the default checkout fetches only one"
+    });
+  }
+  if (!facts.workflows.some((w) => w.file === PULL_REQUEST_WORKFLOW)) {
+    actions.push({
+      kind: "write",
+      file: PULL_REQUEST_WORKFLOW,
+      before: null,
+      after: pullRequestWorkflow(
+        facts.packageManager ?? "npm",
+        workflowStyle(
+          facts.workflows.find((workflow) => workflow.runsTests)?.content ?? ""
+        )
+      ),
+      reason: "one comment on each pull request saying what it affects"
+    });
+  }
+  return actions;
+}
+
+// src/core/setup/diff.ts
+var CONTEXT = 2;
+function diffLines(before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  const lengths = Array.from(
+    { length: a.length + 1 },
+    () => new Array(b.length + 1).fill(0)
+  );
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      const row = lengths[i2];
+      if (row === void 0) continue;
+      row[j2] = a[i2] === b[j2] ? (lengths[i2 + 1]?.[j2 + 1] ?? 0) + 1 : Math.max(lengths[i2 + 1]?.[j2] ?? 0, row[j2 + 1] ?? 0);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      out.push({ kind: "same", text: a[i] ?? "" });
+      i++;
+      j++;
+    } else if ((lengths[i + 1]?.[j] ?? 0) >= (lengths[i]?.[j + 1] ?? 0)) {
+      out.push({ kind: "removed", text: a[i] ?? "" });
+      i++;
+    } else {
+      out.push({ kind: "added", text: b[j] ?? "" });
+      j++;
+    }
+  }
+  for (; i < a.length; i++) out.push({ kind: "removed", text: a[i] ?? "" });
+  for (; j < b.length; j++) out.push({ kind: "added", text: b[j] ?? "" });
+  return out;
+}
+function renderDiff(before, after) {
+  const lines2 = diffLines(before, after);
+  const keep = new Array(lines2.length).fill(false);
+  lines2.forEach((line, index) => {
+    if (line.kind === "same") return;
+    for (let k = Math.max(0, index - CONTEXT); k <= Math.min(lines2.length - 1, index + CONTEXT); k++) {
+      keep[k] = true;
+    }
+  });
+  const out = [];
+  let skipped = false;
+  lines2.forEach((line, index) => {
+    if (!keep[index]) {
+      skipped = true;
+      return;
+    }
+    if (skipped && out.length > 0) out.push("    \u2026");
+    skipped = false;
+    const margin = line.kind === "added" ? "+" : line.kind === "removed" ? "-" : " ";
+    out.push(`  ${margin} ${line.text}`);
+  });
+  return out;
+}
+
+// src/cli/render/init.ts
+function renderFacts(facts, printer = getPrinter()) {
+  const { green, dim } = getColors();
+  const found = (text) => `${green("\u2713")} ${text}`;
+  const absent = (text) => `${dim("\xB7")} ${dim(text)}`;
+  lines(
+    printer,
+    "",
+    facts.packageManager === null ? absent("no lockfile; assuming npm") : found(`${facts.packageManager} detected`),
+    facts.workspacePackages > 0 ? found(
+      `${plural(facts.workspacePackages, "workspace package")} discovered`
+    ) : absent("not a workspace"),
+    ...facts.taskRunner === null ? [] : [
+      found(
+        `${facts.taskRunner === "turborepo" ? "Turborepo" : "Nx"} detected`
+      )
+    ],
+    facts.vitestConfigs.length > 0 ? found(`Vitest detected (${facts.vitestConfigs.join(", ")})`) : facts.vitestWithoutConfig.length + facts.viteConfigs.length > 0 ? found(
+      `Vitest detected, with no Vitest config (${[...facts.vitestWithoutConfig.map((dir) => dir || "the root"), ...facts.viteConfigs].join(", ")})`
+    ) : absent("no Vitest found at the root or in a workspace package"),
+    ...facts.jestConfigs.length > 0 ? [found("Jest detected")] : [],
+    ...facts.playwrightConfigs.length > 0 ? [found("Playwright detected")] : [],
+    facts.workflows.length > 0 ? found(
+      `GitHub Actions detected (${plural(facts.workflows.length, "workflow")})`
+    ) : absent("no GitHub Actions workflows"),
+    facts.defaultBranch === null ? absent("no default branch found") : found(`default branch: ${facts.defaultBranch}`)
+  );
+}
+function renderPlan(actions, printer = getPrinter()) {
+  const { bold, green, red, yellow } = getColors();
+  const changes = actions.filter((action) => action.kind !== "note");
+  if (changes.length === 0) {
+    lines(printer, "", "Nothing to change: this repository is already set up.");
+  }
+  for (const action of actions) {
+    if (action.kind === "install") {
+      lines(
+        printer,
+        "",
+        `${bold("Run")} ${action.command.join(" ")}`,
+        `  ${action.reason}`
+      );
+    } else if (action.kind === "write") {
+      lines(
+        printer,
+        "",
+        `${bold(action.before === null ? "Create" : "Edit")} ${action.file}`,
+        `  ${action.reason}`
+      );
+      if (action.before === null) {
+        for (const line of action.after.trimEnd().split("\n")) {
+          lines(printer, green(`  + ${line}`));
+        }
+      } else {
+        for (const line of renderDiff(action.before, action.after)) {
+          lines(
+            printer,
+            line.startsWith("  +") ? green(line) : line.startsWith("  -") ? red(line) : line
+          );
+        }
+      }
+    } else {
+      lines(printer, "", `${yellow("Note:")} ${action.lines[0] ?? ""}`);
+      for (const line of action.lines.slice(1)) lines(printer, `  ${line}`);
+    }
+  }
+}
+function renderApplied(result, actions, printer = getPrinter()) {
+  const install = actions.find((action) => action.kind === "install");
+  lines(printer, "");
+  for (const file of result.written) lines(printer, `Wrote ${file}`);
+  if (result.installed) lines(printer, "Installed @blzsky/variant");
+  if (result.installError !== void 0 && install?.kind === "install") {
+    lines(
+      printer,
+      `The install did not finish (${result.installError}). Run it yourself: ${install.command.join(" ")}`
+    );
+  }
+  const unchecked = actions.some(
+    (action) => action.kind === "note" && action.gap === true
+  );
+  lines(
+    printer,
+    "",
+    unchecked ? "The pull-request report is set up. Test runs are not checked yet: see the note above." : "variant is configured. Your test command and your pull requests are all you need from here."
+  );
+}
+
+// src/cli/visuals/prompts.ts
+import { createInterface, emitKeypressEvents } from "readline";
+function readLine(input) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input });
+    rl.once("line", (line) => {
+      resolve(line);
+      rl.close();
+    });
+    rl.once("close", () => {
+      resolve("");
+    });
+  });
+}
+function readConfirmKey(input, output, defaultValue) {
+  return new Promise((resolve) => {
+    emitKeypressEvents(input);
+    input.setRawMode?.(true);
+    const settle = (response) => {
+      input.setRawMode?.(false);
+      input.removeListener("keypress", onKeypress);
+      input.pause();
+      resolve(response);
+    };
+    const onKeypress = (_chunk, key) => {
+      if (key?.ctrl === true && key.name === "c") {
+        input.setRawMode?.(false);
+        output.write(`${SHOW_CURSOR}
+`);
+        process.exit(130);
+      }
+      if (key?.name === "y") {
+        settle(true);
+      } else if (key?.name === "n") {
+        settle(false);
+      } else if (key?.name === "return" || key?.name === "enter") {
+        settle(defaultValue);
+      }
+    };
+    input.on("keypress", onKeypress);
+  });
+}
+async function confirm(message, options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stderr;
+  const defaultValue = options.defaultValue ?? false;
+  const colors = getColors();
+  const hint = defaultValue ? "yes" : "no";
+  const prompt = `${colors.yellow("?")} ${colors.bold(message)} ${colors.dim("[y/n]")} ${colors.dim("\u203A")} ${colors.cyan(hint)}`;
+  if (input.isTTY !== true || input.setRawMode === void 0) {
+    output.write(`${prompt} `);
+    const answer = (await readLine(input)).trim().toLowerCase();
+    if (answer === "") return defaultValue;
+    return answer === "y" || answer === "yes";
+  }
+  output.write(`${prompt}${HIDE_CURSOR}`);
+  const response = await readConfirmKey(input, output, defaultValue);
+  const report = `${colors.green("\u2714")} ${colors.bold(message)} ${colors.dim("\xB7")} ${colors.cyan(response ? "yes" : "no")}`;
+  output.write(`\r${CLEAR_LINE}${report}${SHOW_CURSOR}
+`);
+  return response;
+}
+
+// src/cli/commands/init.ts
+var CONFIG_FILENAME = "variant.config.ts";
+function splitList(answer) {
+  return answer.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+async function registerInitAction(opts = {}) {
+  if (opts.tasks === true) return registerInitTasksAction();
+  const cwd = process.cwd();
+  const printer = getPrinter();
+  const facts = await discoverRepository(cwd);
+  renderFacts(facts);
+  const packageSpec = opts.package ?? (opts.version === void 0 ? void 0 : `${PACKAGE_NAME}@${opts.version}`);
+  const actions = await planSetup(cwd, facts, {
+    ...packageSpec !== void 0 && { packageSpec },
+    ...opts.install === false && { install: false }
+  });
+  renderPlan(actions);
+  if (!actions.some((action) => action.kind !== "note")) return;
+  if (opts.dryRun === true) {
+    lines(printer, "", "Dry run: nothing was changed.");
+    return;
+  }
+  if (opts.yes !== true) {
+    if (process.stdin.isTTY !== true) {
+      lines(
+        printer,
+        "",
+        "Nothing was changed. Run `variant init --yes` to apply these changes."
+      );
+      return;
+    }
+    lines(printer, "");
+    if (!await confirm("Apply these changes?")) {
+      lines(printer, "Nothing was changed.");
+      return;
+    }
+  }
+  renderApplied(await applySetup(cwd, actions), actions);
+}
+async function registerInitTasksAction() {
+  const cwd = process.cwd();
+  const printer = getPrinter();
+  const existing = findVariantConfigPath(cwd);
+  if (existing) {
+    lines(
+      printer,
+      `${path4.basename(existing)} already exists \u2014 nothing written.`
+    );
+    return;
+  }
+  const [{ pm, framework }, detectedScripts] = await Promise.all([
+    detectProject(cwd),
+    detectScriptTasks(cwd)
+  ]);
+  const pmName = pm.name;
+  const frameworkName = framework?.name ?? null;
+  const destination = path4.join(cwd, CONFIG_FILENAME);
+  if (!process.stdin.isTTY) {
+    const build = {
+      name: "build",
+      command: defaultCommandFor(pmName, "build", frameworkName),
+      inputs: inputsFor("build")
+    };
+    await writeFile2(destination, renderConfigTemplate([build]));
+    lines(
+      printer,
+      `Created ${CONFIG_FILENAME} (non-interactive, detected ${pmName}${frameworkName ? `/${frameworkName}` : ""})`
+    );
+    return;
+  }
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    lines(
+      printer,
+      "",
+      `Detected: ${pmName}${frameworkName ? ` \xB7 ${frameworkName}` : ""} \xB7 scripts: ${detectedScripts.join(", ")}`,
+      ""
+    );
+    const answeredTasks = await rl.question(
+      `Tasks to configure [${detectedScripts.join(",")}]: `
+    );
+    const taskNames = answeredTasks.trim() ? splitList(answeredTasks) : detectedScripts;
+    const tasks = [];
+    for (const name of taskNames) {
+      const suggestedCommand = defaultCommandFor(pmName, name, frameworkName);
+      const answeredCommand = await rl.question(
+        `  Command for "${name}" [${suggestedCommand}]: `
+      );
+      const suggestedInputs = inputsFor(name);
+      const answeredInputs = await rl.question(
+        `  Inputs for "${name}" [${suggestedInputs.join(", ")}]: `
+      );
+      tasks.push({
+        name,
+        command: answeredCommand.trim() || suggestedCommand,
+        inputs: answeredInputs.trim() ? splitList(answeredInputs) : suggestedInputs
+      });
+    }
+    await writeFile2(destination, renderConfigTemplate(tasks));
+    lines(
+      printer,
+      "",
+      `Created ${CONFIG_FILENAME} \u2014 run \`variant doctor\` to verify.`
+    );
+  } finally {
+    rl.close();
+  }
+}
+export {
+  registerInitAction
+};