@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/robin/claude/hooks/vendor/look/made-of.mjs

@@ -0,0 +1,243 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/look/made-of.ts by the GDK build. Do not edit.
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+export const PRIMITIVES = [
+    'Box', 'Sphere', 'Cylinder', 'Cone', 'Capsule', 'Torus', 'TorusKnot', 'Plane', 'Circle', 'Ring',
+    'Octahedron', 'Icosahedron', 'Dodecahedron', 'Tetrahedron', 'Polyhedron', 'Lathe', 'Extrude', 'Shape', 'Tube',
+];
+const PRIMITIVE = new RegExp(`\\bnew\\s+(?:THREE\\.)?(${PRIMITIVES.join('|')})(?:Buffer)?Geometry\\s*\\(`, 'g');
+const BUFFER = /\bnew\s+(?:THREE\.)?BufferGeometry\s*\(/g;
+const MODEL_SIGNS = [
+    [/\b(GLTFLoader|useGLTF|FBXLoader|OBJLoader|ColladaLoader)\b/, 'a model loader'],
+    [/['"`][^'"`\n]*\.(glb|gltf)\b/i, 'a .glb/.gltf path'],
+    [/findAsset\(\s*['"]models['"]/, "findAsset('models', …)"],
+    [/\b(loadCharacter|loadModel|loadGlb|loadGLB|loadGltf)\s*\(/, 'a model-loading helper'],
+    [/\bcloneSkinned|SkeletonUtils\.clone\b/, 'a skinned clone'],
+];
+export const HERO_WORDS = [
+    'player', 'hero', 'avatar', 'character', 'rival', 'rivals', 'enemy', 'enemies', 'boss', 'opponent', 'npc', 'creature',
+    'monster', 'mob', 'vehicle', 'car', 'cars', 'kart', 'ship', 'boat', 'skiff', 'bike', 'plane', 'craft', 'racer', 'mech',
+    'robot', 'pet', 'knight', 'drone', 'tank',
+];
+const SRC_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs']);
+const SKIP_DIR = new Set(['node_modules', 'dist', '.funtools', '.git', 'test', 'tests', '__tests__']);
+const IMAGE = /\.(png|jpe?g|webp)$/i;
+export function readSources(dir) {
+    const out = [];
+    const walk = (at) => {
+        let names = [];
+        try {
+            names = readdirSync(at);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            const p = join(at, n);
+            let s;
+            try {
+                s = statSync(p);
+            }
+            catch {
+                continue;
+            }
+            if (s.isDirectory()) {
+                if (!SKIP_DIR.has(n))
+                    walk(p);
+                continue;
+            }
+            if (SRC_EXT.has(extname(n)) && !/\.(test|spec)\.[cm]?[jt]sx?$/.test(n) && !n.endsWith('.d.ts'))
+                out.push({ path: relative(dir, p), text: readFileSync(p, 'utf8') });
+        }
+    };
+    walk(join(dir, 'src'));
+    return out;
+}
+export function entryOf(dir, files) {
+    const have = new Set(files.map((f) => f.path));
+    try {
+        const html = readFileSync(join(dir, 'index.html'), 'utf8');
+        for (const m of html.matchAll(/<script[^>]*\bsrc=["'](?:\.?\/)?([^"']+)["']/g))
+            if (have.has(m[1]))
+                return m[1];
+    }
+    catch { }
+    return ['main.tsx', 'main.ts', 'main.jsx', 'main.js', 'index.tsx', 'index.ts', 'index.js'].map((n) => join('src', n)).find((p) => have.has(p)) ?? null;
+}
+const IMPORT = /(?:\bimport\s[^'"]*?from\s*|\bimport\s*\(\s*|\bexport\s[^'"]*?from\s*|\bimport\s+)['"](\.{1,2}\/[^'"]+)['"]/g;
+export function reachable(files, entry) {
+    const byPath = new Map(files.map((f) => [f.path, f]));
+    if (!entry)
+        return new Set(byPath.keys());
+    const resolveImport = (from, spec) => {
+        const base = join(dirname(from), spec);
+        const tries = [base, ...[...SRC_EXT].map((e) => base.replace(/\.(js|jsx|mjs)$/, '') + e), ...[...SRC_EXT].map((e) => join(base, `index${e}`))];
+        return tries.find((t) => byPath.has(t)) ?? null;
+    };
+    const seen = new Set();
+    const stack = [entry];
+    while (stack.length) {
+        const p = stack.pop();
+        if (seen.has(p))
+            continue;
+        seen.add(p);
+        for (const m of byPath.get(p).text.matchAll(IMPORT)) {
+            const r = resolveImport(p, m[1]);
+            if (r && !seen.has(r))
+                stack.push(r);
+        }
+    }
+    return seen;
+}
+const wordsIn = (s) => s.toLowerCase().split(/[^a-z]+/).filter(Boolean);
+export function rolesOf(file, extra = []) {
+    const hits = new Set();
+    const stem = basename(file.path).replace(/\.[^.]+$/, '');
+    for (const w of wordsIn(stem))
+        if (HERO_WORDS.includes(w))
+            hits.add(w);
+    for (const m of file.text.matchAll(/\.name\s*=\s*[`'"]([^`'"]+)[`'"]|\bname\s*:\s*[`'"]([^`'"]+)[`'"]/g)) {
+        const n = m[1] ?? m[2];
+        for (const w of wordsIn(n))
+            if (HERO_WORDS.includes(w))
+                hits.add(w);
+        for (const r of extra)
+            if (r.test(n))
+                hits.add(n);
+    }
+    return [...hits];
+}
+export function makeOf(file, extra = []) {
+    const primitives = {};
+    for (const m of file.text.matchAll(PRIMITIVE))
+        primitives[m[1]] = (primitives[m[1]] ?? 0) + 1;
+    const built = [...file.text.matchAll(BUFFER)].length;
+    const model = MODEL_SIGNS.find(([re]) => re.test(file.text))?.[1] ?? null;
+    return { file: file.path, roles: rolesOf(file, extra), primitives, built, model };
+}
+const count = (p) => Object.values(p).reduce((a, b) => a + b, 0);
+export function shippedModels(dir, reachedText) {
+    const out = [];
+    const walk = (at) => {
+        let names = [];
+        try {
+            names = readdirSync(at);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            const p = join(at, n);
+            let s;
+            try {
+                s = statSync(p);
+            }
+            catch {
+                continue;
+            }
+            if (s.isDirectory()) {
+                if (!SKIP_DIR.has(n))
+                    walk(p);
+                continue;
+            }
+            if (/\.(glb|gltf)$/i.test(n)) {
+                const stem = n.replace(/\.(glb|gltf)$/i, '');
+                out.push({ file: relative(dir, p), bytes: s.size, used: reachedText.includes(n) || new RegExp(`['"\`]${stem.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"\`]`).test(reachedText) });
+            }
+        }
+    };
+    walk(join(dir, 'public'));
+    return out;
+}
+export function declaredOf(dir, manifest) {
+    const a = manifest?.art3d && typeof manifest.art3d === 'object' ? manifest.art3d : {};
+    const proof = typeof a.proof === 'string' && a.proof.trim() ? a.proof.trim() : null;
+    const at = proof ? resolve(dir, proof) : null;
+    return {
+        procedural: a.heroes === 'procedural',
+        why: typeof a.why === 'string' && a.why.trim() ? a.why.trim() : null,
+        proof,
+        proof_exists: !!at && at.startsWith(resolve(dir)) && IMAGE.test(at) && existsSync(at),
+        stand_ins: Array.isArray(a.stand_ins) ? a.stand_ins.filter((s) => typeof s === 'string' && s.trim()).map((s) => s.trim()) : [],
+    };
+}
+function actorPatterns(manifest) {
+    return ['player', 'threats'].flatMap((k) => {
+        const v = manifest?.actors?.[k];
+        try {
+            return typeof v === 'string' && v ? [new RegExp(v, 'i')] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+const kinds = (p) => Object.entries(p).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k} ${n}`).join(', ');
+const mb = (b) => (b >= 1_048_576 ? `${(b / 1_048_576).toFixed(1)} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
+export function heroLine(h) {
+    const bits = [count(h.primitives) ? `${count(h.primitives)} primitive${count(h.primitives) > 1 ? 's' : ''} (${kinds(h.primitives)})` : '', h.built ? `${h.built} hand-built mesh${h.built > 1 ? 'es' : ''}` : ''].filter(Boolean);
+    const what = h.model ? `loads a model (${h.model})${bits.length ? ` beside ${bits.join(' and ')}` : ''}` : bits.join(' and ');
+    return `${basename(h.file)}${h.roles.length ? ` (${h.roles.slice(0, 4).join(', ')})` : ''}: ${what}`;
+}
+const namedIn = (h, standIns) => {
+    const said = standIns.join(' ').toLowerCase();
+    return [basename(h.file).replace(/\.[^.]+$/, ''), ...h.roles].some((w) => said.includes(w.toLowerCase()));
+};
+export function madeOf(dir, given) {
+    let manifest = given?.manifest;
+    if (!manifest) {
+        try {
+            manifest = JSON.parse(readFileSync(join(dir, 'funpixel.json'), 'utf8'));
+        }
+        catch {
+            manifest = {};
+        }
+    }
+    const files = given?.files ?? readSources(dir);
+    const entry = entryOf(dir, files);
+    const reached = reachable(files, entry);
+    const live = files.filter((f) => reached.has(f.path));
+    const three = live.some((f) => /from\s+['"]three['"]|require\(\s*['"]three['"]\s*\)|from\s+['"]@react-three\/fiber['"]/.test(f.text));
+    const extra = actorPatterns(manifest);
+    const makes = live.map((f) => makeOf(f, extra));
+    const totals = { primitives: {}, primitive_count: 0, built: 0, model_files: makes.filter((m) => m.model).map((m) => m.file) };
+    for (const m of makes) {
+        for (const [k, n] of Object.entries(m.primitives))
+            totals.primitives[k] = (totals.primitives[k] ?? 0) + n;
+        totals.built += m.built;
+    }
+    totals.primitive_count = count(totals.primitives);
+    const heroes = makes.filter((m) => m.roles.length && (m.model || count(m.primitives) || m.built));
+    const models = shippedModels(dir, live.map((f) => f.text).join('\n'));
+    const declared = declaredOf(dir, manifest);
+    const base = { three, files: files.length, reached: reached.size, entry, heroes, totals, models, declared };
+    const style = declared.procedural && declared.why && declared.proof_exists;
+    if (!three)
+        return { ...base, verdict: 'not_observed', says: 'not a Three.js game (no source imports three): nothing to judge', unnamed: [] };
+    const codeHeroes = heroes.filter((h) => !h.model);
+    const shipped = models.filter((m) => m.used);
+    const inventory = models.length
+        ? `${models.length} model file${models.length > 1 ? 's' : ''} shipped (${models.slice(0, 4).map((m) => `${basename(m.file)} ${mb(m.bytes)}${m.used ? '' : ', never named in code'}`).join('; ')})`
+        : 'no model file shipped under public/';
+    const declaredWords = style
+        ? `declared a deliberate procedural style ("${declared.why}"), proof ${declared.proof}`
+        : declared.procedural
+            ? `art3d declares a procedural style but ${!declared.why ? 'gives no reason' : `its proof ${declared.proof ? `${declared.proof} is missing` : 'frame is not given'}`}, so it is not proven`
+            : 'no deliberate procedural style declared (funpixel.json art3d)';
+    const allCode = !totals.model_files.length && !shipped.length && totals.primitive_count + totals.built >= 8;
+    if (!heroes.length && !allCode) {
+        return { ...base, verdict: 'not_observed', says: `no player, rival or enemy found by file or node name (${totals.primitive_count} primitives, ${totals.model_files.length} file(s) loading a model; ${inventory}): name the hero nodes, or give funpixel.json "actors"`, unnamed: [] };
+    }
+    if (!codeHeroes.length && !(allCode && !heroes.length)) {
+        return { ...base, verdict: 'pass', says: `hero objects load models: ${heroes.map(heroLine).join('; ')}; ${inventory}`, unnamed: [] };
+    }
+    const subjects = codeHeroes;
+    const unnamed = style ? []
+        : subjects.length ? subjects.filter((h) => !namedIn(h, declared.stand_ins)).map((h) => basename(h.file))
+            : declared.stand_ins.length ? [] : ['the scene'];
+    const what = subjects.length
+        ? `hero objects are code primitives: ${subjects.map(heroLine).join('; ')}`
+        : `everything drawn is code: ${totals.primitive_count} primitives (${kinds(totals.primitives)}) and ${totals.built} hand-built meshes, no model loaded`;
+    const named = style ? '' : declared.stand_ins.length ? `; stand-ins named: ${declared.stand_ins.join('; ')}${unnamed.length ? ` (not named: ${unnamed.join(', ')})` : ''}` : '; not named as stand-ins';
+    return { ...base, verdict: style ? 'pass' : 'fail', says: `${what}; ${inventory}; ${declaredWords}${named}`, unnamed };
+}

package/plugins/robin/claude/hooks/vendor/look/roles.mjs

@@ -0,0 +1,110 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/look/roles.ts by the GDK build. Do not edit.
+const VERDICTS = ['animated', 'slides', 'still'];
+const ENGINES = ['pixi', 'three', 'none'];
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export function recordProblems(r) {
+    if (!isRecord(r))
+        return ['not a JSON object'];
+    const out = [];
+    const engine = r.engine;
+    if (typeof engine !== 'string' || !ENGINES.includes(engine))
+        out.push(`engine must be one of ${ENGINES.join(', ')}`);
+    const none = engine === 'none';
+    if (!Number.isInteger(r.samples) || r.samples < (none ? 0 : 1))
+        out.push(`samples must be an integer of at least ${none ? 0 : 1}`);
+    if (!Array.isArray(r.actors))
+        return [...out, 'actors must be a list'];
+    r.actors.forEach((a, i) => {
+        const at = `actor ${i + 1}`;
+        if (!isRecord(a) || typeof a.name !== 'string' || !a.name.trim() || typeof a.role !== 'string') {
+            out.push(`${at}: needs a name and a role`);
+            return;
+        }
+        const moved = a.moved_px, frames = a.frames;
+        if (typeof moved !== 'number' || !Number.isFinite(moved) || moved < 0)
+            out.push(`${at} (${a.name}): moved_px must be a finite number ≥ 0`);
+        if (!Number.isInteger(frames) || frames < 1)
+            out.push(`${at} (${a.name}): frames must be an integer ≥ 1`);
+        if (typeof a.pose !== 'boolean')
+            out.push(`${at} (${a.name}): pose must be true or false`);
+        if (typeof a.verdict !== 'string' || !VERDICTS.includes(a.verdict)) {
+            out.push(`${at} (${a.name}): verdict must be one of ${VERDICTS.join(', ')}`);
+            return;
+        }
+        if (typeof moved === 'number' && Number.isInteger(frames) && typeof a.pose === 'boolean') {
+            const expect = frames > 1 || a.pose ? 'animated' : moved > 2 ? 'slides' : 'still';
+            if (expect !== a.verdict)
+                out.push(`${at} (${a.name}): verdict ${a.verdict} disagrees with its numbers (${expect})`);
+        }
+    });
+    return out;
+}
+const section = (note, heading) => note.match(new RegExp(`^## ${heading}[^\\n]*\\n([\\s\\S]*?)(?=^## |(?![\\s\\S]))`, 'mi'))?.[1];
+const cells = (line) => line.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+const placeholder = (s) => !s || /<[^>]*>|^…$|^:?-+:?$/.test(s);
+export function intentOf(cell) {
+    const c = cell.toLowerCase().trim();
+    const first = c.match(/^[a-z]+/)?.[0];
+    if (first === 'moves' || first === 'animates' || first === 'still')
+        return first;
+    if (placeholder(c))
+        return null;
+    if (/\b(anim|pose|cycle|frames?|sheet|alive|breath|blink|bob)/.test(c))
+        return 'animates';
+    if (/\b(still|rests?|static|at rest|stationary|no motion|does not move|doesn't move)\b/.test(c))
+        return 'still';
+    if (/\b(mov|slid|walk|run|fl[iy]|fall|drift|chase|roll|swim|hop|jump)/.test(c))
+        return 'moves';
+    return null;
+}
+export function declaredActors(note) {
+    const table = section(note, 'Actors');
+    if (table === undefined)
+        return [];
+    const rows = table.split('\n').filter((l) => l.trim().startsWith('|')).map(cells);
+    const header = rows[0] ?? [];
+    const motion = header.findIndex((c) => /motion|moves?\b/i.test(c));
+    if (motion < 0)
+        return [];
+    const role = header.findIndex((c) => /role/i.test(c));
+    return rows.slice(1).flatMap((r) => {
+        const intent = intentOf(r[motion] ?? '');
+        if (placeholder(r[0] ?? '') || !intent)
+            return [];
+        return [{ name: r[0], role: role >= 0 ? r[role] ?? '' : '', motion: intent }];
+    });
+}
+const words = (s) => s.toLowerCase().replace(/\(.*?\)/g, ' ').match(/[a-z][a-z0-9]{2,}/g) ?? [];
+const base = (s) => s.toLowerCase().replace(/[\d_\-#.\s]+$/g, '');
+const sampledRole = (declared) => /player/i.test(declared) ? 'player' : /enem|threat|hazard|obstacle|foe/i.test(declared) ? 'threat' : /pick|collect|coin|reward|gem/i.test(declared) ? 'pickup' : '';
+function matches(d, sampled) {
+    const keys = words(d.name);
+    const byName = sampled.filter((s) => { const n = base(s.name); return n.length > 1 && keys.some((k) => n.includes(k) || k.includes(n)); });
+    if (byName.length)
+        return byName;
+    const role = sampledRole(d.role);
+    return role ? sampled.filter((s) => s.role === role) : [];
+}
+export function judgeMotion(record, declared, seconds = 1) {
+    const moving = declared.filter((d) => d.motion !== 'still');
+    if (record.engine === 'none' || record.samples < 1) {
+        return { defects: [], unobserved: [moving.length ? `motion of ${moving.map((d) => d.name).join(', ')} (no scene graph)` : 'motion (no scene graph)'] };
+    }
+    if (!declared.length)
+        return { defects: [], unobserved: ['motion by role (no Motion column in the design note\'s ## Actors table)'] };
+    const defects = [], unobserved = [];
+    for (const d of moving) {
+        const seen = matches(d, record.actors);
+        if (!seen.length) {
+            unobserved.push(`motion of ${d.name} (declared ${d.motion}; not found in the sample)`);
+            continue;
+        }
+        if (d.motion === 'moves' && seen.every((s) => s.verdict === 'still')) {
+            defects.push(`${d.name} is declared to move but stood still for ${seconds} s of play`);
+        }
+        else if (d.motion === 'animates' && !seen.some((s) => s.verdict === 'animated')) {
+            defects.push(`${d.name} is declared to animate but ${seen.some((s) => s.verdict === 'slides') ? 'only slid as one picture' : 'never changed picture or pose'} in ${seconds} s of play`);
+        }
+    }
+    return { defects, unobserved };
+}

package/plugins/robin/claude/hooks/vendor/memory/decisions.mjs

@@ -0,0 +1,139 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/memory/decisions.ts by the GDK build. Do not edit.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const DECISIONS_FILE = join('design', 'decisions.md');
+const HEAD = `# Decisions
+
+Each choice made against its alternative, and why, so a later session neither re-argues it nor
+reverses it without a record. Newest last. Replacing one is normal: a new entry says which it
+supersedes (\`npx @funpixel/tools decide "…" --because "…" --supersedes D3\`). Edit by hand freely;
+keep the \`## D<n> · <date> · <choice>\` heading shape.
+`;
+const HEADING = /^##\s+(D\d+)\b\s*[·|-]?\s*(\d{4}-\d{2}-\d{2})?\s*[·|-]?\s*(.*)$/;
+const FIELD = /^[-*]\s*\**(Over|Because|Supersedes|Superseded by|Owner|Shot|From|Touches|Status)\**:\**\s*(.*)$/i;
+const ids = (s) => [...s.matchAll(/\bD\d+\b/g)].map((m) => m[0]);
+export function parseDecisions(text) {
+    const out = [];
+    let cur = null;
+    for (const line of text.split(/\r?\n/)) {
+        const h = HEADING.exec(line.trim());
+        if (h) {
+            cur = { id: h[1], date: h[2] ?? '', choice: h[3].trim(), supersedes: [], touches: [] };
+            out.push(cur);
+            continue;
+        }
+        if (/^#{1,2}\s/.test(line)) {
+            cur = null;
+            continue;
+        }
+        const f = cur && FIELD.exec(line.trim());
+        if (!cur || !f)
+            continue;
+        const key = f[1].toLowerCase(), value = f[2].trim();
+        if (key === 'over')
+            cur.over = value;
+        else if (key === 'because')
+            cur.because = value;
+        else if (key === 'supersedes')
+            cur.supersedes.push(...ids(value));
+        else if (key === 'owner')
+            cur.owner = value.replace(/^"|"$/g, '');
+        else if (key === 'shot')
+            cur.shot = value;
+        else if (key === 'from')
+            cur.from = value;
+        else if (key === 'touches')
+            cur.touches.push(...value.split(',').map((x) => x.trim()).filter(Boolean));
+        else if (key === 'status')
+            cur.status = value;
+        else
+            cur.supersededBy = ids(value)[0] ?? cur.supersededBy;
+    }
+    for (const d of out)
+        for (const old of d.supersedes) {
+            const o = out.find((x) => x.id === old);
+            if (o && !o.supersededBy)
+                o.supersededBy = d.id;
+        }
+    return out;
+}
+export function readDecisions(root) {
+    const file = join(root, DECISIONS_FILE);
+    return existsSync(file) ? parseDecisions(readFileSync(file, 'utf8')) : [];
+}
+export const liveDecisions = (all) => all.filter((d) => !d.supersededBy);
+export function addDecision(root, d, now = new Date()) {
+    const file = join(root, DECISIONS_FILE);
+    let text = existsSync(file) ? readFileSync(file, 'utf8') : HEAD;
+    const all = parseDecisions(text);
+    const supersedes = [...new Set((d.supersedes ?? []).map((s) => s.toUpperCase().replace(/^(\d+)$/, 'D$1')))];
+    for (const old of supersedes) {
+        const o = all.find((x) => x.id === old);
+        if (!o)
+            throw new Error(`no decision ${old} in ${DECISIONS_FILE} (it holds ${all.map((x) => x.id).join(', ') || 'none'})`);
+        if (o.supersededBy)
+            throw new Error(`${old} was already replaced by ${o.supersededBy}; supersede ${o.supersededBy} instead`);
+    }
+    const id = `D${all.reduce((m, x) => Math.max(m, Number(x.id.slice(1))), 0) + 1}`;
+    const date = now.toISOString().slice(0, 10);
+    const one = (s) => s.replace(/\s+/g, ' ').trim();
+    if (supersedes.length) {
+        const lines = text.split('\n');
+        for (const old of supersedes) {
+            const start = lines.findIndex((l) => HEADING.exec(l.trim())?.[1] === old);
+            let end = start + 1;
+            while (end < lines.length && !/^#{1,2}\s/.test(lines[end]))
+                end++;
+            let at = end;
+            while (at > start + 1 && !lines[at - 1].trim())
+                at--;
+            lines.splice(at, 0, `- Superseded by: ${id} (${date})`);
+        }
+        text = lines.join('\n');
+    }
+    const entry = [
+        `## ${id} · ${date} · ${one(d.choice)}`,
+        ...(d.over ? [`- Over: ${one(d.over)}`] : []),
+        ...(d.owner ? [`- Owner: "${one(d.owner)}"`] : []),
+        ...(d.shot ? [`- Shot: ${one(d.shot)}`] : []),
+        ...(d.from ? [`- From: ${one(d.from)}`] : []),
+        `- Because: ${one(d.because)}`,
+        ...(d.touches?.length ? [`- Touches: ${d.touches.map(one).join(', ')}`] : []),
+        ...(d.status ? [`- Status: ${one(d.status)}`] : []),
+        ...(supersedes.length ? [`- Supersedes: ${supersedes.join(', ')}`] : []),
+    ].join('\n');
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${text.replace(/\s*$/, '')}\n\n${entry}\n`);
+    return { id, date, choice: one(d.choice), ...(d.over ? { over: one(d.over) } : {}), because: one(d.because), supersedes,
+        ...(d.owner ? { owner: one(d.owner) } : {}), ...(d.shot ? { shot: one(d.shot) } : {}), ...(d.from ? { from: one(d.from) } : {}),
+        touches: (d.touches ?? []).map(one), ...(d.status ? { status: one(d.status) } : {}) };
+}
+export function setDecisionStatus(root, id, status) {
+    const file = join(root, DECISIONS_FILE);
+    if (!existsSync(file))
+        return false;
+    const lines = readFileSync(file, 'utf8').split('\n');
+    const start = lines.findIndex((l) => HEADING.exec(l.trim())?.[1] === id);
+    if (start < 0)
+        return false;
+    let end = start + 1;
+    while (end < lines.length && !/^#{1,2}\s/.test(lines[end]))
+        end++;
+    const at = lines.slice(start + 1, end).findIndex((l) => /^[-*]\s*\**Status\**:/i.test(l.trim()));
+    const line = `- Status: ${status.replace(/\s+/g, ' ').trim()}`;
+    if (at >= 0)
+        lines[start + 1 + at] = line;
+    else {
+        let k = end;
+        while (k > start + 1 && !lines[k - 1].trim())
+            k--;
+        lines.splice(k, 0, line);
+    }
+    writeFileSync(file, lines.join('\n'));
+    return true;
+}
+export const isOpenDecision = (d) => !d.supersededBy && /^open\b/i.test(d.status ?? '');
+const clip = (s, n) => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
+export function decisionLine(d) {
+    return `- ${d.id} ${clip(d.choice, 100)}${d.over ? `, over ${clip(d.over, 60)}` : ''}${d.because ? ` — ${clip(d.because, 100)}` : ''}${d.supersedes.length ? ` (replaces ${d.supersedes.join(', ')})` : ''}${d.status && /^open\b/i.test(d.status) ? ' [open: not built yet]' : ''}`;
+}

package/plugins/robin/claude/hooks/vendor/memory/journal.mjs

@@ -0,0 +1,109 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/memory/journal.ts by the GDK build. Do not edit.
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { stagedDigests } from '../verify/fingerprint.mjs';
+export const JOURNAL_FILE = join('.funtools', 'journal.jsonl');
+export const AGENT_FILES = join('.funtools', 'agent-files.json');
+export function readJournal(root) {
+    const file = join(root, JOURNAL_FILE);
+    if (!existsSync(file))
+        return [];
+    const out = [];
+    for (const line of readFileSync(file, 'utf8').split('\n')) {
+        try {
+            const e = JSON.parse(line);
+            if (e && typeof e.what === 'string' && typeof e.at === 'string')
+                out.push(e);
+        }
+        catch { }
+    }
+    return out;
+}
+export function appendJournal(root, entry, now = new Date()) {
+    const full = { at: now.toISOString().replace(/\.\d+Z$/, 'Z'), ...entry };
+    mkdirSync(join(root, '.funtools'), { recursive: true });
+    appendFileSync(join(root, JOURNAL_FILE), JSON.stringify(full) + '\n');
+    return full;
+}
+const clip = (s, n) => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
+const when = (at) => at.replace('T', ' ').slice(0, 16);
+const fileList = (files, n = 4) => files.slice(0, n).join(', ') + (files.length > n ? ` and ${files.length - n} more` : '');
+export function journalLine(e) {
+    if (e.inferred) {
+        return `- ${when(e.at)} · detected, not told: ${e.what}${e.files?.length ? ` (${fileList(e.files)})` : ''}; who and why unknown`;
+    }
+    const values = e.values ? Object.entries(e.values).map(([k, v]) => `${k}=${v}`).join(', ') : '';
+    const touched = [values, e.files?.length ? fileList(e.files) : ''].filter(Boolean).join(' · ');
+    return `- ${when(e.at)} · ${e.by}${e.via === 'agent' ? ' (via the agent)' : ''}: ${clip(e.what, 120)}${e.why ? ` — because ${clip(e.why, 120)}` : ''}${touched ? ` · ${touched}` : ''}`;
+}
+export function explained(entries) {
+    const bare = (f) => f.replace(/ \((new|removed)\)$/, '');
+    return entries.filter((e, i) => !e.inferred || !e.files?.length
+        || !entries.slice(i + 1).some((t) => !t.inferred && t.files?.length && e.files.every((f) => t.files.includes(bare(f)))));
+}
+export async function trackedHashes(root, digests) {
+    const out = {};
+    for (const e of digests ?? await stagedDigests(root))
+        out[e.path] = e.digest.slice(0, 16);
+    const design = join(root, 'design');
+    if (existsSync(design)) {
+        for (const f of readdirSync(design))
+            if (f.endsWith('.md'))
+                out[`design/${f}`] = hash(readFileSync(join(design, f)));
+    }
+    return out;
+}
+const hash = (bytes) => createHash('sha256').update(bytes).digest('hex').slice(0, 16);
+export function readAgentFiles(root) {
+    try {
+        const s = JSON.parse(readFileSync(join(root, AGENT_FILES), 'utf8'));
+        return s && typeof s.files === 'object' ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeAgentFiles(root, files, now = new Date()) {
+    mkdirSync(join(root, '.funtools'), { recursive: true });
+    writeFileSync(join(root, AGENT_FILES), JSON.stringify({ at: now.toISOString(), files }) + '\n');
+}
+export function recordAgentFile(root, rel, now = new Date()) {
+    const snap = readAgentFiles(root);
+    if (!snap)
+        return;
+    const path = join(root, rel);
+    if (/^(\.funtools|node_modules|dist|\.git)\//.test(rel) || rel.startsWith('..'))
+        return;
+    const files = { ...snap.files };
+    if (existsSync(path))
+        files[rel] = hash(readFileSync(path));
+    else
+        delete files[rel];
+    writeAgentFiles(root, files, now);
+}
+export function changedFiles(before, now, exists = () => false) {
+    const out = [];
+    for (const [p, h] of Object.entries(now))
+        if (before[p] !== h)
+            out.push(before[p] ? p : `${p} (new)`);
+    for (const p of Object.keys(before))
+        if (!(p in now) && !exists(p))
+            out.push(`${p} (removed)`);
+    return out.sort();
+}
+export async function noticeOutsideChanges(root, now = new Date(), digests) {
+    const snap = readAgentFiles(root);
+    if (!snap)
+        return null;
+    const current = await trackedHashes(root, digests);
+    const changed = changedFiles(snap.files, current, (p) => existsSync(join(root, p)));
+    if (!changed.length)
+        return null;
+    const entry = appendJournal(root, {
+        by: 'unknown', via: 'detected', inferred: true,
+        what: `${changed.length} file(s) changed while no agent turn was running`, files: changed,
+    }, now);
+    writeAgentFiles(root, current, now);
+    return entry;
+}