@thedecipherist/claude-packs 0.0.0-stage → 1.0.0

package/packs/base/hooks/lib/cpp-scan.mjs

@@ -0,0 +1,94 @@
+// Minimal C++ scanner: blanks comments and string/char literals (keeping offsets and
+// newlines intact), then finds audio-thread function definitions and their bodies.
+
+export const AUDIO_FUNCTIONS = new Set([
+  'processBlock',
+  'processBlockBypassed',
+  'renderNextBlock',
+  'processSample',
+]);
+
+const NOT_FUNCTIONS = new Set(['if', 'for', 'while', 'switch', 'catch', 'return', 'sizeof', 'alignof', 'decltype']);
+
+// Text allowed between a definition's ")" and its "{": qualifiers, trailing return type, attributes.
+// Parentheses are not allowed (except `noexcept(...)`, stripped first), so a call inside
+// `if (x.processSample (s)) {` is never mistaken for a definition.
+const TRAILER = /^[\s\w:<>,&*\[\]\-]*$/;
+const NOEXCEPT_ARG = /noexcept\s*\([^()]*\)/g;
+
+// keepStrings: blank comments only, so a check can read string literals in code but not prose
+export function blankCode(src, keepStrings = false) {
+  let out = '';
+  let i = 0;
+  const blank = (s) => s.replace(/[^\n]/g, ' ');
+  while (i < src.length) {
+    const two = src.slice(i, i + 2);
+    if (two === '//') {
+      const end = src.indexOf('\n', i);
+      const stop = end === -1 ? src.length : end;
+      out += blank(src.slice(i, stop));
+      i = stop;
+    } else if (two === '/*') {
+      const end = src.indexOf('*/', i + 2);
+      const stop = end === -1 ? src.length : end + 2;
+      out += blank(src.slice(i, stop));
+      i = stop;
+    } else if (src[i] === '"' || src[i] === "'" || src[i] === '`') {
+      // A string is walked either way, so a // inside one is no comment. A template string can span lines and stays as written.
+      const q = src[i];
+      let j = i + 1;
+      while (j < src.length && src[j] !== q && (src[j] !== '\n' || q === '`')) j += src[j] === '\\' ? 2 : 1;
+      const inner = src.slice(i + 1, j);
+      out += q + (keepStrings || q === '`' ? inner : blank(inner)) + (j < src.length ? src[j] : '');
+      i = j + 1;
+    } else {
+      out += src[i];
+      i += 1;
+    }
+  }
+  return out;
+}
+
+function matchClose(code, openIdx, open, close) {
+  let depth = 0;
+  for (let i = openIdx; i < code.length; i += 1) {
+    if (code[i] === open) depth += 1;
+    else if (code[i] === close) {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+// Returns [{ name, start, end }] where start..end is the body including braces.
+export function findAudioBodies(code) {
+  const bodies = [];
+  const nameRe = /\b([A-Za-z_]\w*)\s*\(/g;
+  let m;
+  while ((m = nameRe.exec(code)) !== null) {
+    const name = m[1];
+    if (NOT_FUNCTIONS.has(name)) continue;
+    const parenOpen = m.index + m[0].length - 1;
+    const parenClose = matchClose(code, parenOpen, '(', ')');
+    if (parenClose === -1) continue;
+    const brace = code.indexOf('{', parenClose);
+    const semi = code.indexOf(';', parenClose);
+    if (brace === -1 || (semi !== -1 && semi < brace)) continue;
+    const trailer = code.slice(parenClose + 1, brace).replace(NOEXCEPT_ARG, 'noexcept');
+    if (!TRAILER.test(trailer)) continue;
+    const isAudio = AUDIO_FUNCTIONS.has(name) || /\bnonblocking\b/.test(trailer);
+    if (!isAudio) continue;
+    const end = matchClose(code, brace, '{', '}');
+    if (end === -1) continue;
+    bodies.push({ name, start: brace, end });
+    nameRe.lastIndex = end;
+  }
+  return bodies;
+}
+
+export function lineAt(src, index) {
+  let line = 1;
+  for (let i = 0; i < index; i += 1) if (src[i] === '\n') line += 1;
+  return line;
+}

package/packs/base/hooks/lib/dup-index.mjs

@@ -0,0 +1,199 @@
+// dup-index: once-only's detector at write time (KWB-24). jscpd read the whole repo on every source write; this keeps an
+// index instead, built once and updated for the files that changed since, so a write costs one walk of the folders (a stat
+// of each source file, no reading) and a lookup, never a rescan.
+//   The index: per source file (lib/dup.mjs: SOURCE, its excludes, the same files jscpd judged), the hash of every window of
+//   WINDOW tokens (comments and blank space left out, as jscpd's mild mode) and the line each token is on; kept in
+//   $TMPDIR/claude-packs-dup-index/<checkout>.json, keyed by modification time and size. A file that changed is read again;
+//   one that is gone leaves.
+//   A candidate clone: the windows of the new text that are also in one other file, chained in order along one diagonal (a
+//   line changed inside a copy moves it by a few tokens; a gap of up to LIMITS.gap lines), covering LOOSE.tokens tokens over
+//   LOOSE.lines lines on either side, a little under jscpd's LIMITS (lib/dup.mjs) so the candidates hold every clone jscpd
+//   finds (measured on a C++ project's 752 sources: all 55 files jscpd flags are among them). A window found in more than COMMON
+//   places is boilerplate and never starts a match.
+//   loadIndex(root, { layout, shape }) -> { root, files: { rel: { h, l } }, built, read }   (read: files tokenized this call)
+//   clonesIn(index, writes, { ignore }) -> [{ at, other, lines, tokens }]  writes: [{ path, after, range | ranges }] (the changed
+//       lines, [lo, hi] each; one write per path), sides { file, start, end }
+//   judgeWrites(root, writes, { layout, shape, ignore }) -> { clones, error, index }: the index finds the candidates (it is
+//       looser than jscpd: a superset, measured on a C++ project's tree), then jscpd confirms on those files alone, so a write is
+//       refused when jscpd over the repo would refuse it, and a write with no candidate never starts jscpd.
+import { createHash } from 'node:crypto';
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join, relative } from 'node:path';
+import { clonesOf, excludeGlobs, LIMITS, real, scan, SOURCE } from './dup.mjs';
+import { matchesAny } from './glob.mjs';
+
+export const WINDOW = 20;
+const COMMON = 40;
+// A candidate is looser than jscpd's clone (it counts tokens and lines its own way: a block jscpd reads as 7 lines can be 5
+// here), so nothing jscpd would refuse is missed; jscpd then judges the candidates (judgeWrites).
+const LOOSE = { tokens: Math.round(LIMITS.tokens * 0.8), lines: LIMITS.lines - 2 };
+const MAX_BYTES = 512 * 1024; // a table or a blob, not code anyone copies by hand
+const VERSION = 1;
+
+const C_LIKE = /\/\/[^\n]*|\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|`(?:\\.|[^`\\])*`|[A-Za-z_$][\w$]*|\d[\w.]*|\S/g;
+const PY = /#[^\n]*|"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|[A-Za-z_]\w*|\d[\w.]*|\S/g;
+
+// -> { t: [token], l: [line of each token] }
+export function tokenize(text, path) {
+  const re = new RegExp((/\.py$/i.test(path) ? PY : C_LIKE).source, 'g');
+  const t = [];
+  const l = [];
+  let line = 1;
+  let at = 0;
+  for (const m of text.matchAll(re)) {
+    for (let i = at; i < m.index; i += 1) if (text.charCodeAt(i) === 10) line += 1;
+    const s = m[0];
+    const comment = s.startsWith('//') || s.startsWith('/*') || (s[0] === '#' && /\.py$/i.test(path));
+    if (!comment) { t.push(s); l.push(line); }
+    for (let i = 0; i < s.length; i += 1) if (s.charCodeAt(i) === 10) line += 1;
+    at = m.index + s.length;
+  }
+  return { t, l };
+}
+
+// FNV-1a over a window's tokens, one number per window start.
+export function windows(t) {
+  const out = [];
+  for (let i = 0; i + WINDOW <= t.length; i += 1) {
+    let h = 0x811c9dc5;
+    for (let k = i; k < i + WINDOW; k += 1) {
+      const s = t[k];
+      for (let c = 0; c < s.length; c += 1) { h ^= s.charCodeAt(c); h = Math.imul(h, 0x01000193); }
+      h ^= 0x1f; h = Math.imul(h, 0x01000193);
+    }
+    out.push(h >>> 0);
+  }
+  return out;
+}
+
+const fileOf = (root) => join(process.env.TMPDIR ?? tmpdir(), 'claude-packs-dup-index', `${createHash('sha1').update(real(root)).digest('hex').slice(0, 16)}.json`);
+
+// Every source file under root that the index judges: { rel: { m, s } }. Folders an exclude covers are never entered.
+function walk(root, ex) {
+  const out = {};
+  const go = (dir, rel) => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) { if (!matchesAny(`${r}/x`, ex) && !matchesAny(`${r}/x/x`, ex)) go(join(dir, e.name), r); continue; }
+      if (!e.isFile() || !SOURCE.test(e.name) || matchesAny(r, ex)) continue;
+      try { const st = statSync(join(dir, e.name)); if (st.size <= MAX_BYTES) out[r] = { m: st.mtimeMs, s: st.size }; } catch { /* gone */ }
+    }
+  };
+  go(root, '');
+  return out;
+}
+
+export function loadIndex(root, { layout = {}, shape = null } = {}) {
+  const file = fileOf(root);
+  let old = null;
+  try { old = JSON.parse(readFileSync(file, 'utf8')); } catch { /* built below */ }
+  if (old?.v !== VERSION || old.root !== real(root)) old = null;
+  const ex = excludeGlobs(layout, shape);
+  const now = walk(root, ex);
+  const files = {};
+  let read = 0;
+  for (const [rel, st] of Object.entries(now)) {
+    const was = old?.files[rel];
+    if (was && was.m === st.m && was.s === st.s) { files[rel] = was; continue; }
+    let text = '';
+    try { text = readFileSync(join(root, rel), 'utf8'); } catch { continue; }
+    const { t, l } = tokenize(text, rel);
+    files[rel] = { m: st.m, s: st.s, h: windows(t), l };
+    read += 1;
+  }
+  const changed = read > 0 || !old || Object.keys(old.files).length !== Object.keys(files).length;
+  if (changed) {
+    try {
+      mkdirSync(join(file, '..'), { recursive: true });
+      const tmp = `${file}.${process.pid}`;
+      writeFileSync(tmp, JSON.stringify({ v: VERSION, root: real(root), files }));
+      renameSync(tmp, file);
+    } catch { /* judged all the same */ }
+  }
+  return { root: real(root), files, built: !old, read };
+}
+
+// The clones the writes add: each write's windows on its changed lines, against every other file (the index, minus the
+// written files and `ignore`; each other write of the call as it will be; the write itself elsewhere in its own text).
+export function clonesIn(index, writes, { ignore = [] } = {}) {
+  const skip = new Set([...ignore, ...writes.map((w) => w.path)].map((p) => relative(index.root, real(p))));
+  const texts = writes.map((w) => { const { t, l } = tokenize(w.after, w.path); return { w, l, h: windows(t), n: t.length }; });
+  const found = [];
+  for (const q of texts) {
+    const ranges = q.w.ranges ?? [q.w.range];
+    const want = new Map();
+    for (let i = 0; i < q.h.length; i += 1) {
+      if (!ranges.some(([lo, hi]) => q.l[i] <= hi && q.l[i + WINDOW - 1] >= lo)) continue;
+      if (!want.has(q.h[i])) want.set(q.h[i], []);
+      want.get(q.h[i]).push(i);
+    }
+    if (!want.size) continue;
+    const others = [];
+    for (const [rel, f] of Object.entries(index.files)) if (!skip.has(rel)) others.push({ file: join(index.root, rel), h: f.h, l: f.l });
+    for (const o of texts) others.push({ file: real(o.w.path), h: o.h, l: o.l, self: o === q });
+    const pairs = new Map(); // other -> [[i, j]]
+    const seen = new Map();
+    for (const o of others) {
+      for (let j = 0; j < o.h.length; j += 1) {
+        const is = want.get(o.h[j]);
+        if (!is) continue;
+        seen.set(o.h[j], (seen.get(o.h[j]) ?? 0) + 1);
+        for (const i of is) if (!o.self || Math.abs(i - j) >= WINDOW) { if (!pairs.has(o)) pairs.set(o, []); pairs.get(o).push([i, j]); }
+      }
+    }
+    for (const [o, ps] of pairs) {
+      const real_ = ps.filter(([i]) => (seen.get(q.h[i]) ?? 0) <= COMMON).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+      for (const c of chains(real_, q.l)) {
+        // either side's lines (jscpd counts a block written on 3 long lines that repeats one of 7 lines)
+        const lines = Math.max(q.l[c.end - 1] - q.l[c.start] + 1, o.l[c.jhi - 1] - o.l[c.jlo] + 1);
+        if (c.covered < LOOSE.tokens || lines < LOOSE.lines) continue;
+        found.push({ at: { file: real(q.w.path), start: q.l[c.start], end: q.l[c.end - 1] }, other: { file: o.file, start: o.l[c.jlo], end: o.l[c.jhi - 1] }, lines, tokens: c.covered });
+      }
+    }
+  }
+  return found;
+}
+
+// Matched window pairs [i (new), j (other)], sorted by i, chained along a diagonal: a change of a few tokens inside a copy
+// keeps it one chain; a gap of more than LIMITS.gap lines in the new text ends it.
+function chains(pairs, lines) {
+  const out = [];
+  for (const [i, j] of pairs) {
+    const d = j - i;
+    const c = out.find((x) => Math.abs(x.d - d) <= 12 && i >= x.lastI && lines[i] <= lines[x.end - 1] + LIMITS.gap + 1);
+    if (!c) { out.push({ start: i, end: i + WINDOW, covered: WINDOW, d, lastI: i, jlo: j, jhi: j + WINDOW }); continue; }
+    if (i === c.lastI && d === c.d) continue;
+    c.covered += Math.max(0, i + WINDOW - Math.max(i, c.end));
+    c.end = Math.max(c.end, i + WINDOW);
+    c.d = d;
+    c.lastI = i;
+    c.jlo = Math.min(c.jlo, j);
+    c.jhi = Math.max(c.jhi, j + WINDOW);
+  }
+  return out;
+}
+
+export function judgeWrites(root, writes, { layout = {}, shape = null, ignore = [] } = {}) {
+  const index = loadIndex(root, { layout, shape });
+  const maybe = clonesIn(index, writes, { ignore });
+  if (!maybe.length) return { clones: [], index };
+  const tmp = mkdtempSync(join(process.env.TMPDIR ?? tmpdir(), 'once-only-new-'));
+  try {
+    const extra = writes.map((w, i) => {
+      const path = join(tmp, String(i), basename(w.path));
+      mkdirSync(join(tmp, String(i)), { recursive: true });
+      writeFileSync(path, w.after);
+      return { path, as: w.path };
+    });
+    const written = new Set(writes.map((w) => real(w.path)));
+    const paths = [...new Set(maybe.map((c) => c.other.file))].filter((f) => !written.has(real(f)));
+    const r = scan(root, { extra, ignore, layout, shape, paths });
+    if (r.error) return { clones: [], error: r.error, index };
+    return { clones: writes.flatMap((w) => (w.ranges ?? [w.range]).flatMap((range) => clonesOf(r.clones, w.path, range))), index };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}

package/packs/base/hooks/lib/dup.mjs

@@ -0,0 +1,127 @@
+// dup: the one copy-paste reader (once-only at write time, making-check at the end of a turn, doctor's count and
+// `claude-packs dup scan`). Code that exists once is called, never copied: a near-duplicate of a block already in the repo
+// is refused with where the first one lives (0.9.0 item 9).
+//
+// The detector is jscpd (5.4.2, an optional dependency of the kit: a Rust binary). Measured on a C++ repo of 580 C++,
+// Python and JS sources: 0.3 s for the whole tree, so it runs at write time; a planted copy of a function with one line
+// changed is found as one near-miss clone (--max-gap-lines). Threshold: 50 tokens and 6 lines, a gap of up to 2 lines.
+//   findJscpd(starts) -> path | null       CLAUDE_PACKS_JSCPD, then node_modules/.bin/jscpd above each start, then PATH
+//   scan(root, { extra, layout, shape, paths }) -> { clones, ms, error }   paths: only these files (once-only's confirmation), else the tree
+//       extra: [{ path, as }] files outside the tree judged as if they were `as` (the text a write would leave), `as`
+//       itself left out of the scan; ignore: more paths left out (a file a move takes away). Clone sides are
+//       { file, start, end }, `file` the real path in the repo (`as` for extra).
+//   changedLines(before, after) -> [lo, hi] | null   the lines of after that differ (1-based), null when none do
+//   isSource(rel), isGenerated(text), excludeGlobs(layout, shape)
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { matchesAny } from './glob.mjs';
+
+export const LIMITS = { tokens: 50, lines: 6, gap: 2 };
+export const SOURCE = /\.(c|cc|cpp|cxx|h|hh|hpp|hxx|inl|mm|m|py|js|mjs|cjs|jsx|ts|tsx)$/i;
+const FORMATS = 'c,c-header,cpp,cpp-header,objectivec,python,javascript,jsx,typescript,tsx';
+// A header and a source are one language: a function copied from a .cpp into a .h is a copy (jscpd compares within a format otherwise).
+const CROSS = 'c,c-header,cpp,cpp-header,objectivec;javascript,jsx,typescript,tsx';
+// Generated files, resources and vendored or built code are never judged (and never a match).
+export const DEFAULT_EXCLUDE = [
+  '.git/**', '.claude/**', 'node_modules/**', '**/node_modules/**', 'third_party/**', '**/third_party/**', 'JUCE/**', '**/JUCE/**',
+  'out/**', 'build/**', '**/resources/**', '**/Resources/**', '**/generated/**', '**/*.generated.*', '**/*_generated.*', '**/BinaryData.*',
+];
+export const FIX = 'call it, or extract one function that both call, parameterized over what differs';
+
+export const isSource = (rel) => SOURCE.test(rel);
+export const isGenerated = (text) => /\b(?:auto-?generated|generated by|do not edit|DO NOT EDIT|@generated)\b/i.test((text ?? '').split('\n').slice(0, 6).join('\n'));
+
+export function excludeGlobs(layout = {}, shape = null) {
+  const out = [...DEFAULT_EXCLUDE];
+  const build = layout.buildOutput;
+  for (const g of Array.isArray(build) ? build : build ? [build] : []) out.push(g);
+  for (const g of shape?.exclude ?? []) out.push(g);
+  out.push('design/shape.json');
+  return [...new Set(out)].filter((g) => !g.includes(',')); // jscpd takes one comma-separated list
+}
+
+// The folders of kind "copy" (another project's code, copied unchanged): a match there is real, but a clone with both
+// sides inside copies is the other project's, never counted here.
+export const copyGlobs = (layout = {}) => Object.values(layout.folders ?? {}).filter((f) => f.kind === 'copy').map((f) => `${f.path.replace(/\/+$/, '')}/**`);
+
+export function findJscpd(starts = []) {
+  const env = process.env.CLAUDE_PACKS_JSCPD;
+  if (env && existsSync(env)) return env;
+  const here = dirname(fileURLToPath(import.meta.url));
+  for (const s of [...starts, here]) {
+    let d = resolve(s);
+    for (;;) {
+      for (const c of ['node_modules/.bin/jscpd', 'node_modules/@thedecipherist/claude-packs/node_modules/.bin/jscpd']) if (existsSync(join(d, c))) return join(d, c);
+      const up = dirname(d);
+      if (up === d) break;
+      d = up;
+    }
+  }
+  for (const p of (process.env.PATH ?? '').split(delimiter)) if (p && existsSync(join(p, 'jscpd'))) return join(p, 'jscpd');
+  return null;
+}
+
+export function changedLines(before, after) {
+  if (after === null || after === undefined || before === after) return null;
+  const a = (before ?? '').split('\n');
+  const b = after.split('\n');
+  let top = 0;
+  while (top < a.length && top < b.length && a[top] === b[top]) top += 1;
+  let tail = 0;
+  while (tail < a.length - top && tail < b.length - top && a[a.length - 1 - tail] === b[b.length - 1 - tail]) tail += 1;
+  const lo = top + 1;
+  const hi = b.length - tail;
+  return hi >= lo ? [lo, hi] : null; // a pure deletion adds no line
+}
+
+// Real paths: /var and /private/var are one folder on a Mac, and jscpd prints the real one.
+export const real = (p) => { try { return realpathSync(p); } catch { const d = dirname(resolve(p)); return d === resolve(p) ? d : join(real(d), resolve(p).slice(d.length + 1)); } };
+
+export function scan(root, { extra = [], ignore: alsoIgnore = [], layout = {}, shape = null, jscpd = null, timeoutMs = 8000, paths = null } = {}) {
+  const bin = jscpd ?? findJscpd([root]);
+  if (!bin) return { clones: [], error: 'jscpd not found (it is an optional dependency of @thedecipherist/claude-packs: npm install in the project, or set CLAUDE_PACKS_JSCPD)' };
+  const out = mkdtempSync(join(process.env.TMPDIR ?? tmpdir(), 'once-only-'));
+  const abs = real(root);
+  const ignore = [...excludeGlobs(layout, shape).map((g) => `${abs}/${g}`), ...extra.map((x) => real(x.as)), ...alsoIgnore.map(real)];
+  const args = ['-a', '-s', '-k', String(LIMITS.tokens), '-l', String(LIMITS.lines), '--max-gap-lines', String(LIMITS.gap), '--exit-code', '0',
+    '-f', FORMATS, '-r', 'json', '-o', out, '--cross-formats', CROSS, '-i', ignore.join(','), ...(paths ?? [abs]), ...extra.map((x) => x.path)];
+  const t0 = Date.now();
+  const r = spawnSync(bin, args, { encoding: 'utf8', timeout: timeoutMs, cwd: abs });
+  const ms = Date.now() - t0;
+  let report = null;
+  try { report = JSON.parse(readFileSync(join(out, 'jscpd-report.json'), 'utf8')); } catch { /* read below */ }
+  rmSync(out, { recursive: true, force: true });
+  if (!report) return { clones: [], ms, error: `jscpd gave no report (exit ${r.status}${r.signal ? `, ${r.signal}` : ''}): ${(r.stderr || r.error?.message || '').split('\n')[0]}` };
+  const back = new Map(extra.map((x) => [real(x.path), real(x.as)]));
+  const side = (f) => { const p = real(resolve(abs, f.name)); return { file: back.get(p) ?? p, start: f.start, end: f.end }; };
+  const clones = (report.duplicates ?? []).map((d) => ({ a: side(d.firstFile), b: side(d.secondFile), lines: d.lines, tokens: d.tokens }));
+  return { clones, ms, sources: report.statistics?.total?.sources ?? 0 };
+}
+
+// The clones a block adds: one side in `file` overlapping [lo, hi], the other side anywhere (another copy in the same
+// file included). Returns [{ at: {file,start,end}, other: {file,start,end}, lines, tokens }].
+export function clonesOf(clones, file, [lo, hi]) {
+  const f = real(file);
+  const hits = (s) => s.file === f && s.start <= hi && s.end >= lo;
+  const out = [];
+  for (const c of clones) {
+    if (hits(c.a)) out.push({ at: c.a, other: c.b, lines: c.lines, tokens: c.tokens });
+    else if (hits(c.b)) out.push({ at: c.b, other: c.a, lines: c.lines, tokens: c.tokens });
+  }
+  return out;
+}
+
+// Every clone of a repo, both sides inside copy trees left out. `rel` makes the paths relative for printing.
+export function repoClones(root, { layout = {}, shape = null, jscpd = null } = {}) {
+  const r = scan(root, { layout, shape, jscpd, timeoutMs: 120000 });
+  const copies = copyGlobs(layout);
+  const base = real(root);
+  const rel = (p) => (p.startsWith(`${base}/`) ? p.slice(base.length + 1) : p);
+  const clones = r.clones
+    .map((c) => ({ ...c, a: { ...c.a, file: rel(c.a.file) }, b: { ...c.b, file: rel(c.b.file) } }))
+    .filter((c) => !(matchesAny(c.a.file, copies) && matchesAny(c.b.file, copies)));
+  return { ...r, clones };
+}

