@kienntpixon/dieu-phoi 0.5.2 → 0.6.0

package/lib/profile.cjs

@@ -0,0 +1,204 @@
+'use strict';
+// `dieu-phoi profile base|apply` (core 0.6.0, unreleased): apply an approved retro to <skill>/profile/lessons.md and
+// profile.json without overwriting what other sessions wrote meanwhile.
+//
+//   profile base --save <dir>   snapshot both files into <dir>/profile-base/ (+ base.json with their sha256) before the
+//                               retro agent reads them; the agent builds its proposed files from this snapshot.
+//   profile apply --base <dir> [--lessons <file>] [--profile <file>] [--dry-run] [--json]
+//                               under <skill>/profile/profile.lock:
+//                               - file unchanged since base → write the proposal;
+//                               - lessons.md changed, but only by ADDED lines (other sessions `>>` a lesson) → write
+//                                 the proposal plus those lines (each after the line it followed, else at the end);
+//                               - lessons.md lines edited/deleted since base, or profile.json changed at all → stop,
+//                                 exit 2, write nothing (the user decides).
+// `>>` appenders take no lock: the live file is re-read right before the renames and the merge redone if it moved
+// (up to 5 times). What is left is the sub-millisecond gap between that last read and the rename.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const core = require('../hook.cjs');
+
+const BASE_DIR = 'profile-base';
+const FILES = { lessons: 'lessons.md', profile: 'profile.json' };
+const LOCK_TRIES = 200; // x 50 ms = 10 s
+const REREAD_TRIES = 5;
+
+const HELP = `Cách dùng: dieu-phoi profile <lệnh> [--skill-dir P] [--json]
+
+  base --save <thư mục>  chụp profile/lessons.md + profile.json vào <thư mục>/profile-base/ (kèm base.json = sha256 lúc đọc).
+                         Agent retro đọc và dựng bản đề xuất từ bản chụp này, không từ file sống
+  apply --base <thư mục> [--lessons <file đề xuất>] [--profile <file đề xuất>] [--dry-run]
+                         áp retro đã duyệt, dưới khoá profile/profile.lock. File chưa đổi từ base → ghi đề xuất.
+                         lessons.md chỉ có dòng THÊM MỚI (phiên khác >> bài học) → tự gộp các dòng đó vào đề xuất.
+                         lessons.md có dòng cũ bị sửa/xoá, hoặc profile.json đã đổi → dừng, exit 2, không ghi gì`;
+
+const sha = (txt) => crypto.createHash('sha256').update(txt, 'utf8').digest('hex');
+const lf = (txt) => String(txt).replace(/^/, '').replace(/\r\n/g, '\n');
+const slash = (p) => String(p).replace(/\\/g, '/');
+
+function readText(file) {
+  try { return lf(fs.readFileSync(file, 'utf8')); } catch (e) { if (e.code === 'ENOENT') return null; throw e; }
+}
+
+function skillDirOf(opts) {
+  const c = require('./commands.cjs');
+  return c.skillDirOf(opts, require('./args.cjs').ctxOf(opts));
+}
+
+function profileDir(opts) {
+  const sd = skillDirOf(opts);
+  if (!sd) throw new Error('không thấy skill dieu-phoi (dùng --skill-dir)');
+  const dir = path.join(sd, 'profile');
+  if (!fs.existsSync(dir)) throw new Error(`không thấy ${slash(dir)}`);
+  return dir;
+}
+
+function cmdBase(opts) {
+  if (typeof opts.save !== 'string' || !opts.save.trim()) return { code: 1, out: 'profile base cần --save <thư mục> (vd. run dir của retro).' };
+  const dir = profileDir(opts);
+  const out = path.join(path.resolve(core.nativePath(opts.save)), BASE_DIR);
+  const meta = { at: new Date().toISOString(), profile_dir: slash(dir) };
+  for (const [k, f] of Object.entries(FILES)) {
+    const txt = readText(path.join(dir, f));
+    if (txt === null) { meta[k] = null; continue; }
+    core.writeFileAtomic(path.join(out, f), txt);
+    meta[k] = sha(txt);
+  }
+  core.writeFileAtomic(path.join(out, 'base.json'), `${JSON.stringify(meta, null, 2)}\n`);
+  if (opts.json) return { code: 0, out: JSON.stringify(Object.assign({ dir: slash(out) }, meta), null, 2) };
+  return { code: 0, out: `Đã chụp base vào ${slash(out)}: lessons=${String(meta.lessons).slice(0, 12)} profile=${String(meta.profile).slice(0, 12)}` };
+}
+
+/**
+ * Lines the live file added on top of base, each with the base line it followed (-1 = file start).
+ * null when a base line is missing from the live file in order (edited or deleted since base).
+ */
+function addedSince(baseTxt, curTxt) {
+  const b = baseTxt.split('\n');
+  const c = curTxt.split('\n');
+  const added = [];
+  let i = 0;
+  for (let j = 0; j < c.length; j++) {
+    if (i < b.length && c[j] === b[i]) { i++; continue; }
+    added.push({ line: c[j], after: i - 1 });
+  }
+  if (i < b.length) {
+    // a trailing empty element is just the final newline
+    const rest = b.slice(i).filter((x) => x !== '');
+    if (rest.length) return { missing: rest };
+  }
+  return { added };
+}
+
+/** Put the lines others added into the proposal: after the same anchor line when the proposal kept it, else at the end. */
+function mergeLessons(baseTxt, curTxt, propTxt) {
+  if (curTxt === baseTxt) return { text: propTxt, merged: [] };
+  const d = addedSince(baseTxt, curTxt);
+  if (d.missing) return { conflict: `lessons.md: ${d.missing.length} dòng có sẵn lúc base đã bị sửa/xoá (vd. "${d.missing[0].slice(0, 80)}")` };
+  const base = baseTxt.split('\n');
+  const out = propTxt.replace(/\n+$/, '').split('\n');
+  const have = new Set(out);
+  const merged = [];
+  const tail = [];
+  const count = new Map(); // anchor text → lines already inserted after it
+  for (const a of d.added) {
+    if (!a.line.trim() || have.has(a.line)) continue;
+    let k = a.after;
+    while (k >= 0 && !base[k].trim()) k--; // anchor on the nearest non-blank line: blank lines repeat
+    const key = k < 0 ? null : base[k];
+    const at = key === null ? -1 : out.indexOf(key);
+    if (key !== null && at < 0) tail.push(a.line); // the proposal changed that line: append at the end
+    else {
+      const n = count.get(key) || 0;
+      out.splice(at + 1 + n, 0, a.line);
+      count.set(key, n + 1);
+    }
+    merged.push(a.line);
+    have.add(a.line);
+  }
+  return { text: `${out.concat(tail).join('\n')}\n`, merged };
+}
+
+function plan(dir, baseDir, props) {
+  const res = { conflicts: [], writes: [] };
+  for (const [k, f] of Object.entries(FILES)) {
+    if (props[k] === undefined) continue;
+    const baseTxt = readText(path.join(baseDir, f));
+    const cur = readText(path.join(dir, f));
+    if (baseTxt === null || cur === null) { res.conflicts.push(`${f}: thiếu ${baseTxt === null ? 'bản base' : 'file sống'}`); continue; }
+    if (cur === props[k]) { res.writes.push({ k, f, same: true }); continue; }
+    if (k === 'profile') {
+      if (sha(cur) !== sha(baseTxt)) { res.conflicts.push('profile.json đã đổi sau base (phiên khác/sửa tay) — không tự gộp'); continue; }
+      res.writes.push({ k, f, text: props[k], cur, merged: [] });
+      continue;
+    }
+    const m = mergeLessons(baseTxt, cur, props[k]);
+    if (m.conflict) { res.conflicts.push(m.conflict); continue; }
+    res.writes.push({ k, f, text: m.text, cur, merged: m.merged });
+  }
+  return res;
+}
+
+function cmdApply(opts) {
+  if (typeof opts.base !== 'string') return { code: 1, out: 'profile apply cần --base <thư mục đã chụp bằng profile base --save>.' };
+  const baseDir = path.join(path.resolve(core.nativePath(opts.base)), BASE_DIR);
+  const meta = core.readJsonFile(path.join(baseDir, 'base.json'), null);
+  if (!meta) return { code: 1, out: `không thấy ${slash(path.join(baseDir, 'base.json'))} — chạy profile base --save trước khi retro đọc profile.` };
+  const props = {};
+  for (const k of Object.keys(FILES)) {
+    if (typeof opts[k] !== 'string') continue;
+    const t = readText(path.resolve(core.nativePath(opts[k])));
+    if (t === null) return { code: 1, out: `không thấy file đề xuất --${k} ${opts[k]}` };
+    if (k === 'profile') { try { JSON.parse(t); } catch (e) { return { code: 1, out: `--profile không phải JSON hợp lệ: ${e.message}` }; } }
+    props[k] = t.endsWith('\n') ? t : `${t}\n`;
+  }
+  if (!Object.keys(props).length) return { code: 1, out: 'cần --lessons và/hoặc --profile (file đề xuất đã được duyệt).' };
+  for (const k of Object.keys(FILES)) {
+    const t = readText(path.join(baseDir, FILES[k]));
+    if (props[k] !== undefined && (t === null || sha(t) !== meta[k])) return { code: 1, out: `bản base ${FILES[k]} không khớp base.json (đã bị sửa?) — chụp lại base.` };
+  }
+  const dir = profileDir(opts);
+  const dry = !!opts['dry-run'];
+  const lockFile = path.join(dir, 'profile.lock');
+  let got = false;
+  for (let i = 0; i < LOCK_TRIES && !got; i++) {
+    got = core.acquireLock(lockFile);
+    if (!got) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+  }
+  if (!got) return { code: 1, out: `profile đang bị khoá (${slash(lockFile)}) — thử lại.` };
+  let res;
+  let written = false;
+  try {
+    for (let t = 0; t < REREAD_TRIES; t++) {
+      res = plan(dir, baseDir, props);
+      if (res.conflicts.length || dry) break;
+      const todo = res.writes.filter((w) => !w.same);
+      const hook = process.env.DIEU_PHOI_TEST_PROFILE_APPEND_ONCE; // test hook: a `>>` landing inside the merge window
+      if (hook && t === 0) fs.appendFileSync(path.join(dir, FILES.lessons), `${hook}
+`);
+      if (todo.some((w) => readText(path.join(dir, w.f)) !== w.cur)) continue; // a `>>` landed while we merged: redo
+      for (const w of todo) core.writeFileAtomic(path.join(dir, w.f), w.text);
+      written = true;
+      break;
+    }
+    if (!written && !dry && !res.conflicts.length) res.conflicts.push(`lessons.md đổi liên tục trong lúc gộp (${REREAD_TRIES} lần) — thử lại`);
+  } finally {
+    try { fs.unlinkSync(lockFile); } catch (_) { /* gone */ }
+  }
+  const code = res.conflicts.length ? 2 : 0;
+  if (opts.json) return { code, out: JSON.stringify({ dry_run: dry, conflicts: res.conflicts, writes: res.writes.map((w) => ({ file: w.f, same: !!w.same, merged: w.merged || [] })) }, null, 2) };
+  if (code) return { code, out: `DỪNG — không ghi gì:\n${res.conflicts.map((c) => `  ! ${c}`).join('\n')}\nBáo người dùng: đọc lại file sống, dựng lại đề xuất (profile base --save lần nữa) rồi apply.` };
+  const lines = res.writes.map((w) => (w.same ? `  = ${w.f} (không đổi)` : `  ${dry ? '~' : '✓'} ${w.f}${w.merged.length ? ` (gộp thêm ${w.merged.length} dòng phiên khác thêm sau base)` : ''}`));
+  return { code: 0, out: `${dry ? '(dry-run — không ghi gì)\n' : ''}profile ${slash(dir)}:\n${lines.join('\n')}` };
+}
+
+function cmdProfile(opts) {
+  const sub = opts._.shift();
+  if (!sub || opts.help || opts.h || sub === 'help') return { code: sub || opts.help || opts.h ? 0 : 1, out: HELP };
+  if (sub === 'base') return cmdBase(opts);
+  if (sub === 'apply') return cmdApply(opts);
+  return { code: 1, out: `Lệnh profile lạ: ${sub}\n\n${HELP}` };
+}
+
+module.exports = { cmdProfile, mergeLessons, addedSince, HELP };

