cubelife 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivy Innovation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# cubelife
+
+CLI for CubeLife. Give your AI agent a living pixel-art companion.
+
+## Install
+
+```bash
+npm install -g cubelife
+```
+
+Or run directly:
+
+```bash
+npx cubelife
+```
+
+## Quick start
+
+```bash
+cubelife register          # Create an account
+cubelife tutorial           # Guided setup (6 steps)
+cubelife status coding "Working on auth"  # Report agent state
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `register` | Create a new CubeLife account |
+| `login` | Log in to your account |
+| `logout` | Log out and clear credentials |
+| `whoami` | Show account, tier, and linked agent |
+| `projects` | Manage CubeLife projects |
+| `agents` | Manage agents within a project |
+| `creature` | Manage creature companions |
+| `init` | Link a project and agent to the current directory |
+| `setup <tool>` | Configure integration for an AI tool |
+| `tutorial` | Interactive setup walkthrough |
+| `doctor` | Run diagnostic checks |
+| `status [state] [detail]` | Report agent state |
+| `mcp` | Start the MCP server (stdio transport) |
+
+## MCP server
+
+The CLI includes an MCP server for AI tool integration:
+
+```bash
+cubelife mcp                          # Start server (stdio)
+cubelife setup claude-code            # Auto-configure Claude Code
+```
+
+The MCP server exposes four tools: `cubelife_report`, `cubelife_complete`, `cubelife_error`, and `cubelife_status`.
+
+## Global flags
+
+- `--json` Output as machine-readable JSON
+- `--yes` Skip confirmation prompts
+- `--agent <id>` Override the default linked agent
+
+## Node SDK
+
+For programmatic access, use the SDK:
+
+```bash
+npm install @cubelife/sdk
+```
+
+```typescript
+import { CubeLifeClient } from '@cubelife/sdk';
+
+const client = new CubeLifeClient({ apiKey: 'your-agent-key' });
+await client.report('coding', { detail: 'Building the auth flow' });
+```
+
+## Requirements
+
+- Node.js 18+
+
+## Licence
+
+MIT (source code). Pixel art sprite assets are proprietary (see SPRITE-LICENSE).

package/SPRITE-LICENSE

@@ -0,0 +1,14 @@
+Sprite Asset Licence
+
+Copyright (c) 2026 Ivy Innovation. All rights reserved.
+
+The pixel art sprite data contained in dist/data/sprite-data.js was generated
+using PixelLab (https://pixellab.ai) and is the property of Ivy Innovation.
+
+These sprite assets are provided as part of the CubeLife CLI for the sole
+purpose of rendering CubeLife agent characters in the terminal. They may not
+be extracted, modified, redistributed, or used independently of the CubeLife
+CLI without prior written permission from Ivy Innovation.
+
+This licence applies only to the sprite data. The CubeLife CLI source code
+is licensed separately under the MIT License (see LICENSE file).

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { logo, version as versionTag } from './ui/index.js';
+import { CLI_VERSION } from './version.js';
+import { registerAuthCommands } from './commands/auth.js';
+import { registerProjectCommands } from './commands/projects.js';
+import { registerAgentCommands } from './commands/agents.js';
+import { registerCreatureCommands } from './commands/creature.js';
+import { registerInitCommand } from './commands/init.js';
+import { registerSetupCommands } from './commands/setup.js';
+import { registerTutorialCommand } from './commands/tutorial.js';
+import { registerDoctorCommand } from './commands/doctor.js';
+import { registerStatusCommand } from './commands/status.js';
+import { registerMcpCommand } from './commands/mcp.js';
+import { registerBillingCommands } from './commands/billing.js';
+import { registerViewCommand } from './commands/view.js';
+import { defaultAction } from './commands/default.js';
+const program = new Command()
+    .name('cubelife')
+    .description('Give your AI agent a living pixel-art companion')
+    .version(CLI_VERSION, '-v, --version')
+    .option('--json', 'Output as machine-readable JSON')
+    .option('--yes', 'Skip confirmation prompts')
+    .option('--agent <id>', 'Override the default linked agent')
+    .addHelpText('beforeAll', `\n${logo()}\n${versionTag(CLI_VERSION)}\n`)
+    .action(() => defaultAction(program));
+registerAuthCommands(program);
+registerProjectCommands(program);
+registerAgentCommands(program);
+registerCreatureCommands(program);
+registerInitCommand(program);
+registerSetupCommands(program);
+registerTutorialCommand(program);
+registerDoctorCommand(program);
+registerStatusCommand(program);
+registerMcpCommand(program);
+registerBillingCommands(program);
+registerViewCommand(program);
+program.parse();

package/dist/commands/agents.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerAgentCommands(program: Command): void;

package/dist/commands/agents.js

@@ -0,0 +1,303 @@
+import * as p from '@clack/prompts';
+import { createAdminClient, ApiError } from '../lib/api.js';
+import { readAgents } from '../lib/config.js';
+import { brand, dot } from '../ui/theme.js';
+import { table } from '../ui/table.js';
+import { panel } from '../ui/panel.js';
+import { CREATURE_TYPES, ID_DISPLAY_LENGTH } from '../lib/constants.js';
+import { isCancel } from '../ui/helpers.js';
+import { rootOpts, requireProject, handleCommandError, } from '../lib/command-helpers.js';
+import * as agentService from '../lib/services/agent-service.js';
+function maskKey(key) {
+    if (key.length <= 12)
+        return key;
+    return `${key.slice(0, ID_DISPLAY_LENGTH)}${'*'.repeat(ID_DISPLAY_LENGTH)}${key.slice(-4)}`;
+}
+function formatForm(agent) {
+    if (agent.form === 'creature' && agent.creature?.type) {
+        return `creature:${agent.creature.type}`;
+    }
+    return agent.form;
+}
+export function registerAgentCommands(program) {
+    const agents = program
+        .command('agents')
+        .description('Manage agents within a project')
+        .option('--project <id>', 'Override the project to operate on');
+    agents
+        .command('list')
+        .description('List agents in the current project')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const { projectId } = await requireProject(this, json);
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Fetching agents');
+        try {
+            const client = await createAdminClient();
+            const { agents: items, linkedAgentId } = await agentService.listAgents(client, projectId);
+            if (json) {
+                console.log(JSON.stringify({ agents: items }));
+                return;
+            }
+            spin.stop('Agents loaded');
+            if (items.length === 0) {
+                p.log.info(`No agents yet. Create one with ${brand.accent('cubelife agents create <name>')}`);
+                return;
+            }
+            const rows = items.map((a) => ({
+                linked: a.id === linkedAgentId ? dot.working : ' ',
+                name: a.name,
+                id: a.id.slice(0, ID_DISPLAY_LENGTH),
+                form: formatForm(a),
+                visibility: a.isPublic ? 'public' : 'private',
+                created: new Date(a.createdAt).toLocaleDateString(),
+            }));
+            console.log(table([
+                { label: '', key: 'linked', width: 2 },
+                { label: 'Name', key: 'name' },
+                { label: 'ID', key: 'id', width: 10 },
+                { label: 'Form', key: 'form', width: 16 },
+                { label: 'Visibility', key: 'visibility', width: 10 },
+                { label: 'Created', key: 'created', width: 12 },
+            ], rows));
+        }
+        catch (err) {
+            handleCommandError({ error: err, json, spinner: spin });
+        }
+    });
+    agents
+        .command('create <name>')
+        .description('Create a new agent')
+        .action(async function (name) {
+        const { json, yes } = rootOpts(this);
+        const { projectId } = await requireProject(this, json);
+        let form = 'human';
+        let creatureType;
+        if (!json) {
+            p.intro(brand.primary('Create a new agent'));
+            const formResult = await p.select({
+                message: 'Character form',
+                options: [
+                    { value: 'human', label: 'Human character' },
+                    { value: 'creature', label: 'Creature companion' },
+                ],
+            });
+            if (isCancel(formResult)) {
+                p.cancel('Cancelled.');
+                process.exit(0);
+            }
+            form = formResult;
+            if (form === 'creature') {
+                const typeResult = await p.select({
+                    message: 'Creature type',
+                    options: CREATURE_TYPES.map((t) => ({ value: t, label: t })),
+                });
+                if (isCancel(typeResult)) {
+                    p.cancel('Cancelled.');
+                    process.exit(0);
+                }
+                creatureType = typeResult;
+            }
+        }
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Creating agent');
+        try {
+            const client = await createAdminClient();
+            const body = {
+                name,
+                form,
+                ...(creatureType ? { creature: { type: creatureType } } : {}),
+            };
+            const result = await agentService.createAgent(client, projectId, body);
+            if (json) {
+                console.log(JSON.stringify(result));
+                return;
+            }
+            spin.stop('Agent created');
+            console.log(panel([
+                `${brand.label('Name'.padEnd(10))}${brand.primary(result.name)}`,
+                `${brand.label('ID'.padEnd(10))}${result.id}`,
+                `${brand.label('API Key'.padEnd(10))}${maskKey(result.apiKey)}`,
+            ], { title: 'New Agent', width: 56 }));
+            if (!yes) {
+                const link = await p.confirm({
+                    message: 'Link this agent to the current directory?',
+                });
+                if (!isCancel(link) && link) {
+                    await agentService.linkAgent(projectId, result.id);
+                    p.log.info('Linked. Run ' + brand.accent(`cubelife status coding "test"`) + ' to try it.');
+                }
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json, spinner: spin });
+        }
+    });
+    agents
+        .command('edit <id>')
+        .description('Edit an agent')
+        .action(async function (agentId) {
+        const { projectId } = await requireProject(this);
+        const spin = p.spinner();
+        spin.start('Fetching agent');
+        try {
+            const client = await createAdminClient();
+            const agent = await agentService.getAgent(client, projectId, agentId);
+            spin.stop('Agent loaded');
+            console.log(panel([
+                `${brand.label('Name'.padEnd(12))}${agent.name}`,
+                `${brand.label('Form'.padEnd(12))}${agent.form}`,
+                `${brand.label('Visibility'.padEnd(12))}${agent.isPublic ? 'public' : 'private'}`,
+            ], { title: 'Current Settings', width: 50 }));
+            const fields = await p.multiselect({
+                message: 'Select fields to edit',
+                options: [
+                    { value: 'name', label: 'Name' },
+                    { value: 'isPublic', label: 'Visibility' },
+                ],
+                required: false,
+            });
+            if (isCancel(fields) || fields.length === 0) {
+                p.cancel('No changes.');
+                return;
+            }
+            const updates = {};
+            const selected = fields;
+            if (selected.includes('name')) {
+                const newName = await p.text({
+                    message: 'New name',
+                    initialValue: agent.name,
+                    validate: (v) => { if (!v.trim())
+                        return 'Name cannot be empty.'; },
+                });
+                if (isCancel(newName)) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+                updates.name = newName;
+            }
+            if (selected.includes('isPublic')) {
+                const pub = await p.confirm({
+                    message: 'Make agent public?',
+                    initialValue: agent.isPublic,
+                });
+                if (isCancel(pub)) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+                updates.isPublic = pub;
+            }
+            const updateSpin = p.spinner();
+            updateSpin.start('Updating agent');
+            await agentService.updateAgent(client, projectId, agentId, updates);
+            updateSpin.stop('Agent updated');
+            p.log.success('Changes saved.');
+        }
+        catch (err) {
+            handleCommandError({ error: err });
+        }
+    });
+    agents
+        .command('delete <id>')
+        .description('Delete an agent')
+        .action(async function (agentId) {
+        const { json, yes } = rootOpts(this);
+        const { projectId } = await requireProject(this, json);
+        try {
+            if (!yes && !json) {
+                const confirmed = await p.confirm({
+                    message: `Delete agent ${brand.primary(agentId.slice(0, ID_DISPLAY_LENGTH))}? This cannot be undone.`,
+                });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+            }
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Deleting agent');
+            const client = await createAdminClient();
+            const { wasLinked } = await agentService.deleteAgent(client, projectId, agentId);
+            if (json) {
+                console.log(JSON.stringify({ deleted: true, id: agentId }));
+            }
+            else {
+                spin.stop('Agent deleted');
+                if (wasLinked)
+                    p.log.info('Unlinked from current directory.');
+                p.log.success('Agent deleted.');
+            }
+        }
+        catch (err) {
+            if (err instanceof ApiError && err.status === 403) {
+                const friendly = 'Agent deletion requires admin access. Use the dashboard or contact support.';
+                if (json)
+                    console.log(JSON.stringify({ error: friendly }));
+                else
+                    p.log.error(friendly);
+                process.exit(1);
+            }
+            handleCommandError({ error: err, json });
+        }
+    });
+    agents
+        .command('key <id>')
+        .description('Reveal or regenerate an agent API key')
+        .option('--reveal', 'Show the full API key')
+        .option('--regenerate', 'Generate a new API key')
+        .action(async function (agentId, opts) {
+        const { json, yes } = rootOpts(this);
+        if (opts.regenerate) {
+            const { projectId } = await requireProject(this, json);
+            if (!yes && !json) {
+                const confirmed = await p.confirm({
+                    message: 'Regenerate API key? Existing integrations using the old key will stop working.',
+                });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+            }
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Regenerating key');
+            try {
+                const client = await createAdminClient();
+                const apiKey = await agentService.regenerateKey(client, projectId, agentId);
+                if (json) {
+                    console.log(JSON.stringify({ apiKey }));
+                }
+                else {
+                    spin.stop('Key regenerated');
+                    p.log.success(`New key: ${brand.primary(apiKey)}`);
+                }
+            }
+            catch (err) {
+                handleCommandError({ error: err, json, spinner: spin });
+            }
+            return;
+        }
+        const store = await readAgents();
+        const key = agentService.getStoredKey(agentId, store);
+        if (!key) {
+            const msg = `No key stored locally for ${agentId.slice(0, ID_DISPLAY_LENGTH)}. Use ${brand.accent('--regenerate')} to create a new one, or ${brand.accent('cubelife init')} to link this agent.`;
+            if (json)
+                console.log(JSON.stringify({ error: 'no_key_stored' }));
+            else
+                p.log.warn(msg);
+            return;
+        }
+        if (json) {
+            console.log(JSON.stringify({ apiKey: key }));
+        }
+        else {
+            const display = opts.reveal ? key : maskKey(key);
+            p.log.info(`API key: ${brand.primary(display)}`);
+            if (!opts.reveal) {
+                p.log.message(brand.muted(`Use ${brand.accent('--reveal')} to show the full key.`));
+            }
+        }
+    });
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerAuthCommands(program: Command): void;