@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/commands/pitch.js

@@ -0,0 +1,205 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { EXIT } from "./verify.js";
+import { designDoc, planVersion } from "../gdd/doc.js";
+import { growFromShelf, sectionsForPicks } from "../gdd/tiers.js";
+import { templateOf } from "../init/starter.js";
+import { TEMPLATES } from "./init.js";
+import { recordLint } from "./spec.js";
+import { specInit } from "../spec/scaffold.js";
+import { FOCUS, freshStudio, labelOf, lock, lockedNotes, manifestStudio, movedSinceLock, pick, propose, readStudio, standing, STUDIO_FILE, TIER_OF, writeGddBlock, writeStudio, } from "../studio/pitch.js";
+import { ui } from "../ui.js";
+import { foldPitchAnswers, lockRefusal, ownerAutonomy, pitchAsk, pitchForks } from "../studio/forks.js";
+import { appendEntry, nextQuestion, readProgress } from "../progress/progress.js";
+export const PITCH_SUBCOMMANDS = ['show', 'propose', 'pick', 'ask', 'lock'];
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+export function studioFor(root) {
+    const have = readStudio(root);
+    const out = have ? { studio: have, fresh: false } : (() => {
+        const m = readJson(join(root, 'funpixel.json')) ?? {};
+        const text = designDoc(root)?.text ?? '';
+        const story = /story\s*:\s*\**\s*declined/i.test(text) ? 'none' : /^\s*\**(antagonist|clock|question)\**\s*:\s*\**\s*[^<\s]/im.test(text) ? 'deep' : /^\s*\**(want|turn)\**\s*:\s*\**\s*[^<\s]/im.test(text) ? 'light' : null;
+        return { studio: freshStudio({ tier: m.production?.tier, story, multiplayer: m.metadata?.mode === 'multiplayer' }), fresh: true };
+    })();
+    foldPitchAnswers(out.studio, readProgress(root));
+    out.studio.autonomy = ownerAutonomy(root) ?? 'plan-then-go';
+    return out;
+}
+export function lockStudio(root, now = new Date()) {
+    const { studio } = studioFor(root);
+    const doc = designDoc(root);
+    const r = lock(studio, planVersion(doc?.text ?? ''), now);
+    writeStudio(root, r.studio);
+    const mf = join(root, 'funpixel.json');
+    let tier = null;
+    if (existsSync(mf)) {
+        const m = readJson(mf);
+        if (m && typeof m === 'object') {
+            m.studio = manifestStudio(r.studio);
+            const depth = r.studio.locked?.picks.depth?.[0];
+            if (depth && TIER_OF[depth] && (!m.production?.tier || m.production?.tierFrom === 'studio')) {
+                m.production = { ...(m.production ?? {}), tier: TIER_OF[depth], tierFrom: 'studio' };
+                tier = TIER_OF[depth];
+            }
+            writeFileSync(mf, JSON.stringify(m, null, 2) + '\n');
+        }
+    }
+    let grown = [];
+    if (doc) {
+        let text = writeGddBlock(doc.text, r.studio);
+        const template = gddTemplate(root);
+        if (template) {
+            const m = readJson(mf) ?? {};
+            const g = growFromShelf(text, template, { tier: isTier(m.production?.tier) ? m.production.tier : null, sections: sectionsForPicks(r.studio.locked?.picks ?? {}, FOCUS) });
+            text = g.text;
+            grown = g.grown;
+        }
+        writeFileSync(join(root, doc.rel), text);
+    }
+    let spec;
+    const t = readJson(mf)?.production?.tier;
+    if ((t === 'mid' || t === 'deep') && existsSync(join(root, 'src')) && !existsSync(join(root, 'design', 'spec', 'tunables.json'))) {
+        const s = specInit(root, { tier: t, now });
+        if (!('refused' in s))
+            spec = `design/spec/ written for the ${s.tier} tier: ${s.tunables} tunables, ${s.rooms} rooms (pars ${Math.round(s.parTotal / 60)} min); spec lint ${recordLint(root, undefined, s.tier).result.counts.warn ? 'has warnings' : 'clean'}`;
+    }
+    return { ...r, tier, grown, ...(spec ? { spec } : {}) };
+}
+const isTier = (t) => t === 'small' || t === 'mid' || t === 'deep';
+export function gddTemplate(root) {
+    const rel = join('.agents', 'skills', 'funpixel-gdd', 'references', 'gdd-template.md');
+    for (const p of [join(root, rel), join(TEMPLATES, 'common', rel)]) {
+        try {
+            const t = templateOf(readFileSync(p, 'utf8'));
+            if (t)
+                return t;
+        }
+        catch { }
+    }
+    return null;
+}
+export async function pitch(opts, io = console) {
+    const u = ui(io, 'pitch');
+    const root = resolve(opts.dir ?? '.');
+    if (!existsSync(root)) {
+        u.error(`no such folder: ${root}`, 'run it in the game folder, or pass --dir');
+        return EXIT.not_observed;
+    }
+    try {
+        if (opts.sub === 'ask') {
+            const { studio } = studioFor(root);
+            writeStudio(root, studio);
+            const f = pitchForks(root, studio);
+            const now = opts.now ?? new Date();
+            const asked = [];
+            for (const c of f.unasked) {
+                const a = pitchAsk(studio, c, nextQuestion(readProgress(root)), now);
+                appendEntry(root, a);
+                asked.push(a);
+            }
+            if (opts.json) {
+                io.log(JSON.stringify({ ok: true, asked, open: f.open.map((q) => q.id), settled: f.settled }, null, 2));
+                return EXIT.pass;
+            }
+            u.heading(`pitch · ${asked.length} choice${asked.length === 1 ? '' : 's'} put to the owner`);
+            for (const a of asked)
+                u.item('warn', `${a.id} (${a.kind}) ${a.topic.slice(6)}: ${a.options.join(' / ')}`, a.text);
+            for (const q of f.open)
+                u.item('note', `${q.id} ${q.topic.slice(6)}: already with the owner`);
+            for (const id of f.settled)
+                u.item('pass', `${id}: the owner's pick`);
+            u.summary('pass', asked.length || f.open.length
+                ? `in the chat: the owner answers each (\`funtools progress answer <Q> <option>\` records it); ${f.needed ? '`pitch lock` waits for every answer' : 'under their autonomy go your proposals stand until they answer'}; meanwhile free plan work only (the invention, the hits, the GDD core), nothing paid`
+                : 'every choice has the owner\'s pick: `pitch lock`');
+            return EXIT.pass;
+        }
+        if (opts.sub === 'lock') {
+            const held = lockRefusal(root, studioFor(root).studio);
+            if (held) {
+                if (opts.json) {
+                    io.log(JSON.stringify({ ok: false, waiting: true, says: held.says, open: held.open.map((q) => q.id), unasked: held.unasked }, null, 2));
+                    return EXIT.fail;
+                }
+                u.summary('fail', `not locked: ${held.says}`);
+                u.line('the owner answers in the chat (`funtools progress answer <Q> <option>` records it); then `funtools pitch lock`', 1);
+                return EXIT.fail;
+            }
+            const r = lockStudio(root, opts.now);
+            if (opts.json) {
+                io.log(JSON.stringify({ ok: true, locked: r.studio.locked, open: r.open, agent_picks: r.agentPicks, tier: r.tier, grown: r.grown }, null, 2));
+                return EXIT.pass;
+            }
+            u.heading(`pitch · locked at ${r.studio.locked.plan}`);
+            show(u, r.studio);
+            if (r.agentPicks.length)
+                u.item(r.studio.autonomy === 'go' ? 'note' : 'warn', `locked at the agent's proposal, not the person's pick: ${r.agentPicks.join(', ')}`, r.studio.autonomy === 'go' ? 'autonomy is go: the person reviews what was made' : 'ask the person, or say so where they will read it');
+            if (r.open.length)
+                u.item('warn', `still open (no pick, no proposal): ${r.open.join(', ')}`);
+            if (r.tier)
+                u.item('note', `production.tier ${r.tier} (from the depth pick)`);
+            if (r.grown.length)
+                u.item('note', `the GDD grew the sections the picks call for: ${r.grown.map((t) => `## ${t}`).join(', ')} (off the "Grows with the game" shelf)`);
+            if (r.spec)
+                u.item('pass', r.spec, 'read design/spec/README.md first; npx @funpixel/tools spec lint after any edit');
+            u.summary('pass', `written to ${STUDIO_FILE}, funpixel.json "studio" and the GDD's ## The studio pitch; go hard on the core`);
+            return EXIT.pass;
+        }
+        const { studio, fresh } = studioFor(root);
+        if (opts.sub === 'propose' || opts.sub === 'pick') {
+            if (!opts.choice || !opts.option) {
+                u.error(`pitch ${opts.sub} needs <choice> <option>`, `choices: ${studio.choices.map((c) => c.id).join(', ')}`);
+                return EXIT.error;
+            }
+            if (opts.sub === 'propose')
+                propose(studio, opts.choice, opts.option, { why: opts.why, label: opts.label, picture: opts.picture, cost: opts.cost });
+            else
+                pick(studio, opts.choice, opts.option, opts.note);
+            writeStudio(root, studio);
+            const doc = designDoc(root);
+            if (doc && /<!-- studio pitch:/.test(doc.text))
+                writeFileSync(join(root, doc.rel), writeGddBlock(doc.text, studio));
+            const c = studio.choices.find((x) => x.id === opts.choice);
+            if (opts.json) {
+                io.log(JSON.stringify({ ok: true, choice: c }, null, 2));
+                return EXIT.pass;
+            }
+            u.summary('pass', `${c.title}: ${opts.sub === 'pick' ? 'picked' : 'proposed'} ${labelOf(studio, c.id, opts.sub === 'pick' ? c.picked : c.proposed)}${studio.locked && movedSinceLock(studio).length ? ' (differs from the lock: `funtools pitch lock` again)' : ''}`);
+            return EXIT.pass;
+        }
+        if (fresh)
+            writeStudio(root, studio);
+        const doc = designDoc(root);
+        const notes = doc && studio.locked ? lockedNotes(studio, doc.text) : [];
+        if (opts.json) {
+            io.log(JSON.stringify({ studio, fresh, moved: movedSinceLock(studio), notes }, null, 2));
+            return EXIT.pass;
+        }
+        u.heading(`pitch · ${studio.locked ? `locked ${studio.locked.at.slice(0, 10)} at ${studio.locked.plan}` : 'not locked'}${fresh ? ` · ${STUDIO_FILE} written from the catalogue` : ''}`);
+        show(u, studio);
+        const moved = movedSinceLock(studio);
+        if (moved.length)
+            u.item('warn', `picked since the lock: ${moved.join(', ')}`, '`funtools pitch lock` locks them');
+        for (const n of notes)
+            u.item(n.state, n.what);
+        u.summary('pass', studio.locked
+            ? 'the locked layer: effort and checks go to the core; what is not picked stays light'
+            : 'propose a pick per card with its reason for this game (`pitch propose core world --why "…"`), show the person (Plan Canvas or here), then `pitch lock`');
+        return EXIT.pass;
+    }
+    catch (e) {
+        u.error(e.message, 'funtools pitch --help');
+        return EXIT.error;
+    }
+}
+function show(u, s) {
+    for (const c of s.choices) {
+        const st = standing(c);
+        const head = st.ids.length ? `${labelOf(s, c.id, st.ids)}${st.by === 'agent' ? ' (proposed)' : ''}` : 'open';
+        u.item(st.by === 'person' ? 'pass' : st.by === 'agent' ? 'note' : 'warn', `${c.title}: ${head}`, [c.proposedWhy, c.note ? `the person: "${c.note}"` : '', `options: ${c.options.map((o) => o.id).join(' · ')}`].filter(Boolean).join(' · '));
+    }
+}

package/dist/commands/places.js

@@ -0,0 +1,89 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { EXIT } from "./verify.js";
+import { withPage } from "./look.js";
+import { drive, evalJson, load } from "../look/look.js";
+import { decodePng } from "../look/png.js";
+import { comparePlaces, LIMITS, shotOf } from "../variety/places.js";
+import { hookMapOf } from "../verify/hooks.js";
+import { ui } from "../ui.js";
+export const PLACES_RECORD = join('.funtools', 'places.json');
+export const PLACES_DIR = join('.funtools', 'places');
+export const MIN_PLACES = 3;
+export function lightApart(a, b) {
+    if (!a || !b)
+        return null;
+    const out = [];
+    if (a.preset && b.preset && a.preset !== b.preset)
+        out.push(`${a.preset} against ${b.preset}`);
+    if (a.exposure !== null && b.exposure !== null && Math.abs(a.exposure - b.exposure) >= 0.15)
+        out.push(`exposure ${a.exposure} against ${b.exposure}`);
+    if (a.ambient !== null && b.ambient !== null && Math.abs(a.ambient - b.ambient) / Math.max(a.ambient, b.ambient) >= 0.3)
+        out.push(`fill ${a.ambient} against ${b.ambient}`);
+    if (a.key && b.key && a.key.toLowerCase() !== b.key.toLowerCase() && !out.length)
+        out.push(`key ${a.key} against ${b.key}`);
+    return out.length ? out.join(', ') : null;
+}
+export function judgePlaces(views) {
+    const shots = views.filter((v) => v.entered && v.grid);
+    if (shots.length < 2)
+        return { verdict: 'not_observed', pairs: [], twins: [], why: `${shots.length} place view(s) entered: nothing to compare (declare a place-<id> view per place, or name them with --view)` };
+    const pairs = [];
+    for (let i = 0; i < shots.length; i++)
+        for (let j = i + 1; j < shots.length; j++) {
+            const p = comparePlaces(shots[i].grid, shots[j].grid), light = lightApart(shots[i].light, shots[j].light);
+            pairs.push({ ...p, light, alike: p.alike && !(light && p.colour >= LIMITS.SAME_COLOUR * 0.75), why: p.alike && light ? `${p.why}; the light differs (${light})` : p.why });
+        }
+    const twins = [...new Set(pairs.filter((p) => p.alike).flatMap((p) => [p.a, p.b]))];
+    const few = shots.length < MIN_PLACES;
+    const verdict = twins.length || few ? 'warn' : 'pass';
+    const why = twins.length ? `${twins.length} of ${shots.length} places read as another place repainted: give each its own light preset, palette, ground and kit (src/places.json)`
+        : few ? `${shots.length} distinct place(s); the bar is ${MIN_PLACES} in the first fifteen minutes (Silt: 7)` : `${shots.length} places apart in colour and light`;
+    return { verdict, pairs, twins, why };
+}
+export async function places(opts, io = console) {
+    const u = ui(io, 'places');
+    const r = await withPage(u, opts, async (page, t) => {
+        await load(page, t.url, hookMapOf(t.manifest));
+        const declared = (await evalJson(page, 'capture_view', { view: null, verbs: [], verb_gap_ms: 0, hold_ms: 0, freeze: false }))?.views ?? [];
+        const names = opts.views.length ? opts.views : declared.map((v) => v.name).filter((n) => /^place[-_]/.test(n)).slice(0, 10);
+        if (t.dir)
+            await mkdir(join(t.dir, PLACES_DIR), { recursive: true });
+        const out = [];
+        for (const view of names) {
+            const d = await drive(page, { view, verbs: [], holdMs: 1500, freeze: false, click: null });
+            const world = await page.evaluate('(() => { try { return window.__FPX_STATE__?.()?.world ?? null; } catch { return null; } })()').catch(() => null);
+            const png = await page.screenshot().catch(() => null);
+            const img = png ? decodePng(png) : null;
+            let shot = null;
+            if (png && t.dir) {
+                shot = join(PLACES_DIR, `${view.replace(/[^A-Za-z0-9_-]+/g, '_')}.png`);
+                await writeFile(join(t.dir, shot), png);
+            }
+            const l = world?.light, num = (v) => (typeof v === 'number' ? v : null);
+            out.push({
+                view, place: typeof world?.place === 'string' ? world.place : null, entered: d.view?.entered === true, shot,
+                light: l ? { preset: typeof l.preset === 'string' ? l.preset : null, exposure: num(l.exposure), key: typeof l.key === 'string' ? l.key : null, ambient: num(l.ambient), fog: Array.isArray(l.fog) ? l.fog : null } : null,
+                dressing: num(world?.dressing?.per100), ...(img ? { grid: shotOf(view, shot ?? view, img) } : {}),
+            });
+        }
+        const j = judgePlaces(out);
+        const record = { tool: 'funtools', command: 'places', at: new Date().toISOString(), viewport: opts.viewport, views: out.map(({ grid, ...v }) => v), ...j };
+        if (t.dir)
+            await writeFile(join(t.dir, PLACES_RECORD), JSON.stringify(record, null, 2) + '\n');
+        return record;
+    });
+    if (typeof r === 'number')
+        return r;
+    if (opts.json) {
+        io.log(JSON.stringify(r, null, 2));
+        return r.verdict === 'not_observed' ? EXIT.not_observed : EXIT.pass;
+    }
+    u.heading(`places · ${r.views.length} view(s) · ${opts.viewport}`);
+    for (const v of r.views)
+        u.line(`${v.view}${v.entered ? '' : ' · NOT ENTERED'}: ${v.place ?? '?'}${v.light?.preset ? ` · ${v.light.preset}` : ''}${v.dressing !== null ? ` · ${v.dressing} things/100 m²` : ''}${v.shot ? ` · ${v.shot}` : ''}`);
+    for (const p of r.pairs)
+        u.item(p.alike ? 'warn' : 'pass', `${p.a} ↔ ${p.b}: colour ΔE ${p.colour}${p.layout !== null ? `, layout ${p.layout}` : ''}${p.light ? `; light ${p.light}` : '; the same light'}`, p.alike ? p.why : undefined);
+    u.summary(r.verdict, `${r.why} — a mirror, never a gate (${PLACES_RECORD})`);
+    return r.verdict === 'not_observed' ? EXIT.not_observed : EXIT.pass;
+}