bitfab 0.29.1 → 0.30.1

package/dist/index.cjs

@@ -329,6 +329,203 @@ var init_replayContext = __esm({
   }
 });
 
+// src/codeChange.ts
+async function resolveAutoCodeChange(label) {
+  if (typeof process === "undefined") {
+    return null;
+  }
+  if (process.env?.BITFAB_DISABLE_CODE_CHANGE_CAPTURE) {
+    return null;
+  }
+  const fromEnv = await readCodeChangeFile();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  return captureCodeChangeFromGit(process.cwd?.() ?? ".", label);
+}
+async function readCodeChangeFile() {
+  const path = process.env?.BITFAB_CODE_CHANGE_PATH;
+  if (!path) {
+    return null;
+  }
+  try {
+    const { readFile } = await import("fs/promises");
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    const files = Array.isArray(parsed?.files) && parsed.files.every(
+      (f) => typeof f === "object" && f !== null && !Array.isArray(f)
+    ) ? parsed.files : void 0;
+    const description = typeof parsed?.description === "string" ? parsed.description : void 0;
+    if (!files && description === void 0) {
+      return null;
+    }
+    return { description, files };
+  } catch {
+    return null;
+  }
+}
+async function captureCodeChangeFromGit(cwd, label) {
+  let execFile;
+  let readFile;
+  try {
+    ;
+    ({ execFile } = await import("child_process"));
+    ({ readFile } = await import("fs/promises"));
+  } catch {
+    return null;
+  }
+  const git = (dir, args) => new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      // 30s timeout so a hung git (e.g. a network-touching ref op) can't
+      // block the whole replay indefinitely.
+      { cwd: dir, maxBuffer: 64 * 1024 * 1024, timeout: 3e4 },
+      (err, stdout) => resolve(err ? null : stdout)
+    );
+  });
+  try {
+    const root = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
+    if (!root) {
+      return null;
+    }
+    const resolved = await resolveBase(git, root);
+    if (!resolved) {
+      return null;
+    }
+    const { base, fromTrunk } = resolved;
+    const blobBytes = async (ref, path) => {
+      const out = await git(root, ["cat-file", "-s", `${ref}:${path}`]);
+      const n = out ? Number.parseInt(out.trim(), 10) : Number.NaN;
+      return Number.isFinite(n) ? n : 0;
+    };
+    const workingBytes = async (path) => {
+      try {
+        const { stat } = await import("fs/promises");
+        const { join } = await import("path");
+        return (await stat(join(root, path))).size;
+      } catch {
+        return 0;
+      }
+    };
+    const tracked = await git(root, [
+      "diff",
+      "--name-status",
+      "--no-renames",
+      "-z",
+      base,
+      "--",
+      ":!.bitfab"
+    ]);
+    const untracked = await git(root, [
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "-z",
+      "--",
+      ":!.bitfab"
+    ]);
+    const entries = [
+      ...parseNameStatusZ(tracked ?? ""),
+      ...(untracked ?? "").split(NUL).filter((p) => p.length > 0).map((path) => ({ status: "A", path }))
+    ];
+    if (entries.length === 0) {
+      return null;
+    }
+    const files = [];
+    let totalBytes = 0;
+    for (const { status, path } of entries) {
+      if (files.length >= MAX_FILES) {
+        break;
+      }
+      const beforeBytes = status === "A" ? 0 : await blobBytes(base, path);
+      const afterBytes = status === "D" ? 0 : await workingBytes(path);
+      if (beforeBytes > MAX_FILE_BYTES || afterBytes > MAX_FILE_BYTES) {
+        continue;
+      }
+      const before = (status === "A" ? "" : await git(root, ["show", `${base}:${path}`]) ?? "").replace(/\r\n/g, "\n");
+      const after = (status === "D" ? "" : await readWorkingFile(readFile, root, path)).replace(/\r\n/g, "\n");
+      if (before === after) {
+        continue;
+      }
+      const size = Buffer.byteLength(before, "utf8") + Buffer.byteLength(after, "utf8");
+      if (totalBytes + size > MAX_TOTAL_BYTES || looksBinary(before) || looksBinary(after)) {
+        continue;
+      }
+      totalBytes += size;
+      files.push({ path, before, after });
+    }
+    if (files.length === 0) {
+      return null;
+    }
+    const subject = (await git(root, ["log", "-1", "--format=%s", "HEAD"]))?.trim();
+    const fileWord = files.length === 1 ? "file" : "files";
+    const head = label?.trim() || subject || "Working-tree change";
+    const against = fromTrunk ? "vs trunk" : "uncommitted (vs HEAD)";
+    return {
+      description: `${head} (${files.length} ${fileWord} changed ${against})`,
+      files
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveBase(git, root) {
+  const forced = process.env?.BITFAB_CODE_CHANGE_BASE;
+  if (forced && await refExists(git, root, forced)) {
+    const base = (await git(root, ["merge-base", "HEAD", forced]))?.trim() || (await git(root, ["rev-parse", "--verify", forced]))?.trim() || null;
+    return base ? { base, fromTrunk: true } : null;
+  }
+  for (const candidate of TRUNK_CANDIDATES) {
+    if (!await refExists(git, root, candidate)) {
+      continue;
+    }
+    const mb = (await git(root, ["merge-base", "HEAD", candidate]))?.trim();
+    if (mb) {
+      return { base: mb, fromTrunk: true };
+    }
+  }
+  return await refExists(git, root, "HEAD") ? { base: "HEAD", fromTrunk: false } : null;
+}
+async function refExists(git, root, ref) {
+  return await git(root, ["rev-parse", "--verify", `${ref}^{object}`]) !== null;
+}
+async function readWorkingFile(readFile, root, path) {
+  try {
+    const { join } = await import("path");
+    return await readFile(join(root, path), "utf8");
+  } catch {
+    return "";
+  }
+}
+function parseNameStatusZ(raw) {
+  const parts = raw.split(NUL).filter((p) => p.length > 0);
+  const out = [];
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    out.push({ status: parts[i].charAt(0), path: parts[i + 1] });
+  }
+  return out;
+}
+function looksBinary(s) {
+  return s.slice(0, 8e3).includes(NUL);
+}
+var MAX_FILES, MAX_FILE_BYTES, MAX_TOTAL_BYTES, TRUNK_CANDIDATES, NUL;
+var init_codeChange = __esm({
+  "src/codeChange.ts"() {
+    "use strict";
+    MAX_FILES = 60;
+    MAX_FILE_BYTES = 5e5;
+    MAX_TOTAL_BYTES = 2e6;
+    TRUNK_CANDIDATES = [
+      "origin/HEAD",
+      "origin/main",
+      "origin/master",
+      "main",
+      "master"
+    ];
+    NUL = String.fromCharCode(0);
+  }
+});
+
 // src/replay.ts
 var replay_exports = {};
 __export(replay_exports, {
@@ -553,6 +750,15 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     }
   }
   await replayContextReady;
+  let codeChangeDescription = options?.codeChangeDescription;
+  let codeChangeFiles = options?.codeChangeFiles;
+  if (codeChangeDescription === void 0 && codeChangeFiles === void 0) {
+    const captured = await resolveAutoCodeChange(options?.name);
+    if (captured) {
+      codeChangeDescription = captured.description;
+      codeChangeFiles = captured.files;
+    }
+  }
   const {
     testRunId,
     testRunUrl,
@@ -564,12 +770,13 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     options?.traceIds ? void 0 : options?.limit ?? 5,
     options?.traceIds,
     options?.name,
-    options?.codeChangeDescription,
-    options?.codeChangeFiles,
+    codeChangeDescription,
+    codeChangeFiles,
     options?.environment !== void 0,
     // includeDbBranchLease
     options?.experimentGroupId,
-    options?.datasetId
+    options?.datasetId,
+    options?.graderIds
   );
   const mockStrategy = options?.mock ?? "marked";
   const maxConcurrency = options?.maxConcurrency ?? 10;
@@ -720,6 +927,7 @@ var BITFAB_PROGRESS_PREFIX;
 var init_replay = __esm({
   "src/replay.ts"() {
     "use strict";
+    init_codeChange();
     init_errors();
     init_mockOverride();
     init_randomUuid();
@@ -755,7 +963,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.generated.ts
-var __version__ = "0.29.1";
+var __version__ = "0.30.1";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -1114,7 +1322,7 @@ var HttpClient = class {
    * Start a replay session by fetching historical traces.
    * Blocking call - creates a test run and returns lightweight item references.
    */
-  async startReplay(traceFunctionKey, limit, traceIds, name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId, datasetId) {
+  async startReplay(traceFunctionKey, limit, traceIds, name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId, datasetId, graderIds) {
     const payload = { traceFunctionKey };
     if (limit !== void 0) {
       payload.limit = limit;
@@ -1140,6 +1348,9 @@ var HttpClient = class {
     if (datasetId !== void 0) {
       payload.datasetId = datasetId;
     }
+    if (graderIds !== void 0) {
+      payload.graderIds = graderIds;
+    }
     const timeout = includeDbBranchLease ? 18e4 : 3e4;
     return this.request("/api/sdk/replay/start", payload, {
       timeout