@askexenow/exe-os 0.9.371 → 0.9.372

package/dist/{branch-hygiene-HFJ3HA62.js → branch-hygiene-KCGXRAWP.js}

@@ -1,3 +1,8 @@
+import {
+  getRemoteDefaultBranch,
+  ghPrStateLookup,
+  listRemoteHeads
+} from "./chunk-SI5SZAJA.js";
 import {
   EXE_AI_DIR
 } from "./chunk-QMSEL5YS.js";
@@ -16,6 +21,9 @@ var MAX_BRANCHES_SCANNED = 60;
 var DEFAULT_LISTING_CAP = 10;
 var SCAN_CONCURRENCY = 8;
 var DEFAULT_CACHE_MAX_AGE_MS = 90 * 60 * 1e3;
+function isAttention(c) {
+  return c === "closed_unmerged" || c === "never_proposed";
+}
 async function git(repoRoot, args) {
   const { stdout } = await execFileAsync("git", args, {
     cwd: repoRoot,
@@ -24,21 +32,6 @@ async function git(repoRoot, args) {
   });
   return stdout.trim();
 }
-async function detectRemoteBase(repoRoot) {
-  for (const candidate of ["main", "master"]) {
-    try {
-      await git(repoRoot, ["rev-parse", "--verify", `refs/remotes/origin/${candidate}`]);
-      return `origin/${candidate}`;
-    } catch {
-    }
-  }
-  return null;
-}
-function parseRefLine(line) {
-  const [name, committedAt] = line.split("");
-  if (!name) return null;
-  return { name: name.replace(/^origin\//, ""), committedAt: committedAt ?? "" };
-}
 async function mapPool(items, concurrency, fn) {
   const results = new Array(items.length);
   let next = 0;
@@ -53,74 +46,115 @@ async function mapPool(items, concurrency, fn) {
   await Promise.all(Array.from({ length: lanes }, () => worker()));
   return results;
 }
-async function scanUnmergedBranchesRaw(repoRoot) {
-  const emptyRaw = { branches: [], truncated: false };
-  let base;
-  try {
-    base = await detectRemoteBase(repoRoot);
-  } catch {
-    return emptyRaw;
+async function scanUnmergedBranchesRaw(repoRoot, prStateLookup = ghPrStateLookup) {
+  const emptyRaw = {
+    branches: [],
+    truncated: false,
+    remoteRead: false,
+    prStateAvailable: false
+  };
+  const heads = await listRemoteHeads(repoRoot);
+  if (!heads) return emptyRaw;
+  const remoteDefault = await getRemoteDefaultBranch(repoRoot);
+  let baseName = remoteDefault?.name;
+  if (!baseName) {
+    baseName = heads.find((h) => h.name === "main")?.name ?? heads.find((h) => h.name === "master")?.name;
   }
-  if (!base) return emptyRaw;
-  const baseRef = base;
-  let lines;
+  if (!baseName) return { ...emptyRaw, remoteRead: true };
+  const baseSha = heads.find((h) => h.name === baseName)?.sha ?? remoteDefault?.sha;
+  if (!baseSha) return { ...emptyRaw, remoteRead: true };
+  let baseLocal = false;
   try {
-    const raw = await git(repoRoot, [
-      "for-each-ref",
-      `--no-merged=${baseRef}`,
-      "--sort=-committerdate",
-      "--format=%(refname:short)%(committerdate:iso-strict)",
-      "refs/remotes/origin"
-    ]);
-    lines = raw ? raw.split("\n") : [];
+    await git(repoRoot, ["cat-file", "-e", `${baseSha}^{commit}`]);
+    baseLocal = true;
   } catch {
-    return emptyRaw;
+    baseLocal = false;
   }
-  const baseShort = baseRef.replace(/^origin\//, "");
   const candidates = [];
   let truncated = false;
-  for (const line of lines) {
-    const parsed = parseRefLine(line);
-    if (!parsed) continue;
-    if (parsed.name === baseShort || parsed.name === "HEAD") continue;
+  for (const h of heads) {
+    if (h.name === baseName || h.name === "HEAD") continue;
     if (candidates.length >= MAX_BRANCHES_SCANNED) {
       truncated = true;
       break;
     }
-    candidates.push(parsed);
+    candidates.push(h);
   }
-  const counted = await mapPool(candidates, SCAN_CONCURRENCY, async (c) => {
+  const measured = await mapPool(candidates, SCAN_CONCURRENCY, async (c) => {
     let ahead = 0;
+    let aheadUnknown = true;
+    let committedAt = "";
+    if (baseLocal) {
+      try {
+        const cnt = await git(repoRoot, ["rev-list", "--count", `${baseSha}..${c.sha}`]);
+        ahead = parseInt(cnt, 10) || 0;
+        aheadUnknown = false;
+      } catch {
+        aheadUnknown = true;
+      }
+    }
     try {
-      const cnt = await git(repoRoot, ["rev-list", "--count", `${baseRef}..origin/${c.name}`]);
-      ahead = parseInt(cnt, 10) || 0;
+      committedAt = await git(repoRoot, ["log", "-1", "--format=%cI", c.sha]);
     } catch {
-      ahead = 0;
+      committedAt = "";
     }
-    return { c, ahead };
+    return { c, ahead, aheadUnknown, committedAt };
   });
+  const kept = measured.filter((m) => m.aheadUnknown || m.ahead > 0);
+  const prMap = await prStateLookup(repoRoot, kept.map((m) => m.c.name));
+  const prStateAvailable = prMap !== null;
   const now = Date.now();
-  const out = [];
-  for (const { c, ahead } of counted) {
-    if (ahead <= 0) continue;
-    const committedMs = c.committedAt ? Date.parse(c.committedAt) : NaN;
+  const out = kept.map((m) => {
+    const committedMs = m.committedAt ? Date.parse(m.committedAt) : NaN;
     const ageHours = Number.isFinite(committedMs) ? Math.max(0, (now - committedMs) / 36e5) : 0;
-    out.push({ name: c.name, ahead, committedAt: c.committedAt, ageHours, filesChanged: 0 });
-  }
-  return { branches: out, truncated };
+    const pr = prMap?.get(m.c.name);
+    return {
+      name: m.c.name,
+      ahead: m.ahead,
+      aheadUnknown: m.aheadUnknown,
+      committedAt: m.committedAt,
+      ageHours,
+      // filesChanged retained in the shape (cosmetic) but no longer computed — 0.
+      filesChanged: 0,
+      classification: pr?.state ?? "unknown",
+      prNumber: pr?.number ?? null
+    };
+  });
+  out.sort((a, b) => (Date.parse(b.committedAt) || 0) - (Date.parse(a.committedAt) || 0));
+  return { branches: out, truncated, remoteRead: true, prStateAvailable };
 }
-function finalizeScan(rawBranches, truncated, staleHours, listingCap, now = Date.now()) {
-  const refreshed = rawBranches.map((b) => {
+function finalizeScan(raw, staleHours, listingCap, include, now = Date.now()) {
+  const refreshed = raw.branches.map((b) => {
     const ms = b.committedAt ? Date.parse(b.committedAt) : NaN;
     const ageHours = Number.isFinite(ms) ? Math.max(0, (now - ms) / 36e5) : b.ageHours;
     return { ...b, ageHours };
   });
-  const staleCount = refreshed.filter((b) => b.ageHours >= staleHours).length;
+  const selected = include ? refreshed.filter((b) => include.includes(b.classification)) : refreshed.filter((b) => isAttention(b.classification));
+  return {
+    branches: selected.slice(0, listingCap),
+    total: selected.length,
+    staleCount: selected.filter((b) => b.ageHours >= staleHours).length,
+    truncated: raw.truncated,
+    liveTotal: refreshed.length,
+    mergedCount: refreshed.filter((b) => b.classification === "merged").length,
+    openCount: refreshed.filter((b) => b.classification === "open").length,
+    unknownCount: refreshed.filter((b) => b.classification === "unknown").length,
+    remoteRead: raw.remoteRead,
+    prStateAvailable: raw.prStateAvailable
+  };
+}
+function unknownScanResult() {
   return {
-    branches: refreshed.slice(0, listingCap),
-    total: refreshed.length,
-    staleCount,
-    truncated
+    branches: [],
+    total: 0,
+    staleCount: 0,
+    truncated: false,
+    liveTotal: 0,
+    mergedCount: 0,
+    openCount: 0,
+    unknownCount: 0,
+    remoteRead: false,
+    prStateAvailable: false
   };
 }
 async function scanUnmergedBranches(repoRoot, options = {}) {
@@ -128,13 +162,13 @@ async function scanUnmergedBranches(repoRoot, options = {}) {
   const listingCap = options.listingCap ?? DEFAULT_LISTING_CAP;
   let raw;
   try {
-    raw = await scanUnmergedBranchesRaw(repoRoot);
+    raw = await scanUnmergedBranchesRaw(repoRoot, options.prStateLookup);
   } catch {
-    return { branches: [], total: 0, staleCount: 0, truncated: false };
+    return unknownScanResult();
   }
-  return finalizeScan(raw.branches, raw.truncated, staleHours, listingCap);
+  return finalizeScan(raw, staleHours, listingCap, options.include);
 }
-var BRANCH_SCAN_CACHE_VERSION = 1;
+var BRANCH_SCAN_CACHE_VERSION = 2;
 function branchScanCacheDir() {
   return join(EXE_AI_DIR, "session-cache");
 }
@@ -177,29 +211,47 @@ async function scanUnmergedBranchesCached(repoRoot, options = {}, cacheOpts = {}
     if (entry?.scannedAt) {
       const age = Date.now() - Date.parse(entry.scannedAt);
       if (Number.isFinite(age) && age >= 0 && age <= maxAgeMs) {
-        return finalizeScan(entry.branches ?? [], entry.truncated ?? false, staleHours, listingCap);
+        return finalizeScan(
+          {
+            branches: entry.branches ?? [],
+            truncated: entry.truncated ?? false,
+            remoteRead: entry.remoteRead ?? false,
+            prStateAvailable: entry.prStateAvailable ?? false
+          },
+          staleHours,
+          listingCap,
+          options.include
+        );
       }
     }
   }
   let raw;
   try {
-    raw = await scanUnmergedBranchesRaw(repoRoot);
+    raw = await scanUnmergedBranchesRaw(repoRoot, options.prStateLookup);
   } catch {
-    return { branches: [], total: 0, staleCount: 0, truncated: false };
+    return unknownScanResult();
   }
-  await writeBranchScanCacheEntryAsync(repoRoot, {
-    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    branches: raw.branches,
-    truncated: raw.truncated
-  });
-  return finalizeScan(raw.branches, raw.truncated, staleHours, listingCap);
+  if (raw.remoteRead) {
+    await writeBranchScanCacheEntryAsync(repoRoot, {
+      scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      branches: raw.branches,
+      truncated: raw.truncated,
+      remoteRead: raw.remoteRead,
+      prStateAvailable: raw.prStateAvailable
+    });
+  }
+  return finalizeScan(raw, staleHours, listingCap, options.include);
 }
 function slugForMatch(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 async function findMatchingBranches(repoRoot, opts) {
   const result = [];
-  const scan = await scanUnmergedBranches(repoRoot, { listingCap: MAX_BRANCHES_SCANNED });
+  const scan = await scanUnmergedBranchesCached(repoRoot, {
+    listingCap: MAX_BRANCHES_SCANNED,
+    include: ["closed_unmerged", "never_proposed", "open"],
+    prStateLookup: opts.prStateLookup
+  });
   if (scan.branches.length === 0) return result;
   const idToken = opts.id ? slugForMatch(opts.id) : "";
   const shortId = idToken ? idToken.replace(/-/g, "").slice(0, 8) : "";