package/lib/prune.cjs

@@ -218,6 +218,28 @@ function writeArchive(ctx, texts) {
   return file;
 }
 
+const ACTIVE_WINDOW_MIN = 15;
+
+/**
+ * Events of another session inside the last ACTIVE_WINDOW_MIN minutes. Own session = --session, else
+ * $CLAUDE_CODE_SESSION_ID (events carry `session` = sha8 of the raw id); unknown own session => every session counts.
+ * Events without a session (verdict/steer/discard by the user) are not attributable and are ignored.
+ */
+function otherSessionActive(ctx, opts, events) {
+  const rawOwn = typeof opts.session === 'string' && opts.session ? opts.session : (process.env.CLAUDE_CODE_SESSION_ID || '');
+  const own = rawOwn ? core.sha8(rawOwn) : null;
+  const now = typeof opts.now === 'number' ? opts.now : Date.now();
+  const since = now - ACTIVE_WINDOW_MIN * 60000;
+  const sessions = new Set(); let count = 0; let last = 0;
+  for (const e of events) {
+    if (typeof e.session !== 'string' || !e.session || e.session === own) continue;
+    const t = Date.parse(e.ts);
+    if (!(t >= since)) continue;
+    sessions.add(e.session); count++; if (t > last) last = t;
+  }
+  return count ? { count, sessions: Array.from(sessions), last: new Date(last).toISOString(), ownKnown: !!own } : null;
+}
+
 function cmdPrune(opts) {
   const ctx = ctxOf(opts);
   const retro = typeof opts['after-retro'] === 'string' ? path.resolve(opts['after-retro']) : null;
@@ -264,6 +286,16 @@ function cmdPrune(opts) {
   };
 
   if (yes) {
+    // 0. a session other than this one touched the log recently => refuse (a live hook could be mid-append)
+    const busy = opts.force === true ? null : otherSessionActive(ctx, opts, allEvents);
+    if (busy) {
+      return { code: 1, out: [
+        `prune: từ chối — ${busy.count} sự kiện của ${busy.sessions.length} phiên khác trong ${ACTIVE_WINDOW_MIN} phút gần nhất (mới nhất ${busy.last}); phiên khác đang chạy có thể ghi events.jsonl cùng lúc.`,
+        busy.ownKnown ? 'Chờ phiên đó xong rồi chạy lại, hoặc thêm --force nếu chắc chắn.'
+          : 'Không biết phiên hiện tại (thiếu CLAUDE_CODE_SESSION_ID): thêm --session <id> để loại trừ phiên của bạn, hoặc --force.',
+        'Không có gì bị thay đổi.',
+      ].join('\n') };
+    }
     // 1. events → archive (archive first + verified, then rewrite events.jsonl via temp + rename)
     if (moving.length) {
       const fresh = moving.filter((l) => !archived.has(l.text));
@@ -271,25 +303,30 @@ function cmdPrune(opts) {
       if (!lock) return { code: 1, out: 'prune: sync đang giữ khoá — thử lại sau' };
       try {
         if (fresh.length) writeArchive(ctx, fresh.map((l) => l.text));
-        const buf = core.readEventsBuffer(ctx);
-        const drop = new Map(moving.map((l) => [l.start, l.text]));
-        const parts = []; let removedBeforeOffset = 0;
-        let pos = 0;
-        for (const l of core.eventLinesFrom(buf, 0)) {
-          parts.push(buf.subarray(pos, l.start)); // blank lines between
-          if (drop.get(l.start) === l.text) {
-            if (l.end <= unsynced.offset) removedBeforeOffset += l.end - l.start;
-          } else parts.push(buf.subarray(l.start, l.end));
-          pos = l.end;
-        }
-        parts.push(buf.subarray(pos));
-        let next = Buffer.concat(parts);
-        const cur = core.readEventsBuffer(ctx);
-        if (cur.length > buf.length) next = Buffer.concat([next, cur.subarray(buf.length)]); // appended meanwhile
-        const tmp = `${ctx.paths.events}.tmp-${process.pid}`;
-        fs.writeFileSync(tmp, next);
-        core.renameWithRetry(tmp, ctx.paths.events);
-        if (unsynced.offset > 0) core.writeFileAtomic(ctx.paths.syncOffset, `${JSON.stringify({ offset: Math.max(0, unsynced.offset - removedBeforeOffset), ts: core.nowIso() })}\n`);
+        // Core 0.5.4: the read-rewrite-rename below runs under events.lock, the same lock appendEvent takes, so no
+        // event can land between the read and the rename (the old code re-read then renamed with a gap, and the
+        // line appended inside it was lost). Lines appended after the first snapshot are kept untouched.
+        const rewritten = core.withFileLock(ctx.paths.eventsLock, { timeoutMs: Number(opts['lock-timeout-ms']) > 0 ? Number(opts['lock-timeout-ms']) : 15000, staleMs: 60000, required: true }, () => {
+          const off = core.unsyncedInfo(ctx).offset; // sync is stopped (sync.lock) but may have advanced since the first read
+          const buf = core.readEventsBuffer(ctx);
+          const drop = new Map(moving.map((l) => [l.start, l.text]));
+          const parts = []; let removedBeforeOffset = 0;
+          let pos = 0;
+          for (const l of core.eventLinesFrom(buf, 0)) {
+            parts.push(buf.subarray(pos, l.start)); // blank lines between
+            if (drop.get(l.start) === l.text) {
+              if (l.end <= off) removedBeforeOffset += l.end - l.start;
+            } else parts.push(buf.subarray(l.start, l.end));
+            pos = l.end;
+          }
+          parts.push(buf.subarray(pos)); // blank tail + an unterminated line still being written
+          const tmp = `${ctx.paths.events}.tmp-${process.pid}`;
+          fs.writeFileSync(tmp, Buffer.concat(parts));
+          core.renameWithRetry(tmp, ctx.paths.events);
+          if (off > 0) core.writeFileAtomic(ctx.paths.syncOffset, `${JSON.stringify({ offset: Math.max(0, off - removedBeforeOffset), ts: core.nowIso() })}\n`);
+          return true;
+        });
+        if (rewritten.skipped) return { code: 1, out: 'prune: events.jsonl đang bận (khoá events.lock) — archive đã ghi, events.jsonl giữ nguyên; thử lại sau' };
       } finally {
         try { fs.unlinkSync(ctx.paths.lock); } catch (_) { /* gone */ }
       }
@@ -318,4 +355,4 @@ function cmdPrune(opts) {
   return { code: 0, out: L.join('\n') };
 }
 
-module.exports = { cmdPrune, keepSet, cutoffOf };
+module.exports = { cmdPrune, keepSet, cutoffOf, otherSessionActive };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienntpixon/dieu-phoi",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Hook + CLI ghi log subagent của Claude Code và chọn model/effort theo chi phí + thời gian tới lúc nghiệm thu.",
   "license": "MIT",
   "author": "kiennt <kiennt@pixon.games>",