@blzsky/variant 0.2.1 → 0.3.0-canary.0

package/dist/{chunk-FZEXZBXB.js → chunk-MAK3HG46.js}

@@ -1,13 +1,13 @@
 import {
   resolveCommit
-} from "./chunk-6BXSZPHC.js";
+} from "./chunk-RSIOYQOQ.js";
 import {
   collectExportedSurface,
   significantText
-} from "./chunk-RC23JQKI.js";
+} from "./chunk-DSQDMFQ6.js";
 import {
   GitRefError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-ACTY42RE.js";
 
 // src/core/vcs/base-ref.ts
 async function assertBaseRef(cwd, ref) {
@@ -25,18 +25,22 @@ function createClassifier() {
       const tsm2 = await import("ts-morph");
       return {
         tsm: tsm2,
-        project: new tsm2.Project({ useInMemoryFileSystem: true })
+        project: new tsm2.Project({
+          useInMemoryFileSystem: true,
+          compilerOptions: { allowJs: true }
+        })
       };
     })();
     const { tsm, project } = await host;
     const id = nextId++;
+    const ext = sourceExtension(input.filePath);
     const beforeFile = project.createSourceFile(
-      `__before_${id}.ts`,
+      `__before_${id}${ext}`,
       input.before,
       { overwrite: true }
     );
     const afterFile = project.createSourceFile(
-      `__after_${id}.ts`,
+      `__after_${id}${ext}`,
       input.after,
       { overwrite: true }
     );
@@ -76,15 +80,23 @@ function compareSurfaces(input, beforeFile, afterFile, tsm) {
     if (!afterApi.symbols.has(name)) removed.push(name);
   }
   const surfaceChanged = added.length > 0 || removed.length > 0 || changed.some((c) => c.kind !== "body");
+  const parseNotes = [
+    ...hasParseErrors(beforeFile) ? ["base"] : [],
+    ...hasParseErrors(afterFile) ? ["working-tree"] : []
+  ].map(
+    (side) => `the ${side} version does not parse; classified as breaking without trusting the comparison`
+  );
   let classification;
-  if (surfaceChanged) {
+  if (surfaceChanged || parseNotes.length > 0) {
     classification = "breaking";
   } else if (changed.length > 0 || significantText(input.before, tsm) !== significantText(input.after, tsm)) {
     classification = "internal";
   } else {
     classification = "non-impacting";
   }
-  const confidenceNotes = [.../* @__PURE__ */ new Set([...beforeApi.notes, ...afterApi.notes])];
+  const confidenceNotes = [
+    .../* @__PURE__ */ new Set([...parseNotes, ...beforeApi.notes, ...afterApi.notes])
+  ];
   const confidence = Math.max(
     0.3,
     Math.round((1 - confidenceNotes.length * 0.15) * 100) / 100
@@ -94,9 +106,29 @@ function compareSurfaces(input, beforeFile, afterFile, tsm) {
     classification,
     exportedSymbols: { added, removed, changed },
     confidence,
-    confidenceNotes
+    confidenceNotes,
+    syntaxErrors: parseNotes.length > 0
   };
 }
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+function sourceExtension(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  const ext = dot === -1 ? "" : filePath.slice(dot);
+  return SOURCE_EXTENSIONS.has(ext) ? ext : ".ts";
+}
+function hasParseErrors(file) {
+  const { parseDiagnostics } = file.compilerNode;
+  return (parseDiagnostics?.length ?? 0) > 0;
+}
 
 export {
   createClassifier,

package/dist/chunk-MT4BOAAV.js

@@ -0,0 +1,167 @@
+import {
+  appendReconciliation,
+  defaultHistoryDir,
+  readImpactPredictions
+} from "./chunk-H5C4SE73.js";
+import {
+  ImpactReportError
+} from "./chunk-ACTY42RE.js";
+
+// src/core/impact/verify.ts
+import { realpathSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+function realpathOrSelf(target) {
+  try {
+    return realpathSync.native(target);
+  } catch {
+    return target;
+  }
+}
+function escapes(relative) {
+  return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
+}
+function toRelativePosix(cwd, testPath, realpath) {
+  let relative = testPath;
+  if (path.isAbsolute(testPath)) {
+    relative = path.relative(cwd, testPath);
+    if (escapes(relative)) {
+      relative = path.relative(realpath(cwd), realpath(testPath));
+    }
+  }
+  return relative.replace(/\\/g, "/");
+}
+function parseTestRun(cwd, raw, realpath = realpathOrSelf) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new ImpactReportError("it is not valid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new ImpactReportError("it is not a JSON object");
+  }
+  const results = parsed.testResults;
+  if (!Array.isArray(results)) {
+    throw new ImpactReportError("it has no `testResults` array");
+  }
+  const ran = /* @__PURE__ */ new Set();
+  const failed = /* @__PURE__ */ new Set();
+  for (const entry of results) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { name, status } = entry;
+    if (typeof name !== "string") continue;
+    const file = toRelativePosix(cwd, name, realpath);
+    ran.add(file);
+    if (status === "failed") failed.add(file);
+  }
+  return { ran: [...ran].sort(), failed: [...failed].sort() };
+}
+function testRunFrom(cwd, results, realpath = realpathOrSelf) {
+  const ran = /* @__PURE__ */ new Set();
+  const failed = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    const file = toRelativePosix(cwd, result.file, realpath);
+    ran.add(file);
+    if (result.failed) failed.add(file);
+  }
+  return { ran: [...ran].sort(), failed: [...failed].sort() };
+}
+function reconcile(prediction, failedTests) {
+  const selected = new Set(prediction.affectedTests);
+  const caught = [];
+  const falseSkips = [];
+  for (const test of failedTests) {
+    if (prediction.selectAll || selected.has(test)) caught.push(test);
+    else falseSkips.push(test);
+  }
+  return {
+    caught,
+    falseSkips,
+    falseSkipRate: failedTests.length === 0 ? 0 : falseSkips.length / failedTests.length
+  };
+}
+function selectPrediction(predictions, headSha) {
+  if (headSha !== void 0) {
+    for (let i = predictions.length - 1; i >= 0; i--) {
+      const candidate = predictions[i];
+      if (candidate?.headSha === headSha) {
+        return { prediction: candidate, matchedBy: "head-sha" };
+      }
+    }
+    return null;
+  }
+  const latest = predictions[predictions.length - 1];
+  return latest === void 0 ? null : { prediction: latest, matchedBy: "most-recent" };
+}
+async function readReport(cwd, reportPath) {
+  try {
+    return await readFile(path.resolve(cwd, reportPath), "utf8");
+  } catch (error) {
+    const code = error instanceof Error && "code" in error ? String(error.code) : "";
+    throw new ImpactReportError(
+      code === "ENOENT" ? `no file at ${reportPath}` : `${reportPath} could not be read${code === "" ? "" : ` (${code})`}`
+    );
+  }
+}
+async function verifyImpact(cwd, reportPaths, options = {}) {
+  const paths = typeof reportPaths === "string" ? [reportPaths] : reportPaths;
+  return verifyRun(
+    cwd,
+    async () => {
+      const reports = await Promise.all(
+        paths.map((reportPath) => readReport(cwd, reportPath))
+      );
+      return reports.map((raw) => parseTestRun(cwd, raw));
+    },
+    options
+  );
+}
+async function verifyRun(cwd, runs, options = {}) {
+  const historyDir = defaultHistoryDir(cwd);
+  const predictions = options.predictions ?? await readImpactPredictions(historyDir);
+  const match = selectPrediction(predictions, options.headSha);
+  if (match === null) return null;
+  const resolved = typeof runs === "function" ? await runs() : Array.isArray(runs) ? runs : [runs];
+  const failedTests = [
+    ...new Set(resolved.flatMap((run) => run.failed))
+  ].sort();
+  const ran = new Set(resolved.flatMap((run) => run.ran));
+  const selected = new Set(match.prediction.affectedTests);
+  const predictedRan = match.prediction.selectAll ? ran.size : [...ran].filter((test) => selected.has(test)).length;
+  const { caught, falseSkips, falseSkipRate } = reconcile(
+    match.prediction,
+    failedTests
+  );
+  const historyLogged = options.log === false ? true : await appendReconciliation(historyDir, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    headSha: match.prediction.headSha,
+    baseRef: match.prediction.baseRef,
+    predictedTests: match.prediction.affectedTests.length,
+    totalTests: match.prediction.totalTests,
+    failedTests: failedTests.length,
+    caught: caught.length,
+    falseSkips: falseSkips.length,
+    confidence: match.prediction.confidence,
+    selectAll: match.prediction.selectAll,
+    ranTests: ran.size,
+    predictedRan
+  });
+  return {
+    prediction: match.prediction,
+    matchedBy: match.matchedBy,
+    failedTests,
+    caught,
+    falseSkips,
+    falseSkipRate,
+    ranTests: ran.size,
+    predictedRan,
+    historyLogged
+  };
+}
+
+export {
+  testRunFrom,
+  verifyImpact,
+  verifyRun
+};

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

