cubelife 0.2.0

package/dist/lib/tutorial.js

@@ -0,0 +1,358 @@
+import * as p from '@clack/prompts';
+import { basename } from 'node:path';
+import { currentUser, login, register } from './auth.js';
+import { createAdminClient, AgentClient } from './api.js';
+import { readProjectConfig, readAgents, resolveAgentKey } from './config.js';
+import { CREATURE_TYPES, CREATURE_DESCRIPTIONS, CREATURE_DEFAULT_COLORS, CREATURE_NAME_MAX, ID_DISPLAY_LENGTH, isValidHexColor, } from './constants.js';
+import { detectInstalledTools } from './detect.js';
+import { mergeSettings, writeHookScript, readClaudeSettings, writeClaudeSettings, hasMcpServer, resolveProjectRoot, isClaudeMcpRegistered, } from './integration.js';
+import { brand } from '../ui/theme.js';
+import { isCancel } from '../ui/helpers.js';
+import { getErrorMessage } from './command-helpers.js';
+import * as agentService from './services/agent-service.js';
+export async function detectProgress() {
+    const user = await currentUser();
+    if (!user)
+        return 0;
+    const config = await readProjectConfig();
+    if (!config?.projectId)
+        return 1;
+    if (!config.agentId)
+        return 2;
+    const store = await readAgents();
+    if (!resolveAgentKey(config.agentId, store))
+        return 2;
+    const existing = await readClaudeSettings(resolveProjectRoot());
+    if (!isClaudeMcpRegistered() && !hasMcpServer(existing))
+        return 4;
+    return 6;
+}
+export async function stepAccount() {
+    const user = await currentUser();
+    if (user) {
+        p.log.success(`Logged in as ${brand.primary(user.email)}`);
+        return;
+    }
+    const hasAccount = await p.confirm({
+        message: 'Do you have a CubeLife account?',
+    });
+    if (isCancel(hasAccount)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    const email = await p.text({
+        message: 'Email',
+        validate: (v) => { if (!v.includes('@'))
+            return 'Please enter a valid email.'; },
+    });
+    if (isCancel(email)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    const password = await p.password({ message: 'Password' });
+    if (isCancel(password)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    const spin = p.spinner();
+    if (hasAccount) {
+        spin.start('Logging in');
+        try {
+            const auth = await login(email, password);
+            spin.stop(`Logged in as ${brand.primary(auth.email)}`);
+        }
+        catch (err) {
+            spin.stop('Login failed');
+            p.log.error(getErrorMessage(err));
+            process.exit(1);
+        }
+    }
+    else {
+        const confirmPw = await p.password({ message: 'Confirm password' });
+        if (isCancel(confirmPw)) {
+            p.cancel('Tutorial cancelled.');
+            process.exit(0);
+        }
+        if (password !== confirmPw) {
+            p.log.error('Passwords do not match.');
+            process.exit(1);
+        }
+        spin.start('Creating account');
+        try {
+            const auth = await register(email, password);
+            spin.stop(`Account created for ${brand.primary(auth.email)}`);
+        }
+        catch (err) {
+            spin.stop('Registration failed');
+            p.log.error(getErrorMessage(err));
+            process.exit(1);
+        }
+    }
+}
+export async function stepProject() {
+    const config = await readProjectConfig();
+    if (config?.projectId) {
+        p.log.success(`Project linked: ${brand.primary(config.projectId.slice(0, ID_DISPLAY_LENGTH))}`);
+        return config.projectId;
+    }
+    const client = await createAdminClient();
+    const spin = p.spinner();
+    spin.start('Fetching projects');
+    const { projects } = await client.listProjects();
+    spin.stop(`${projects.length} project${projects.length === 1 ? '' : 's'} found`);
+    let projectId;
+    if (projects.length > 0) {
+        const CREATE = '__create__';
+        const selected = await p.select({
+            message: 'Select a project or create a new one',
+            options: [
+                ...projects.map((proj) => ({
+                    value: proj.id,
+                    label: proj.name,
+                    hint: proj.id.slice(0, ID_DISPLAY_LENGTH),
+                })),
+                { value: CREATE, label: '+ Create new project' },
+            ],
+        });
+        if (isCancel(selected)) {
+            p.cancel('Tutorial cancelled.');
+            process.exit(0);
+        }
+        if (selected !== CREATE) {
+            projectId = selected;
+            await agentService.linkAgent(projectId, '');
+            return projectId;
+        }
+    }
+    const dirName = basename(process.cwd());
+    const name = await p.text({
+        message: 'Project name',
+        initialValue: dirName,
+        validate: (v) => { if (!v.trim())
+            return 'Name cannot be empty.'; },
+    });
+    if (isCancel(name)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    const createSpin = p.spinner();
+    createSpin.start('Creating project');
+    const result = await client.createProject(name);
+    createSpin.stop(`Project created: ${brand.primary(result.name)}`);
+    await agentService.linkAgent(result.id, '');
+    return result.id;
+}
+export async function stepAgent(projectId) {
+    const config = await readProjectConfig();
+    if (config?.agentId) {
+        const store = await readAgents();
+        const key = resolveAgentKey(config.agentId, store);
+        if (key) {
+            const client = await createAdminClient();
+            try {
+                const agent = await client.getAgent(projectId, config.agentId);
+                p.log.success(`Agent: ${brand.primary(agent.name)} (${agent.form})`);
+                return { agentId: config.agentId, form: agent.form, apiKey: key };
+            }
+            catch {
+                // Agent deleted, fall through to creation
+            }
+        }
+    }
+    const dirName = basename(process.cwd());
+    const name = await p.text({
+        message: 'What should we call your agent?',
+        initialValue: dirName,
+        validate: (v) => { if (!v.trim())
+            return 'Name cannot be empty.'; },
+    });
+    if (isCancel(name)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    const form = await p.select({
+        message: 'Choose a form',
+        options: [
+            { value: 'creature', label: 'Creature Companion', hint: '8 unique creatures with personality' },
+            { value: 'human', label: 'Human Character', hint: 'Customisable pixel art character' },
+        ],
+    });
+    if (isCancel(form)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    let creature;
+    if (form === 'creature') {
+        const type = await p.select({
+            message: 'Choose a creature type',
+            options: CREATURE_TYPES.map((t) => ({
+                value: t,
+                label: t.charAt(0).toUpperCase() + t.slice(1),
+                hint: CREATURE_DESCRIPTIONS[t],
+            })),
+        });
+        if (isCancel(type)) {
+            p.cancel('Tutorial cancelled.');
+            process.exit(0);
+        }
+        creature = {
+            type: type,
+            color: CREATURE_DEFAULT_COLORS[type],
+        };
+    }
+    const client = await createAdminClient();
+    const spin = p.spinner();
+    spin.start('Creating agent');
+    const result = await agentService.createAgent(client, projectId, {
+        name: name,
+        form: form,
+        ...(creature ? { creature } : {}),
+    });
+    spin.stop('Agent created');
+    await agentService.linkAgent(projectId, result.id);
+    p.log.success(`Agent ${brand.primary(result.name)} created`);
+    return { agentId: result.id, form: form, apiKey: result.apiKey };
+}
+export async function stepAppearance(projectId, agentId, form) {
+    if (form === 'human') {
+        p.log.info(`Customise your character at ${brand.accent('life.cubeworld.co.za/#dashboard')}`);
+        return;
+    }
+    const wantCustomise = await p.confirm({
+        message: 'Customise creature colour and name?',
+        initialValue: false,
+    });
+    if (isCancel(wantCustomise)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    if (!wantCustomise)
+        return;
+    const client = await createAdminClient();
+    const agent = await agentService.getAgent(client, projectId, agentId);
+    const currentType = agent.creature?.type ?? 'gremlin';
+    const defaultColour = CREATURE_DEFAULT_COLORS[currentType];
+    const colourChoice = await p.select({
+        message: 'Creature colour',
+        options: [
+            { value: defaultColour, label: `Default (${defaultColour})`, hint: 'Recommended' },
+            { value: '#E8A0BF', label: 'Rose' },
+            { value: '#7EAAC1', label: 'Sky Blue' },
+            { value: '#5B8C5A', label: 'Forest Green' },
+            { value: '#D4874E', label: 'Amber' },
+            { value: '#9B7ED8', label: 'Lavender' },
+            { value: '__custom__', label: 'Custom hex colour' },
+        ],
+    });
+    if (isCancel(colourChoice)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    let colour = colourChoice;
+    if (colour === '__custom__') {
+        const hex = await p.text({
+            message: 'Hex colour (e.g. #FF5500)',
+            validate: (v) => {
+                const n = v.startsWith('#') ? v : `#${v}`;
+                if (!isValidHexColor(n))
+                    return 'Expected format: #RRGGBB';
+            },
+        });
+        if (isCancel(hex)) {
+            p.cancel('Tutorial cancelled.');
+            process.exit(0);
+        }
+        colour = hex.startsWith('#') ? hex : `#${hex}`;
+    }
+    const nameInput = await p.text({
+        message: 'Name your creature (leave empty to skip)',
+        initialValue: '',
+        validate: (v) => {
+            if (v.length > CREATURE_NAME_MAX)
+                return `Must be ${CREATURE_NAME_MAX} characters or fewer.`;
+        },
+    });
+    if (isCancel(nameInput)) {
+        p.cancel('Tutorial cancelled.');
+        process.exit(0);
+    }
+    const spin = p.spinner();
+    spin.start('Updating appearance');
+    await agentService.updateAgent(client, projectId, agentId, {
+        creature: {
+            type: currentType,
+            color: colour,
+            ...(nameInput ? { name: nameInput } : {}),
+        },
+    });
+    spin.stop('Appearance updated');
+}
+export async function stepIntegration() {
+    const tools = detectInstalledTools();
+    if (tools.length === 0) {
+        p.log.info(`No AI tools detected. Run ${brand.accent('cubelife setup')} later to configure.`);
+        return;
+    }
+    p.log.info(`Detected: ${tools.map((t) => brand.primary(t.name)).join(', ')}`);
+    const claudeCode = tools.find((t) => t.id === 'claude-code');
+    if (claudeCode) {
+        try {
+            const root = resolveProjectRoot();
+            await writeHookScript();
+            const existing = await readClaudeSettings(root);
+            const { settings } = mergeSettings(existing, 'both');
+            await writeClaudeSettings(root, settings);
+            p.log.success('Claude Code: MCP + Hooks configured');
+        }
+        catch (err) {
+            p.log.warn(`Claude Code setup failed: ${getErrorMessage(err)}`);
+            p.log.info(`Run ${brand.accent('cubelife setup claude-code')} to retry.`);
+        }
+    }
+    const others = tools.filter((t) => t.id !== 'claude-code');
+    if (others.length > 0) {
+        p.log.info(`Run ${brand.accent('cubelife setup <tool>')} to configure: ${others.map((t) => t.name).join(', ')}`);
+    }
+}
+export async function stepVerify(apiKey) {
+    const spin = p.spinner();
+    spin.start('Sending test state report');
+    const client = new AgentClient(apiKey);
+    try {
+        await client.report('complete', { detail: 'Tutorial finished!' });
+        spin.stop('State report delivered');
+    }
+    catch (err) {
+        spin.stop('Delivery failed');
+        p.log.warn(`Could not deliver state: ${getErrorMessage(err)}`);
+        p.log.info('This might be a network issue. Your agent is configured correctly.');
+    }
+}
+export async function runTutorial() {
+    p.intro(brand.primary('Welcome to CubeLife'));
+    const progress = await detectProgress();
+    if (progress >= 6) {
+        p.log.success('Already fully configured.');
+        p.outro(`Run ${brand.accent('cubelife view')} to see your agent in the terminal.`);
+        return;
+    }
+    if (progress > 0) {
+        p.log.info(`Previous progress detected (completed through step ${progress}).`);
+    }
+    p.log.step('Step 1/6: Account');
+    await stepAccount();
+    p.log.step('Step 2/6: Project');
+    const projectId = await stepProject();
+    p.log.step('Step 3/6: Agent');
+    const { agentId, form, apiKey } = await stepAgent(projectId);
+    p.log.step('Step 4/6: Appearance');
+    await stepAppearance(projectId, agentId, form);
+    p.log.step('Step 5/6: Integration');
+    await stepIntegration();
+    p.log.step('Step 6/6: Verify');
+    await stepVerify(apiKey);
+    p.outro(`You're all set!\n` +
+        `  ${brand.accent('cubelife view')}                         See your agent in the terminal\n` +
+        `  ${brand.accent('cubelife status coding "My first task"')}  Report a state\n` +
+        `  ${brand.accent('cubelife billing')}                      Check your plan and usage`);
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { AgentClient } from '../lib/api.js';
+export declare function resolveApiKey(): Promise<{
+    apiKey: string;
+    agentId: string;
+} | null>;
+export declare function createMcpServer(client: AgentClient): McpServer;
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,116 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { AgentClient, ApiError } from '../lib/api.js';
+import { readProjectConfig, readAgents, resolveAgentKey } from '../lib/config.js';
+import { VALID_STATES, VALID_SENTIMENTS } from '../lib/constants.js';
+import { CLI_VERSION } from '../version.js';
+import { getErrorMessage } from '../lib/command-helpers.js';
+function toolError(action, err) {
+    if (err instanceof ApiError && err.status === 429) {
+        return { content: [{ type: 'text', text: 'Rate limited. State not delivered.' }] };
+    }
+    return {
+        content: [{ type: 'text', text: `Failed to ${action}: ${getErrorMessage(err)}` }],
+        isError: true,
+    };
+}
+export async function resolveApiKey() {
+    const store = await readAgents();
+    const envAgentId = process.env['CUBELIFE_AGENT_ID'];
+    if (envAgentId) {
+        const key = resolveAgentKey(envAgentId, store);
+        if (key)
+            return { apiKey: key, agentId: envAgentId };
+    }
+    const config = await readProjectConfig();
+    if (config?.agentId) {
+        const key = resolveAgentKey(config.agentId, store);
+        if (key)
+            return { apiKey: key, agentId: config.agentId };
+    }
+    const envKey = process.env['CUBELIFE_API_KEY'];
+    if (envKey)
+        return { apiKey: envKey, agentId: 'env' };
+    return null;
+}
+export function createMcpServer(client) {
+    const server = new McpServer({
+        name: 'cubelife',
+        version: CLI_VERSION,
+    });
+    server.registerTool('cubelife_report', {
+        description: 'Report the AI agent\'s current work state to CubeLife. Call this when starting a new task or changing activity.',
+        inputSchema: {
+            state: z.enum(VALID_STATES).describe('The current work state'),
+            detail: z.string().optional().describe('Brief description of what the agent is doing'),
+            progress: z.number().min(0).max(1).optional().describe('Task progress from 0 to 1'),
+            sentiment: z.enum(VALID_SENTIMENTS).optional().describe('Current sentiment'),
+        },
+    }, async ({ state, detail, progress, sentiment }) => {
+        try {
+            await client.report(state, { detail, progress, sentiment });
+            return { content: [{ type: 'text', text: `State updated: ${state}` }] };
+        }
+        catch (err) {
+            return toolError('report state', err);
+        }
+    });
+    server.registerTool('cubelife_complete', {
+        description: 'Mark the current task as complete. Triggers a celebration animation on the character.',
+        inputSchema: {
+            detail: z.string().optional().describe('What was completed'),
+        },
+    }, async ({ detail }) => {
+        try {
+            await client.report('complete', { detail, sentiment: 'positive' });
+            return { content: [{ type: 'text', text: 'Task marked complete.' }] };
+        }
+        catch (err) {
+            return toolError('mark complete', err);
+        }
+    });
+    server.registerTool('cubelife_error', {
+        description: 'Report that an error occurred. Shows frustration on the character.',
+        inputSchema: {
+            detail: z.string().optional().describe('What went wrong'),
+        },
+    }, async ({ detail }) => {
+        try {
+            await client.report('error', { detail, sentiment: 'negative' });
+            return { content: [{ type: 'text', text: 'Error state reported.' }] };
+        }
+        catch (err) {
+            return toolError('report error', err);
+        }
+    });
+    server.registerTool('cubelife_status', {
+        description: 'Get the agent\'s current state.',
+        inputSchema: {},
+    }, async () => {
+        try {
+            const state = await client.getState();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(state) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to get status: ${getErrorMessage(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+export async function startMcpServer() {
+    const resolved = await resolveApiKey();
+    if (!resolved) {
+        process.stderr.write('No CubeLife API key found. Run `cubelife init` or set CUBELIFE_API_KEY.\n');
+        process.exit(1);
+    }
+    const client = new AgentClient(resolved.apiKey);
+    const server = createMcpServer(client);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/ui/banner.d.ts

@@ -0,0 +1,3 @@
+export declare function logo(): string;
+export declare function sectionHeader(title: string): string;
+export declare function version(v: string): string;

package/dist/ui/banner.js

@@ -0,0 +1,27 @@
+import { brand } from './theme.js';
+const LOGO_RAW = [
+    '  ▄▄▄▄▄  ▄  ▄ ▄▄▄▄  ▄▄▄▄▄',
+    '  █      █  █ █   █ █     ',
+    '  █      █  █ █▄▄▄▀ █▄▄▄  ',
+    '  █      █  █ █   █ █     ',
+    '  ▀▀▀▀▀  ▀▀▀  ▀▀▀▀  ▀▀▀▀▀',
+];
+const LIFE_RAW = [
+    '  █     ▀ ▄▄▄▄ ▄▄▄▄▄',
+    '  █     █ █    █     ',
+    '  █     █ █▄▄  █▄▄▄  ',
+    '  █     █ █    █     ',
+    '  ▀▀▀▀▀ ▀ ▀    ▀▀▀▀▀',
+];
+export function logo() {
+    const cube = LOGO_RAW.map((line) => brand.primary(line));
+    const life = LIFE_RAW.map((line) => brand.accent(line));
+    return cube.map((c, i) => c + life[i]).join('\n');
+}
+export function sectionHeader(title) {
+    const bar = brand.muted('─'.repeat(40));
+    return `\n${bar}\n  ${brand.heading(brand.primary(title))}\n${bar}`;
+}
+export function version(v) {
+    return brand.muted(`v${v}`);
+}

package/dist/ui/half-block.d.ts

@@ -0,0 +1,6 @@
+export interface RenderOptions {
+    bgR?: number;
+    bgG?: number;
+    bgB?: number;
+}
+export declare function renderHalfBlock(rgba: Uint8Array, width: number, height: number, options?: RenderOptions): string;

package/dist/ui/half-block.js

@@ -0,0 +1,45 @@
+const UPPER_HALF = '▀';
+const LOWER_HALF = '▄';
+const RESET = '\x1b[0m';
+function fg(r, g, b) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+function bg(r, g, b) {
+    return `\x1b[48;2;${r};${g};${b}m`;
+}
+export function renderHalfBlock(rgba, width, height, options = {}) {
+    const { bgR = 0, bgG = 0, bgB = 0 } = options;
+    const rows = [];
+    for (let y = 0; y < height; y += 2) {
+        let row = '';
+        for (let x = 0; x < width; x++) {
+            const topIdx = (y * width + x) * 4;
+            const botIdx = ((y + 1) * width + x) * 4;
+            const topR = rgba[topIdx];
+            const topG = rgba[topIdx + 1];
+            const topB = rgba[topIdx + 2];
+            const topA = rgba[topIdx + 3];
+            const hasBot = y + 1 < height;
+            const botR = hasBot ? rgba[botIdx] : 0;
+            const botG = hasBot ? rgba[botIdx + 1] : 0;
+            const botB = hasBot ? rgba[botIdx + 2] : 0;
+            const botA = hasBot ? rgba[botIdx + 3] : 0;
+            const topOpaque = topA >= 128;
+            const botOpaque = hasBot && botA >= 128;
+            if (topOpaque && botOpaque) {
+                row += fg(topR, topG, topB) + bg(botR, botG, botB) + UPPER_HALF;
+            }
+            else if (topOpaque && !botOpaque) {
+                row += fg(topR, topG, topB) + bg(bgR, bgG, bgB) + UPPER_HALF;
+            }
+            else if (!topOpaque && botOpaque) {
+                row += fg(botR, botG, botB) + bg(bgR, bgG, bgB) + LOWER_HALF;
+            }
+            else {
+                row += bg(bgR, bgG, bgB) + ' ';
+            }
+        }
+        rows.push(row + RESET);
+    }
+    return rows.join('\n');
+}

package/dist/ui/helpers.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function isCancel(value: unknown): value is symbol;
+export declare function getRootOpts(cmd: Command): Record<string, unknown>;

package/dist/ui/helpers.js

@@ -0,0 +1,11 @@
+import * as p from '@clack/prompts';
+export function isCancel(value) {
+    return p.isCancel(value);
+}
+export function getRootOpts(cmd) {
+    let current = cmd;
+    while (current?.parent) {
+        current = current.parent;
+    }
+    return current?.opts() ?? {};
+}

package/dist/ui/index.d.ts

@@ -0,0 +1,5 @@
+export { logo, sectionHeader, version } from './banner.js';
+export { panel } from './panel.js';
+export { table } from './table.js';
+export { renderSprite, textFallback } from './preview.js';
+export { brand, status, dot, label, heading, dim } from './theme.js';

package/dist/ui/index.js

@@ -0,0 +1,5 @@
+export { logo, sectionHeader, version } from './banner.js';
+export { panel } from './panel.js';
+export { table } from './table.js';
+export { renderSprite, textFallback } from './preview.js';
+export { brand, status, dot, label, heading, dim } from './theme.js';

package/dist/ui/panel.d.ts

@@ -0,0 +1,7 @@
+interface PanelOptions {
+    title?: string;
+    width?: number;
+    padding?: number;
+}
+export declare function panel(lines: string[], options?: PanelOptions): string;
+export {};

package/dist/ui/panel.js

@@ -0,0 +1,21 @@
+import { DEFAULT_PANEL_WIDTH } from '../lib/constants.js';
+import { brand } from './theme.js';
+export function panel(lines, options = {}) {
+    const { title, width = DEFAULT_PANEL_WIDTH, padding = 1 } = options;
+    const pad = ' '.repeat(padding);
+    const innerWidth = width - 2;
+    const top = title
+        ? `╭─ ${brand.heading(title)} ${'─'.repeat(Math.max(0, innerWidth - title.length - 3))}╮`
+        : `╭${'─'.repeat(innerWidth)}╮`;
+    const bottom = `╰${'─'.repeat(innerWidth)}╯`;
+    const empty = `│${' '.repeat(innerWidth)}│`;
+    const body = lines.map((line) => {
+        const visible = stripAnsi(line);
+        const fill = Math.max(0, innerWidth - visible.length - padding * 2);
+        return `│${pad}${line}${' '.repeat(fill)}${pad}│`;
+    });
+    return [top, empty, ...body, empty, bottom].join('\n');
+}
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/dist/ui/preview.d.ts

@@ -0,0 +1,7 @@
+interface PreviewOptions {
+    width?: number;
+    height?: number;
+}
+export declare function renderSprite(imagePath: string, options?: PreviewOptions): Promise<string>;
+export declare function textFallback(form: string, colour: string, name?: string): string;
+export {};

package/dist/ui/preview.js

@@ -0,0 +1,21 @@
+import { brand } from './theme.js';
+export async function renderSprite(imagePath, options = {}) {
+    const { width = 32, height = 16 } = options;
+    try {
+        const terminalImage = await import('terminal-image');
+        const { readFile } = await import('node:fs/promises');
+        const buffer = await readFile(imagePath);
+        return await terminalImage.default.buffer(buffer, { width, height });
+    }
+    catch {
+        return brand.muted(`[sprite: ${imagePath}]`);
+    }
+}
+export function textFallback(form, colour, name) {
+    const parts = [form];
+    if (colour)
+        parts.push(colour);
+    if (name)
+        parts.push(`"${name}"`);
+    return brand.muted(`[${parts.join(', ')}]`);
+}

package/dist/ui/table.d.ts

@@ -0,0 +1,8 @@
+interface Column<K extends string = string> {
+    label: string;
+    key: K;
+    width?: number;
+    colour?: (value: string) => string;
+}
+export declare function table<K extends string>(columns: Column<K>[], rows: Record<K, string>[]): string;
+export {};