@kienntpixon/dieu-phoi 0.7.5 → 0.7.6

package/lib/repos.cjs

@@ -0,0 +1,387 @@
+'use strict';
+// core 0.7.6 (s2, contract r1; fix try2): sổ repo đã chạm — <dataDir>/repos.json = { "<checkout chính, / không \": { last_ts, src } }.
+//  - checkoutOfPath: dò checkout chính bằng fs (đi lên tìm `.git`; worktree đọc `gitdir:`), không spawn git.
+//  - recordRepo / recordMany: best effort, không ném; khoá file quanh đọc-sửa-ghi; chỉ ghi khi repo chưa có hoặc last_ts cũ hơn 1 giờ.
+//    Nguồn src: hook (cwd + repo đích của brief), live (SubagentStart/Stop: cwd và worktree của agent), wt (wt add),
+//    worktree (sự kiện kind=worktree có repo), seed (wt repos --seed và tự seed).
+//  - recordWorktreeAddCommand: lệnh Bash `git [-C dir] worktree add` → repo qua `git rev-parse --git-common-dir`.
+//  - seedRepos: quét thư mục tới độ sâu --depth (mặc định 3), sự kiện worktree có repo, và git worktree list của repo đã biết.
+//  - autoSeedIfStale: helper cho wt gc (s3): seed khi dấu seed cũ hơn 24 giờ; gốc quét = roots truyền vào + thư mục cha của repo đã biết.
+//  - listRepos: bỏ repo không còn `.git` khi đọc; không ghi lại file.
+//  - cmdRepos: dieu-phoi wt repos [--seed <dir>…] [--depth N] [--json].
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+
+const REGISTRY_FILE = 'repos.json';
+const STAMP_FILE = 'repos.seeded';
+const DEEP_STAMP = 'repos.deepscan'; // lần quét sâu thư mục gần nhất hoàn tất (chu kỳ AUTO_SEED_MS)
+const REFRESH_MS = 60 * 60 * 1000;
+const AUTO_SEED_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_DEPTH = 3;
+const MAX_DEPTH = 6;
+const MAX_UP = 64;
+const MAX_SCAN_ENTRIES = 20000;
+const LOCK_WAIT_MS = 1500;
+const LOCK_STALE_MS = 30000;
+const SKIP_DIRS = new Set(['node_modules', 'Library', 'Temp', 'obj', 'Logs', 'Packages']);
+const WT_ADD_RE = /\bgit\s+(?:-C\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s+)?worktree\s+add\b/;
+
+function norm(p) {
+  return path.resolve(p).replace(/\\/g, '/');
+}
+
+function registryFile(dataDir) {
+  return path.join(dataDir, REGISTRY_FILE);
+}
+
+function readRegistry(dataDir) {
+  try {
+    const j = JSON.parse(fs.readFileSync(registryFile(dataDir), 'utf8').replace(/^/, ''));
+    return j && typeof j === 'object' && !Array.isArray(j) ? j : {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function writeRegistry(dataDir, reg) {
+  fs.mkdirSync(dataDir, { recursive: true });
+  const f = registryFile(dataDir);
+  const tmp = `${f}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(reg, null, 2)}\n`, 'utf8');
+  fs.renameSync(tmp, f);
+}
+
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+// Khoá file quanh đọc-sửa-ghi sổ. Chờ tối đa 1,5 s rồi chạy không khoá (sổ chỉ là gợi ý); khoá cũ hơn 30 s bị bỏ.
+function withRegLock(dataDir, fn) {
+  fs.mkdirSync(dataDir, { recursive: true });
+  const lock = `${registryFile(dataDir)}.lock`;
+  let got = false;
+  const t0 = Date.now();
+  for (;;) {
+    try {
+      fs.writeFileSync(lock, String(process.pid), { flag: 'wx' });
+      got = true;
+      break;
+    } catch (_) {
+      try { if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) fs.unlinkSync(lock); } catch (_2) { /* đã mất */ }
+      if (Date.now() - t0 > LOCK_WAIT_MS) break;
+      sleepMs(20);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (got) { try { fs.unlinkSync(lock); } catch (_) { /* đã mất */ } }
+  }
+}
+
+// Checkout chính (thư mục có `.git` thư mục) của một đường dẫn trong repo hoặc worktree; null nếu không phải repo git. Không spawn.
+function checkoutOfPath(dir) {
+  try {
+    let d = path.resolve(dir);
+    for (let i = 0; i < MAX_UP; i++) {
+      const g = path.join(d, '.git');
+      let st = null;
+      try { st = fs.statSync(g); } catch (_) { st = null; }
+      if (st && st.isDirectory()) return norm(d);
+      if (st && st.isFile()) {
+        // worktree: `.git` là file "gitdir: <common>/worktrees/<name>"
+        const m = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(g, 'utf8'));
+        if (!m) return null;
+        const common = path.resolve(d, m[1].trim(), '..', '..');
+        return path.basename(common) === '.git' ? norm(path.dirname(common)) : null;
+      }
+      const up = path.dirname(d);
+      if (up === d) return null;
+      d = up;
+    }
+  } catch (_) { /* best effort */ }
+  return null;
+}
+
+// Ghi nhiều đường dẫn trong MỘT lần đọc-ghi. Trả số repo mới được ghi (vượt ngưỡng làm mới).
+function recordMany(dataDir, dirs, src, now) {
+  try {
+    if (!dataDir) return 0;
+    const mains = new Set();
+    for (const d of dirs) {
+      if (typeof d !== 'string' || !d) continue;
+      const m = checkoutOfPath(d);
+      if (m) mains.add(m);
+    }
+    if (!mains.size) return 0;
+    const ts = typeof now === 'number' ? now : Date.now();
+    return withRegLock(dataDir, () => {
+      const reg = readRegistry(dataDir);
+      let n = 0;
+      for (const main of mains) {
+        const cur = reg[main];
+        if (cur && typeof cur.last_ts === 'number' && ts - cur.last_ts < REFRESH_MS) continue;
+        reg[main] = { last_ts: ts, src: src || 'hook' };
+        n++;
+      }
+      if (n) writeRegistry(dataDir, reg);
+      return n;
+    });
+  } catch (_) {
+    return 0;
+  }
+}
+
+/** Ghi repo của `dir` vào sổ (best effort, không ném). Trả true khi đã ghi. */
+function recordRepo(dataDir, dir, src, now) {
+  return recordMany(dataDir, [dir], src, now) > 0;
+}
+
+/**
+ * Lệnh Bash `git [-C dir] worktree add ...`: repo = dir của -C (hoặc cwd), resolve bằng `git rev-parse --git-common-dir`.
+ * Trả true khi ghi được. Chỉ spawn git khi lệnh khớp.
+ */
+function recordWorktreeAddCommand(dataDir, command, cwd) {
+  try {
+    if (typeof command !== 'string' || command.indexOf('worktree') < 0) return false;
+    const m = WT_ADD_RE.exec(command);
+    if (!m) return false;
+    const base = cwd || process.cwd();
+    const given = m[1] || m[2] || m[3];
+    const dir = given ? path.resolve(base, given) : base;
+    const r = cp.spawnSync('git', ['-C', dir, 'rev-parse', '--path-format=absolute', '--git-common-dir'], {
+      encoding: 'utf8', windowsHide: true, timeout: 5000,
+    });
+    if (r.status !== 0) return false;
+    const common = String(r.stdout || '').trim();
+    if (path.basename(common) !== '.git') return false;
+    return recordMany(dataDir, [path.dirname(common)], 'hook') > 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/** Danh sách repo còn tồn tại (có `.git`), mới nhất trước. */
+function listRepos(dataDir) {
+  const reg = readRegistry(dataDir);
+  return Object.keys(reg)
+    .filter((k) => fs.existsSync(path.join(k, '.git')))
+    .map((k) => ({ path: k, last_ts: Number(reg[k].last_ts) || 0, src: String(reg[k].src || '') }))
+    .sort((a, b) => b.last_ts - a.last_ts);
+}
+
+function clampDepth(d) {
+  const n = Number(d);
+  if (!Number.isFinite(n) || n < 1) return DEFAULT_DEPTH;
+  return Math.min(MAX_DEPTH, Math.floor(n));
+}
+
+// Thư mục con của `base` tới độ sâu `depth` có `.git`. Bỏ dot-dir, node_modules và thư mục sinh ra của Unity.
+function scanRepos(base, depth, out, budget) {
+  let entries = [];
+  try { entries = fs.readdirSync(base, { withFileTypes: true }); } catch (_) { return; }
+  for (const e of entries) {
+    if (budget.left-- <= 0) return;
+    if (budget.deadline && (budget.left & 63) === 0 && Date.now() > budget.deadline) { budget.left = 0; return; }
+    if (!e.isDirectory() || e.name.startsWith('.') || SKIP_DIRS.has(e.name)) continue;
+    const c = path.join(base, e.name);
+    if (fs.existsSync(path.join(c, '.git'))) out.push(c);
+    if (depth > 1) scanRepos(c, depth - 1, out, budget);
+  }
+}
+
+// Mọi worktree liên kết của một repo, đọc thẳng <repo>/.git/worktrees/*/gitdir (không gọi git: ~1 giây/lệnh trên máy thật,
+// `git worktree list` cho 13 repo mất 118 giây). Mỗi cái trỏ về cùng checkout chính, nên chỉ có tác dụng với repo khác git-common-dir.
+function worktreesOf(repo) {
+  const root = path.join(repo, '.git', 'worktrees');
+  let names = [];
+  try { names = fs.readdirSync(root); } catch (_) { return []; }
+  const out = [];
+  for (const n of names) {
+    try { out.push(path.dirname(fs.readFileSync(path.join(root, n, 'gitdir'), 'utf8').trim())); } catch (_) { /* admin hỏng: bỏ */ }
+  }
+  return out;
+}
+
+function touchStamp(dataDir) {
+  try { fs.writeFileSync(path.join(dataDir, STAMP_FILE), new Date().toISOString(), 'utf8'); } catch (_) { /* best effort */ }
+}
+
+function lastSeedMs(dataDir) {
+  try { return fs.statSync(path.join(dataDir, STAMP_FILE)).mtimeMs; } catch (_) { return 0; }
+}
+
+// Repo (đường dẫn tuyệt đối) nhắc tới trong sự kiện: trường repo / cwd / worktree. Đọc cả events.jsonl, gộp trùng.
+function reposFromEvents(eventsFile) {
+  const out = new Set();
+  let text = '';
+  try { text = fs.readFileSync(eventsFile, 'utf8'); } catch (_) { return []; }
+  for (const line of text.split(String.fromCharCode(10))) {
+    if (line.indexOf('"repo"') < 0 && line.indexOf('"cwd"') < 0 && line.indexOf('"worktree"') < 0) continue;
+    try {
+      const ev = JSON.parse(line);
+      if (!ev) continue;
+      for (const k of ['repo', 'cwd', 'worktree']) if (typeof ev[k] === 'string' && ev[k] && path.isAbsolute(ev[k])) out.add(ev[k]);
+    } catch (_) { /* dòng hỏng: bỏ */ }
+  }
+  return [...out];
+}
+
+const RUN_FILE_RE = /^(dp-out|brief|handoff|contract|context|steps|plan)[^/\\]*\.(md|json|txt)$/i;
+const RUN_REPO_RE = /(?:^|[\s,;|(])(?:repo|worktree)\s*:\s*`?((?:[A-Za-z]:[\\/]|\/)[^\s`'",;|)]+)/gim;
+// Dòng `repo: …` / `worktree: …` trong brief, dp-out, contract… của các run dir (mới nhất trước, có trần số run và số file).
+function reposFromRuns(runsDir, maxRuns) {
+  const out = new Set();
+  let names = [];
+  try { names = fs.readdirSync(runsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name); } catch (_) { return []; }
+  const stamped = names.map((n) => { let t = 0; try { t = fs.statSync(path.join(runsDir, n)).mtimeMs; } catch (_) { /* bỏ */ } return { n, t }; })
+    .sort((x, y) => y.t - x.t).slice(0, maxRuns || 400);
+  let files = 0;
+  for (const { n } of stamped) {
+    let ents = [];
+    try { ents = fs.readdirSync(path.join(runsDir, n)); } catch (_) { continue; }
+    for (const f of ents) {
+      if (!RUN_FILE_RE.test(f)) continue;
+      if (files++ > 6000) return [...out];
+      let text = '';
+      try {
+        const fd = fs.openSync(path.join(runsDir, n, f), 'r');
+        const buf = Buffer.alloc(8192);
+        const len = fs.readSync(fd, buf, 0, 8192, 0);
+        fs.closeSync(fd);
+        text = buf.slice(0, len).toString('utf8');
+      } catch (_) { continue; }
+      RUN_REPO_RE.lastIndex = 0;
+      let m;
+      while ((m = RUN_REPO_RE.exec(text))) out.add(m[1].replace(/[.:]+$/, ''));
+    }
+  }
+  return [...out];
+}
+
+// Mọi thư mục con TRỰC TIẾP của `base` có `.git` (ngân sách riêng: không phụ thuộc quét sâu).
+function directChildRepos(base) {
+  const out = [];
+  let ents = [];
+  try { ents = fs.readdirSync(base, { withFileTypes: true }); } catch (_) { return out; }
+  for (const e of ents.slice(0, 5000)) {
+    if (!e.isDirectory() || e.name.startsWith('.') || SKIP_DIRS.has(e.name)) continue;
+    const c = path.join(base, e.name);
+    if (fs.existsSync(path.join(c, '.git'))) out.push(c);
+  }
+  return out;
+}
+
+/**
+ * Seed: (1) quét `dirs` tới độ sâu `opts.depth` (mặc định 3); (2) repo trong sự kiện (repo/cwd/worktree) của eventsFile;
+ * (3) dòng `repo:`/`worktree:` trong run dir (opts.runsDir); (4) mọi repo nằm TRỰC TIẾP dưới thư mục cha của mỗi repo đã biết
+ * (D:/Projects/Anything/*, D:/Projects/*); (5) `git worktree list` của mọi repo đã biết. Trả số repo mới ghi.
+ */
+function seedRepos(dataDir, dirs, eventsFile, now, opts) {
+  const o = opts || {};
+  const depth = clampDepth(o.depth);
+  const stats = o.stats || {};
+  stats.phases = stats.phases || {};
+  stats.skipped = stats.skipped || [];
+  const over = () => !!o.deadline && Date.now() > o.deadline;
+  // Mỗi pha ghi vào sổ ngay (recordMany) nên bị cắt giữa chừng vẫn giữ phần đã tìm được.
+  const phase = (name, fn, force) => {
+    if (!force && over()) { stats.skipped.push(name); return 0; }
+    const t = Date.now();
+    let r = 0;
+    try { r = fn() || 0; } finally { stats.phases[name] = Date.now() - t; }
+    return r;
+  };
+  let added = 0;
+  // events / runs / siblings rẻ (vài giây) và là nguồn chính: luôn chạy. Quét sâu thư mục đắt hơn: chạy sau cùng, theo hạn chót.
+  if (eventsFile) added += phase('events', () => recordMany(dataDir, reposFromEvents(eventsFile), 'seed', now), true);
+  if (o.runsDir) added += phase('runs', () => recordMany(dataDir, reposFromRuns(o.runsDir, o.maxRuns), 'seed', now), true);
+  added += phase('siblings', () => {
+    const parents = new Set();
+    for (const r of listRepos(dataDir)) parents.add(path.dirname(r.path));
+    const kids = [];
+    for (const d of parents) for (const c of directChildRepos(d)) kids.push(c);
+    return recordMany(dataDir, kids, 'seed', now);
+  }, true);
+  if (dirs.length) {
+    added += phase('scan', () => {
+      const found = [];
+      const budget = { left: MAX_SCAN_ENTRIES, deadline: o.deadline || 0 };
+      for (const base of dirs) scanRepos(path.resolve(base), depth, found, budget);
+      if (budget.left <= 0) stats.skipped.push('scan(bị cắt)');
+      return recordMany(dataDir, found, 'seed', now);
+    });
+  }
+  // Pha tuỳ chọn (opts.worktrees): chỉ có ích với repo khác git-common-dir nên mặc định tắt; không chặn đóng dấu seed.
+  if (o.worktrees === true) added += phase('worktrees', () => {
+    const wts = [];
+    let n = 0;
+    for (const r of listRepos(dataDir)) {
+      if (over()) { stats.skipped.push('worktrees(còn lại)'); break; }
+      for (const w of worktreesOf(r.path)) wts.push(w);
+      n++;
+    }
+    stats.worktree_repos = n;
+    return recordMany(dataDir, wts, 'seed', now);
+  });
+  // Đóng dấu khi các pha rẻ đã xong; quét sâu bị cắt thì dấu quét sâu không ghi, lần seed sau thử lại.
+  if (!stats.skipped.some((x) => !x.startsWith('scan'))) touchStamp(dataDir);
+  stats.added = added;
+  return added;
+}
+
+/**
+ * Helper cho `wt gc` (s3): seed khi dấu seed cũ hơn maxAgeMs (mặc định 24 giờ). Gốc quét = opts.roots + thư mục cha của
+ * mỗi repo đã biết. Trả { seeded, added, roots }.
+ */
+function autoSeedIfStale(dataDir, opts) {
+  const o = opts || {};
+  const now = typeof o.now === 'number' ? o.now : Date.now();
+  const maxAge = typeof o.maxAgeMs === 'number' ? o.maxAgeMs : AUTO_SEED_MS;
+  if (now - lastSeedMs(dataDir) < maxAge) return { seeded: false, added: 0, roots: 0 };
+  const roots = new Set((o.roots || []).map((p) => path.resolve(p)));
+  for (const r of listRepos(dataDir)) roots.add(path.dirname(r.path));
+  let dirs = [...roots].filter((d) => { try { return fs.statSync(d).isDirectory(); } catch (_) { return false; } });
+  // gốc nằm trong gốc khác (≤ độ sâu quét) đã được quét rồi; và quét sâu chỉ lặp lại sau AUTO_SEED_MS.
+  const depthN = clampDepth(o.depth);
+  dirs = dirs.filter((d) => !dirs.some((p) => p !== d && norm(d).startsWith(norm(p) + '/') && norm(d).split('/').length - norm(p).split('/').length < depthN));
+  const deepFile = path.join(dataDir, DEEP_STAMP);
+  let deepFresh = false;
+  try { deepFresh = now - fs.statSync(deepFile).mtimeMs < AUTO_SEED_MS; } catch (_) { deepFresh = false; }
+  const scanDirs = deepFresh ? [] : dirs;
+  const stats = {};
+  const t0 = Date.now();
+  const added = seedRepos(dataDir, scanDirs, o.eventsFile, now, { depth: o.depth, runsDir: o.runsDir, deadline: o.deadline, stats });
+  if (scanDirs.length && stats.phases.scan !== undefined && !stats.skipped.some((x) => x.startsWith('scan'))) { try { fs.writeFileSync(deepFile, new Date().toISOString(), 'utf8'); } catch (_) { /* best effort */ } }
+  return { seeded: true, added, roots: dirs.length, ms: Date.now() - t0, phases: stats.phases, skipped: stats.skipped };
+}
+
+function cmdRepos(opts, ctx) {
+  const dataDir = ctx.paths.data;
+  if (opts.seed) {
+    const dirs = [];
+    if (typeof opts.seed === 'string') dirs.push(opts.seed);
+    for (const d of (opts._ || []).slice(1)) dirs.push(d);
+    if (!dirs.length) throw new Error('Cú pháp: dieu-phoi wt repos --seed <thư mục…> [--depth N] [--json]');
+    const n = seedRepos(dataDir, dirs.map((d) => path.resolve(d)), ctx.paths.events, Date.now(), { depth: opts.depth, worktrees: true, runsDir: require('../hook.cjs').runsDir ? require('../hook.cjs').runsDir() : null });
+    console.log(`wt repos --seed: thêm ${n} repo (độ sâu ${clampDepth(opts.depth)}, ${dirs.length} thư mục gốc, sự kiện và worktree của repo đã biết)`);
+  }
+  const rows = listRepos(dataDir);
+  if (opts.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (!rows.length) {
+    console.log('(sổ repo trống — chạy `dieu-phoi wt repos --seed <thư mục…>` hoặc chờ hook ghi)');
+    return;
+  }
+  for (const r of rows) {
+    console.log(`${new Date(r.last_ts).toISOString()}  ${r.src.padEnd(8)}  ${r.path}`);
+  }
+}
+
+module.exports = {
+  REGISTRY_FILE, DEFAULT_DEPTH, AUTO_SEED_MS, checkoutOfPath, recordRepo, recordMany, recordWorktreeAddCommand,
+  listRepos, seedRepos, autoSeedIfStale, cmdRepos, readRegistry,
+};

package/lib/setup.cjs

@@ -361,6 +361,21 @@ function skillDirOfInstall(opts, claudeDir, home) {
   return skillDir || findSkillDir(claudeDir);
 }
 
+/** Copy every lib/*.cjs of the package to <binDir>/lib (LF); drop stale .cjs there. Returns the copied names. */
+function installLib(binDir) {
+  const srcDir = path.join(PKG_ROOT, 'lib');
+  const dstDir = path.join(binDir, 'lib');
+  fs.mkdirSync(dstDir, { recursive: true });
+  const names = fs.readdirSync(srcDir).filter((f) => f.endsWith('.cjs')).sort();
+  for (const f of names) {
+    core.writeFileAtomic(path.join(dstDir, f), fs.readFileSync(path.join(srcDir, f), 'utf8').replace(/\r\n/g, '\n'));
+  }
+  try {
+    for (const f of fs.readdirSync(dstDir)) if (f.endsWith('.cjs') && !names.includes(f)) fs.unlinkSync(path.join(dstDir, f));
+  } catch (_) { /* stale module left behind: harmless */ }
+  return names;
+}
+
 function setup(opts) {
   const claudeDir = path.resolve(opts.claudeDir);
   const home = path.join(claudeDir, 'dieu-phoi');
@@ -383,6 +398,11 @@ function setup(opts) {
     core.writeFileAtomic(path.join(paths.bin, dest), src);
   }
 
+  // r1 s6 (0.7.6): the hook lazily requires ./lib/repos.cjs (registry) and ./lib/wtgc.cjs (background gc, which pulls
+  // aggregate/args/deps/wtfast/worktree and ../hook.cjs). Ship the whole lib/ as bin/lib/ so the installed copy resolves
+  // them exactly like the repo layout does (bin/lib/x.cjs -> ../hook.cjs = bin/hook.cjs).
+  const libFiles = installLib(paths.bin);
+
   // 2. config
   const cfg = core.loadConfig(home);
   if (opts.dept !== undefined) cfg.dept = String(opts.dept);
@@ -428,6 +448,7 @@ function setup(opts) {
     agents,
     home,
     hook: paths.hook,
+    lib: libFiles,
     command: cmd,
     settings: settingsFile,
     settings_changed: res.changed,
@@ -458,6 +479,7 @@ function uninstall(opts) {
   if (opts.purge && fs.existsSync(hookFile)) {
     fs.unlinkSync(hookFile);
     hookRemoved = true;
+    try { fs.rmSync(path.join(path.dirname(hookFile), 'lib'), { recursive: true, force: true }); } catch (_) { /* best effort */ }
   }
   return { removed, agents_removed: agentsRemoved, permissions_removed: permsRemoved, settings: settingsFile, backup: res.backup, hook_removed: hookRemoved, data_kept: core.pathsFor(home).data };
 }