@blzsky/variant 0.2.0

package/dist/chunk-XTYVVUWW.js

@@ -0,0 +1,279 @@
+import {
+  matchPathAlias
+} from "./chunk-KSHWC2XN.js";
+
+// src/core/graph/import-graph.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 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/import-graph.ts
+var TS_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+var JS_TO_TS = {
+  ".js": [".ts", ".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"],
+  ".jsx": [".tsx"]
+};
+function buildImportGraph(symbolGraph, options = {}) {
+  const files = new Set(Object.keys(symbolGraph.files));
+  const packageDirs = options.packageDirs ?? {};
+  const pathAliases = options.pathAliases ?? [];
+  const packageExports = options.packageExports ?? {};
+  const imports = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const externals = /* @__PURE__ */ new Map();
+  const unresolved = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  for (const file of [...files].sort()) {
+    imports.set(file, /* @__PURE__ */ new Set());
+    dependents.set(file, /* @__PURE__ */ new Set());
+    externals.set(file, /* @__PURE__ */ new Set());
+    unresolved.set(file, /* @__PURE__ */ new Set());
+    edges.set(file, /* @__PURE__ */ new Map());
+  }
+  const addEdge = (from, to, imp) => {
+    imports.get(from)?.add(to);
+    const perFile = edges.get(from);
+    if (perFile === void 0) return;
+    let edge = perFile.get(to);
+    if (edge === void 0) {
+      edge = { names: /* @__PURE__ */ new Set(), typeOnly: true, dynamic: false };
+      perFile.set(to, edge);
+    }
+    for (const name of imp.names) edge.names.add(name);
+    if (imp.kind === "dynamic") edge.dynamic = true;
+    edge.typeOnly = edge.typeOnly && imp.typeOnly;
+  };
+  for (const file of [...files].sort()) {
+    const index = symbolGraph.files[file];
+    if (index === void 0) continue;
+    for (const imp of index.imports) {
+      const spec = imp.module;
+      if (spec.startsWith("./") || spec.startsWith("../")) {
+        const resolved = resolveRelativeImport(file, spec, files);
+        if (resolved === void 0) unresolved.get(file)?.add(spec);
+        else addEdge(file, resolved, imp);
+        continue;
+      }
+      if (spec.startsWith("node:")) {
+        externals.get(file)?.add(spec);
+        continue;
+      }
+      const pkg = matchWorkspacePackage(spec, packageDirs);
+      if (pkg !== void 0) {
+        const resolved = resolvePackageImport(
+          pkg.dir,
+          pkg.subpath,
+          files,
+          packageExports[pkg.name]
+        );
+        if (resolved === void 0) unresolved.get(file)?.add(spec);
+        else addEdge(file, resolved, imp);
+        continue;
+      }
+      const aliased = resolveAliasImport(spec, pathAliases, files);
+      if (aliased !== void 0) {
+        addEdge(file, aliased, imp);
+        continue;
+      }
+      if (matchPathAlias(spec, pathAliases).length > 0) {
+        unresolved.get(file)?.add(spec);
+        continue;
+      }
+      externals.get(file)?.add(spec);
+    }
+  }
+  for (const [file, targets] of imports) {
+    for (const target of targets) {
+      dependents.get(target)?.add(file);
+    }
+  }
+  return { imports, dependents, externals, unresolved, edges };
+}
+function computeAffectedFiles(changed, graph) {
+  const affected = /* @__PURE__ */ new Set();
+  for (const file of changed) affected.add(toPosix(file));
+  let frontier = new Set(affected);
+  while (frontier.size > 0) {
+    const next = /* @__PURE__ */ new Set();
+    for (const file of frontier) {
+      for (const dependent of graph.dependents.get(file) ?? []) {
+        if (!affected.has(dependent)) {
+          affected.add(dependent);
+          next.add(dependent);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return affected;
+}
+function resolveRelativeImport(fromFile, spec, files) {
+  const base = path2.posix.normalize(
+    path2.posix.join(path2.posix.dirname(fromFile), spec)
+  );
+  if (base.startsWith("../")) return void 0;
+  return firstExisting(candidatePaths(base), files);
+}
+function resolvePackageImport(pkgDir, subpath, files, exportsField) {
+  const fromExports = exportsCandidates(exportsField, subpath);
+  const candidates = fromExports.flatMap(
+    (base) => candidatePaths(path2.posix.join(pkgDir, base))
+  );
+  if (subpath === "") {
+    candidates.push(
+      ...candidatePaths(`${pkgDir}/src/index`),
+      ...candidatePaths(`${pkgDir}/index`)
+    );
+  } else {
+    candidates.push(
+      ...candidatePaths(path2.posix.join(pkgDir, subpath)),
+      ...candidatePaths(path2.posix.join(pkgDir, "src", subpath))
+    );
+  }
+  return firstExisting(candidates, files);
+}
+function resolveAliasImport(spec, aliases, files) {
+  for (const base of matchPathAlias(spec, aliases)) {
+    const resolved = firstExisting(candidatePaths(base), files);
+    if (resolved !== void 0) return resolved;
+  }
+  return void 0;
+}
+function matchWorkspacePackage(spec, packageDirs) {
+  const segments = spec.split("/");
+  const nameLength = spec.startsWith("@") ? 2 : 1;
+  if (segments.length < nameLength) return void 0;
+  const name = segments.slice(0, nameLength).join("/");
+  const dir = packageDirs[name];
+  if (dir === void 0) return void 0;
+  return {
+    name,
+    dir: toPosix(dir),
+    subpath: segments.slice(nameLength).join("/")
+  };
+}
+function candidatePaths(base) {
+  const ext = path2.posix.extname(base);
+  if (TS_EXTENSIONS.includes(ext)) {
+    return [base];
+  }
+  const tsExts = JS_TO_TS[ext];
+  if (tsExts !== void 0) {
+    const stem = base.slice(0, -ext.length);
+    return tsExts.map((e) => stem + e);
+  }
+  return [
+    ...TS_EXTENSIONS.map((e) => base + e),
+    ...TS_EXTENSIONS.map((e) => `${base}/index${e}`)
+  ];
+}
+function firstExisting(candidates, files) {
+  for (const c of candidates) {
+    if (files.has(c)) return c;
+  }
+  return void 0;
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+
+export {
+  buildImportGraph,
+  computeAffectedFiles,
+  resolveRelativeImport
+};

package/dist/chunk-XUBWCTJZ.js

@@ -0,0 +1,100 @@
+// src/core/vcs/git.ts
+function toPosix(relPath) {
+  return relPath.replace(/\\/g, "/");
+}
+async function git(cwd, args) {
+  try {
+    const { execa } = await import("execa");
+    const { stdout } = await execa("git", args, { cwd });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+function toFileList(stdout) {
+  if (stdout === null) return null;
+  return stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+async function readFileAtRef(cwd, ref, relPath) {
+  return git(cwd, ["show", `${ref}:${toPosix(relPath)}`]);
+}
+var CAT_FILE_BATCH_SIZE = 256;
+async function readFilesAtRef(cwd, ref, relPaths) {
+  const out = /* @__PURE__ */ new Map();
+  if (relPaths.length === 0) return out;
+  if (relPaths.some((p) => p.includes("\n") || p.includes("\0"))) return null;
+  const { execa } = await import("execa");
+  for (let start = 0; start < relPaths.length; start += CAT_FILE_BATCH_SIZE) {
+    const chunk = relPaths.slice(start, start + CAT_FILE_BATCH_SIZE);
+    let stdout;
+    try {
+      const result = await execa("git", ["cat-file", "--batch"], {
+        cwd,
+        input: `${chunk.map((p) => `${ref}:${toPosix(p)}`).join("\n")}
+`,
+        encoding: "buffer",
+        // The response framing is byte-exact; execa's default of
+        // trimming the final newline would truncate the last record.
+        stripFinalNewline: false
+      });
+      stdout = result.stdout;
+    } catch {
+      return null;
+    }
+    if (!parseCatFileBatch(stdout, chunk, out)) return null;
+  }
+  return out;
+}
+var NEWLINE = 10;
+function stripFinalNewline(text) {
+  if (text.endsWith("\r\n")) return text.slice(0, -2);
+  if (text.endsWith("\n")) return text.slice(0, -1);
+  return text;
+}
+function parseCatFileBatch(stdout, requested, out) {
+  const decoder = new TextDecoder();
+  let offset = 0;
+  for (const relPath of requested) {
+    const lineEnd = stdout.indexOf(NEWLINE, offset);
+    if (lineEnd === -1) return false;
+    const header = decoder.decode(stdout.subarray(offset, lineEnd));
+    offset = lineEnd + 1;
+    const parts = header.split(" ");
+    const type = parts[1];
+    if (type !== "blob") {
+      out.set(relPath, null);
+      continue;
+    }
+    const size = Number(parts[2]);
+    if (!Number.isInteger(size) || size < 0) return false;
+    const end = offset + size;
+    if (end > stdout.length) return false;
+    out.set(
+      relPath,
+      stripFinalNewline(decoder.decode(stdout.subarray(offset, end)))
+    );
+    offset = end + 1;
+  }
+  return true;
+}
+async function readHeadSha(cwd) {
+  const stdout = await git(cwd, ["rev-parse", "HEAD"]);
+  const sha = stdout?.trim();
+  return sha === void 0 || sha === "" ? null : sha;
+}
+async function listChangedFiles(cwd, ref) {
+  return toFileList(await git(cwd, ["diff", "--name-only", ref, "--"]));
+}
+async function listChangedFilesSinceMergeBase(cwd, ref) {
+  return toFileList(
+    await git(cwd, ["diff", "--name-only", `${ref}...HEAD`, "--"])
+  );
+}
+
+export {
+  readFileAtRef,
+  readFilesAtRef,
+  readHeadSha,
+  listChangedFiles,
+  listChangedFilesSinceMergeBase
+};

package/dist/chunk-YYGCSKIQ.js

@@ -0,0 +1,29 @@
+// src/cli/visuals/color.ts
+import pc from "picocolors";
+function envFlagSet(name) {
+  const value = process.env[name];
+  return value !== void 0 && value !== "";
+}
+function resolveColorChoice(flags = {}) {
+  const { color } = flags;
+  if (color === "auto" || color === "always" || color === "never") return color;
+  if (color === false) return "never";
+  if (envFlagSet("NO_COLOR")) return "never";
+  if (envFlagSet("FORCE_COLOR") || envFlagSet("CLICOLOR_FORCE")) {
+    return "always";
+  }
+  return "auto";
+}
+var globalColors = pc;
+function writeGlobalColorChoice(choice) {
+  globalColors = choice === "auto" ? pc.createColors(pc.isColorSupported) : pc.createColors(choice === "always");
+}
+function getColors() {
+  return globalColors;
+}
+
+export {
+  resolveColorChoice,
+  writeGlobalColorChoice,
+  getColors
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import {
+  getColors,
+  resolveColorChoice,
+  writeGlobalColorChoice
+} from "./chunk-YYGCSKIQ.js";
+import {
+  CliUsageError,
+  VariantError
+} from "./chunk-RVXUCJYA.js";
+import {
+  Printer,
+  setGlobalPrinter
+} from "./chunk-V22IPJ7A.js";
+
+// src/cli/index.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { Command, Option } from "commander";
+
+// src/cli/parse-opts.ts
+function parseConcurrency(opts) {
+  if (opts.concurrency === void 0) return void 0;
+  const n = Number.parseInt(opts.concurrency, 10);
+  if (!Number.isFinite(n) || n < 1 || String(n) !== opts.concurrency.trim()) {
+    throw new CliUsageError(
+      `--concurrency must be a positive integer, got "${opts.concurrency}"`
+    );
+  }
+  return n;
+}
+
+// src/cli/render/provenance.ts
+var HASH_PREFIX_LENGTH = 7;
+var MAX_LISTED_FILES = 3;
+var MAX_LISTED_DEPENDENTS = 5;
+function shortHash(hash) {
+  return hash.slice(0, HASH_PREFIX_LENGTH);
+}
+function listWithOverflow(items, max) {
+  const shown = items.slice(0, max).join(", ");
+  const hidden = items.length - max;
+  return hidden > 0 ? `${shown} and ${hidden} more` : shown;
+}
+function describeReason(reason) {
+  if (reason.kind === "always") {
+    return "this task is never cached, so it runs every time";
+  }
+  if (reason.kind === "cache-miss") {
+    return reason.expectedHash === null ? "cache miss \u2014 nothing cached for this task yet" : `cache miss \u2014 inputs hash ${shortHash(reason.actualHash)}, cached ${shortHash(reason.expectedHash)}`;
+  }
+  if (reason.changedFiles.length === 0) return "affected by the current diff";
+  return `${listWithOverflow(reason.changedFiles, MAX_LISTED_FILES)} changed`;
+}
+function provenanceLines(provenance) {
+  const block = [`ran because: ${describeReason(provenance.reason)}`];
+  const { dirtyDependents } = provenance;
+  if (dirtyDependents.length > 0) {
+    block.push(
+      `also affected: ${listWithOverflow(dirtyDependents, MAX_LISTED_DEPENDENTS)}`
+    );
+  }
+  return block;
+}
+
+// src/cli/render/error.ts
+var writeStderr = (text) => {
+  process.stderr.write(text);
+};
+function renderError(err, write = writeStderr) {
+  const colors = getColors();
+  write(`${colors.red(`[${err.code}]`)} ${err.message}
+`);
+  if (err.provenance) {
+    for (const line of provenanceLines(err.provenance)) {
+      write(`${colors.dim(`  ${line}`)}
+`);
+    }
+  }
+  if (err.hint) write(`${colors.dim(`  Hint: ${err.hint}`)}
+`);
+}
+function renderUnexpectedError(err, write = writeStderr) {
+  const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+  write(`Unexpected error \u2014 please file a bug:
+${detail}
+`);
+}
+
+// src/cli/index.ts
+var _dir = dirname(fileURLToPath(import.meta.url));
+var _pkg = JSON.parse(
+  readFileSync(join(_dir, "..", "package.json"), "utf8")
+);
+var countFlag = (_value, previous) => previous + 1;
+var program = new Command().name("variant").description(
+  "Change intelligence and task orchestration for TypeScript monorepos"
+).version(_pkg.version).option(
+  "-q, --quiet",
+  "use quiet output (repeat, e.g. -qq, for silent)",
+  countFlag,
+  0
+).option("-v, --verbose", "use verbose output", countFlag, 0).option("--no-progress", "hide progress bars and spinners").addOption(
+  new Option("--color <when>", "control colored output").choices([
+    "auto",
+    "always",
+    "never"
+  ])
+).option("--no-color", "disable colored output (alias for --color never)").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  writeGlobalColorChoice(resolveColorChoice({ color: opts.color }));
+  setGlobalPrinter(
+    Printer.fromFlags({
+      quiet: opts.quiet,
+      verbose: opts.verbose,
+      noProgress: !opts.progress
+    })
+  );
+});
+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-AF453PLK.js");
+  await registerImpactAction({
+    base: opts.base,
+    ...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) => {
+    const { registerImpactVerifyAction } = await import("./impact-AF453PLK.js");
+    await registerImpactVerifyAction(report, {
+      ...opts.headSha !== void 0 && { headSha: opts.headSha },
+      ...opts.json === true && { json: true }
+    });
+  }
+);
+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-GFI6RAEA.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-X5FUBTY3.js");
+  await registerWorkspaceCheckAction({
+    ...opts.json === true && { json: true }
+  });
+});
+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-UFZRZX6S.js");
+  await registerPrCheckAction({ 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(
+  async (opts) => {
+    const { registerPrReportAction } = await import("./pr-UFZRZX6S.js");
+    await registerPrReportAction(opts);
+  }
+);
+program.command("build").description("Run the build task").option("-c, --concurrency <n>", "max tasks per DAG level").option(
+  "--affected",
+  "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-2LO7GD2S.js");
+    const concurrency = parseConcurrency(opts);
+    await registerBuildAction({
+      ...concurrency !== void 0 && { concurrency },
+      ...opts.affected && { affected: true },
+      ...opts.dryRun && { dryRun: true }
+    });
+  }
+);
+program.command("run <task>").description("Run a named task").option(
+  "-c, --concurrency <n>",
+  "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-6PNH4QRA.js");
+    const concurrency = parseConcurrency(opts);
+    await registerRunAction(taskName, {
+      ...concurrency !== void 0 && { concurrency },
+      ...opts.dryRun && { dryRun: true }
+    });
+  }
+);
+program.command("init").description("Scaffold variant.config.ts in the current directory").action(async () => {
+  const { registerInitAction } = await import("./init-KJIUNGAN.js");
+  await registerInitAction();
+});
+program.command("doctor").description("Validate config and diagnose common issues").action(async () => {
+  const { registerDoctorAction } = await import("./doctor-GH4RZVEH.js");
+  await registerDoctorAction();
+});
+program.command("insight").description("Show task timing and cache hit stats").action(async () => {
+  const { registerInsightAction } = await import("./insight-DZ5NQY6D.js");
+  await registerInsightAction();
+});
+program.command("env").description(
+  "Show detected environment (runtime, package manager, framework)"
+).action(async () => {
+  const { registerEnvAction } = await import("./env-QORDD6FQ.js");
+  await registerEnvAction();
+});
+program.command("check").description("Validate config and task graph (no execution)").action(async () => {
+  const { registerCheckAction } = await import("./check-ZTKGGF4M.js");
+  await registerCheckAction();
+});
+program.parseAsync(process.argv).catch((err) => {
+  if (err instanceof VariantError) {
+    renderError(err);
+    process.exit(1);
+  }
+  renderUnexpectedError(err);
+  process.exit(2);
+});

package/dist/diff-GFI6RAEA.js

@@ -0,0 +1,60 @@
+import {
+  DEFAULT_DIFF_BASE_REF,
+  classifyFileAgainstRef,
+  toWorkspaceRelative
+} from "./chunk-NSNZOH5P.js";
+import "./chunk-LJDDS4RR.js";
+import "./chunk-XUBWCTJZ.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+import "./chunk-O4LZKXNZ.js";
+
+// src/cli/render/diff.ts
+var CLASS_MEANING = {
+  "non-impacting": "safe to skip build",
+  internal: "implementation-only change",
+  breaking: "exported API changed"
+};
+function renderClassification(result, baseRef, printer = getPrinter()) {
+  const meaning = `${result.classification.padEnd(15)}(${CLASS_MEANING[result.classification]})`;
+  lines(
+    printer,
+    "",
+    `File:           ${result.filePath}`,
+    `Base ref:       ${baseRef}`,
+    `Classification: ${meaning}`,
+    `Confidence:     ${Math.round(result.confidence * 100)}%`
+  );
+  const { added, removed, changed } = result.exportedSymbols;
+  if (added.length > 0 || removed.length > 0 || changed.length > 0) {
+    lines(printer, "", "Exported symbol changes:");
+    if (added.length > 0) lines(printer, `  added:   ${added.join(", ")}`);
+    if (removed.length > 0) lines(printer, `  removed: ${removed.join(", ")}`);
+    if (changed.length > 0) {
+      const detail = changed.map((c) => `${c.name} [${c.kind}]`).join(", ");
+      lines(printer, `  changed: ${detail}`);
+    }
+  }
+  if (result.confidenceNotes.length > 0) {
+    lines(printer, "", "Confidence lowered by:");
+    for (const note of result.confidenceNotes) lines(printer, `  - ${note}`);
+  }
+}
+
+// src/cli/commands/diff.ts
+async function registerDiffAction(filePath, opts = {}) {
+  const cwd = process.cwd();
+  const baseRef = opts.base ?? DEFAULT_DIFF_BASE_REF;
+  const relPath = toWorkspaceRelative(cwd, filePath);
+  renderClassification(
+    await classifyFileAgainstRef(cwd, relPath, baseRef),
+    baseRef
+  );
+}
+export {
+  registerDiffAction
+};