@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/gdd/chapters.js

@@ -0,0 +1,71 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const chapterStage = (id) => `chapter:${id}`;
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+const PICTURE = /\.(png|jpe?g|webp)$/i;
+const FIRST_LOOK = join('design', 'first-look');
+function gddText(root) {
+    for (const f of [join('design', 'GDD.md'), 'GDD.md']) {
+        try {
+            return readFileSync(join(root, f), 'utf8');
+        }
+        catch { }
+    }
+    return '';
+}
+function body(text, heading) {
+    const lines = text.split('\n');
+    const at = lines.findIndex((l) => new RegExp(`^##+\\s+(?:\\d+\\s*[.·]\\s*)?${heading}\\b`, 'i').test(l.trim()));
+    if (at < 0)
+        return null;
+    const level = /^(#+)/.exec(lines[at].trim())[1].length;
+    const end = lines.findIndex((l, i) => i > at && /^(#+)\s/.test(l.trim()) && /^(#+)/.exec(l.trim())[1].length <= level);
+    return lines.slice(at + 1, end < 0 ? lines.length : end).join('\n');
+}
+const cells = (row) => row.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+const plain = (c) => c.replace(/[*_`]/g, '').trim();
+export function readChapters(root) {
+    const b = body(gddText(root), 'Chapters');
+    if (!b)
+        return [];
+    const rows = b.split('\n').filter((l) => /^\s*\|/.test(l) && !/^\s*\|?[\s:|-]+\|?\s*$/.test(l));
+    if (rows.length < 2)
+        return [];
+    const head = cells(rows[0]).map((c) => plain(c).toLowerCase());
+    const tcol = head.findIndex((h) => /target|frame/.test(h));
+    let dir = [];
+    try {
+        dir = readdirSync(join(root, FIRST_LOOK)).filter((f) => PICTURE.test(f));
+    }
+    catch { }
+    const out = [];
+    for (const row of rows.slice(1)) {
+        const c = cells(row);
+        const name = plain(c[0] ?? '');
+        if (!name || /^</.test(name))
+            continue;
+        const id = slug(name.split(/\s+[·—–:]\s+/)[0]) || slug(name);
+        const named = tcol >= 0 ? (c[tcol] ?? '').split(/[\s,;]+/).map((x) => x.replace(/[`()]/g, '')).filter((x) => PICTURE.test(x)) : [];
+        const found = named.map((n) => [n, join(FIRST_LOOK, n)].find((p) => existsSync(join(root, p)))).filter((p) => !!p);
+        const byName = dir.filter((f) => f.toLowerCase().startsWith(`target-${id}`) || f.toLowerCase().startsWith(`chapter-${id}`)).map((f) => join(FIRST_LOOK, f));
+        out.push({ id, name, targets: [...new Set([...found, ...byName])] });
+    }
+    return out;
+}
+export function chaptersGate(root, verdicts, T = 'npx @funpixel/tools') {
+    const all = readChapters(root);
+    if (!all.length)
+        return { state: 'open', says: 'the GDD names no chapters yet', closes: 'the GDD\'s ## Chapters: one row per chapter (its place, what it adds, its story beat, its length, its target frames)', run: 'write ## Chapters in design/GDD.md with the owner (skill funpixel-gdd), then make the first chapter\'s target frames' };
+    const last = (id) => [...verdicts].reverse().find((v) => v.stage === chapterStage(id));
+    const done = all.filter((ch) => last(ch.id)?.says === 'accept');
+    const next = all.find((ch) => last(ch.id)?.says !== 'accept');
+    if (!next)
+        return { state: 'met', says: `all ${all.length} chapters accepted by the owner`, closes: '', run: '' };
+    const at = `chapter ${all.indexOf(next) + 1} of ${all.length}, ${next.name}${done.length ? ` (${done.length} accepted)` : ''}`;
+    const sent = last(next.id);
+    if (sent?.says === 'reject')
+        return { state: 'failing', says: `${at}: the owner sent it back${sent.words ? `: "${sent.words}"` : ''}`, closes: `the owner's yes on ${next.name}`, run: `fix what they named, show it again in the chat, then ${T} note verdict ${chapterStage(next.id)} accept "<their words>"` };
+    if (!next.targets.length)
+        return { state: 'open', says: `${at}: no target frames yet`, closes: `target frames for ${next.name} in design/first-look/ (target-${next.id}-*.png)`, run: `make ${next.name}'s target frames first (${T} gen), show them in the chat, then build it to them` };
+    return { state: 'open', says: `${at}: build it to its ${next.targets.length} target frame${next.targets.length === 1 ? '' : 's'}`, closes: `the owner's yes on ${next.name}`, run: `build it with its assets and the look-dev loop (${T} compare --target ${next.targets[0]}), show it in the chat, then on their yes: ${T} note verdict ${chapterStage(next.id)} accept "<their words>"` };
+}