package/packs/base/hooks/lib/elements.mjs

@@ -0,0 +1,87 @@
+// Elements built by hand (0.23.0: anything "component" used more than once is a template, in html, c++ and apps). once-only compares
+// code as written, so two controls that differ in their names and text look different to it. Here names and text are stripped, and what is
+// left is the element's shape: copies of one element have one shape.
+//   markup   an element and its children: tags, attribute names, nesting (HTML, JSX, Vue, Svelte, template strings)
+//   code     setups, runs of statements and tables written as code (lib/code-shapes.mjs)
+// Using a template is never a shape: a capitalised tag (<Knob ... />) is a component, and a list from .map() appears once.
+//   shapesOf(text, ext) -> [{ id, kind, line, what }]     codeFiles(root, skipGlobs) -> [rel]
+import { readdirSync, statSync } from 'node:fs';
+import { extname, join, relative } from 'node:path';
+import { codeShapes } from './code-shapes.mjs';
+import { matchesAny } from './glob.mjs';
+
+export const CODE = new Set(['.c', '.cc', '.cpp', '.cxx', '.h', '.hh', '.hpp', '.mm', '.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx']);
+export const MARKUP = new Set(['.html', '.htm', '.vue', '.svelte', '.tsx', '.jsx', '.ts', '.js', '.mjs']);
+export const SKIP = /(^|\/)(\.git|node_modules|build|Builds|dist|out|target|_deps|JUCE|JuceLibraryCode|third_party|vendor|Pods|venv|\.venv|site-packages|__pycache__|\.tox|\.next|coverage|cmake-build[^/]*|\.claude)(\/|$)/;
+export const TESTS = ['tests/**', 'test/**', '**/tests/**', '**/test/**', '**/*.test.*', '**/*.spec.*', '**/*_test.*'];
+
+const VOID = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr']);
+const TAG = /<(\/?)([A-Za-z][\w.:-]*)((?:[^<>{}"'`]|"[^"]*"|'[^']*'|`[^`]*`|\{(?:[^{}]|\{[^{}]*\})*\})*?)(\/?)>/g;
+const ATTR = /([A-Za-z_:@][\w:.-]*)(?==|\s|$)/g;
+const MIN_NODES = 4; // the element, and at least three more tags or attributes: a bare <li> is not a component
+
+const attrsOf = (raw) => [...raw.replace(/"[^"]*"|'[^']*'|`[^`]*`|\{(?:[^{}]|\{[^{}]*\})*\}/g, ' ').matchAll(ATTR)].map((m) => m[1]).sort();
+const lineOf = (text, index) => text.slice(0, index).split('\n').length;
+
+// Every plain element with its children, as one string. An unclosed or unbalanced tag ends the walk for that branch, never the file.
+function markupShapes(text) {
+  const out = [];
+  const stack = [];
+  for (const m of text.matchAll(TAG)) {
+    const [, close, tag, attrs, self] = m;
+    if (close) {
+      const at = stack.map((e) => e.tag).lastIndexOf(tag);
+      if (at === -1) continue;
+      stack.length = at + 1;
+      const el = stack.pop();
+      const shape = `${el.tag}[${el.attrs.join(',')}](${el.kids.join('')})`;
+      stack.at(-1)?.kids.push(shape);
+      if (stack.at(-1)) stack.at(-1).nodes += el.nodes;
+      if (/^[a-z]/.test(el.tag) && el.nodes >= MIN_NODES && el.kids.length >= 1) out.push({ id: `m:${shape}`, kind: 'markup', line: lineOf(text, el.index), what: `<${el.tag}>`, nodes: el.nodes });
+      continue;
+    }
+    const names = attrsOf(attrs);
+    if (self || VOID.has(tag.toLowerCase())) {
+      const top = stack.at(-1);
+      if (top) { top.kids.push(`${tag}[${names.join(',')}]`); top.nodes += 1 + names.length; }
+      continue;
+    }
+    stack.push({ tag, attrs: names, kids: [], nodes: 1 + names.length, index: m.index });
+  }
+  // Keep the largest: the parts of a repeated element repeat too.
+  return out.filter((s) => !out.some((o) => o !== s && o.id.length > s.id.length && o.id.includes(s.id.slice(2))));
+}
+
+export function shapesOf(text, ext) {
+  return [...(MARKUP.has(ext) ? markupShapes(text) : []), ...codeShapes(text, ext)];
+}
+
+// A short setup needs a third copy to be a pattern (two members; three on one name, the same habit in two files). Rows are a fault on their own.
+export const copiesNeeded = (shape, oneName = false) => (shape.kind === 'rows' ? 1 : shape.kind === 'setup' && (shape.nodes < 3 || (shape.nodes === 3 && oneName)) ? 3 : 2);
+
+// What the law leaves alone: `protected` globs, folders of kind copy (a tree kept the same as its source on purpose) and `guards.templates.exclude`.
+export const skippedBy = (layout) => [...(layout.protected ?? []), ...(layout.guards?.templates?.exclude ?? []),
+  ...Object.values(layout.folders ?? {}).filter((f) => f.kind === 'copy').map((f) => `${f.path}/**`)];
+
+// What each kind of repeat becomes: the refusal and the scan say it, so a repeat is never only named.
+export const TEMPLATE = {
+  markup: 'one component, with the differences passed in',
+  setup: 'one factory function: it builds the object from its arguments',
+  run: 'one function, with the differences as parameters',
+  rows: 'one table of the arguments, and one loop',
+};
+
+export function codeFiles(root, skipGlobs = [], exts = CODE) {
+  const out = [];
+  const walk = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const abs = join(dir, e.name);
+      const rel = relative(root, abs).replace(/\\/g, '/');
+      if (SKIP.test(rel) || matchesAny(rel, skipGlobs)) continue;
+      if (e.isDirectory()) walk(abs);
+      else if (exts.has(extname(e.name)) && statSync(abs).size < 400_000) out.push(rel);
+    }
+  };
+  walk(root);
+  return out;
+}

package/packs/base/hooks/lib/event-log.mjs

@@ -0,0 +1,67 @@
+// The detail behind hooks.log. Every call is one line of .claude/logs/events.jsonl: who, where, what was attempted, and each hook's time, exit code and reason. Every refusal
+// and crash is also a line of .claude/logs/refusals.jsonl, with an id, the branch and commit, the kit's version and the hash of the hook that decided, so it can be judged
+// later: `claude-packs logs mark <id> right|wrong "<why>"`. Bug logs only record the refusals somebody complained about; this records them all. Secrets are masked. File
+// contents are not kept, only their size. Logs rotate and are never cleared.
+//   logCall(root, text, [{ hook, ms, code, reason, out }], append, total)
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { maskSecrets } from './secret-patterns.mjs';
+
+export const EVENTS = join('.claude', 'logs', 'events.jsonl');
+export const REFUSALS = join('.claude', 'logs', 'refusals.jsonl');
+const KEEP = { command: 4000, prompt: 1000, reason: 4000, out: 500 };
+
+const cut = (text, n) => { const t = maskSecrets(text ?? ''); return t.length > n ? `${t.slice(0, n)}... [${t.length} chars]` : t; };
+
+// The branch and commit of a checkout, from its files: no process is started on the hot path. A worktree's .git is a file.
+export function headOf(cwd) {
+  try {
+    let git = join(cwd, '.git');
+    if (statSync(git).isFile()) git = resolve(cwd, readFileSync(git, 'utf8').replace('gitdir:', '').trim());
+    const head = readFileSync(join(git, 'HEAD'), 'utf8').trim();
+    const ref = head.match(/^ref: (.+)$/)?.[1];
+    if (!ref) return { commit: head.slice(0, 12) };
+    const common = existsSync(join(git, 'commondir')) ? resolve(git, readFileSync(join(git, 'commondir'), 'utf8').trim()) : git;
+    let commit;
+    try { commit = readFileSync(join(common, ref), 'utf8').trim().slice(0, 12); } catch { /* packed, or no commit yet */ }
+    return { branch: ref.replace('refs/heads/', ''), commit };
+  } catch { return {}; }
+}
+
+// What the call tried to do, from the event itself.
+function attempt(ev) {
+  const i = ev.tool_input ?? {};
+  const body = i.content ?? i.new_string ?? i.new_source;
+  return {
+    ...(i.file_path || i.notebook_path ? { file: i.file_path ?? i.notebook_path } : {}),
+    ...(typeof body === 'string' ? { bytes: body.length } : {}),
+    ...(i.edits ? { edits: i.edits.length } : {}),
+    ...(i.command ? { command: cut(i.command, KEEP.command) } : {}),
+    ...(i.description ? { description: cut(i.description, 200) } : {}),
+    ...(ev.prompt ? { prompt: cut(ev.prompt, KEEP.prompt) } : {}),
+  };
+}
+
+function lawOf(root, hook) {
+  try {
+    const lock = JSON.parse(readFileSync(join(root, '.claude/claude-packs.lock.json'), 'utf8'));
+    return { kit: lock.kit, hookHash: lock.files?.[`.claude/hooks/${hook}.mjs`]?.slice(0, 12) };
+  } catch { return {}; }
+}
+
+export function logCall(root, text, hooks, append, total) {
+  try {
+    let ev = {};
+    try { ev = JSON.parse(text) ?? {}; } catch { /* a line with no event is still a line */ }
+    const t = new Date().toISOString();
+    const where = { session: ev.session_id, agent: ev.agent_id ?? ev.agent_type, cwd: ev.cwd, event: ev.hook_event_name, tool: ev.tool_name ?? ev.source, mode: ev.permission_mode };
+    const what = attempt(ev);
+    const judged = hooks.map((h) => ({ hook: h.hook, ms: Math.round(h.ms), code: h.code, ...(h.code !== 0 && h.reason ? { reason: cut(h.reason, KEEP.reason) } : {}), ...(h.out ? { out: cut(h.out, KEEP.out) } : {}) }));
+    append(root, EVENTS, `${JSON.stringify({ t, ...where, ...what, ...(total ? { ms: Math.round(total) } : {}), hooks: judged })}\n`);
+    for (const h of judged.filter((x) => x.code !== 0)) {
+      const id = createHash('sha1').update(`${t}${h.hook}${h.reason ?? ''}`).digest('hex').slice(0, 8);
+      append(root, REFUSALS, `${JSON.stringify({ id, t, hook: h.hook, code: h.code, reason: h.reason, ...where, ...what, ...headOf(ev.cwd ?? root), ...lawOf(root, h.hook) })}\n`);
+    }
+  } catch { /* the log never stops a hook */ }
+}