@su-record/vibe 4.2.19 → 4.2.21

package/hooks/retest.cjs

@@ -0,0 +1,145 @@
+// Retest gate: a test command that already passed on exactly this code is not run again. PostToolUse(Bash)
+// remembers a passing test command with the state of the git work tree after it; PreToolUse(Bash) stops the same
+// command, from the same folder, while that state is unchanged. A failed run is never remembered, so a fix can
+// always be tested. `vibe retest block|warn|off` is the person's setting (block by default); `VIBE_RETEST=1`
+// in front of a command lets one run through when the user asked for it or the test depends on more than files.
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { createHash } = require('node:crypto');
+const { segments, runOutcome } = require('./knowledge-journal.cjs');
+const { readPrivate, writePrivate } = require('./private-store.cjs');
+
+const DAY = 86400000;
+const MODES = ['block', 'warn', 'off'];
+const KEEP_PASSED = 100;
+const KEEP_EVENTS = 500;
+const MAX_FILES = 2000;
+const HASH_LIMIT = 16777216;
+
+const settingsFile = home => path.join(home, '.config', 'vibe', 'retest.json');
+function mode(home) {
+  try { const raw = JSON.parse(fs.readFileSync(settingsFile(home), 'utf8')); return MODES.includes(raw.mode) ? raw.mode : 'block'; } catch { return 'block'; }
+}
+
+// Test runners and the scripts that usually run them; `vibe check` is the harness's own verdict run.
+const TEST = [
+  /^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|check)(?::\S+)?(?:\s|$)/,
+  /^(?:npx\s+|bunx\s+|pnpm\s+(?:exec\s+|dlx\s+)?|yarn\s+)?(?:vitest|jest|mocha|ava|playwright\s+test|cypress\s+run)(?:\s|$)/,
+  /^(?:python3?\s+-m\s+)?(?:pytest|unittest)(?:\s|$)/, /^(?:uv|poetry)\s+run\s+pytest(?:\s|$)/,
+  /^go\s+test(?:\s|$)/, /^cargo\s+(?:test|nextest)(?:\s|$)/, /^dotnet\s+test(?:\s|$)/, /^deno\s+test(?:\s|$)/,
+  /^(?:\.\/)?(?:mvnw?|gradlew?)\s+(?:\S+\s+)*(?:test|check|verify)(?:\s|$)/, /^(?:bundle\s+exec\s+)?rspec(?:\s|$)/,
+  /^(?:\.\/vendor\/bin\/)?phpunit(?:\s|$)/, /^node\s+--test(?:\s|$)/, /^make\s+(?:test|check)(?:\s|$)/,
+  /^vibe\s+check(?:\s|$)/, /^node\s+\S*dist\/cli\.js\s+check(?:\s|$)/,
+];
+const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/;
+const withoutAssignments = segment => { let s = segment; while (ASSIGNMENT.test(s)) s = s.replace(ASSIGNMENT, ''); return s; };
+
+// A client may hand the command over wrapped in a shell, as `bash -lc "…"` or as an argument list.
+function unwrapped(raw) {
+  if (Array.isArray(raw)) return /(?:^|\/)(?:ba|z)?sh$/.test(String(raw[0])) && /^-l?c$/.test(String(raw[1])) ? String(raw[2] ?? '') : raw.join(' ');
+  const text = String(raw ?? '');
+  const shell = /^\s*(?:\/\S*\/)?(?:ba|z)?sh\s+-l?c\s+(['"])([\s\S]*)\1\s*$/.exec(text);
+  return shell ? shell[2] : text;
+}
+
+/** The command as remembered (leading variable assignments dropped, spaces collapsed) when it runs a test, else null. */
+function testCommand(command) {
+  const parts = segments(unwrapped(command)).map(withoutAssignments);
+  return parts.some(part => TEST.some(re => re.test(part))) ? parts.join(' && ').replace(/\s+/g, ' ') : null;
+}
+const bypassed = command => segments(unwrapped(command)).some(part => /^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*VIBE_RETEST=1(?:\s|$)/.test(part));
+
+function git(cwd, args) {
+  const r = spawnSync('git', args, { cwd, encoding: 'buffer', timeout: 3000, windowsHide: true });
+  return r.status === 0 ? r.stdout : null;
+}
+function fileId(file) {
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile()) return 'other';
+    if (stat.size > HASH_LIMIT) return `${stat.size}:${stat.mtimeMs}`;
+    return createHash('sha1').update(fs.readFileSync(file)).digest('hex');
+  } catch { return 'deleted'; }
+}
+
+/** The git work tree a command runs in and a fingerprint of its content: HEAD plus every changed or untracked file, `.vibe/` aside. */
+function workState(cwd) {
+  const top = git(cwd, ['rev-parse', '--show-toplevel', 'HEAD'])?.toString('utf8').trim().split('\n');
+  if (!top || top.length !== 2) return null;
+  const [root, head] = top;
+  const status = git(root, ['status', '--porcelain=v1', '-z', '--untracked-files=all', '--no-renames']);
+  if (status === null) return null;
+  const files = status.toString('utf8').split('\0').filter(Boolean).map(entry => entry.slice(3)).filter(file => !file.startsWith('.vibe/')).sort();
+  if (files.length > MAX_FILES) return null;
+  const hash = createHash('sha256').update(head);
+  for (const file of files) hash.update(`\n${file}:${fileId(path.join(root, file))}`);
+  return { root: fs.realpathSync(root), state: hash.digest('hex').slice(0, 16) };
+}
+
+const storeName = root => `retest-${createHash('sha256').update(root).digest('hex').slice(0, 32)}.json`;
+function readStore(root, home) {
+  try {
+    const raw = JSON.parse(readPrivate(root, storeName(root), 1048576, home) ?? '{}');
+    return { passed: Array.isArray(raw.passed) ? raw.passed : [], events: Array.isArray(raw.events) ? raw.events : [] };
+  } catch { return { passed: [], events: [] }; }
+}
+const writeStore = (root, store, home) => writePrivate(root, storeName(root), JSON.stringify(store), home);
+
+function where(payload) {
+  const input = payload.tool_input ?? {};
+  const cwd = input.cwd ?? input.workdir ?? payload.cwd ?? process.cwd();
+  return path.resolve(typeof cwd === 'string' ? cwd : process.cwd());
+}
+const folderOf = (root, cwd) => { try { return path.relative(root, fs.realpathSync(cwd)).split(path.sep).join('/'); } catch { return path.relative(root, cwd); } };
+const clock = at => new Date(at).toISOString().slice(11, 16);
+
+/** PreToolUse(Bash): null to let the command run, or the decision and the message for the model. */
+function before(payload, home, now = Date.now()) {
+  const setting = mode(home);
+  const command = payload.tool_input?.command;
+  const key = setting === 'off' ? null : testCommand(command);
+  if (!key || bypassed(command)) return null;
+  const cwd = where(payload);
+  const work = workState(cwd);
+  if (!work) return null;
+  const store = readStore(work.root, home);
+  const folder = folderOf(work.root, cwd);
+  const hit = store.passed.find(p => p.cmd === key && p.cwd === folder && p.state === work.state);
+  if (!hit) return null;
+  store.events = [...store.events.filter(e => e.at >= now - 30 * DAY), { at: now, cmd: key, action: setting }].slice(-KEEP_EVENTS);
+  writeStore(work.root, store, home);
+  const said = `[vibe] \`${key}\` already passed on exactly this code at ${clock(hit.at)} UTC and no file has changed since`;
+  return setting === 'block'
+    ? { decision: 'block', message: `${said}: not run again. Use that result. Run it again only when the user asks or the test depends on something outside the files (a service, data, the clock): put VIBE_RETEST=1 in front of the command.` }
+    : { decision: 'warn', message: `${said}; running it again repeats a known result unless the test depends on something outside the files.` };
+}
+
+/** PostToolUse(Bash): remember a test command that passed, with the state it passed on. */
+function after(payload, home, now = Date.now()) {
+  const key = mode(home) === 'off' ? null : testCommand(payload.tool_input?.command);
+  if (!key || runOutcome(payload) !== true) return;
+  const cwd = where(payload);
+  const work = workState(cwd);
+  if (!work) return;
+  const store = readStore(work.root, home);
+  const folder = folderOf(work.root, cwd);
+  store.passed = [...store.passed.filter(p => !(p.cmd === key && p.cwd === folder)), { cmd: key, cwd: folder, state: work.state, at: now }].slice(-KEEP_PASSED);
+  writeStore(work.root, store, home);
+}
+
+/** What the gate did in a work tree over 30 days, for `vibe knowledge journal` and `vibe retest`. */
+function summary(cwd, home, now = Date.now()) {
+  let root;
+  try { root = fs.realpathSync(git(cwd, ['rev-parse', '--show-toplevel'])?.toString('utf8').trim() || cwd); } catch { root = path.resolve(cwd); }
+  const events = readStore(root, home).events.filter(e => e.at >= now - 30 * DAY);
+  const counts = new Map();
+  for (const e of events) counts.set(e.cmd, (counts.get(e.cmd) ?? 0) + 1);
+  return {
+    mode: mode(home), days: 30,
+    stopped: events.filter(e => e.action === 'block').length, warned: events.filter(e => e.action === 'warn').length,
+    commands: [...counts].map(([command, count]) => ({ command, count })).sort((a, b) => b.count - a.count).slice(0, 10),
+  };
+}
+
+module.exports = { MODES, settingsFile, mode, testCommand, bypassed, workState, before, after, summary };

