cubelife 0.2.0

package/dist/lib/compositor.js

@@ -0,0 +1,232 @@
+import { SPRITE_DATA, STATE_MANIFEST, CREATURE_MANIFEST, } from '../data/sprite-data.js';
+const FRAME_SIZE = 48;
+const SPRITE_HALF = FRAME_SIZE / 2;
+const PIXELS = FRAME_SIZE * FRAME_SIZE;
+const RGBA_BYTES = PIXELS * 4;
+const CREATURE_BODY_SCALE = 0.6;
+export function hexToColour(hex) {
+    const h = hex.replace('#', '');
+    const r = parseInt(h.slice(0, 2), 16);
+    const g = parseInt(h.slice(2, 4), 16);
+    const b = parseInt(h.slice(4, 6), 16);
+    return {
+        r: Number.isNaN(r) ? 128 : r,
+        g: Number.isNaN(g) ? 128 : g,
+        b: Number.isNaN(b) ? 128 : b,
+    };
+}
+function decodeFrames(asset) {
+    return asset.frames.map(b64 => new Uint8Array(Buffer.from(b64, 'base64').buffer));
+}
+export function applyTint(lumAlpha, colour) {
+    const rgba = new Uint8Array(lumAlpha.length * 2);
+    for (let i = 0; i < lumAlpha.length; i += 2) {
+        const lum = lumAlpha[i];
+        const alpha = lumAlpha[i + 1];
+        const j = i * 2;
+        rgba[j] = Math.round(lum * colour.r / 255);
+        rgba[j + 1] = Math.round(lum * colour.g / 255);
+        rgba[j + 2] = Math.round(lum * colour.b / 255);
+        rgba[j + 3] = alpha;
+    }
+    return rgba;
+}
+export function alphaBlend(dst, src) {
+    for (let i = 0; i < dst.length; i += 4) {
+        const srcA = src[i + 3] / 255;
+        if (srcA === 0)
+            continue;
+        const dstA = dst[i + 3] / 255;
+        const outA = srcA + dstA * (1 - srcA);
+        if (outA === 0)
+            continue;
+        dst[i] = Math.round((src[i] * srcA + dst[i] * dstA * (1 - srcA)) / outA);
+        dst[i + 1] = Math.round((src[i + 1] * srcA + dst[i + 1] * dstA * (1 - srcA)) / outA);
+        dst[i + 2] = Math.round((src[i + 2] * srcA + dst[i + 2] * dstA * (1 - srcA)) / outA);
+        dst[i + 3] = Math.round(outA * 255);
+    }
+}
+function resolveRgba(key, frameIndex, tint) {
+    const asset = SPRITE_DATA[key];
+    if (!asset)
+        return null;
+    const frames = decodeFrames(asset);
+    const idx = Math.min(frameIndex, frames.length - 1);
+    const frame = frames[idx];
+    if (asset.type === 'tintable' && tint) {
+        return applyTint(frame, tint);
+    }
+    if (asset.type === 'tintable') {
+        return applyTint(frame, { r: 200, g: 200, b: 200 });
+    }
+    return frame;
+}
+function scaleAndPlace(src, scale, anchorX, anchorY) {
+    if (scale >= 1)
+        return src;
+    const scaledSize = Math.round(FRAME_SIZE * scale);
+    const offsetX = Math.round(anchorX - scaledSize * (anchorX / FRAME_SIZE));
+    const offsetY = Math.round(anchorY - scaledSize * (anchorY / FRAME_SIZE));
+    const out = new Uint8Array(RGBA_BYTES);
+    for (let dy = 0; dy < scaledSize; dy++) {
+        const dstY = offsetY + dy;
+        if (dstY < 0 || dstY >= FRAME_SIZE)
+            continue;
+        const srcY = Math.floor(dy * FRAME_SIZE / scaledSize);
+        for (let dx = 0; dx < scaledSize; dx++) {
+            const dstX = offsetX + dx;
+            if (dstX < 0 || dstX >= FRAME_SIZE)
+                continue;
+            const srcX = Math.floor(dx * FRAME_SIZE / scaledSize);
+            const si = (srcY * FRAME_SIZE + srcX) * 4;
+            const di = (dstY * FRAME_SIZE + dstX) * 4;
+            out[di] = src[si];
+            out[di + 1] = src[si + 1];
+            out[di + 2] = src[si + 2];
+            out[di + 3] = src[si + 3];
+        }
+    }
+    return out;
+}
+export function compositeCreature(creature, state, frameIndex) {
+    const canvas = new Uint8Array(RGBA_BYTES);
+    const colour = hexToColour(creature.color);
+    const stateConfig = STATE_MANIFEST[state];
+    if (stateConfig) {
+        if (stateConfig.background) {
+            const bgLayer = resolveRgba(stateConfig.background, 0);
+            if (bgLayer)
+                alphaBlend(canvas, bgLayer);
+        }
+        if (stateConfig.prop && stateConfig.propLayer === 'back') {
+            const propLayer = resolveRgba(stateConfig.prop, 0);
+            if (propLayer) {
+                const propScale = stateConfig.propScale ?? 1;
+                const anchorX = SPRITE_HALF + (stateConfig.propOffsetX ?? 0);
+                const anchorY = SPRITE_HALF + (stateConfig.propOffsetY ?? 0);
+                alphaBlend(canvas, scaleAndPlace(propLayer, propScale, anchorX, anchorY));
+            }
+        }
+    }
+    const creatureKey = `creatures/${creature.type}/idle`;
+    const creatureFrame = resolveRgba(creatureKey, frameIndex, colour);
+    if (creatureFrame) {
+        const scaled = scaleAndPlace(creatureFrame, CREATURE_BODY_SCALE, SPRITE_HALF, SPRITE_HALF);
+        alphaBlend(canvas, scaled);
+    }
+    if (stateConfig?.prop && stateConfig.propLayer === 'front') {
+        const propLayer = resolveRgba(stateConfig.prop, 0);
+        if (propLayer) {
+            const propScale = stateConfig.propScale ?? 1;
+            const anchorX = SPRITE_HALF + (stateConfig.propOffsetX ?? 0);
+            const anchorY = SPRITE_HALF + (stateConfig.propOffsetY ?? 0);
+            alphaBlend(canvas, scaleAndPlace(propLayer, propScale, anchorX, anchorY));
+        }
+    }
+    return { rgba: canvas, width: FRAME_SIZE, height: FRAME_SIZE };
+}
+export function compositeHuman(traits, state, frameIndex) {
+    const canvas = new Uint8Array(RGBA_BYTES);
+    const stateConfig = STATE_MANIFEST[state] ?? STATE_MANIFEST['idle'];
+    const facing = stateConfig.facing ?? 'south';
+    const variant = facing === 'north' ? 'back' : 'standing';
+    if (stateConfig.background) {
+        const bgLayer = resolveRgba(stateConfig.background, 0);
+        if (bgLayer)
+            alphaBlend(canvas, bgLayer);
+    }
+    if (stateConfig.prop && stateConfig.propLayer === 'back') {
+        const propLayer = resolveRgba(stateConfig.prop, 0);
+        if (propLayer) {
+            const propScale = stateConfig.propScale ?? 1;
+            const anchorX = SPRITE_HALF + (stateConfig.propOffsetX ?? 0);
+            const anchorY = SPRITE_HALF + (stateConfig.propOffsetY ?? 0);
+            alphaBlend(canvas, scaleAndPlace(propLayer, propScale, anchorX, anchorY));
+        }
+    }
+    const skinColour = traits.skinTone ? hexToColour(traits.skinTone) : { r: 220, g: 180, b: 140 };
+    const bodyFrame = resolveRgba(stateConfig.bodySheet, frameIndex, skinColour);
+    if (bodyFrame)
+        alphaBlend(canvas, bodyFrame);
+    const outfit = traits.outfit ?? 'default_tee';
+    const outfitColour = traits.outfitColor ? hexToColour(traits.outfitColor) : { r: 100, g: 150, b: 200 };
+    const outfitKey = `outfits/${outfit}_${variant}`;
+    const outfitFrame = resolveRgba(outfitKey, 0, outfitColour);
+    if (outfitFrame)
+        alphaBlend(canvas, outfitFrame);
+    const hair = traits.hairStyle ?? 'short';
+    const hairColour = traits.hairColor ? hexToColour(traits.hairColor) : { r: 80, g: 50, b: 30 };
+    const hairKey = `hair/${hair}_${variant}`;
+    const hairFrame = resolveRgba(hairKey, 0, hairColour);
+    if (hairFrame)
+        alphaBlend(canvas, hairFrame);
+    if (traits.accessories) {
+        for (const acc of traits.accessories) {
+            if (acc === 'glasses' && facing === 'north')
+                continue;
+            const accKey = facing === 'north'
+                ? `accessories/${acc}_back`
+                : `accessories/${acc}`;
+            const accFrame = resolveRgba(accKey, 0);
+            if (accFrame)
+                alphaBlend(canvas, accFrame);
+        }
+    }
+    if (stateConfig.prop && stateConfig.propLayer === 'front') {
+        const propLayer = resolveRgba(stateConfig.prop, 0);
+        if (propLayer) {
+            const propScale = stateConfig.propScale ?? 1;
+            const anchorX = SPRITE_HALF + (stateConfig.propOffsetX ?? 0);
+            const anchorY = SPRITE_HALF + (stateConfig.propOffsetY ?? 0);
+            alphaBlend(canvas, scaleAndPlace(propLayer, propScale, anchorX, anchorY));
+        }
+    }
+    return { rgba: canvas, width: FRAME_SIZE, height: FRAME_SIZE };
+}
+export function getFrameCount(form, creatureType, state) {
+    if (form === 'creature' && creatureType) {
+        return CREATURE_MANIFEST[creatureType]?.idleFrameCount ?? 5;
+    }
+    const stateConfig = STATE_MANIFEST[state ?? 'idle'];
+    return stateConfig?.frameCount ?? 4;
+}
+export function getFps(form, creatureType, state) {
+    if (form === 'creature' && creatureType) {
+        return CREATURE_MANIFEST[creatureType]?.fps ?? 2;
+    }
+    const stateConfig = STATE_MANIFEST[state ?? 'idle'];
+    return stateConfig?.fps ?? 2;
+}
+function shuffledIndices(count) {
+    const arr = new Uint16Array(count);
+    for (let i = 0; i < count; i++)
+        arr[i] = i;
+    for (let i = count - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        const tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+    }
+    return arr;
+}
+export function createDissolve() {
+    return shuffledIndices(PIXELS);
+}
+export function applyDissolve(from, to, order, t) {
+    const revealed = Math.round(Math.max(0, Math.min(1, t)) * order.length);
+    const out = new Uint8Array(from.length);
+    const revealedSet = new Uint8Array(order.length);
+    for (let i = 0; i < revealed; i++) {
+        revealedSet[order[i]] = 1;
+    }
+    for (let px = 0; px < order.length; px++) {
+        const off = px * 4;
+        const src = revealedSet[px] ? to : from;
+        out[off] = src[off];
+        out[off + 1] = src[off + 1];
+        out[off + 2] = src[off + 2];
+        out[off + 3] = src[off + 3];
+    }
+    return out;
+}
+export { STATE_MANIFEST, CREATURE_MANIFEST };