package/dist/gdd/design.js

@@ -0,0 +1,135 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { underLabel } from "./rubric.js";
+export const QUESTIONS = [
+    { key: 'meaning', label: /what (the|our) core (object|thing) means/i, asks: 'what the core object MEANS in this world (paintings that watch, not "paintings to protect")', specific: (a) => (/\b(protect|collect|destroy|important|valuable|precious)\b/i.test(a) && words(a) < 20 ? 'reads as its function, not its meaning: what is it, to the people in this world?' : null) },
+    { key: 'verb', label: /why the verb exists/i, asks: 'why the core verb exists in this world (who made it necessary, and what it costs)', specific: (a) => (/\b(fun|satisfying|engaging|players? (like|enjoy))\b/i.test(a) ? 'answers why it is fun, not why the world needs it' : null) },
+    { key: 'wants', label: /who wants what/i, asks: 'who wants what, by name: the player\'s side, the other side (a want that is half right), the bystanders', specific: (a) => { const [head = '', ...subs] = a.split('\n'); return !/\b[A-Z][a-z]{2,}/.test([head.replace(/^\W*\w/, ''), ...subs].join('\n')) ? 'no names: a want belongs to someone' : null; } },
+    { key: 'twist', label: /what the twist costs/i, asks: 'what the twist costs, in feeling AND in play', specific: (a) => (!/feel|hurt|guilt|lose|shame|fear|grief|love|proud|regret|protect|care|trust|face|alone|sorry/i.test(a) && !/\d|second|time|score|life|health|ammo|route|slower|harder|lose|darker|next|fewer|less|more|cost/i.test(a) ? 'name both costs: what the player feels, and what changes in play' : null) },
+    { key: 'living', label: /(one|the) system that lives/i, asks: 'the one system that lives and reacts to the player, with two or more jobs in play', specific: (a) => (!/\b(warns?|shows?|tells?|blocks?|opens?|hides?|guides?|radar|signals?|reacts?|watches|follows?|flinch|marks?|reveals?|counts?)\b/i.test(a) ? 'no job in play: what does it DO that the player reads and uses?' : null) },
+    { key: 'only', label: /what only this game has/i, asks: 'what only this game has, that the genre\'s hits do not', specific: (a) => (/\b(unique|fun|polished|beautiful|immersive|fresh|innovative)\b/i.test(a) && words(a) < 18 ? 'adjectives, not a thing: name the mechanic or the moment' : null) },
+];
+const words = (s) => (s.match(/[A-Za-zÀ-ÿ0-9'’]+/g) ?? []).length;
+const PLACEHOLDER = /<[^<>\n]{2,}>/g;
+const sectionOf = (text, re) => {
+    const lines = text.split('\n');
+    const at = lines.findIndex((l) => /^##\s/.test(l) && re.test(l.replace(/^##\s+/, '')));
+    if (at < 0)
+        return null;
+    const end = lines.findIndex((l, i) => i > at && /^##\s/.test(l));
+    return lines.slice(at + 1, end < 0 ? lines.length : end).join('\n');
+};
+export function answerOf(body, label) {
+    const lines = body.split('\n');
+    const at = lines.findIndex((l) => label.test(l));
+    if (at < 0)
+        return '';
+    const clean = (s) => s.replace(PLACEHOLDER, '').trim();
+    const parts = [clean(lines[at].replace(/^[^:]*:\**\s*/, '')), ...underLabel(lines, at, (l) => QUESTIONS.some((q) => q.label.test(l))).map(clean)];
+    return parts.some(Boolean) ? parts.join('\n') : '';
+}
+export function readInvention(text) {
+    const body = sectionOf(text, /^(the\s+)?invention\b/i);
+    if (body === null)
+        return null;
+    const answered = [], missing = [], generic = [], notes = [];
+    for (const q of QUESTIONS) {
+        const answer = answerOf(body, q.label);
+        if (words(answer) < 6) {
+            missing.push(q.key);
+            notes.push({ state: 'warn', what: `${q.key}: not answered — ${q.asks}` });
+            continue;
+        }
+        const g = q.specific(answer);
+        if (g) {
+            generic.push({ key: q.key, why: g });
+            notes.push({ state: 'warn', what: `${q.key}: generic — ${g}` });
+        }
+        else
+            answered.push(q.key);
+    }
+    return { answered, missing, generic, notes };
+}
+export const AXES = ['mechanic', 'feel', 'touch controls', 'layout', 'surface satisfaction', 'readability', 'market'];
+export function readHits(text) {
+    const body = sectionOf(text, /^(the\s+)?hits\b|^research\b|^reference(s)? per axis/i);
+    if (body === null)
+        return null;
+    const lines = body.split('\n').filter((l) => /^\s*\|.*\|\s*$/.test(l) && !/^\s*\|[\s:|-]+\|\s*$/.test(l));
+    const head = (lines[0] ?? '').toLowerCase().split('|').map((c) => c.trim()).filter(Boolean);
+    const at = (re, d) => { const i = head.findIndex((h) => re.test(h)); return i < 0 ? d : i; };
+    const ci = { axis: at(/axis/, 0), hit: at(/hit|game/, 1), take: at(/take/, 2), avoid: at(/avoid|leave/, 3), source: at(/source|link/, 4) };
+    const rows = lines.slice(1).map((l) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim().replace(PLACEHOLDER, '').trim()))
+        .filter((c) => c[ci.axis] && c[ci.hit]).map((c) => ({ axis: c[ci.axis], hit: c[ci.hit], take: c[ci.take] ?? '', avoid: c[ci.avoid] ?? '', source: c[ci.source] ?? '' }));
+    const norm = (s) => s.toLowerCase().replace(/[^a-z ]/g, '');
+    const missingAxes = AXES.filter((a) => !rows.some((r) => norm(r.axis).includes(a.split(' ')[0])));
+    const unsourced = rows.filter((r) => !/https?:\/\/\S+|\bdesign\/\S+|\bdocs?\/\S+/.test(r.source)).map((r) => `${r.axis} (${r.hit})`);
+    const notes = [];
+    if (missingAxes.length)
+        notes.push({ state: 'warn', what: `no hit for: ${missingAxes.join(', ')} — one genre hit is not research; each axis has its own best game` });
+    if (unsourced.length)
+        notes.push({ state: 'note', what: `no source link: ${unsourced.slice(0, 6).join(', ')}${unsourced.length > 6 ? ` and ${unsourced.length - 6} more` : ''} (say what was left out unverified)` });
+    const thin = rows.filter((r) => words(r.take) < 3 || words(r.avoid) < 2).map((r) => r.axis);
+    if (thin.length)
+        notes.push({ state: 'note', what: `take or avoid left thin: ${thin.join(', ')}` });
+    return { rows, missingAxes, unsourced, notes };
+}
+export function namedTests(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let on = false, level = 0;
+    for (const l of lines) {
+        const h = /^(#{2,4})\s+(.+)$/.exec(l);
+        if (h) {
+            if (/behaviou?r (tests?|contract)|named tests|tests named after/i.test(h[2])) {
+                on = true;
+                level = h[1].length;
+                continue;
+            }
+            if (on && h[1].length <= level)
+                on = false;
+            continue;
+        }
+        if (!on || /^\s*\|[\s:|-]+\|\s*$/.test(l))
+            continue;
+        const tick = /^\s*(?:[-*]|\d+[.)]|\|)\s*(?:\*\*)?(?:T\d+[.:]?\s*)?`([^`]{6,140})`/.exec(l);
+        const quoted = /^\s*(?:[-*]|\d+[.)])\s+(?:T\d+[.:]?\s*)?["“]([^"”]{6,140})["”]/.exec(l);
+        const name = (tick?.[1] ?? quoted?.[1])?.trim();
+        if (name && !/^(name|test|<)/i.test(name) && !out.includes(name))
+            out.push(name);
+    }
+    return out;
+}
+const stem = (s) => s.toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').split(/\s+/).filter((w) => w.length > 2 && !STOP.has(w)).map((w) => w.replace(/(ing|ed|es|s)$/, ''));
+const STOP = new Set(['the', 'and', 'for', 'when', 'with', 'that', 'than', 'its', 'are', 'every', 'each', 'into', 'from', 'what', 'one']);
+export function testsInCode(root) {
+    const out = [];
+    const walk = (d, depth) => {
+        if (!existsSync(d) || depth > 4)
+            return;
+        for (const f of readdirSync(d)) {
+            if (f.startsWith('.') || f === 'node_modules' || f === 'dist')
+                continue;
+            const p = join(d, f);
+            if (statSync(p).isDirectory())
+                walk(p, depth + 1);
+            else if (/\.(test|spec)\.[mc]?[jt]sx?$|^probes?\.[jt]s$/.test(f)) {
+                for (const m of readFileSync(p, 'utf8').matchAll(/\b(?:test|it|describe)\s*\(\s*(['"`])((?:(?!\1).){4,200})\1/g))
+                    out.push(m[2]);
+            }
+        }
+    };
+    for (const d of ['test', 'tests', 'src'])
+        walk(join(root, d), 0);
+    return out;
+}
+export function readBack(named, code) {
+    const cs = code.map(stem);
+    const inCode = [], notYet = [];
+    for (const n of named) {
+        const w = stem(n);
+        const hit = cs.some((c) => w.length > 0 && w.filter((x) => c.includes(x)).length / w.length >= 0.7);
+        (hit ? inCode : notYet).push(n);
+    }
+    return { inCode, notYet };
+}

