termi-kids 0.1.2 → 0.2.1

package/dist/setup/wizard.js

@@ -16,7 +16,6 @@ import { appendAudit } from '../safety/audit.js';
 import { ensureGuardFetch, guardProgressBar } from '../safety/guarddownload.js';
 import { guardModelReady } from '../safety/modelstore.js';
 import { nameIsOkay } from '../safety/prefilter.js';
-import { scaffoldById } from '../projects/scaffolds/index.js';
 import { renderBanner } from '../ui/banner.js';
 import { mascot } from '../ui/mascot.js';
 import { style } from '../ui/theme.js';
@@ -262,14 +261,7 @@ async function createPinStep() {
     }
 }
 async function consentStep(settings) {
-    const ageBand = ensure(await p.select({
-        message: 'How old is your kid?',
-        options: [
-            { value: 'under13', label: 'Under 13' },
-            { value: 'teen', label: '13 or older' },
-        ],
-        initialValue: 'under13',
-    }));
+    // One safety bar for every age. No under-13 / over-13 split.
     const agreed = ensure(await p.confirm({ message: `${T.wizard.consentIntro} Do you agree?`, initialValue: true }));
     if (!agreed) {
         bail();
@@ -280,13 +272,13 @@ async function consentStep(settings) {
             ts: attestedAt,
             layer: 'system',
             event: 'consent',
-            excerpt: `parent consent, age band ${ageBand}`,
+            excerpt: 'parent consent, one safety bar for all ages',
         });
     }
     catch {
         // Consent still counts; the audit line is best effort.
     }