package/dist/lib/config.d.ts

@@ -0,0 +1,39 @@
+export interface AuthConfig {
+    email: string;
+    token: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+export interface GlobalConfig {
+    auth?: AuthConfig;
+    defaults?: {
+        projectId?: string;
+    };
+}
+export interface AgentEntry {
+    key: string;
+    name: string;
+    project: string;
+}
+export interface AgentsStore {
+    agents: Record<string, AgentEntry>;
+}
+export interface ProjectConfig {
+    projectId: string;
+    agentId?: string;
+    integration?: string;
+}
+export declare function globalDir(): string;
+export declare function globalConfigPath(): string;
+export declare function agentsPath(): string;
+export declare function projectConfigPath(cwd?: string): string;
+export declare function projectDirPath(cwd?: string): string;
+export declare function readGlobalConfig(): Promise<GlobalConfig>;
+export declare function writeGlobalConfig(config: GlobalConfig): Promise<void>;
+export declare function readAgents(): Promise<AgentsStore>;
+export declare function writeAgents(store: AgentsStore): Promise<void>;
+export declare function readProjectConfig(cwd?: string): Promise<ProjectConfig | null>;
+export declare function writeProjectConfig(config: ProjectConfig, cwd?: string): Promise<void>;
+export declare function resolveAgentKey(agentId: string, agents: AgentsStore): string | null;
+export declare function hasAuth(config: GlobalConfig): boolean;
+export declare function isTokenExpired(config: GlobalConfig): boolean;

package/dist/lib/config.js

@@ -0,0 +1,89 @@
+import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+const GLOBAL_DIR = join(homedir(), '.cubelife');
+const GLOBAL_CONFIG = join(GLOBAL_DIR, 'config.json');
+const AGENTS_FILE = join(GLOBAL_DIR, 'agents.json');
+const PROJECT_DIR = '.cubelife';
+const PROJECT_CONFIG = join(PROJECT_DIR, 'config.json');
+export function globalDir() {
+    return GLOBAL_DIR;
+}
+export function globalConfigPath() {
+    return GLOBAL_CONFIG;
+}
+export function agentsPath() {
+    return AGENTS_FILE;
+}
+export function projectConfigPath(cwd) {
+    const base = cwd ?? process.cwd();
+    return resolve(base, PROJECT_CONFIG);
+}
+export function projectDirPath(cwd) {
+    const base = cwd ?? process.cwd();
+    return resolve(base, PROJECT_DIR);
+}
+async function ensureGlobalDir() {
+    if (!existsSync(GLOBAL_DIR)) {
+        await mkdir(GLOBAL_DIR, { recursive: true });
+        await chmod(GLOBAL_DIR, 0o700);
+    }
+}
+async function readJson(path) {
+    let raw;
+    try {
+        raw = await readFile(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        console.warn(`Warning: corrupted JSON in ${path}`);
+        return null;
+    }
+}
+async function writeJson(path, data, secure = false) {
+    await writeFile(path, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    if (secure) {
+        await chmod(path, 0o600);
+    }
+}
+export async function readGlobalConfig() {
+    return (await readJson(GLOBAL_CONFIG)) ?? {};
+}
+export async function writeGlobalConfig(config) {
+    await ensureGlobalDir();
+    await writeJson(GLOBAL_CONFIG, config, true);
+}
+export async function readAgents() {
+    return (await readJson(AGENTS_FILE)) ?? { agents: {} };
+}
+export async function writeAgents(store) {
+    await ensureGlobalDir();
+    await writeJson(AGENTS_FILE, store, true);
+}
+export async function readProjectConfig(cwd) {
+    return readJson(projectConfigPath(cwd));
+}
+export async function writeProjectConfig(config, cwd) {
+    const dir = projectDirPath(cwd);
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeJson(projectConfigPath(cwd), config);
+}
+export function resolveAgentKey(agentId, agents) {
+    return agents.agents[agentId]?.key ?? null;
+}
+export function hasAuth(config) {
+    return !!(config.auth?.token && config.auth?.refreshToken);
+}
+export function isTokenExpired(config) {
+    if (!config.auth?.expiresAt)
+        return true;
+    return Date.now() >= config.auth.expiresAt;
+}

package/dist/lib/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const API_BASE_URL = "https://cubelife-2dd2e.web.app";
+export declare const ID_DISPLAY_LENGTH = 8;
+export declare const LABEL_WIDTH = 14;
+export declare const DEFAULT_PANEL_WIDTH = 50;
+export declare const API_TIMEOUT_MS = 5000;
+export declare const CREATURE_TYPES: readonly ["gremlin", "cat", "owl", "axolotl", "robot", "fox", "dragon", "blob"];
+export declare const CREATURE_DEFAULT_COLORS: Record<typeof CREATURE_TYPES[number], string>;
+export declare const CREATURE_DESCRIPTIONS: Record<typeof CREATURE_TYPES[number], string>;
+export declare const CREATURE_NAME_MAX = 24;
+export declare function isValidHexColor(value: string): boolean;
+export declare const VALID_STATES: readonly ["coding", "reading", "researching", "designing", "testing", "reviewing", "thinking", "writing", "error", "complete", "waiting", "awaiting_input"];
+export declare const VALID_SENTIMENTS: readonly ["positive", "negative", "neutral"];

package/dist/lib/constants.js

@@ -0,0 +1,39 @@
+export const API_BASE_URL = 'https://cubelife-2dd2e.web.app';
+export const ID_DISPLAY_LENGTH = 8;
+export const LABEL_WIDTH = 14;
+export const DEFAULT_PANEL_WIDTH = 50;
+export const API_TIMEOUT_MS = 5000;
+export const CREATURE_TYPES = [
+    'gremlin', 'cat', 'owl', 'axolotl', 'robot', 'fox', 'dragon', 'blob',
+];
+export const CREATURE_DEFAULT_COLORS = {
+    gremlin: '#7B9F35',
+    cat: '#D4874E',
+    owl: '#8B7355',
+    axolotl: '#E8A0BF',
+    robot: '#7EAAC1',
+    fox: '#C75B39',
+    dragon: '#5B8C5A',
+    blob: '#9B7ED8',
+};
+export const CREATURE_DESCRIPTIONS = {
+    gremlin: 'Mischievous tinkerer. Loves breaking things to understand them.',
+    cat: 'Independent and curious. Watches everything with quiet judgement.',
+    owl: 'Wise observer. Thinks before acting, acts with precision.',
+    axolotl: 'Cheerful and resilient. Always regenerating, always smiling.',
+    robot: 'Logical and efficient. Runs on structure and clear objectives.',
+    fox: 'Clever and adaptable. Finds the shortcut others miss.',
+    dragon: 'Bold and protective. Guards the codebase with fire.',
+    blob: 'Easygoing shapeshifter. Goes with the flow, absorbs everything.',
+};
+export const CREATURE_NAME_MAX = 24;
+const HEX_COLOR_RE = /^#[0-9A-Fa-f]{6}$/;
+export function isValidHexColor(value) {
+    return HEX_COLOR_RE.test(value);
+}
+export const VALID_STATES = [
+    'coding', 'reading', 'researching', 'designing', 'testing',
+    'reviewing', 'thinking', 'writing', 'error', 'complete', 'waiting',
+    'awaiting_input',
+];
+export const VALID_SENTIMENTS = ['positive', 'negative', 'neutral'];

package/dist/lib/detect.d.ts

@@ -0,0 +1,17 @@
+export interface DetectedTool {
+    name: string;
+    id: string;
+    configPath: string;
+    installed: boolean;
+}
+export interface ToolDef {
+    name: string;
+    id: string;
+    paths: (home: string, cwd: string) => string[];
+}
+export declare const CLINE_EXTENSION_IDS: string[];
+export declare function vscodeUserPath(): string;
+export declare function vscodeGlobalStoragePath(): string;
+export declare function detectTools(): DetectedTool[];
+export declare function detectInstalledTools(): DetectedTool[];
+export declare function getToolDef(id: string): ToolDef | undefined;

package/dist/lib/detect.js

@@ -0,0 +1,99 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const CLINE_EXTENSION_IDS = [
+    'saoudrizwan.claude-dev',
+    'kodu-ai.claude-dev-experimental',
+];
+export function vscodeUserPath() {
+    const h = homedir();
+    switch (process.platform) {
+        case 'darwin':
+            return join(h, 'Library', 'Application Support', 'Code', 'User');
+        case 'win32':
+            return join(process.env['APPDATA'] ?? join(h, 'AppData', 'Roaming'), 'Code', 'User');
+        default:
+            return join(h, '.config', 'Code', 'User');
+    }
+}
+export function vscodeGlobalStoragePath() {
+    return join(vscodeUserPath(), 'globalStorage');
+}
+function clinePaths() {
+    const gs = vscodeGlobalStoragePath();
+    return CLINE_EXTENSION_IDS.map((id) => join(gs, id, 'settings', 'cline_mcp_settings.json'));
+}
+const TOOL_DEFS = [
+    {
+        name: 'Claude Code',
+        id: 'claude-code',
+        paths: (h, c) => [
+            join(h, '.claude', 'settings.json'),
+            join(c, '.claude', 'settings.json'),
+        ],
+    },
+    {
+        name: 'Cursor',
+        id: 'cursor',
+        paths: (h, c) => [
+            join(c, '.cursor', 'mcp.json'),
+            join(h, '.cursor', 'mcp.json'),
+        ],
+    },
+    {
+        name: 'Windsurf',
+        id: 'windsurf',
+        paths: (h) => [
+            join(h, '.codeium', 'windsurf', 'mcp_config.json'),
+        ],
+    },
+    {
+        name: 'Cline',
+        id: 'cline',
+        paths: () => clinePaths(),
+    },
+    {
+        name: 'Continue.dev',
+        id: 'continue',
+        paths: (h, c) => [
+            join(c, '.continue', 'config.yaml'),
+            join(h, '.continue', 'config.yaml'),
+        ],
+    },
+    {
+        name: 'GitHub Copilot',
+        id: 'copilot',
+        paths: (_h, c) => [
+            join(c, '.vscode', 'mcp.json'),
+            join(vscodeUserPath(), 'mcp.json'),
+        ],
+    },
+    {
+        name: 'Codex CLI',
+        id: 'codex',
+        paths: (h, c) => [
+            join(c, '.codex'),
+            join(h, '.codex'),
+        ],
+    },
+];
+export function detectTools() {
+    const h = homedir();
+    const c = process.cwd();
+    return TOOL_DEFS.map((def) => {
+        const paths = def.paths(h, c);
+        const found = paths.find((p) => existsSync(p));
+        return {
+            name: def.name,
+            id: def.id,
+            configPath: found ?? paths[0],
+            installed: !!found,
+        };
+    });
+}
+export function detectInstalledTools() {
+    return detectTools().filter((t) => t.installed);
+}
+export function getToolDef(id) {
+    return TOOL_DEFS.find((d) => d.id === id);
+}

package/dist/lib/doctor.d.ts

@@ -0,0 +1,18 @@
+import { AdminClient } from './api.js';
+export type CheckStatus = 'pass' | 'fail' | 'warn';
+export interface CheckResult {
+    name: string;
+    status: CheckStatus;
+    message: string;
+    fix?: string;
+}
+export declare function checkAuth(autoFix: boolean): Promise<CheckResult>;
+export declare function checkTier(adminClient?: AdminClient): Promise<CheckResult>;
+export declare function checkProject(adminClient?: AdminClient): Promise<CheckResult>;
+export declare function checkAgent(adminClient?: AdminClient): Promise<CheckResult>;
+export declare function checkApiKey(): Promise<CheckResult>;
+export declare function checkIntegration(): Promise<CheckResult>;
+export declare function checkHookScript(): Promise<CheckResult>;
+export declare function checkConnectivity(): Promise<CheckResult>;
+export declare function checkStateReport(): Promise<CheckResult>;
+export declare function runAllChecks(autoFix: boolean): Promise<CheckResult[]>;