package/dist/gdd/doc.js

@@ -0,0 +1,32 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const DOC_FILES = ['GDD.md', 'README.md'];
+export const EXTRA_FILES = ['gameplay.md', 'plan.md'];
+export const GDD_RECORD = join('.funtools', 'gdd.json');
+export function designDoc(game) {
+    const name = DOC_FILES.find((f) => existsSync(join(game, 'design', f)));
+    if (!name)
+        return null;
+    const extras = EXTRA_FILES.map((f) => join(game, 'design', f)).filter((f) => existsSync(f));
+    const text = readFileSync(join(game, 'design', name), 'utf8') + extras.map((f) => `\n\n${readFileSync(f, 'utf8')}`).join('');
+    return { rel: `design/${name}`, text, sha256: sha256(text) };
+}
+export const sha256 = (text) => createHash('sha256').update(text).digest('hex');
+export function field(text, label) {
+    return new RegExp(`\\*\\*${label}:\\*\\*\\s*(.+)`, 'i').exec(text)?.[1].trim() ?? '';
+}
+export function section(text, heading) {
+    return new RegExp(`^##\\s+${heading}[^\\n]*\\n([\\s\\S]*?)(?=^##\\s|(?![\\s\\S]))`, 'im').exec(text)?.[1] ?? '';
+}
+export const isVision = (title) => /^the vision\b/i.test(title.trim());
+export function withoutVision(text) {
+    return text.replace(/^##[ \t]+the vision\b[^\n]*\n?[\s\S]*?(?=^#{1,2}[ \t]|(?![\s\S]))/gim, '');
+}
+export function withoutLiving(text) {
+    return withoutVision(text).replace(/^##[ \t]+(?:where we are|where the build moved|fix round)\b[^\n]*\n?[\s\S]*?(?=^#{1,2}[ \t]|(?![\s\S]))/gim, '');
+}
+export function planVersion(text) {
+    const v = field(text, 'Version');
+    return /\bv\d+(\.\d+)*\b/.exec(v)?.[0] ?? /\bv\d+(\.\d+)+\b/.exec(text.slice(0, 2000))?.[0] ?? 'v0';
+}