-    return { ...settings, ageBand, consentAttestedAt: attestedAt };
+    return { ...settings, ageBand: 'under13', consentAttestedAt: attestedAt };
 }
 async function providerLoop(settings) {
     let current = settings;
@@ -318,41 +310,27 @@ async function providerLoop(settings) {
     return { ...current, activeProvider: null };
 }
 /**
- * Offers the on-device safety checker download. Default is yes: the
- * classifier setting ships on, and this step starts fetching its model file
- * in the background. The parent hears, plainly, that basic safety (the
- * local filter plus the online checks) is already on and that the checker
- * strengthens it when the download lands, then chooses to start building
- * now or wait and watch the bar. Either way the pipeline hot-attaches the
- * checker the moment the verified file is in place. Declining turns the
- * setting off; a failed or interrupted download resumes on the next start.
+ * Installs the on-device safety checker as part of setup. Always on: the
+ * model download starts here (and resumes on later boots). Parent can wait
+ * for the bar or keep going; declining is not offered.
  */
 async function localGuardStep(settings) {
     if (guardModelReady()) {
-        // Model already present: keep whatever the parent chose before. A
-        // wizard re-run must not silently flip a deliberate off back to on.
-        return settings;
-    }
-    const wants = ensure(await p.confirm({ message: T.wizard.guardOffer, initialValue: true }));
-    if (!wants) {
-        p.log.info(T.wizard.guardDeclined);
-        audit('settings_change', 'local classifier off (declined in setup)');
-        return { ...settings, localClassifier: false };
+        return { ...settings, localClassifier: true };
     }
+    p.log.info(T.wizard.guardOffer);
     const fetchDone = ensureGuardFetch();
     p.log.info(T.wizard.guardBackground);
+    audit('settings_change', 'local classifier install started in setup');
     const wait = ensure(await p.select({
         message: T.wizard.guardWaitPick,
         options: [
-            { value: 'now', label: T.wizard.guardStartNow, hint: T.wizard.guardStartNowHint },
             { value: 'wait', label: T.wizard.guardWaitHere, hint: T.wizard.guardWaitHereHint },
+            { value: 'now', label: T.wizard.guardStartNow, hint: T.wizard.guardStartNowHint },
         ],
-        initialValue: 'now',
+        initialValue: 'wait',
     }));
     if (wait === 'wait') {
-        // The wait shows a live bar with periodic escape hatches (after one
-        // minute, then every ten): a slow connection must not trap the parent
-        // in setup when the download finishes fine in the background anyway.
         const escapeAfterMs = [60_000, 600_000];
         let escapeIndex = 0;
         for (;;) {
@@ -406,64 +384,12 @@ async function firstGameStep(settings) {
     if (p.isCancel(wants) || !wants) {
         return;
     }
-    const games = scaffoldById('games');
-    if (games === undefined) {
-        return;
-    }
-    const themeId = await p.select({
-        message: 'Pick a style for your game.',
-        options: games.themes.map((t) => ({ value: t.id, label: `${t.emoji} ${t.label}` })),
-    });
-    if (p.isCancel(themeId)) {
-        return;
-    }
-    const theme = games.themes.find((t) => t.id === themeId);
-    if (theme === undefined) {
-        return;
-    }
-    const CUSTOM = '__custom__';
-    const suggestions = suggestProjectNames(theme.label);
-    const namePick = await p.select({
-        message: 'Pick a name for it.',
-        options: [
-            ...suggestions.map((n) => ({ value: n, label: n })),
-            { value: CUSTOM, label: 'Type my own name' },
-        ],
-    });
-    if (p.isCancel(namePick)) {
-        return;
-    }
-    let prettyName = namePick;
-    if (namePick === CUSTOM) {
-        const typed = await p.text({
-            message: 'What is its name?',
-            validate: (value) => {
-                const trimmed = (value ?? '').trim();
-                if (trimmed.length === 0)
-                    return 'It needs a name.';
-                if (!nameIsOkay(trimmed))
-                    return 'That name will not work. Try another one.';
-                return undefined;
-            },
-        });
-        if (p.isCancel(typed)) {
-            return;
-        }
-        prettyName = typed.trim();
-    }
     try {
-        const create = await import('../projects/create.js');
-        const home = await import('../surfaces/home.js');
-        const made = create.createProject('games', theme.id, prettyName);
-        await home.awardBadge('first-project');
-        const starters = made.starterPrompts.slice(0, 2);
-        if (starters.length > 0) {
-            p.note(starters.map((line) => `- ${line}`).join('\n'), 'Try saying');
-        }
-        await home.openChatLoop(made.project, settings);
+        const build = await import('../surfaces/buildGame.js');
+        await build.runBuildGame(settings);
     }
     catch {
-        p.log.warn('I could not start the game yet. Try "termi new" next time.');
+        p.log.warn('I could not start the game yet. Try Build a game next time.');
     }
 }
 /** Runs the full setup wizard, parent flow then kid flow. */

package/dist/surfaces/buildGame.js

@@ -0,0 +1,335 @@
+/**
+ * Build a game: pick an idea, prompt loop, live preview, done/improve,
+ * final polish. Projects save in the local library under TERMI_PROJECTS_DIR.
+ */
+import * as p from '@clack/prompts';
+import { getSecret } from '../auth/keychain.js';
+import { hasTokens } from '../auth/tokens.js';
+import { startPreview } from '../preview/server.js';
+import { createProviderClient, pickClassifierBackend, } from '../providers/index.js';
+import { classifyProviderError } from '../providers/errors.js';
+import { appendAudit } from '../safety/audit.js';
+import { createSafetyPipeline } from '../safety/classifier.js';
+import { ensureGuardFetch } from '../safety/guarddownload.js';
+import { lazyGuardAccessor } from '../safety/guardrunner.js';
+import { guardModelReady } from '../safety/modelstore.js';
+import { createSessionState } from '../safety/session.js';
+import { nameIsOkay } from '../safety/prefilter.js';
+import { createBlankGameProject } from '../projects/blankGame.js';
+import { GAME_IDEAS, gameIdeaById, gameIdeaMenuOptions, isOwnIdea, } from '../projects/gameIdeas.js';
+import { providerLabel } from '../setup/wizard.js';
+import { renderProviderError } from '../ui/errors.js';
+import { style } from '../ui/theme.js';
+import { T } from '../ui/text.js';
+import { completenessHint, defaultNameForIdea, helpQuestions, parseDoneChoice, polishPrompt, seedPromptForIdea, suggestPromptFromAnswers, summarizeProjectFiles, } from './buildLoop.js';
+import { awardBadge } from './home.js';
+function audit(event) {
+    try {
+        appendAudit(event);
+    }
+    catch {
+        // Never break the kid flow for the log.
+    }
+}
+function providerAvailability(settings) {
+    return {
+        'openai-chatgpt': hasTokens(),
+        'openai-api': (getSecret('api-key-openai-api') ?? '').length > 0,
+        anthropic: (getSecret('api-key-anthropic') ?? '').length > 0,
+        xai: (getSecret('api-key-xai') ?? '').length > 0 && settings.xaiParentAck,
+    };
+}
+async function pickIdea() {
+    const pick = await p.select({
+        message: 'Build a game. What do you want to make?',
+        options: gameIdeaMenuOptions(),
+        initialValue: GAME_IDEAS[0].id,
+    });
+    if (p.isCancel(pick)) {
+        return null;
+    }
+    return gameIdeaById(pick) ?? null;
+}
+async function pickProjectName(idea) {
+    const suggested = defaultNameForIdea(idea);
+    const typed = await p.text({
+        message: 'Name your game.',
+        placeholder: suggested,
+        defaultValue: suggested,
+        validate: (value) => {
+            const trimmed = (value ?? '').trim() || suggested;
+            if (trimmed.length === 0)
+                return 'It needs a name.';
+            if (!nameIsOkay(trimmed))
+                return 'That name will not work. Try another one.';
+            return undefined;
+        },
+    });
+    if (p.isCancel(typed)) {
+        return null;
+    }
+    const name = typed.trim() || suggested;
+    return name;
+}
+async function gatherHelpAnswers(idea) {
+    const questions = helpQuestions(idea);
+    const answers = [];
+    for (const question of questions) {
+        const ans = await p.text({
+            message: question,
+            validate: (value) => (value ?? '').trim().length > 0 ? undefined : 'Say a little so I can help.',
+        });
+        if (p.isCancel(ans)) {
+            return null;
+        }
+        answers.push(ans.trim());
+    }
+    return answers;
+}
+async function obtainPrompt(idea) {
+    const path = await p.select({
+        message: 'How do you want to tell Termi what to build?',
+        options: [
+            { value: 'write', label: 'I will write my own prompt' },
+            { value: 'help', label: 'Help me with a prompt for my idea' },
+            ...(seedPromptForIdea(idea).length > 0
+                ? [{ value: 'seed', label: 'Use the ready idea prompt' }]
+                : []),
+        ],
+    });
+    if (p.isCancel(path)) {
+        return null;
+    }
+    let draft = '';
+    if (path === 'seed') {
+        draft = seedPromptForIdea(idea);
+    }
+    else if (path === 'help') {
+        const answers = await gatherHelpAnswers(idea);
+        if (answers === null) {
+            return null;
+        }
+        draft = suggestPromptFromAnswers(idea, answers);
+        p.note(draft, 'Suggested prompt');
+    }
+    const text = await p.text({
+        message: path === 'write' ? 'Type your prompt.' : 'Edit the prompt, or press Enter to run it.',
+        defaultValue: draft,
+        placeholder: draft || 'Make a fun browser game where...',
+        validate: (value) => (value ?? '').trim().length > 0 ? undefined : 'Need a prompt to build.',
+    });
+    if (p.isCancel(text)) {
+        return null;
+    }
+    return text.trim();
+}
+function listKidFileSummaries(project) {
+    const out = [];
+    for (const file of project.listKidFiles()) {
+        const content = project.readFile(file.relPath);
+        if (content !== null) {
+            out.push({ relPath: file.relPath, content });
+        }
+    }
+    return out;
+}
+async function runOneTurn(kidMessage, deps) {
+    const loop = await import('../agent/loop.js');
+    const spin = p.spinner();
+    spin.start(T.chat.thinking);
+    let result;
+    try {
+        result = await loop.runTurn(kidMessage, {
+            provider: deps.provider,
+            modelAlias: deps.settings.modelAlias,
+            safety: deps.safety,
+            session: deps.session,
+            project: deps.project,
+            snapshots: deps.snapshots,
+            preview: deps.preview,
+            audit,
+            ui: {
+                onActivity(line) {
+                    spin.message(line);
+                },
+            },
+        });
+    }
+    catch (err) {
+        spin.stop();
+        const label = deps.settings.activeProvider !== null
+            ? providerLabel(deps.settings.activeProvider)
+            : 'AI helper';
+        console.log(renderProviderError(classifyProviderError(err), label));
+        return 'error';
+    }
+    spin.stop(T.chat.working);
+    if (result.status === 'ok') {
+        if (result.replyText) {
+            console.log(result.replyText);
+        }
+        try {
+            deps.preview.notifyChange();
+        }
+        catch {
+            // Preview may already be closed.
+        }
+        return 'ok';
+    }
+    if (result.status === 'blocked') {
+        if (result.screen !== null) {
+            console.log(result.screen.body);
+        }
+        else {
+            console.log(T.blocks.generic);
+        }
+        return 'blocked';
+    }
+    if (result.screen !== null) {
+        console.log(result.screen.body);
+    }
+    else {
+        console.log(T.errors.oops);
+    }
+    return 'error';
+}
+/**
+ * Full Build a game session for one project from idea pick to library save.
+ * Returns the project when something was saved, null on cancel at the start.
+ */
+export async function runBuildGame(settings) {
+    const idea = await pickIdea();
+    if (idea === null) {
+        return null;
+    }
+    const prettyName = await pickProjectName(idea);
+    if (prettyName === null) {
+        return null;
+    }
+    let project;
+    try {
+        project = createBlankGameProject(prettyName, idea.label);
+    }
+    catch (err) {
+        p.log.error(err instanceof Error ? err.message : 'Could not create the game folder.');
+        return null;
+    }
+    await awardBadge('first-project');
+    let provider = null;
+    if (settings.activeProvider !== null) {
+        try {
+            provider = createProviderClient(settings.activeProvider);
+        }
+        catch {
+            provider = null;
+        }
+    }
+    if (provider === null) {
+        p.log.warn(`${T.offline.noProvider} ${T.offline.stillWorks}`);
+        p.log.info(`Your game folder is ready: ${project.meta.prettyName}`);
+        return project;
+    }
+    if (settings.localClassifier && !guardModelReady()) {
+        void ensureGuardFetch();
+    }
+    const backend = pickClassifierBackend(settings, providerAvailability(settings));
+    const safety = createSafetyPipeline({
+        classifierModel: () => backend.classifierClient !== null
+            ? backend.classifierClient.languageModel('classifier', settings.modelAlias)
+            : null,
+        moderationKey: () => backend.moderationKey,
+        localGuard: lazyGuardAccessor(settings.localClassifier),
+        audit,
+    });
+    const session = createSessionState();
+    let snapshots = {
+        beginTurn() { },
+        undo() {
+            return false;
+        },
+        redo() {
+            return false;
+        },
+    };
+    try {
+        const snapMod = await import('../projects/snapshots.js');
+        snapshots = snapMod.createSnapshotStore(project);
+    }
+    catch {
+        // undo optional
+    }
+    const preview = await startPreview(project.dir, { openBrowser: true });
+    console.log(`${T.chat.previewOpened} ${style.dim(preview.url)}`);
+    console.log(style.dim('The browser will update after each build.'));
+    const turnDeps = { provider, settings, project, preview, safety, session, snapshots };
+    // First build
+    for (;;) {
+        const prompt = await obtainPrompt(idea);
+        if (prompt === null) {
+            break;
+        }
+        const status = await runOneTurn(prompt, turnDeps);
+        if (status === 'ok') {
+            try {
+                preview.notifyChange();
+            }
+            catch {
+                //
+            }
+        }
+        const next = await p.select({
+            message: 'Do you think you are done, or want to improve the idea?',
+            options: [
+                { value: 'improve', label: 'Improve' },
+                { value: 'done', label: 'I am done' },
+            ],
+            initialValue: 'improve',
+        });
+        if (p.isCancel(next)) {
+            break;
+        }
+        const choice = parseDoneChoice(next);
+        if (choice === 'improve') {
+            continue;
+        }
+        if (choice === 'done') {
+            console.log(style.title('Testing your game and making final fixes...'));
+            const summary = summarizeProjectFiles(listKidFileSummaries(project));
+            const hint = completenessHint(summary);
+            console.log(style.dim(`Suggestion: ${hint}`));
+            const approve = await p.confirm({
+                message: 'Apply this final improvement?',
+                initialValue: true,
+            });
+            if (!p.isCancel(approve) && approve) {
+                const finalPrompt = polishPrompt(`${hint}. Project: ${summary}`);
+                await runOneTurn(finalPrompt, turnDeps);
+                try {
+                    preview.notifyChange();
+                }
+                catch {
+                    //
+                }
+                console.log(style.good('Final fixes applied. Check the browser!'));
+            }
+            else {
+                console.log('Okay. Your game is saved as is.');
+            }
+            break;
+        }
+    }
+    p.log.success(`Saved in your game library: ${project.meta.prettyName}`);
+    // Keep preview open so the kid can keep playing; they Ctrl+C later or return home.
+    return project;
+}
+/** Exported for tests that assert the catalog is wired. */
+export function buildGameIdeaCount() {
+    return GAME_IDEAS.length;
+}
+export function buildGameFirstLabel() {
+    return GAME_IDEAS[0]?.label ?? '';
+}
+export function buildGameIsOwnFirst() {
+    const first = GAME_IDEAS[0];
+    return first !== undefined && isOwnIdea(first);
+}

package/dist/surfaces/buildLoop.js

@@ -0,0 +1,114 @@
+/**
+ * Pure helpers for the Build a game prompt loop.
+ * UI and network live in buildGame.ts; tests cover this module fully.
+ */
+import { isOwnIdea } from '../projects/gameIdeas.js';
+/** Clarifying questions when the kid picks Help me with a prompt. */
+export function helpQuestions(idea) {
+    if (isOwnIdea(idea)) {
+        return [
+            'What is your game about in one short line?',
+            'How does the player win or finish?',
+            'What keys or clicks should control it?',
+        ];
+    }
+    return [
+        `What should feel special about "${idea.label}"?`,
+        'Do you want easy mode, normal, or hard?',
+    ];
+}
+/** Builds a starter prompt from a catalog idea (not own-idea). */
+export function seedPromptForIdea(idea) {
+    if (isOwnIdea(idea) || idea.seedPrompt.trim().length === 0) {
+        return '';
+    }
+    return idea.seedPrompt.trim();
+}
+/**
+ * Turns help-question answers into a suggested build prompt the kid can
+ * edit. Works offline without a model call.
+ */
+export function suggestPromptFromAnswers(idea, answers) {
+    const cleaned = answers.map((a) => a.trim()).filter((a) => a.length > 0);
+    if (isOwnIdea(idea)) {
+        const about = cleaned[0] ?? 'a fun browser game';
+        const win = cleaned[1] ?? 'reach a high score';
+        const controls = cleaned[2] ?? 'arrow keys or click';
+        return (`Make a complete local browser game about ${about}. ` +
+            `The player wins when they ${win}. ` +
+            `Controls: ${controls}. ` +
+            `Use only HTML, CSS, and JavaScript in index.html, style.css, and game.js. ` +
+            `No images from the internet. Keep it kid friendly and playable after one load.`);
+    }
+    const special = cleaned[0] ?? idea.blurb;
+    const difficulty = cleaned[1] ?? 'normal';
+    const base = seedPromptForIdea(idea) || `Make a ${idea.label} browser game.`;
+    return (`${base} ` +
+        `Make it feel special by: ${special}. ` +
+        `Difficulty: ${difficulty}. ` +
+        `Use only HTML, CSS, and JavaScript files. No outside images.`);
+}
+/** Final polish instruction after the kid says they are done. */
+export function polishPrompt(projectSummary) {
+    const summary = projectSummary.trim().length > 0
+        ? projectSummary.trim().slice(0, 800)
+        : 'the current game files';
+    return (`You are doing final testing and fixes for this kid game. ` +
+        `Read the project files. Based on ${summary}, make ONE clear improvement ` +
+        `so the game feels more complete (for example a start screen, score, ` +
+        `restart key, win or lose message, or clearer controls). ` +
+        `Apply the change in the files. Keep it simple and kid friendly. ` +
+        `No internet images. Then briefly say what you fixed.`);
+}
+/** Summarize kid files for the polish prompt (pure). */
+export function summarizeProjectFiles(files) {
+    if (files.length === 0) {
+        return 'no files yet';
+    }
+    return files
+        .map((f) => {
+        const lines = f.content.split('\n').length;
+        const hasCanvas = /canvas/i.test(f.content);
+        const hasScore = /score/i.test(f.content);
+        const flags = [
+            hasCanvas ? 'canvas' : null,
+            hasScore ? 'score' : null,
+            lines < 20 ? 'short' : null,
+        ]
+            .filter(Boolean)
+            .join(',');
+        return `${f.relPath}(${lines} lines${flags ? `; ${flags}` : ''})`;
+    })
+        .join('; ');
+}
+/** Maps select values to done/improve. */
+export function parseDoneChoice(value) {
+    if (value === 'done' || value === 'improve') {
+        return value;
+    }
+    return null;
+}
+/** Default project name from an idea label. */
+export function defaultNameForIdea(idea) {
+    if (isOwnIdea(idea)) {
+        return 'My Game';
+    }
+    return idea.label;
+}
+/**
+ * One completeness suggestion line for the terminal (before the kid
+ * approves a polish apply). Pure heuristic from file summary text.
+ */
+export function completenessHint(summary) {
+    const s = summary.toLowerCase();
+    if (!s.includes('score')) {
+        return 'Add a clear score the player can see.';
+    }
+    if (!s.includes('canvas') && !s.includes('button')) {
+        return 'Add a start screen with a Play button.';
+    }
+    if (s.includes('short')) {
+        return 'Add a win or lose message and a restart key.';
+    }
+    return 'Add clearer control hints on the start screen.';
+}

package/dist/surfaces/commands.js

@@ -110,10 +110,10 @@ export function helpText() {
         ['/preview', 'watch your project run'],
         ['/undo', 'take back the last change'],
         ['/redo', 'bring a change back'],
-        ['/new', 'start a fresh project'],
-        ['/ideas', 'get fun ideas'],
+        ['/new', 'build a new game'],
+        ['/ideas', 'get game ideas'],
         ['/badges', 'see your badges'],
-        ['/learn', 'play short AI lessons'],
+        ['/learn', 'Learn AI lessons'],
         ['/quest', 'build with me, step by step'],
         ['/help', 'show this list'],
         ['/done', 'finish and celebrate'],