@kienntpixon/dieu-phoi 0.7.5 → 0.7.6

package/lib/wtfast.cjs

@@ -0,0 +1,156 @@
+'use strict';
+// wt gc (r1 s3, try2): đường đọc NHANH cho quét hàng loạt. Trên máy thật mỗi lệnh git ~1 giây (Windows + AV), nên 109 repo ×
+// vài lệnh/repo/worktree là vài phút. Ở đây: sổ worktree đọc thẳng từ <common>/worktrees/* (không `git worktree list`),
+// tên nhánh từ refs/heads + packed-refs (không git), và "đã vào nhánh bền nào chưa" tính theo lô (vài lệnh/repo) thay vì
+// một `for-each-ref --contains` cho mỗi worktree. Kết quả CHỈ ĐỂ PHÂN LỚP (dry-run); gỡ thật luôn kiểm lại bằng wtSafety đầy đủ.
+const fs = require('fs');
+const path = require('path');
+const W = require('./worktree.cjs');
+
+const NL = String.fromCharCode(10);
+const lines = (t) => String(t).split(NL).map((l) => l.replace(String.fromCharCode(13), '')).filter(Boolean);
+
+/** { main, common } không gọi git khi `<dir>/.git` là thư mục (checkout chính); còn lại rơi về W.mainCheckoutOf. */
+function mainOf(dir) {
+  try {
+    const g = path.join(dir, '.git');
+    if (fs.statSync(g).isDirectory()) return { main: dir, common: g };
+  } catch (_) { /* rơi về git */ }
+  return W.mainCheckoutOf(dir);
+}
+
+function readText(p) { try { return fs.readFileSync(p, 'utf8').trim(); } catch (_) { return null; } }
+
+/** HEAD của một git-dir: { branch, detached }. */
+function headOf(gitDir) {
+  const t = readText(path.join(gitDir, 'HEAD'));
+  if (t === null) return { branch: null, detached: false };
+  const m = /^ref:\s*refs\/heads\/(.+)$/.exec(t);
+  return m ? { branch: m[1], detached: false } : { branch: null, detached: true };
+}
+
+/** Sổ worktree như registeredOf nhưng đọc từ <common>/worktrees/*. Mục đầu = checkout chính. */
+function registeredFs(main, common) {
+  const h = headOf(common);
+  const out = [{ path: main, branch: h.branch, detached: h.detached, locked: null, prunable: false, admin: null }];
+  const root = path.join(common, 'worktrees');
+  let names = [];
+  try { names = fs.readdirSync(root); } catch (_) { return out; }
+  for (const n of names) {
+    const admin = path.join(root, n);
+    const gd = readText(path.join(admin, 'gitdir'));
+    if (!gd) continue;
+    const p = path.dirname(gd);
+    const hh = headOf(admin);
+    const lockedTxt = readText(path.join(admin, 'locked'));
+    out.push({
+      path: p, branch: hh.branch, detached: hh.detached, locked: lockedTxt, prunable: !fs.existsSync(p), admin,
+    });
+  }
+  return out;
+}
+
+/** Tên nhánh cục bộ (refs/heads loose + packed-refs), không gọi git. */
+function localHeadNames(common) {
+  const names = new Set();
+  const walk = (dir, prefix, depth) => {
+    let ents = [];
+    try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+    for (const e of ents) {
+      if (e.isDirectory()) { if (depth < 8) walk(path.join(dir, e.name), `${prefix}${e.name}/`, depth + 1); } else if (!e.name.endsWith('.lock')) names.add(prefix + e.name);
+    }
+  };
+  walk(path.join(common, 'refs', 'heads'), '', 0);
+  const packed = readText(path.join(common, 'packed-refs'));
+  if (packed) {
+    for (const l of lines(packed)) {
+      if (l[0] === '#' || l[0] === '^') continue;
+      const i = l.indexOf(' refs/heads/');
+      if (i > 0) names.add(l.slice(i + ' refs/heads/'.length));
+    }
+  }
+  return [...names];
+}
+
+/**
+ * Sự kiện của repo cho quét: một lệnh `for-each-ref` (heads + remotes, kèm sha, ngày commit, upstream) rồi mergedOf(branch)
+ * theo lô. Chính sách "đích bền" = W.durablePolicy (cùng chính sách với mergedAnywhere): mọi ref không tạm, trừ chính nó và nhánh
+ * LÀM VIỆC đang checkout trong worktree liên kết (không upstream); nhánh checkout của checkout chính (vd feat/overhaul) luôn bền;
+ * nhánh tích hợp có upstream (feat/rust-poc) bền dù đang checkout ở worktree liên kết. Nhánh được coi là đã merge nếu là tổ tiên của
+ * MỘT tip bền bất kỳ: một lệnh `for-each-ref --merged=<tip1> --merged=<tip2>...` (hợp); tên đích chỉ tra vài tip ưu tiên đầu.
+ * `reg` (sổ worktree, mục đầu = checkout chính) truyền sẵn thì khỏi đọc lại.
+ */
+function makeFacts(main, reg0) {
+  const r = W.gitRun(main, ['for-each-ref', '--format=%(refname)%09%(objectname)%09%(committerdate:unix)%09%(upstream)', 'refs/heads', 'refs/remotes']);
+  let reg = reg0;
+  if (!reg) { try { reg = registeredFs(main, mainOf(main).common); } catch (_) { reg = []; } }
+  const heads = new Map(); // tên ngắn nhánh cục bộ -> { sha, ts }
+  const rows = []; // { name, ref, sha, local }
+  const hasUp = new Set(); // nhánh cục bộ có upstream
+  let originHead = null;
+  if (r.ok) {
+    for (const l of lines(r.out)) {
+      const [ref, sha, ts, up] = l.split(String.fromCharCode(9));
+      if (!ref || !sha) continue;
+      const local = ref.startsWith('refs/heads/');
+      if (local) {
+        const name = ref.slice('refs/heads/'.length);
+        heads.set(name, { sha, ts: Number(ts) || 0 });
+        if (up) hasUp.add(name);
+      }
+      const m = /^refs\/(?:heads|remotes\/[^/]+)\/(.+)$/.exec(ref);
+      if (!m) continue;
+      if (m[1] === 'HEAD') { originHead = sha; continue; }
+      rows.push({ name: m[1], ref, sha, local });
+    }
+  }
+  const ok = W.durablePolicy(reg, (n) => hasUp.has(n), null);
+  const durable = rows.filter((d) => ok(d.name, d.local)); // ref bền: nơi một nhánh có thể "đã vào"
+  const mainBranch = reg.length && reg[0].branch ? reg[0].branch : null;
+  // tip bền, ưu tiên: nhánh checkout chính, origin/HEAD (nếu trỏ vào một ref bền), main/master/develop/dev/trunk, rồi phần còn lại; khử trùng sha.
+  const prefer = ['main', 'master', 'develop', 'dev', 'trunk'];
+  const tips = [];
+  const seen = new Set();
+  const addTip = (d) => { if (d && !seen.has(d.sha)) { seen.add(d.sha); tips.push(d); } };
+  if (mainBranch) addTip(durable.find((d) => d.name === mainBranch && d.local));
+  if (originHead) addTip(durable.find((d) => d.sha === originHead));
+  for (const p of prefer) for (const d of durable.filter((x) => x.name === p)) addTip(d);
+  for (const d of durable.filter((x) => x.local)) addTip(d);
+  for (const d of durable) addTip(d);
+  const merged = new Map(); // sha tip -> Set refname cục bộ nằm trong tip
+  const containedIn = (tip) => {
+    if (!merged.has(tip.sha)) {
+      const q = W.gitRun(main, ['for-each-ref', `--merged=${tip.sha}`, '--format=%(refname)', 'refs/heads']);
+      merged.set(tip.sha, new Set(q.ok ? lines(q.out) : []));
+    }
+    return merged.get(tip.sha);
+  };
+  let anyCache = null; // refname cục bộ nằm trong ÍT NHẤT một tip (một lệnh, nhiều --merged)
+  const containedInAny = (list) => {
+    if (list.length === 1) return containedIn(list[0]);
+    const key = list.map((t) => t.sha).join(',');
+    if (anyCache && anyCache.key === key) return anyCache.set;
+    const q = W.gitRun(main, ['for-each-ref', ...list.map((t) => `--merged=${t.sha}`), '--format=%(refname)', 'refs/heads']);
+    anyCache = { key, set: new Set(q.ok ? lines(q.out) : []) };
+    return anyCache.set;
+  };
+  const mergedOf = (branch) => {
+    const none = { merged: false, into: [] };
+    const h = heads.get(branch);
+    if (!h) return none;
+    const into = [];
+    for (const d of durable) if (d.name !== branch && d.sha === h.sha && !into.includes(d.name)) into.push(d.name);
+    if (!into.length) {
+      const cand = tips.filter((t) => t.name !== branch);
+      if (cand.length && containedInAny(cand).has(`refs/heads/${branch}`)) {
+        // tên đích chỉ để hiển thị: tra tối đa 4 tip ưu tiên (mỗi tip một lệnh git), không thấy thì ghi chung.
+        for (const t of cand.slice(0, 4)) if (containedIn(t).has(`refs/heads/${branch}`)) { into.push(t.name); break; }
+        if (!into.length) into.push('(nhánh bền khác)');
+      }
+    }
+    return { merged: into.length > 0, into };
+  };
+  return { ok: r.ok, heads, mergedOf, shaOf: (branch) => (heads.has(branch) ? heads.get(branch).sha : null), commitMs: (branch) => (heads.has(branch) && heads.get(branch).ts ? heads.get(branch).ts * 1000 : null) };
+}
+
+module.exports = { mainOf, registeredFs, localHeadNames, makeFacts, headOf };