@blzsky/variant 0.2.1 → 0.3.0-canary.1

package/dist/chunk-X3VVGTEV.js

@@ -0,0 +1,268 @@
+// src/core/graph/tsconfig-paths.ts
+import { readFile } from "fs/promises";
+import path3 from "path";
+
+// src/core/graph/package-imports.ts
+import path2 from "path";
+
+// src/core/graph/package-exports.ts
+import path from "path";
+var BUILD_DIRS = ["dist", "lib", "build", "out", "es", "esm", "cjs"];
+var SOURCE_DIRS = ["src", "lib", "source", ""];
+var CONDITIONS = [
+  "source",
+  "development",
+  "import",
+  "module",
+  "require",
+  "types",
+  "node",
+  "default"
+];
+var MAX_CONDITION_DEPTH = 8;
+function conditionTargets(value) {
+  return targetsOf(value);
+}
+function targetsOf(value, depth = 0) {
+  if (depth > MAX_CONDITION_DEPTH) return [];
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => targetsOf(entry, depth + 1));
+  }
+  if (typeof value !== "object" || value === null) return [];
+  const record = value;
+  const out = [];
+  for (const condition of CONDITIONS) {
+    if (condition in record) {
+      out.push(...targetsOf(record[condition], depth + 1));
+    }
+  }
+  for (const [key, nested] of Object.entries(record)) {
+    if (!CONDITIONS.includes(key) && !key.startsWith(".")) {
+      out.push(...targetsOf(nested, depth + 1));
+    }
+  }
+  return out;
+}
+function clean(target) {
+  if (!target.startsWith("./")) return void 0;
+  return target.slice(2);
+}
+function resolveExportsSubpath(exportsField, subpath) {
+  if (exportsField === void 0 || exportsField === null) return [];
+  const request = subpath === "" ? "." : `./${subpath}`;
+  const isSubpathMap = typeof exportsField === "object" && !Array.isArray(exportsField) && Object.keys(exportsField).some(
+    (k) => k.startsWith(".")
+  );
+  if (!isSubpathMap) {
+    return request === "." ? targetsOf(exportsField).map(clean).filter((t) => t !== void 0) : [];
+  }
+  const map = exportsField;
+  if (request in map) {
+    return targetsOf(map[request]).map(clean).filter((t) => t !== void 0);
+  }
+  const patterns = Object.keys(map).filter((key) => key.startsWith("./") && key.includes("*")).sort((a, b) => b.length - a.length);
+  for (const pattern of patterns) {
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (request.length < prefix.length + suffix.length || !request.startsWith(prefix) || !request.endsWith(suffix)) {
+      continue;
+    }
+    const captured = request.slice(
+      prefix.length,
+      request.length - suffix.length
+    );
+    const targets = targetsOf(map[pattern]).map((t) => clean(t.replace("*", captured))).filter((t) => t !== void 0);
+    if (targets.length > 0) return targets;
+  }
+  return [];
+}
+function toSourceCandidates(target) {
+  const withoutExtension = stripExtension(target);
+  const segments = withoutExtension.split("/");
+  const head = segments[0];
+  const bodies = head !== void 0 && BUILD_DIRS.includes(head) && segments.length > 1 ? [segments.slice(1).join("/")] : [withoutExtension];
+  const out = [];
+  for (const body of bodies) {
+    for (const dir of SOURCE_DIRS) {
+      out.push(dir === "" ? body : `${dir}/${body}`);
+    }
+  }
+  return [...new Set(out)];
+}
+function stripExtension(target) {
+  if (target.endsWith(".d.ts")) return target.slice(0, -".d.ts".length);
+  const ext = path.posix.extname(target);
+  return ext === "" ? target : target.slice(0, -ext.length);
+}
+function exportsCandidates(exportsField, subpath) {
+  const targets = resolveExportsSubpath(exportsField, subpath);
+  if (targets.length === 0) return [];
+  const out = [];
+  for (const target of targets) out.push(stripExtension(target));
+  for (const target of targets) out.push(...toSourceCandidates(target));
+  return [...new Set(out)];
+}
+
+// src/core/graph/package-imports.ts
+function toImportAliases(dir, importsField) {
+  if (typeof importsField !== "object" || importsField === null || Array.isArray(importsField)) {
+    return [];
+  }
+  const aliases = [];
+  for (const [key, value] of Object.entries(importsField)) {
+    if (!key.startsWith("#")) continue;
+    const stars = key.split("*").length - 1;
+    if (stars > 1) continue;
+    const targets = conditionTargets(value).filter((target) => target.startsWith("./")).map((target) => path2.posix.join(dir, target));
+    if (targets.length === 0) continue;
+    const wildcard = stars === 1;
+    const [prefix = "", suffix = ""] = wildcard ? key.split("*") : [key, ""];
+    aliases.push({
+      prefix,
+      suffix,
+      wildcard,
+      targets,
+      ...dir !== "" && { scope: dir }
+    });
+  }
+  aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+  return aliases;
+}
+
+// src/core/graph/tsconfig-paths.ts
+var MAX_WILDCARDS = 1;
+function toPathAliases(cwd, paths, baseUrl, scope) {
+  if (paths === void 0) return [];
+  const base = baseUrl ?? cwd;
+  const aliases = [];
+  for (const [pattern, rawTargets] of Object.entries(paths)) {
+    const stars = pattern.split("*").length - 1;
+    if (stars > MAX_WILDCARDS) continue;
+    const wildcard = stars === 1;
+    const [prefix = "", suffix = ""] = wildcard ? pattern.split("*") : [pattern, ""];
+    const targets = [];
+    for (const target of rawTargets) {
+      if (target.split("*").length - 1 > MAX_WILDCARDS) continue;
+      const absolute = path3.resolve(base, target);
+      const relative = path3.relative(cwd, absolute).replace(/\\/g, "/");
+      if (relative === "" || relative.startsWith("../")) continue;
+      targets.push(relative);
+    }
+    if (targets.length > 0) {
+      aliases.push({
+        prefix,
+        suffix,
+        wildcard,
+        targets,
+        ...scope !== void 0 && { scope }
+      });
+    }
+  }
+  aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+  return aliases;
+}
+function matchPathAlias(spec, aliases) {
+  const bases = [];
+  for (const alias of aliases) {
+    if (!alias.wildcard) {
+      if (spec === alias.prefix) bases.push(...alias.targets);
+      continue;
+    }
+    if (spec.length < alias.prefix.length + alias.suffix.length || !spec.startsWith(alias.prefix) || !spec.endsWith(alias.suffix)) {
+      continue;
+    }
+    const captured = spec.slice(
+      alias.prefix.length,
+      spec.length - alias.suffix.length
+    );
+    for (const target of alias.targets) {
+      bases.push(target.replace("*", captured));
+    }
+  }
+  return bases;
+}
+function aliasesInScope(file, aliases) {
+  return aliases.filter(
+    (alias) => alias.scope === void 0 || file.startsWith(`${alias.scope}/`)
+  ).sort((a, b) => (b.scope?.length ?? -1) - (a.scope?.length ?? -1));
+}
+var CONFIG_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  ".git/**",
+  ".variant/**"
+];
+async function readPathAliases(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const found = (await fg(["**/tsconfig.json", "**/package.json"], {
+    cwd,
+    onlyFiles: true,
+    ignore: CONFIG_IGNORE
+  })).map((file) => file.replace(/\\/g, "/")).sort();
+  const named = (name) => found.filter((file) => path3.posix.basename(file) === name);
+  const [fromTsconfig, fromManifests] = await Promise.all([
+    tsconfigAliases(cwd, named("tsconfig.json")),
+    Promise.all(
+      named("package.json").map((file) => manifestImportAliases(cwd, file))
+    )
+  ]);
+  return [...fromTsconfig, ...fromManifests.flat()];
+}
+async function manifestImportAliases(cwd, manifestPath) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(path3.join(cwd, manifestPath), "utf8")
+    );
+    if (typeof manifest !== "object" || manifest === null) return [];
+    const dir = path3.posix.dirname(manifestPath);
+    return toImportAliases(
+      dir === "." ? "" : dir,
+      manifest.imports
+    );
+  } catch {
+    return [];
+  }
+}
+async function tsconfigAliases(cwd, configs) {
+  if (configs.length === 0) return [];
+  const { ts } = await import("ts-morph");
+  const aliases = [];
+  for (const config of configs) {
+    const configPath = path3.join(cwd, config);
+    const configDir = path3.dirname(configPath);
+    const read = ts.readConfigFile(configPath, (file) => ts.sys.readFile(file));
+    if (read.error !== void 0 || read.config === void 0) continue;
+    const { options } = ts.parseJsonConfigFileContent(
+      read.config,
+      {
+        ...ts.sys,
+        // Enumerating every file in the workspace is pure waste: only
+        // `compilerOptions` is wanted, and a large repo makes this the
+        // most expensive call in the command.
+        readDirectory: () => [],
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
+      },
+      configDir
+    );
+    const pathsBase = options["pathsBasePath"];
+    const base = options.baseUrl ?? (typeof pathsBase === "string" ? pathsBase : configDir);
+    const scope = path3.posix.dirname(config);
+    aliases.push(
+      ...toPathAliases(
+        cwd,
+        options.paths,
+        base,
+        scope === "." ? void 0 : scope
+      )
+    );
+  }
+  return aliases;
+}
+
+export {
+  exportsCandidates,
+  toPathAliases,
+  matchPathAlias,
+  aliasesInScope,
+  readPathAliases
+};