package/internal/guides/wiki.md

@@ -40,7 +40,8 @@ updated: 2026-10-16
 - `summary` is what lists and search results show, so write the conclusion, not "notes about X"; put it in double quotes when it holds a colon.
 - `tags`: one to five, reusing tags other pages already have (search finds them); lowercase, no spaces.
 - `aliases`: other names the user or a model would search for: synonyms, abbreviations and the user's own words in their language. This is the only place a record holds words outside English, so search in the user's language finds the page.
-- `type`, one of: `decision` (follow it), `method` (reuse it), `problem` (avoid or solve it), `fact`, `project`, `research`, `skill`, `proposal`. `vibe knowledge lint` reports any other value.
+- `type`, one of: `decision` (follow it), `method` (reuse it), `problem` (avoid or solve it), `fact`, `project`, `research`, `skill`, `proposal`, `source`. `vibe knowledge lint` reports any other value.
+- `source`: raw material kept as evidence (a transcript, a web clipping, a video analysis; voin marks meeting transcripts so). Never rewrite or split it; an organised page holds the conclusions and links it for its claims. The lint skips its length, not its links.
 - `supersedes: "[[old-page]]"` on a page that replaces another, and `status: archived` on a finished project or knowledge no longer in force. Search ranks both lower and marks them, so keep the old page for its reasons instead of deleting it.
 - One subject per page; a page covering two subjects is two pages linked to each other. Keep `## Related` at the end for links that are not already in the text.
 
