cubelife 0.2.0

package/dist/commands/view.js

@@ -0,0 +1,262 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { createAdminClient, createAgentClient } from '../lib/api.js';
+import { renderHalfBlock } from '../ui/half-block.js';
+import { compositeCreature, compositeHuman, createDissolve, applyDissolve, getFrameCount, getFps, } from '../lib/compositor.js';
+import { openBrowser } from '../lib/browser.js';
+import { brand } from '../ui/theme.js';
+import { rootOpts, requireLinkedAgent, handleCommandError, } from '../lib/command-helpers.js';
+const EMBED_BASE = 'https://life.cubeworld.co.za';
+const STATE_POLL_MS = 5_000;
+const METADATA_ROWS = 6;
+const DISSOLVE_MS = 500;
+const TRANSITION_FPS = 15;
+const TRANSITION_INTERVAL = Math.round(1000 / TRANSITION_FPS);
+function relativeTime(ms) {
+    const seconds = Math.floor((Date.now() - ms) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ago`;
+}
+function renderProgressBar(progress, width = 12) {
+    const filled = Math.round(progress * width);
+    const empty = width - filled;
+    return chalk.green('█'.repeat(filled)) + chalk.grey('░'.repeat(empty));
+}
+function sentimentColour(sentiment) {
+    if (sentiment === 'positive')
+        return chalk.green(sentiment);
+    if (sentiment === 'negative')
+        return chalk.red(sentiment);
+    return chalk.grey(sentiment ?? 'neutral');
+}
+function renderMetadata(agent, state) {
+    const lines = [''];
+    if (agent.form === 'creature' && agent.creature) {
+        const colourHex = agent.creature.color ?? '#888888';
+        const swatch = chalk.hex(colourHex)('██');
+        const label = agent.creature.type.charAt(0).toUpperCase() + agent.creature.type.slice(1);
+        const name = agent.creature.name ? ` "${agent.creature.name}"` : '';
+        lines.push(`  ${label}${name}       ${swatch} ${brand.muted(colourHex)}`);
+    }
+    else {
+        lines.push(`  ${agent.name}`);
+    }
+    if (state) {
+        const detail = state.detail ? ` ${brand.muted(`"${state.detail}"`)}` : '';
+        lines.push(`  State: ${brand.primary(state.state)}${detail}`);
+        if (state.progress !== undefined && state.progress !== null) {
+            const pct = Math.round(state.progress * 100);
+            lines.push(`  Progress: ${renderProgressBar(state.progress)} ${pct}%`);
+        }
+        else {
+            lines.push('');
+        }
+        lines.push(`  Sentiment: ${sentimentColour(state.sentiment)}`);
+        if (state.updatedAt) {
+            lines.push(`  Updated: ${brand.muted(relativeTime(state.updatedAt))}`);
+        }
+        else {
+            lines.push('');
+        }
+    }
+    else {
+        lines.push(`  State: ${brand.muted('idle')}`);
+        lines.push('');
+        lines.push('');
+        lines.push('');
+    }
+    while (lines.length < METADATA_ROWS)
+        lines.push('');
+    return lines.map(l => l + '\x1b[K').join('\n');
+}
+function compositeFrame(agent, state, frameIndex) {
+    if (agent.form === 'creature' && agent.creature) {
+        const traits = {
+            type: agent.creature.type,
+            color: agent.creature.color ?? '#888888',
+            name: agent.creature.name,
+        };
+        return compositeCreature(traits, state, frameIndex);
+    }
+    const char = (agent.character ?? {});
+    const traits = {
+        skinTone: char.skinTone,
+        outfit: char.outfit,
+        outfitColor: char.outfitColor,
+        hairStyle: char.hairStyle,
+        hairColor: char.hairColor,
+        accessories: char.accessories,
+    };
+    return compositeHuman(traits, state, frameIndex);
+}
+async function pollState(agentClient) {
+    if (!agentClient)
+        return null;
+    try {
+        return await agentClient.getState();
+    }
+    catch {
+        return null;
+    }
+}
+export function registerViewCommand(program) {
+    program
+        .command('view')
+        .description('Render the linked agent in the terminal (live, animated)')
+        .option('--once', 'Render a single frame and exit')
+        .option('--browser', 'Open the web embed instead')
+        .option('--agent <id>', 'Agent ID (overrides linked agent)')
+        .option('--project <id>', 'Project ID (overrides linked project)')
+        .action(async function (opts) {
+        const { json } = rootOpts(this);
+        let projectId;
+        let agentId;
+        if (opts.agent && opts.project) {
+            projectId = opts.project;
+            agentId = opts.agent;
+        }
+        else if (opts.agent || opts.project) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'both_ids_required' }));
+            }
+            else {
+                p.log.error('Both --agent and --project are required when overriding.');
+            }
+            process.exit(1);
+        }
+        else {
+            const linked = await requireLinkedAgent(json);
+            projectId = linked.projectId;
+            agentId = linked.agentId;
+        }
+        const embedUrl = `${EMBED_BASE}/embed/${projectId}/${agentId}`;
+        if (opts.browser) {
+            if (json) {
+                console.log(JSON.stringify({ embedUrl }));
+            }
+            else {
+                p.log.info(`Opening ${brand.accent(embedUrl)}`);
+                await openBrowser(embedUrl);
+            }
+            return;
+        }
+        try {
+            const adminClient = await createAdminClient();
+            const agentClient = await createAgentClient(agentId);
+            const agent = await adminClient.getAgent(projectId, agentId);
+            let agentState = await pollState(agentClient);
+            let currentState = agentState?.state ?? 'idle';
+            if (json) {
+                const output = {
+                    agent: { id: agent.id, name: agent.name, form: agent.form },
+                    state: agentState ?? { state: 'idle' },
+                    embedUrl,
+                };
+                if (agent.form === 'creature' && agent.creature) {
+                    output.creature = agent.creature;
+                }
+                console.log(JSON.stringify(output, null, 2));
+                return;
+            }
+            if (opts.once) {
+                const result = compositeFrame(agent, currentState, 0);
+                const rendered = renderHalfBlock(result.rgba, result.width, result.height);
+                console.log(rendered);
+                console.log(renderMetadata(agent, agentState));
+                return;
+            }
+            const form = agent.form === 'creature' ? 'creature' : 'human';
+            let totalFrames = getFrameCount(form, agent.creature?.type, currentState);
+            let fps = getFps(form, agent.creature?.type, currentState);
+            let frameInterval = Math.round(1000 / fps);
+            let frame = 0;
+            let transitionTimer = null;
+            let transitionStart = 0;
+            let transitionFromState = '';
+            let dissolveOrder = null;
+            let pollTimer = null;
+            const cleanup = () => {
+                clearInterval(animTimer);
+                if (transitionTimer)
+                    clearInterval(transitionTimer);
+                if (pollTimer)
+                    clearInterval(pollTimer);
+                process.stdout.write('\x1b[?25h');
+                process.stdout.write('\x1b[?1049l');
+                process.exit(0);
+            };
+            process.on('SIGINT', cleanup);
+            process.on('SIGTERM', cleanup);
+            process.stdout.write('\x1b[?1049h');
+            process.stdout.write('\x1b[?25l');
+            process.stdout.write('\x1b[H');
+            const paintFrame = (rgba, w, h) => {
+                const rendered = renderHalfBlock(rgba, w, h);
+                const metadata = renderMetadata(agent, agentState);
+                process.stdout.write('\x1b[H');
+                process.stdout.write(rendered + '\n' + metadata + '\n');
+            };
+            const render = () => {
+                const result = compositeFrame(agent, currentState, frame);
+                paintFrame(result.rgba, result.width, result.height);
+                frame = (frame + 1) % totalFrames;
+            };
+            const renderTransitionFrame = () => {
+                const elapsed = Date.now() - transitionStart;
+                const t = Math.min(elapsed / DISSOLVE_MS, 1);
+                const fromResult = compositeFrame(agent, transitionFromState, 0);
+                const toResult = compositeFrame(agent, currentState, 0);
+                const blended = applyDissolve(fromResult.rgba, toResult.rgba, dissolveOrder, t);
+                paintFrame(blended, toResult.width, toResult.height);
+                if (t >= 1) {
+                    if (transitionTimer)
+                        clearInterval(transitionTimer);
+                    transitionTimer = null;
+                    dissolveOrder = null;
+                    frame = 0;
+                }
+            };
+            const startTransition = (fromState) => {
+                if (transitionTimer)
+                    clearInterval(transitionTimer);
+                transitionFromState = fromState;
+                transitionStart = Date.now();
+                dissolveOrder = createDissolve();
+                transitionTimer = setInterval(renderTransitionFrame, TRANSITION_INTERVAL);
+            };
+            render();
+            let animTimer = setInterval(render, frameInterval);
+            pollTimer = setInterval(async () => {
+                const newState = await pollState(agentClient);
+                if (!newState)
+                    return;
+                const stateChanged = newState.state !== currentState;
+                const previousState = currentState;
+                agentState = newState;
+                currentState = newState.state ?? 'idle';
+                if (stateChanged) {
+                    clearInterval(animTimer);
+                    startTransition(previousState);
+                    totalFrames = getFrameCount(form, agent.creature?.type, currentState);
+                    fps = getFps(form, agent.creature?.type, currentState);
+                    frameInterval = Math.round(1000 / fps);
+                    frame = 0;
+                    const waitForTransition = setInterval(() => {
+                        if (!transitionTimer) {
+                            clearInterval(waitForTransition);
+                            animTimer = setInterval(render, frameInterval);
+                        }
+                    }, TRANSITION_INTERVAL);
+                }
+            }, STATE_POLL_MS);
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+}

package/dist/data/sprite-data.d.ts

@@ -0,0 +1,32 @@
+export interface TintableAsset {
+    type: 'tintable';
+    width: number;
+    height: number;
+    frames: string[];
+}
+export interface ColourAsset {
+    type: 'colour';
+    width: number;
+    height: number;
+    frames: string[];
+}
+export type SpriteAsset = TintableAsset | ColourAsset;
+export interface StateConfig {
+    bodySheet: string;
+    frameCount: number;
+    fps: number;
+    facing?: 'north' | 'south';
+    background?: string;
+    prop?: string;
+    propLayer?: 'front' | 'back';
+    propScale?: number;
+    propOffsetX?: number;
+    propOffsetY?: number;
+}
+export interface CreatureConfig {
+    idleFrameCount: number;
+    fps: number;
+}
+export declare const SPRITE_DATA: Record<string, SpriteAsset>;
+export declare const STATE_MANIFEST: Record<string, StateConfig>;
+export declare const CREATURE_MANIFEST: Record<string, CreatureConfig>;