jules-orchestrator-kit 0.72.2 → 0.73.0

package/src/git.mjs

@@ -392,8 +392,40 @@ export function resolveBase(root = process.cwd(), baseRef = "main") {
   );
 }
 
+export function getHeadCommit(root = process.cwd()) {
+  try {
+    const res = execFileSync("git", ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], {
+      cwd: root,
+      encoding: "utf-8",
+      shell: false,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    return res && res.trim() ? res.trim() : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+export function getHeadParent(root = process.cwd()) {
+  try {
+    const res = execFileSync("git", ["rev-parse", "--verify", "--quiet", "HEAD~1^{commit}"], {
+      cwd: root,
+      encoding: "utf-8",
+      shell: false,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    return res && res.trim() ? res.trim() : null;
+  } catch (_) {
+    return null;
+  }
+}
+
 export function changedFiles(root = process.cwd(), base = "main", mode = "committed") {
   const resolvedRef = resolveBase(root, base);
+  const headCommit = getHeadCommit(root);
+  const isHeadRef = typeof base === "string" && (base === "HEAD" || base.startsWith("HEAD~") || base.startsWith("HEAD^") || base.startsWith("HEAD@"));
+  const isBaseAtHead = Boolean(!isHeadRef && headCommit && resolvedRef === headCommit);
+
   if (mode === "working-tree" || mode === "working") {
     const committedRaw = git(["-c", "core.quotePath=false", "diff", "-z", "--name-only", `${resolvedRef}...HEAD`], { cwd: root, raw: true, ignoreError: true }) || "";
     const uncommittedRaw = git(["-c", "core.quotePath=false", "diff", "-z", "--name-only", "HEAD"], { cwd: root, raw: true, ignoreError: true }) || "";
@@ -409,6 +441,16 @@ export function changedFiles(root = process.cwd(), base = "main", mode = "commit
     const raw = git(["-c", "core.quotePath=false", "diff", "-z", "--name-only", "--cached", resolvedRef], { cwd: root, raw: true });
     return raw.split("\0").map(normalizePath).filter(Boolean);
   } else {
+    if (isBaseAtHead) {
+      const headParent = getHeadParent(root);
+      if (headParent) {
+        const raw = git(["-c", "core.quotePath=false", "diff", "-z", "--name-only", `${headParent}...HEAD`], { cwd: root, raw: true });
+        return raw.split("\0").map(normalizePath).filter(Boolean);
+      } else {
+        const raw = git(["-c", "core.quotePath=false", "diff-tree", "--root", "--no-commit-id", "-r", "-z", "--name-only", headCommit], { cwd: root, raw: true });
+        return raw.split("\0").map(normalizePath).filter(Boolean);
+      }
+    }
     const raw = git(["-c", "core.quotePath=false", "diff", "-z", "--name-only", `${resolvedRef}...HEAD`], { cwd: root, raw: true });
     return raw.split("\0").map(normalizePath).filter(Boolean);
   }
@@ -416,6 +458,10 @@ export function changedFiles(root = process.cwd(), base = "main", mode = "commit
 
 export function diffText(root = process.cwd(), base = "main", mode = "committed") {
   const resolvedRef = resolveBase(root, base);
+  const headCommit = getHeadCommit(root);
+  const isHeadRef = typeof base === "string" && (base === "HEAD" || base.startsWith("HEAD~") || base.startsWith("HEAD^") || base.startsWith("HEAD@"));
+  const isBaseAtHead = Boolean(!isHeadRef && headCommit && resolvedRef === headCommit);
+
   if (mode === "working-tree" || mode === "working") {
     const committed = git(["diff", `${resolvedRef}...HEAD`], { cwd: root, raw: true, ignoreError: true }) || "";
     const uncommitted = git(["diff", "HEAD"], { cwd: root, raw: true, ignoreError: true }) || "";
@@ -465,6 +511,15 @@ export function diffText(root = process.cwd(), base = "main", mode = "committed"
   } else if (mode === "staged" || mode === "index") {
     return git(["diff", "--cached", resolvedRef], { cwd: root, raw: true });
   }
+
+  if (isBaseAtHead) {
+    const headParent = getHeadParent(root);
+    if (headParent) {
+      return git(["diff", `${headParent}...HEAD`], { cwd: root, raw: true });
+    } else {
+      return git(["diff-tree", "-p", "--no-commit-id", "--root", headCommit], { cwd: root, raw: true });
+    }
+  }
   return git(["diff", `${resolvedRef}...HEAD`], { cwd: root, raw: true });
 }
 
@@ -486,38 +541,72 @@ export function diffText(root = process.cwd(), base = "main", mode = "committed"
  * @param {string} mode
  * @returns {Array<{ file: string, bytes: number }>}
  */
+function parseRawDiffOutput(raw, out) {
+  // `--raw -z` emits ":<srcmode> <dstmode> <srcsha> <dstsha> <status>\0<path>\0".
+  const fields = raw.split("\0").filter(Boolean);
+  for (let i = 0; i < fields.length; i++) {
+    const meta = fields[i];
+    if (!meta.startsWith(":")) continue;
+    const parts = meta.slice(1).split(/\s+/);
+    const file = fields[i + 1];
+    i += 1;
+    if (!file) continue;
+    out.push({
+      file,
+      srcMode: parts[0] || "",
+      dstMode: parts[1] || "",
+      srcSha: parts[2] || "",
+      dstSha: parts[3] || "",
+      status: (parts[4] || "").charAt(0),
+    });
+  }
+}
+
 export function parseRawDiff(root = process.cwd(), base = "main", mode = "committed") {
   const resolvedRef = resolveBase(root, base);
-  const ranges =
-    mode === "working-tree" || mode === "working"
-      ? [[`${resolvedRef}...HEAD`], ["HEAD"]]
-      : [[`${resolvedRef}...HEAD`]];
+  const headCommit = getHeadCommit(root);
+  const isHeadRef = typeof base === "string" && (base === "HEAD" || base.startsWith("HEAD~") || base.startsWith("HEAD^") || base.startsWith("HEAD@"));
+  const isBaseAtHead = Boolean(!isHeadRef && headCommit && resolvedRef === headCommit);
 
   const out = [];
-  for (const range of ranges) {
+  if (mode === "working-tree" || mode === "working") {
+    for (const range of [[`${resolvedRef}...HEAD`], ["HEAD"]]) {
+      let raw = "";
+      try {
+        raw = git(["diff", "--raw", "--no-renames", "-z", ...range], { cwd: root, raw: true, ignoreError: true }) || "";
+      } catch (_) {
+        continue;
+      }
+      parseRawDiffOutput(raw, out);
+    }
+  } else if (mode === "staged" || mode === "index") {
     let raw = "";
     try {
-      raw = git(["diff", "--raw", "--no-renames", "-z", ...range], { cwd: root, raw: true, ignoreError: true }) || "";
-    } catch (_) {
-      continue;
-    }
-    // `--raw -z` emits ":<srcmode> <dstmode> <srcsha> <dstsha> <status>\0<path>\0".
-    const fields = raw.split("\0").filter(Boolean);
-    for (let i = 0; i < fields.length; i++) {
-      const meta = fields[i];
-      if (!meta.startsWith(":")) continue;
-      const parts = meta.slice(1).split(/\s+/);
-      const file = fields[i + 1];
-      i += 1;
-      if (!file) continue;
-      out.push({
-        file,
-        srcMode: parts[0] || "",
-        dstMode: parts[1] || "",
-        srcSha: parts[2] || "",
-        dstSha: parts[3] || "",
-        status: (parts[4] || "").charAt(0),
-      });
+      raw = git(["diff", "--raw", "--no-renames", "-z", "--cached", resolvedRef], { cwd: root, raw: true, ignoreError: true }) || "";
+    } catch (_) {}
+    parseRawDiffOutput(raw, out);
+  } else {
+    if (isBaseAtHead) {
+      const headParent = getHeadParent(root);
+      if (headParent) {
+        let raw = "";
+        try {
+          raw = git(["diff", "--raw", "--no-renames", "-z", `${headParent}...HEAD`], { cwd: root, raw: true, ignoreError: true }) || "";
+        } catch (_) {}
+        parseRawDiffOutput(raw, out);
+      } else {
+        let raw = "";
+        try {
+          raw = git(["diff-tree", "--root", "--no-commit-id", "-r", "--raw", "--no-renames", "-z", headCommit], { cwd: root, raw: true, ignoreError: true }) || "";
+        } catch (_) {}
+        parseRawDiffOutput(raw, out);
+      }
+    } else {
+      let raw = "";
+      try {
+        raw = git(["diff", "--raw", "--no-renames", "-z", `${resolvedRef}...HEAD`], { cwd: root, raw: true, ignoreError: true }) || "";
+      } catch (_) {}
+      parseRawDiffOutput(raw, out);
     }
   }
   return out;
@@ -878,6 +967,79 @@ export function partitionTracked(root = process.cwd(), files = []) {
   };
 }
 
+// Root-level package-manager manifests a just-run `npm install` (or equivalent)
+// writes while onboarding a cold-start repository. `npm init -y` creates a
+// brand-new package.json; `npm install` adds/updates the lockfile. The scope
+// rules legitimately `protect` these — but a tool's *own* install step must not
+// brick the first interaction a newcomer has with it. The two helpers below
+// give callers a way to tell "fresh onboarding artifact" (untracked) apart from
+// "a dependency change the maintainer actually shipped" (tracked+modified), so
+// the gate keeps its teeth while task creation and the init commit hint stop
+// tripping over scaffolding the installer just laid down.
+const ONBOARDING_ROOT_ARTIFACTS = [
+  "package.json",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lock",
+  "bun.lockb",
+];
+
+/**
+ * Among the given repo-relative paths, which are *untracked* root-level
+ * package-manager artifacts — i.e. manifests a fresh `npm init -y`/install just
+ * created rather than files the maintainer committed and an agent then rewrote?
+ *
+ * The scope rules flag a brand-new package.json as `protect`, which is the
+ * right call for the gate. But a task-create preflight that rejects a brand-new
+ * repository because its own onboarding just produced package.json is a cold
+ * start deadlock: the user has not committed anything yet, so they cannot make
+ * the preflight pass without guessing the secret incantation. Modified
+ * *tracked* lockfiles are deliberately NOT returned here — those stay protected
+ * as supply-chain tampering.
+ *
+ * @param {string} root
+ * @param {string[]} files repo-relative paths (as reported by a scope phase)
+ * @returns {string[]}
+ */
+export function untrackedOnboardingArtifacts(root = process.cwd(), files = []) {
+  const { untracked } = partitionTracked(root, files);
+  if (untracked.length === 0) return [];
+  return untracked.filter((f) => ONBOARDING_ROOT_ARTIFACTS.includes(f));
+}
+
+/**
+ * Root-level package-manager artifacts a `git add` in this repo would actually
+ * stage *right now* — present on disk and not gitignored — for a commit hint.
+ *
+ * A cold-start repo has these as brand-new untracked files; an existing repo
+ * that just ran `npm install -D` may have a modified (tracked) package.json
+ * plus a new lockfile. Gitignored lockfiles (a repo that chooses not to track
+ * them) are excluded, so the suggested `git add …` never errors on a path git
+ * refuses to add.
+ *
+ * @param {string} root
+ * @returns {string[]}
+ */
+export function addableOnboardingArtifacts(root = process.cwd()) {
+  let porcelain = "";
+  try {
+    // `--untracked-files=all` so a lone new file appears verbatim, not as a
+    // collapsed `dir/` entry that would not match a root manifest name.
+    porcelain = git(["status", "--porcelain", "--untracked-files=all"], { cwd: root, ignoreError: true }) || "";
+  } catch (_) {
+    return [];
+  }
+  const changed = new Set();
+  for (const line of porcelain.split("\n")) {
+    // Porcelain v1: two status chars, one space, then the path.
+    const path = line.length > 3 ? line.slice(3) : "";
+    if (path && !path.startsWith('"')) changed.add(path);
+  }
+  return ONBOARDING_ROOT_ARTIFACTS.filter((a) => changed.has(a) && existsSync(join(root, a)));
+}
+
 export function detectDefaultBranch(root = process.cwd()) {
   // `git()` returns trimmed stdout, and "" for a non-zero exit under
   // ignoreError — there is no status field to read.
@@ -896,7 +1058,12 @@ export function detectDefaultBranch(root = process.cwd()) {
   }
 
   for (const candidate of ["main", "master"]) {
-    if (ask(["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`])) return candidate;
+    if (
+      ask(["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`]) ||
+      ask(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${candidate}`])
+    ) {
+      return candidate;
+    }
   }
 
   const current = ask(["branch", "--show-current"]);
@@ -914,3 +1081,107 @@ export function resolveGitRemoteOrigin(root = process.cwd()) {
   }
 }
 
+/**
+ * Default globs for generated, bundled, and lockfile paths that exhaust the diff budget.
+ */
+export const DEFAULT_GENERATED_GLOBS = [
+  "dist/**",
+  "**/dist/**",
+  "**/*.map",
+  "**/*-lock.yaml",
+  "**/*-lock.json",
+  "**/package-lock.json",
+  "**/pnpm-lock.yaml",
+  "**/yarn.lock",
+  "**/Cargo.lock",
+  "**/generated/**",
+];
+
+const REGEXP_SPECIAL = ".+?^${}()|[]\\";
+
+/**
+ * Convert a glob with * and ** into an anchored RegExp.
+ * @param {string} glob
+ * @returns {RegExp}
+ */
+export function globToRegExp(glob = "") {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          re += "(?:.*/)?";
+          i += 2;
+        } else {
+          re += ".*";
+          i += 1;
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (REGEXP_SPECIAL.includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp("^" + re + "$");
+}
+
+/**
+ * Filter out per-file sections whose target path matches any ignore glob from a unified git diff.
+ * Returns the filtered diff text and the array of excluded file paths.
+ * If filtering would remove all file sections, the original diff is preserved.
+ *
+ * @param {string} diff - Unified git diff
+ * @param {string[]} [ignoreGlobs=DEFAULT_GENERATED_GLOBS] - List of glob patterns
+ * @returns {{ diff: string, excludedPaths: string[] }}
+ */
+export function filterDiffByPaths(diff = "", ignoreGlobs = DEFAULT_GENERATED_GLOBS) {
+  if (!diff || typeof diff !== "string" || !ignoreGlobs || ignoreGlobs.length === 0) {
+    return { diff: diff || "", excludedPaths: [] };
+  }
+
+  const matchers = ignoreGlobs.map(globToRegExp);
+  const sections = diff.split(/(?=^diff --git )/m);
+  const kept = [];
+  const excludedPaths = [];
+  let fileSectionsCount = 0;
+
+  for (const section of sections) {
+    if (!section.startsWith("diff --git ")) {
+      if (section.length > 0) kept.push(section);
+      continue;
+    }
+
+    fileSectionsCount++;
+    const match = section.match(/^diff --git a\/.*? b\/(.+)$/m);
+    let path = match ? match[1].trim() : undefined;
+    if (path) {
+      path = path.replace(/^["']|["']$/g, "");
+    }
+
+    if (path && matchers.some((re) => re.test(path))) {
+      excludedPaths.push(path);
+      continue;
+    }
+    kept.push(section);
+  }
+
+  if (fileSectionsCount > 0 && excludedPaths.length === fileSectionsCount) {
+    return { diff, excludedPaths: [] };
+  }
+
+  return { diff: kept.join(""), excludedPaths };
+}
+
+/**
+ * Compute byte length of diff after pruning generated files and lockfiles.
+ */
+export function prunedDiffBytes(root = process.cwd(), base = "main", mode = "committed", ignoreGlobs = DEFAULT_GENERATED_GLOBS) {
+  const text = diffText(root, base, mode);
+  const filtered = filterDiffByPaths(text, ignoreGlobs);
+  return Buffer.byteLength(filtered.diff, "utf-8");
+}
+