@@ -80,7 +81,11 @@ Keep `proposals.md` in the wiki (`type: proposal` pages or one line each): what,
 
 ## Keep the connections
 
-Link related pages with `[[page]]` where a reader would follow the connection, with the reason; do not link every noun. `vibe knowledge find` shows which pages a subject touches. When the wiki has grown or links were edited, run `vibe knowledge lint` and fix what it reports: create or redirect a broken link's target, link an orphan from `index.md` or a related page, merge duplicate pages, split long ones. An unlinked shared page needs nothing: the next session start lists it; link it from a related page where the connection means something.
+Link related pages with `[[page]]` where a reader would follow the connection, with the reason; do not link every noun. `vibe knowledge find` shows which pages a subject touches. Every knowledge turn runs `vibe knowledge lint --fix` first: orphans join `index.md` on lines ending `<!-- vibe:auto -->` (removed when the page goes) and a project page `log.md` links to is created; unmarked lines are only reported. The turn names what is left: redirect or create a broken link's target, merge pages sharing a title, split long pages, fix unknown types. Give an auto line a real description when you can. An unlinked shared page needs nothing: the next session start lists it; link it from a related page where the connection means something.
+
+## Review
+
+After enough changed pages (`--review`, `--review-days`), the knowledge turn is also a review turn listing the changed pages and the pages they link. Read those together, not the whole wiki, for what a script cannot see: two pages disagreeing on one subject, a dated claim later facts or the code no longer support, a replaced decision still reading as current. Correct it with a one-line reason, date and source; mark a replaced decision with `supersedes` or `status: archived`; when unsure which claim holds, ask the user in one line. Report it like any knowledge turn ("점검: 모순 1건 수정 · 대체된 결정 1건 표시"), or nothing when everything holds.
 
 ## Tell the user
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "4.2.19",
+  "version": "4.2.21",
   "description": "Your personal FDE in Claude and Codex. Understand the work, use the right tools, deliver and retain useful context. One entry: vibe.",
   "type": "module",
   "bin": {