@@ -1,24 +1,52 @@
 import {
   collectExportedSurface
-} from "./chunk-RC23JQKI.js";
+} from "./chunk-DSQDMFQ6.js";
 import {
   GraphError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-ACTY42RE.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 = 5;
 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-W6N3WMYQ.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/{chunk-26DHEXGS.js → chunk-RJBFCURK.js}

@@ -1,6 +1,6 @@
 import {
   ConfigError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-ACTY42RE.js";
 
 // src/core/config/loader.ts
 import { existsSync } from "fs";

package/dist/{chunk-6BXSZPHC.js → chunk-RSIOYQOQ.js}

@@ -1,4 +1,5 @@
 // src/core/vcs/git.ts
+import path from "path";
 function toPosix(relPath) {
   return relPath.replace(/\\/g, "/");
 }
@@ -16,11 +17,26 @@ function isOptionLike(ref) {
 }
 function toFileList(stdout) {
   if (stdout === null) return null;
-  return stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  return stdout.split("\0").filter((file) => file.length > 0);
+}
+async function listDiff(cwd, range) {
+  const [stdout, prefix] = await Promise.all([
+    git(cwd, ["diff", "--name-only", "-z", "--no-renames", range, "--"]),
+    git(cwd, ["rev-parse", "--show-prefix"])
+  ]);
+  const files = toFileList(stdout);
+  const cwdFromRoot = prefix?.trim() ?? "";
+  if (files === null || cwdFromRoot === "") return files;
+  return files.map(
+    (file) => path.posix.relative(`/${cwdFromRoot}`, `/${file}`)
+  );
+}
+function blobAt(ref, relPath) {
+  return `${ref}:./${toPosix(relPath)}`;
 }
 async function readFileAtRef(cwd, ref, relPath) {
   if (isOptionLike(ref)) return null;
-  return git(cwd, ["show", `${ref}:${toPosix(relPath)}`]);
+  return git(cwd, ["show", blobAt(ref, relPath)]);
 }
 var CAT_FILE_BATCH_SIZE = 256;
 async function readFilesAtRef(cwd, ref, relPaths) {
@@ -34,7 +50,7 @@ async function readFilesAtRef(cwd, ref, relPaths) {
     try {
       const result = await execa("git", ["cat-file", "--batch"], {
         cwd,
-        input: `${chunk.map((p) => `${ref}:${toPosix(p)}`).join("\n")}
+        input: `${chunk.map((p) => blobAt(ref, p)).join("\n")}
 `,
         encoding: "buffer",
         // The response framing is byte-exact; execa's default of
@@ -97,15 +113,54 @@ async function resolveCommit(cwd, ref) {
   const sha = stdout?.trim();
   return sha === void 0 || sha === "" ? null : sha;
 }
+async function listRepositoryFiles(cwd, patterns) {
+  return toFileList(
+    await git(cwd, [
+      "ls-files",
+      "-z",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "--",
+      ...patterns
+    ])
+  );
+}
 async function listChangedFiles(cwd, ref) {
   if (isOptionLike(ref)) return null;
-  return toFileList(await git(cwd, ["diff", "--name-only", ref, "--"]));
+  return listDiff(cwd, ref);
 }
 async function listChangedFilesSinceMergeBase(cwd, ref) {
   if (isOptionLike(ref)) return null;
-  return toFileList(
-    await git(cwd, ["diff", "--name-only", `${ref}...HEAD`, "--"])
-  );
+  return listDiff(cwd, `${ref}...HEAD`);
+}
+async function mergeBase(cwd, a, b) {
+  if (isOptionLike(a) || isOptionLike(b)) return null;
+  const sha = (await git(cwd, ["merge-base", a, b]))?.trim();
+  return sha === void 0 || sha === "" ? null : sha;
+}
+var DEFAULT_BRANCH_GUESSES = [
+  "origin/main",
+  "origin/master",
+  "main",
+  "master"
+];
+async function defaultBranchRef(cwd) {
+  const head = (await git(cwd, [
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]))?.trim();
+  if (head !== void 0 && head !== "") return head;
+  for (const guess of DEFAULT_BRANCH_GUESSES) {
+    if (await resolveCommit(cwd, guess) !== null) return guess;
+  }
+  return null;
+}
+async function repositoryRoot(cwd) {
+  const top = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
+  return top === void 0 || top === "" ? null : top;
 }
 
 export {
@@ -113,6 +168,10 @@ export {
   readFilesAtRef,
   readHeadSha,
   resolveCommit,
+  listRepositoryFiles,
   listChangedFiles,
-  listChangedFilesSinceMergeBase
+  listChangedFilesSinceMergeBase,
+  mergeBase,
+  defaultBranchRef,
+  repositoryRoot
 };