package/dist/{chunk-TCISS2AS.js → chunk-XXMD4NC5.js}

@@ -1,24 +1,52 @@
 import {
   collectExportedSurface
-} from "./chunk-RC23JQKI.js";
+} from "./chunk-WULBOSG5.js";
 import {
   GraphError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-C3NZIFW6.js";
 
 // src/core/semantic/symbol-graph.ts
 import { createHash } from "crypto";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import path from "path";
-var SYMBOL_GRAPH_VERSION = 1;
+var SYMBOL_GRAPH_VERSION = 6;
 var GRAPH_FILENAME = "symbols.json";
 var DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"];
+var JAVASCRIPT_INCLUDE = ["**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs"];
+var JAVASCRIPT_PATHSPECS = ["*.js", "*.jsx", "*.mjs", "*.cjs"];
+var MAX_JAVASCRIPT_BYTES = 512 * 1024;
 var DEFAULT_IGNORE = [
-  "node_modules/**",
+  "**/node_modules/**",
   ".git/**",
   ".variant/**",
-  "dist/**",
-  "**/*.d.ts"
+  "**/dist/**",
+  "**/*.d.ts",
+  "**/*.d.mts",
+  "**/*.d.cts"
 ];
+var JAVASCRIPT_FILE = /\.(?:[cm]?js|jsx)$/;
+function isJavaScript(file) {
+  return JAVASCRIPT_FILE.test(file);
+}
+async function listJavaScript(cwd, ignore, fg) {
+  const { listRepositoryFiles } = await import("./git-VGHUF2SY.js");
+  const tracked = await listRepositoryFiles(cwd, JAVASCRIPT_PATHSPECS);
+  if (tracked === null) {
+    return fg(JAVASCRIPT_INCLUDE, { cwd, onlyFiles: true, ignore });
+  }
+  const ignored = ignore.map(globToRegExp);
+  return tracked.filter(
+    (file) => !/\.min\.[cm]?js$/.test(file) && !ignored.some((pattern) => pattern.test(file))
+  );
+}
+function globToRegExp(pattern) {
+  const source = pattern.split("**/").map(
+    (part) => part.split("**").map(
+      (piece) => piece.split("*").map((text) => text.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")
+    ).join(".*")
+  ).join("(?:.*/)?");
+  return new RegExp(`^${source}$`);
+}
 function defaultGraphDir(cwd) {
   return path.join(cwd, ".variant", "graph");
 }
@@ -26,11 +54,14 @@ async function buildSymbolGraph(cwd, options = {}) {
   const fg = (await import("fast-glob")).default;
   const include = options.include ?? DEFAULT_INCLUDE;
   for (const p of include) assertSafePattern(p);
-  const files = (await fg(include, {
-    cwd,
-    onlyFiles: true,
-    ignore: [...DEFAULT_IGNORE, ...options.ignore ?? []]
-  })).map(toPosix).sort();
+  const ignore = [...DEFAULT_IGNORE, ...options.ignore ?? []];
+  const [typescript, javascript] = await Promise.all([
+    fg(include, { cwd, onlyFiles: true, ignore }),
+    options.include === void 0 ? listJavaScript(cwd, ignore, fg) : []
+  ]);
+  const files = [
+    ...new Set([...typescript, ...javascript].map(toPosix))
+  ].sort();
   const previous = options.previous?.version === SYMBOL_GRAPH_VERSION ? options.previous : null;
   const stats = {
     scanned: files.length,
@@ -40,6 +71,7 @@ async function buildSymbolGraph(cwd, options = {}) {
   };
   const contents = new Array(files.length);
   const limit = Math.max(1, options.parallel ?? 32);
+  const read = options.readFile ?? ((absolutePath) => readFile(absolutePath, "utf8"));
   let next = 0;
   const worker = async () => {
     while (true) {
@@ -47,7 +79,15 @@ async function buildSymbolGraph(cwd, options = {}) {
       if (i >= files.length) return;
       const relPath = files[i];
       if (relPath === void 0) return;
-      contents[i] = await readFile(path.join(cwd, relPath), "utf8");
+      try {
+        const content = await read(path.join(cwd, relPath));
+        if (isJavaScript(relPath) && content.length > MAX_JAVASCRIPT_BYTES) {
+          continue;
+        }
+        contents[i] = content;
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
     }
   };
   await Promise.all(
@@ -69,12 +109,19 @@ async function buildSymbolGraph(cwd, options = {}) {
     }
     if (tsm === void 0 || project === void 0) {
       tsm = await import("ts-morph");
-      project = new tsm.Project({ useInMemoryFileSystem: true });
+      project = new tsm.Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: { allowJs: true }
+      });
     }
     const sourceFile = project.createSourceFile(relPath, content, {
       overwrite: true
     });
-    out[relPath] = indexSourceFile(sourceFile, contentHash, tsm);
+    try {
+      out[relPath] = indexSourceFile(sourceFile, contentHash, tsm);
+    } finally {
+      project.removeSourceFile(sourceFile);
+    }
     stats.parsed++;
   }
   if (previous !== null) {
@@ -188,24 +235,72 @@ function collectImports(file, tsm) {
       names: named.length > 0 ? named : ["*"]
     });
   }
-  for (const call of file.getDescendantsOfKind(tsm.SyntaxKind.CallExpression)) {
-    if (call.getExpression().getKind() !== tsm.SyntaxKind.ImportKeyword) {
+  for (const decl of file.getDescendantsOfKind(
+    tsm.SyntaxKind.ImportEqualsDeclaration
+  )) {
+    const reference = decl.getModuleReference();
+    if (!tsm.Node.isExternalModuleReference(reference)) continue;
+    const expression = reference.getExpression();
+    if (expression === void 0 || !tsm.Node.isStringLiteral(expression)) {
       continue;
     }
+    imports.push({
+      module: expression.getLiteralValue(),
+      kind: "static",
+      typeOnly: decl.isTypeOnly(),
+      names: ["*"]
+    });
+  }
+  for (const call of file.getDescendantsOfKind(tsm.SyntaxKind.CallExpression)) {
+    const callee = call.getExpression();
+    const isImport = callee.getKind() === tsm.SyntaxKind.ImportKeyword;
+    const isRequire = tsm.Node.isIdentifier(callee) && callee.getText() === "require";
+    if (!isImport && !isRequire) continue;
     const arg = call.getArguments()[0];
-    if (arg !== void 0 && tsm.Node.isStringLiteral(arg)) {
-      imports.push({
-        module: arg.getLiteralValue(),
-        kind: "dynamic",
-        typeOnly: false,
-        names: []
-      });
-    } else {
-      notes.push("dynamic import() with a non-literal specifier");
+    if (arg !== void 0 && (tsm.Node.isStringLiteral(arg) || tsm.Node.isNoSubstitutionTemplateLiteral(arg))) {
+      imports.push(
+        isImport ? {
+          module: arg.getLiteralValue(),
+          kind: "dynamic",
+          typeOnly: false,
+          names: []
+        } : {
+          module: arg.getLiteralValue(),
+          kind: "static",
+          typeOnly: false,
+          names: ["*"]
+        }
+      );
+      continue;
+    }
+    const prefix = arg === void 0 ? "" : staticPrefix(arg, tsm);
+    imports.push({
+      module: prefix,
+      kind: "pattern",
+      typeOnly: false,
+      names: []
+    });
+    if (prefix === "") {
+      notes.push(
+        `${isImport ? "dynamic import()" : "require()"} with a non-literal specifier`
+      );
     }
   }
   return { imports, notes };
 }
+function staticPrefix(arg, tsm) {
+  if (tsm.Node.isTemplateExpression(arg)) {
+    return arg.getHead().getLiteralText();
+  }
+  if (tsm.Node.isBinaryExpression(arg) && arg.getOperatorToken().getKind() === tsm.SyntaxKind.PlusToken) {
+    const left = arg.getLeft();
+    if (tsm.Node.isStringLiteral(left) || tsm.Node.isNoSubstitutionTemplateLiteral(left)) {
+      return left.getLiteralValue();
+    }
+    return staticPrefix(left, tsm);
+  }
+  return "";
+}
 function sha256(text) {
   return createHash("sha256").update(text).digest("hex");
 }

package/dist/cli.js

@@ -11,7 +11,7 @@ import {
 import {
   CliUsageError,
   VariantError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-C3NZIFW6.js";
 
 // src/cli/index.ts
 import { readFileSync } from "fs";
@@ -71,6 +71,8 @@ var writeStderr = (text) => {
 function renderError(err, write = writeStderr) {
   const colors = getColors();
   write(`${colors.red(`[${err.code}]`)} ${err.message}
+`);
+  for (const line of err.details ?? []) write(`${colors.dim(`  ${line}`)}
 `);
   if (err.provenance) {
     for (const line of provenanceLines(err.provenance)) {
@@ -118,21 +120,54 @@ var program = new Command().name("variant").description(
     })
   );
 });
+program.command("check").description(
+  "Mutate the lines you changed and report the mutations your tests did not notice"
+).option(
+  "--base <ref>",
+  "git ref to compare against (default: HEAD for uncommitted changes, else detected)"
+).option("--max-mutants <n>", "mutations to run at most (default: 50)").option(
+  "--budget <time>",
+  "stop after this long, baseline included: 300, 90s or 5m (default: 5m)"
+).option("--vitest-config <file>", "the Vitest config to run the tests with").option(
+  "--fail-on-survivors",
+  "exit 1 when a mutation went undetected or unreached, or the run is incomplete"
+).option("--json", "output the result as JSON").action(
+  async (opts) => {
+    const { registerCheckAction } = await import("./check-AKYABBIV.js");
+    await registerCheckAction({
+      ...opts.base !== void 0 && { base: opts.base },
+      ...opts.maxMutants !== void 0 && { maxMutants: opts.maxMutants },
+      ...opts.budget !== void 0 && { budget: opts.budget },
+      ...opts.vitestConfig !== void 0 && {
+        vitestConfig: opts.vitestConfig
+      },
+      ...opts.failOnSurvivors === true && { failOnSurvivors: true },
+      ...opts.json === true && { json: true }
+    });
+  }
+);
 var impactCmd = program.command("impact").description(
   "Predict which tests a change requires \u2014 report-only; the full suite should still run"
-).option("--base <ref>", "git ref to compare against", "HEAD~1").option("--json", "output the report as JSON").action(async (opts) => {
-  const { registerImpactAction } = await import("./impact-PRZ6HEP5.js");
+).option(
+  "--base <ref>",
+  "git ref to compare against (default: detected from git and CI)"
+).option(
+  "--head-sha <sha>",
+  "record the prediction against this commit instead of HEAD"
+).option("--json", "output the report as JSON").action(async (opts) => {
+  const { registerImpactAction } = await import("./impact-AXLZTLVT.js");
   await registerImpactAction({
-    base: opts.base,
+    ...opts.base !== void 0 && { base: opts.base },
+    ...opts.headSha !== void 0 && { headSha: opts.headSha },
     ...opts.json === true && { json: true }
   });
 });
-impactCmd.command("verify <report>").description(
-  "Reconcile a logged prediction against a Vitest/Jest JSON report \u2014 reports false skips"
-).option("--head-sha <sha>", "reconcile the prediction made at this commit").option("--json", "output the reconciliation as JSON").action(async (report, _opts, command) => {
-  const { registerImpactVerifyAction } = await import("./impact-PRZ6HEP5.js");
+impactCmd.command("verify <report...>").description(
+  "Reconcile a logged prediction against one or more Vitest/Jest JSON reports \u2014 reports false skips"
+).option("--head-sha <sha>", "reconcile the prediction made at this commit").option("--json", "output the reconciliation as JSON").action(async (reports, _opts, command) => {
+  const { registerImpactVerifyAction } = await import("./impact-AXLZTLVT.js");
   const opts = command.optsWithGlobals();
-  await registerImpactVerifyAction(report, {
+  await registerImpactVerifyAction(reports, {
     ...opts.headSha !== void 0 && { headSha: opts.headSha },
     ...opts.json === true && { json: true }
   });
@@ -140,14 +175,14 @@ impactCmd.command("verify <report>").description(
 program.command("diff <file>").description(
   "Classify a TypeScript file change as non-impacting / internal / breaking"
 ).option("--base <ref>", "git ref to compare against", "HEAD~1").action(async (file, opts) => {
-  const { registerDiffAction } = await import("./diff-HSJBZFMC.js");
+  const { registerDiffAction } = await import("./diff-ST5KHT7P.js");
   await registerDiffAction(file, { base: opts.base });
 });
 var workspaceCmd = program.command("workspace").description("Workspace-level analysis commands");
 workspaceCmd.command("check").description(
   "Detect packages importing dependencies they do not declare (CI gate: exits 1 on violations)"
 ).option("--json", "output the result as JSON").action(async (opts) => {
-  const { registerWorkspaceCheckAction } = await import("./workspace-HRTFGWKN.js");
+  const { registerWorkspaceCheckAction } = await import("./workspace-IQFLR3RY.js");
   await registerWorkspaceCheckAction({
     ...opts.json === true && { json: true }
   });
@@ -155,14 +190,28 @@ workspaceCmd.command("check").description(
 var prCmd = program.command("pr").description("PR-aware analysis commands");
 prCmd.command("check").description(
   "Classify all TypeScript changes in this PR and report a build verdict"
-).option("--base <ref>", "base branch or ref for the PR diff", "main").action(async (opts) => {
-  const { registerPrCheckAction } = await import("./pr-Y724QAHE.js");
-  await registerPrCheckAction({ base: opts.base });
+).option(
+  "--base <ref>",
+  "base branch or ref for the PR diff (default: the target or default branch)"
+).action(async (opts) => {
+  const { registerPrCheckAction } = await import("./pr-7JXUC5BQ.js");
+  await registerPrCheckAction({
+    ...opts.base !== void 0 && { base: opts.base }
+  });
 });
-prCmd.command("report").description("Render `pr check` as a structured JSON or markdown report").option("--base <ref>", "base branch or ref for the PR diff", "main").option("--markdown", "output a markdown summary instead of JSON").option("--output <file>", "write report to file instead of stdout").action(
+prCmd.command("report").description(
+  "Describe what this PR changes and what must be verified before it merges"
+).option(
+  "--base <ref>",
+  "base branch or ref for the PR diff (default: the target or default branch)"
+).option("--markdown", "output a markdown summary instead of JSON").option("--output <file>", "write report to file instead of stdout").action(
   async (opts) => {
-    const { registerPrReportAction } = await import("./pr-Y724QAHE.js");
-    await registerPrReportAction(opts);
+    const { registerPrReportAction } = await import("./pr-7JXUC5BQ.js");
+    await registerPrReportAction({
+      ...opts.base !== void 0 && { base: opts.base },
+      ...opts.markdown === true && { markdown: true },
+      ...opts.output !== void 0 && { output: opts.output }
+    });
   }
 );
 program.command("build").description("Run the build task").option("-c, --concurrency <n>", "max tasks per DAG level").option(
@@ -170,7 +219,7 @@ program.command("build").description("Run the build task").option("-c, --concurr
   "run only packages affected by changes since baseRef (includes cascade dependents)"
 ).option("--dry-run", "print the task plan without executing").action(
   async (opts) => {
-    const { registerBuildAction } = await import("./build-3DSBMMI3.js");
+    const { registerBuildAction } = await import("./build-GCUFPPIB.js");
     const concurrency = parseConcurrency(opts);
     await registerBuildAction({
       ...concurrency !== void 0 && { concurrency },
@@ -184,7 +233,7 @@ program.command("run <task>").description("Run a named task").option(
   "max tasks to run concurrently per DAG level"
 ).option("--dry-run", "print the task plan without executing").action(
   async (taskName, opts) => {
-    const { registerRunAction } = await import("./run-C6VAQOVM.js");
+    const { registerRunAction } = await import("./run-UOPS5FRU.js");
     const concurrency = parseConcurrency(opts);
     await registerRunAction(taskName, {
       ...concurrency !== void 0 && { concurrency },
@@ -192,28 +241,38 @@ program.command("run <task>").description("Run a named task").option(
     });
   }
 );
-program.command("init").description("Scaffold variant.config.ts in the current directory").action(async () => {
-  const { registerInitAction } = await import("./init-O2BY3FOY.js");
-  await registerInitAction();
-});
+program.command("init").description(
+  "Set variant up in this repository: detect how it is tested, show the changes, apply them"
+).option("--dry-run", "show what would change and stop").option("-y, --yes", "apply without asking").option("--no-install", "do not install @blzsky/variant; print the command").option(
+  "--package <spec>",
+  "install this in place of the running version (a tarball path or a spec)"
+).option("--tasks", "write variant.config.ts for the task runner instead").action(
+  async (opts) => {
+    const { registerInitAction } = await import("./init-QCOZWLOO.js");
+    await registerInitAction({
+      version: _pkg.version,
+      ...opts.dryRun === true && { dryRun: true },
+      ...opts.yes === true && { yes: true },
+      ...opts.install === false && { install: false },
+      ...opts.package !== void 0 && { package: opts.package },
+      ...opts.tasks === true && { tasks: true }
+    });
+  }
+);
 program.command("doctor").description("Validate config and diagnose common issues").action(async () => {
-  const { registerDoctorAction } = await import("./doctor-B7MHFIYJ.js");
+  const { registerDoctorAction } = await import("./doctor-OEIY4Y5X.js");
   await registerDoctorAction();
 });
 program.command("insight").description("Show task timing and cache hit stats").action(async () => {
-  const { registerInsightAction } = await import("./insight-JQLTGFYB.js");
+  const { registerInsightAction } = await import("./insight-KRWT6Z47.js");
   await registerInsightAction();
 });
 program.command("env").description(
   "Show detected environment (runtime, package manager, framework)"
 ).action(async () => {
-  const { registerEnvAction } = await import("./env-I7JZRWDN.js");
+  const { registerEnvAction } = await import("./env-EQAOZCFR.js");
   await registerEnvAction();
 });
-program.command("check").description("Validate config and task graph (no execution)").action(async () => {
-  const { registerCheckAction } = await import("./check-SIQJU6Z2.js");
-  await registerCheckAction();
-});
 for (const stream of [process.stdout, process.stderr]) {
   stream.on("error", (error) => {
     if (error.code !== "EPIPE" && error.code !== "EOF") throw error;