cubelife 0.2.0

package/dist/commands/creature.js

@@ -0,0 +1,166 @@
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+import { createAdminClient } from '../lib/api.js';
+import { CREATURE_TYPES, CREATURE_DEFAULT_COLORS, CREATURE_DESCRIPTIONS, CREATURE_NAME_MAX, isValidHexColor, } from '../lib/constants.js';
+import { brand } from '../ui/theme.js';
+import { table } from '../ui/table.js';
+import { rootOpts, requireLinkedAgent, handleCommandError, } from '../lib/command-helpers.js';
+import { setCreatureType, setCreatureColour, setCreatureName, AgentNotCreatureError, } from '../lib/services/creature-service.js';
+function colourSwatch(hex) {
+    return chalk.hex(hex)('██') + ' ' + brand.muted(hex);
+}
+export function registerCreatureCommands(program) {
+    const creature = program
+        .command('creature')
+        .description('Manage creature companions');
+    creature
+        .command('types')
+        .description('List available creature types')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        if (json) {
+            const types = CREATURE_TYPES.map((t) => ({
+                type: t,
+                description: CREATURE_DESCRIPTIONS[t],
+                defaultColor: CREATURE_DEFAULT_COLORS[t],
+            }));
+            console.log(JSON.stringify({ types }));
+            return;
+        }
+        const rows = CREATURE_TYPES.map((t) => ({
+            type: t,
+            colour: colourSwatch(CREATURE_DEFAULT_COLORS[t]),
+            description: CREATURE_DESCRIPTIONS[t],
+        }));
+        console.log(table([
+            { label: 'Type', key: 'type', width: 10 },
+            { label: 'Colour', key: 'colour', width: 16 },
+            { label: 'Description', key: 'description' },
+        ], rows));
+    });
+    creature
+        .command('set <type>')
+        .description('Set the creature type for the linked agent')
+        .action(async function (type) {
+        const { json } = rootOpts(this);
+        if (!CREATURE_TYPES.includes(type)) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'invalid_type', validTypes: CREATURE_TYPES }));
+            }
+            else {
+                p.log.error(`Invalid creature type: ${type}`);
+                p.log.message(brand.muted(`Valid types: ${CREATURE_TYPES.join(', ')}`));
+            }
+            process.exit(1);
+        }
+        const linked = await requireLinkedAgent(json);
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Updating agent');
+        try {
+            const client = await createAdminClient();
+            const result = await setCreatureType(client, linked.projectId, linked.agentId, type);
+            if (json) {
+                console.log(JSON.stringify({ ok: true, type: result.type, color: result.color }));
+            }
+            else {
+                spin.stop('Agent updated');
+                p.log.success(`Set to ${brand.primary(result.type)} ${colourSwatch(result.color)}`);
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json, spinner: spin });
+        }
+    });
+    creature
+        .command('colour <hex>')
+        .alias('color')
+        .description('Set the creature colour')
+        .action(async function (hex) {
+        const { json } = rootOpts(this);
+        const normalised = hex.startsWith('#') ? hex : `#${hex}`;
+        if (!isValidHexColor(normalised)) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'invalid_hex', expected: '#RRGGBB' }));
+            }
+            else {
+                p.log.error(`Invalid hex colour: ${hex}`);
+                p.log.message(brand.muted('Expected format: #RRGGBB (e.g. #7B9F35)'));
+            }
+            process.exit(1);
+        }
+        const linked = await requireLinkedAgent(json);
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Updating creature');
+        try {
+            const client = await createAdminClient();
+            const result = await setCreatureColour(client, linked.projectId, linked.agentId, normalised);
+            if (json) {
+                console.log(JSON.stringify({ ok: true, color: result.color }));
+            }
+            else {
+                spin.stop('Colour updated');
+                p.log.success(`Colour set to ${colourSwatch(result.color)}`);
+            }
+        }
+        catch (err) {
+            if (err instanceof AgentNotCreatureError) {
+                if (!json)
+                    spin.stop('Failed');
+                if (json) {
+                    console.log(JSON.stringify({ error: 'agent_not_creature' }));
+                }
+                else {
+                    p.log.error(`Agent is in human form. Switch to creature first with ${brand.accent('cubelife creature set <type>')}.`);
+                }
+                process.exit(1);
+            }
+            handleCommandError({ error: err, json, spinner: spin });
+        }
+    });
+    creature
+        .command('name <name>')
+        .description('Name the creature')
+        .action(async function (name) {
+        const { json } = rootOpts(this);
+        if (name.length > CREATURE_NAME_MAX) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'name_too_long', max: CREATURE_NAME_MAX }));
+            }
+            else {
+                p.log.error(`Name must be ${CREATURE_NAME_MAX} characters or fewer (got ${name.length}).`);
+            }
+            process.exit(1);
+        }
+        const linked = await requireLinkedAgent(json);
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Updating creature');
+        try {
+            const client = await createAdminClient();
+            const result = await setCreatureName(client, linked.projectId, linked.agentId, name);
+            if (json) {
+                console.log(JSON.stringify({ ok: true, name: result.name }));
+            }
+            else {
+                spin.stop('Name updated');
+                p.log.success(`Creature named ${brand.primary(result.name)}`);
+            }
+        }
+        catch (err) {
+            if (err instanceof AgentNotCreatureError) {
+                if (!json)
+                    spin.stop('Failed');
+                if (json) {
+                    console.log(JSON.stringify({ error: 'agent_not_creature' }));
+                }
+                else {
+                    p.log.error(`Agent is in human form. Switch to creature first with ${brand.accent('cubelife creature set <type>')}.`);
+                }
+                process.exit(1);
+            }
+            handleCommandError({ error: err, json, spinner: spin });
+        }
+    });
+}

package/dist/commands/default.d.ts

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

package/dist/commands/default.js

@@ -0,0 +1,87 @@
+import * as p from '@clack/prompts';
+import { logo, version as versionTag } from '../ui/index.js';
+import { brand } from '../ui/theme.js';
+import { isCancel } from '../ui/helpers.js';
+import { CLI_VERSION } from '../version.js';
+import { detectProgress, runTutorial } from '../lib/tutorial.js';
+import { runAllChecks } from '../lib/doctor.js';
+import { detectInstalledTools } from '../lib/detect.js';
+function formatCheck(r) {
+    const icon = r.status === 'pass' ? '✓' : r.status === 'warn' ? '!' : '✗';
+    let line = `  ${icon} ${r.name}: ${r.message}`;
+    if (r.fix)
+        line += `\n         ${r.fix}`;
+    return line;
+}
+export async function defaultAction(program) {
+    const progress = await detectProgress();
+    if (progress < 6) {
+        await runTutorial();
+        return;
+    }
+    console.log(`\n${logo()}\n${versionTag(CLI_VERSION)}\n`);
+    const action = await p.select({
+        message: 'What would you like to do?',
+        options: [
+            { value: 'view', label: 'View your agent', hint: 'cubelife view' },
+            { value: 'billing', label: 'Billing overview', hint: 'cubelife billing' },
+            { value: 'doctor', label: 'Run diagnostics', hint: 'cubelife doctor' },
+            { value: 'setup', label: 'Configure a tool', hint: 'cubelife setup <tool>' },
+            { value: 'tutorial', label: 'Re-run setup wizard', hint: 'cubelife tutorial' },
+            { value: 'help', label: 'View all commands', hint: 'cubelife --help' },
+        ],
+    });
+    if (isCancel(action)) {
+        process.exit(0);
+    }
+    switch (action) {
+        case 'view':
+            await program.parseAsync(['view'], { from: 'user' });
+            break;
+        case 'billing':
+            await program.parseAsync(['billing'], { from: 'user' });
+            break;
+        case 'doctor': {
+            const spin = p.spinner();
+            spin.start('Running diagnostics');
+            const results = await runAllChecks(false);
+            spin.stop('Diagnostics complete');
+            console.log();
+            for (const r of results) {
+                console.log(formatCheck(r));
+            }
+            console.log();
+            const fails = results.filter((r) => r.status === 'fail');
+            if (fails.length > 0) {
+                p.log.error(`${fails.length} check${fails.length === 1 ? '' : 's'} failed`);
+            }
+            else {
+                p.log.success('All checks passed');
+            }
+            break;
+        }
+        case 'setup': {
+            const tools = detectInstalledTools();
+            if (tools.length === 0) {
+                p.log.info('No AI tools detected on this system.');
+                p.log.message(`Run ${brand.accent('cubelife setup manual')} for generic integration instructions.`);
+                break;
+            }
+            const toolId = await p.select({
+                message: 'Which tool?',
+                options: tools.map((t) => ({ value: t.id, label: t.name })),
+            });
+            if (isCancel(toolId)) {
+                process.exit(0);
+            }
+            await program.parseAsync(['setup', toolId], { from: 'user' });
+            break;
+        }
+        case 'tutorial':
+            await runTutorial();
+            break;
+        case 'help':
+            program.outputHelp();
+            break;
+    }
+}

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -0,0 +1,48 @@
+import * as p from '@clack/prompts';
+import { runAllChecks } from '../lib/doctor.js';
+import { getRootOpts } from '../ui/helpers.js';
+import { status as statusIcons, dim } from '../ui/theme.js';
+function formatResult(r) {
+    const icon = statusIcons[r.status] ?? `[${r.status}]`;
+    let line = `  ${icon} ${r.name}: ${r.message}`;
+    if (r.fix)
+        line += `\n         ${dim(r.fix)}`;
+    return line;
+}
+export function registerDoctorCommand(program) {
+    program
+        .command('doctor')
+        .description('Run diagnostic checks')
+        .option('--fix', 'Auto-fix common issues')
+        .action(async function () {
+        const opts = this.opts();
+        const rootOpts = getRootOpts(this);
+        const autoFix = !!opts['fix'];
+        const json = !!rootOpts['json'];
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Running diagnostics');
+        const results = await runAllChecks(autoFix);
+        if (json) {
+            console.log(JSON.stringify({ checks: results }, null, 2));
+            return;
+        }
+        spin.stop('Diagnostics complete');
+        console.log();
+        for (const r of results) {
+            console.log(formatResult(r));
+        }
+        console.log();
+        const fails = results.filter((r) => r.status === 'fail');
+        const warns = results.filter((r) => r.status === 'warn');
+        if (fails.length > 0) {
+            p.log.error(`${fails.length} check${fails.length === 1 ? '' : 's'} failed`);
+        }
+        else if (warns.length > 0) {
+            p.log.warn(`All checks passed with ${warns.length} warning${warns.length === 1 ? '' : 's'}`);
+        }
+        else {
+            p.log.success('All checks passed');
+        }
+    });
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,200 @@
+import * as p from '@clack/prompts';
+import { requireAuth } from '../lib/auth.js';
+import { createAdminClient, } from '../lib/api.js';
+import { readProjectConfig, readAgents } from '../lib/config.js';
+import { detectInstalledTools } from '../lib/detect.js';
+import { CREATURE_TYPES, ID_DISPLAY_LENGTH } from '../lib/constants.js';
+import { brand } from '../ui/theme.js';
+import { panel } from '../ui/panel.js';
+import { isCancel } from '../ui/helpers.js';
+import * as agentService from '../lib/services/agent-service.js';
+async function selectOrCreateProject(client, projects) {
+    const CREATE_VALUE = '__create__';
+    const options = [
+        ...projects.map((proj) => ({
+            value: proj.id,
+            label: proj.name,
+            hint: proj.id.slice(0, ID_DISPLAY_LENGTH),
+        })),
+        { value: CREATE_VALUE, label: '+ Create new project' },
+    ];
+    const selected = await p.select({ message: 'Select a project', options });
+    if (isCancel(selected)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    if (selected === CREATE_VALUE) {
+        const name = await p.text({
+            message: 'Project name',
+            validate: (v) => { if (!v.trim())
+                return 'Name cannot be empty.'; },
+        });
+        if (isCancel(name)) {
+            p.cancel('Cancelled.');
+            process.exit(0);
+        }
+        const spin = p.spinner();
+        spin.start('Creating project');
+        const result = await client.createProject(name);
+        spin.stop('Project created');
+        return { id: result.id, name: result.name };
+    }
+    const project = projects.find((proj) => proj.id === selected);
+    return { id: project.id, name: project.name };
+}
+async function selectOrCreateAgent(client, projectId, agents) {
+    const CREATE_VALUE = '__create__';
+    const options = [
+        ...agents.map((a) => ({
+            value: a.id,
+            label: a.name,
+            hint: `${a.form}${a.creature ? `:${a.creature.type}` : ''}`,
+        })),
+        { value: CREATE_VALUE, label: '+ Create new agent' },
+    ];
+    const selected = await p.select({ message: 'Select an agent', options });
+    if (isCancel(selected)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    if (selected === CREATE_VALUE) {
+        const name = await p.text({
+            message: 'Agent name',
+            validate: (v) => { if (!v.trim())
+                return 'Name cannot be empty.'; },
+        });
+        if (isCancel(name)) {
+            p.cancel('Cancelled.');
+            process.exit(0);
+        }
+        const form = await p.select({
+            message: 'Character form',
+            options: [
+                { value: 'human', label: 'Human character' },
+                { value: 'creature', label: 'Creature companion' },
+            ],
+        });
+        if (isCancel(form)) {
+            p.cancel('Cancelled.');
+            process.exit(0);
+        }
+        let creatureType;
+        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();
+        spin.start('Creating agent');
+        const result = await agentService.createAgent(client, projectId, {
+            name: name,
+            form: form,
+            ...(creatureType ? { creature: { type: creatureType } } : {}),
+        });
+        spin.stop('Agent created');
+        return { id: result.id, name: result.name, isNew: true };
+    }
+    const agent = agents.find((a) => a.id === selected);
+    return { id: agent.id, name: agent.name, isNew: false };
+}
+export function registerInitCommand(program) {
+    program
+        .command('init')
+        .description('Link a project and agent to the current directory')
+        .option('--project <id>', 'Project ID (non-interactive)')
+        .option('--agent <id>', 'Agent ID (non-interactive)')
+        .option('--regenerate-key', 'Regenerate key when linking an existing agent non-interactively')
+        .action(async function (opts) {
+        const nonInteractive = !!(opts.project && opts.agent);
+        try {
+            await requireAuth();
+        }
+        catch {
+            p.log.error(`Not logged in. Run ${brand.accent('cubelife login')} first.`);
+            process.exit(1);
+        }
+        if (nonInteractive) {
+            await runNonInteractive(opts.project, opts.agent, opts.regenerateKey);
+            return;
+        }
+        p.intro(brand.primary('Initialise CubeLife'));
+        const existing = await readProjectConfig();
+        if (existing?.projectId && existing?.agentId) {
+            console.log(panel([
+                `${brand.label('Project'.padEnd(10))}${existing.projectId.slice(0, ID_DISPLAY_LENGTH)}`,
+                `${brand.label('Agent'.padEnd(10))}${existing.agentId.slice(0, ID_DISPLAY_LENGTH)}`,
+            ], { title: 'Current Config', width: 40 }));
+            const reconfigure = await p.confirm({ message: 'Reconfigure?' });
+            if (isCancel(reconfigure) || !reconfigure) {
+                p.outro('Keeping current configuration.');
+                return;
+            }
+        }
+        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`);
+        const project = await selectOrCreateProject(client, projects);
+        spin.start('Fetching agents');
+        const { agents } = await client.listAgents(project.id);
+        spin.stop(`${agents.length} agent${agents.length === 1 ? '' : 's'} found`);
+        const agent = await selectOrCreateAgent(client, project.id, agents);
+        if (!agent.isNew) {
+            const store = await readAgents();
+            if (!store.agents[agent.id]) {
+                const regen = await p.confirm({
+                    message: 'API key not stored locally. Regenerate key? (existing integrations using the old key will stop working)',
+                });
+                if (!isCancel(regen) && regen) {
+                    const regenSpin = p.spinner();
+                    regenSpin.start('Regenerating key');
+                    await agentService.regenerateKey(client, project.id, agent.id);
+                    regenSpin.stop('Key regenerated');
+                }
+                else {
+                    p.log.warn(`Status reporting won't work without a stored key. Regenerate later with ${brand.accent(`cubelife agents key ${agent.id.slice(0, ID_DISPLAY_LENGTH)} --regenerate`)}.`);
+                }
+            }
+        }
+        await agentService.linkAgent(project.id, agent.id);
+        const tools = detectInstalledTools();
+        if (tools.length > 0) {
+            p.log.info(`Detected: ${tools.map((t) => brand.primary(t.name)).join(', ')}. Run ${brand.accent('cubelife setup')} to configure integrations.`);
+        }
+        p.outro(`Linked to ${brand.primary(agent.name)} in ${brand.primary(project.name)}. Run ${brand.accent('cubelife status coding "test"')} to try it.`);
+    });
+}
+async function runNonInteractive(projectId, agentId, regenerateKey) {
+    const client = await createAdminClient();
+    const spin = p.spinner();
+    spin.start('Validating');
+    let agentName = agentId;
+    try {
+        const agent = await agentService.getAgent(client, projectId, agentId);
+        agentName = agent.name;
+    }
+    catch {
+        spin.stop('Failed');
+        p.log.error(`Agent ${agentId.slice(0, ID_DISPLAY_LENGTH)} not found in project ${projectId.slice(0, ID_DISPLAY_LENGTH)}.`);
+        process.exit(1);
+    }
+    const store = await readAgents();
+    if (!store.agents[agentId]) {
+        if (!regenerateKey) {
+            spin.stop('Failed');
+            p.log.error(`No API key stored for this agent. Use ${brand.accent('--regenerate-key')} to create one.`);
+            process.exit(1);
+        }
+        await agentService.regenerateKey(client, projectId, agentId);
+    }
+    await agentService.linkAgent(projectId, agentId);
+    spin.stop('Linked');
+    p.log.success(`Linked to agent ${agentId.slice(0, ID_DISPLAY_LENGTH)} in project ${projectId.slice(0, ID_DISPLAY_LENGTH)}.`);
+}

package/dist/commands/mcp.d.ts

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

package/dist/commands/mcp.js

@@ -0,0 +1,9 @@
+import { startMcpServer } from '../mcp/server.js';
+export function registerMcpCommand(program) {
+    program
+        .command('mcp')
+        .description('Start the MCP server (stdio transport)')
+        .action(async () => {
+        await startMcpServer();
+    });
+}

package/dist/commands/projects.d.ts

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

package/dist/commands/projects.js

@@ -0,0 +1,122 @@
+import * as p from '@clack/prompts';
+import { createAdminClient, ApiError } from '../lib/api.js';
+import { ID_DISPLAY_LENGTH } from '../lib/constants.js';
+import { brand, dot } from '../ui/theme.js';
+import { table } from '../ui/table.js';
+import { isCancel } from '../ui/helpers.js';
+import { rootOpts, handleCommandError, } from '../lib/command-helpers.js';
+import * as projectService from '../lib/services/project-service.js';
+export function registerProjectCommands(program) {
+    const projects = program
+        .command('projects')
+        .description('Manage CubeLife projects');
+    projects
+        .command('list')
+        .description('List your projects')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Fetching projects');
+        try {
+            const client = await createAdminClient();
+            const { projects: items, linkedProjectId } = await projectService.listProjects(client);
+            if (json) {
+                console.log(JSON.stringify({ projects: items }));
+                return;
+            }
+            spin.stop('Projects loaded');
+            if (items.length === 0) {
+                p.log.info(`No projects yet. Create one with ${brand.accent('cubelife projects create <name>')}`);
+                return;
+            }
+            const rows = items.map((proj) => ({
+                linked: proj.id === linkedProjectId ? dot.working : ' ',
+                id: proj.id.slice(0, ID_DISPLAY_LENGTH),
+                name: proj.name,
+                product: proj.product,
+                created: new Date(proj.createdAt).toLocaleDateString(),
+            }));
+            console.log(table([
+                { label: '', key: 'linked', width: 2 },
+                { label: 'ID', key: 'id', width: 10 },
+                { label: 'Name', key: 'name' },
+                { label: 'Product', key: 'product', width: 8 },
+                { label: 'Created', key: 'created', width: 12 },
+            ], rows));
+        }
+        catch (err) {
+            handleCommandError({ error: err, json, spinner: spin });
+        }
+    });
+    projects
+        .command('create <name>')
+        .description('Create a new project')
+        .action(async function (name) {
+        const { json, yes } = rootOpts(this);
+        const spin = p.spinner();
+        if (!json)
+            spin.start('Creating project');
+        try {
+            const client = await createAdminClient();
+            const result = await projectService.createProject(client, name);
+            if (json) {
+                console.log(JSON.stringify(result));
+                return;
+            }
+            spin.stop('Project created');
+            p.log.success(`${brand.primary(result.name)} ${brand.muted(`(${result.id})`)}`);
+            if (!yes) {
+                const setDefault = await p.confirm({
+                    message: 'Set as default project?',
+                });
+                if (!isCancel(setDefault) && setDefault) {
+                    await projectService.setDefaultProject(result.id);
+                    p.log.info('Default project updated.');
+                }
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json, spinner: spin });
+        }
+    });
+    projects
+        .command('delete <id>')
+        .description('Delete a project')
+        .action(async function (id) {
+        const { json, yes } = rootOpts(this);
+        try {
+            if (!yes && !json) {
+                const confirmed = await p.confirm({
+                    message: `Delete project ${brand.primary(id.slice(0, ID_DISPLAY_LENGTH))}? This will delete all agents in this project.`,
+                });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+            }
+            const client = await createAdminClient();
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Deleting project');
+            await projectService.deleteProject(client, id);
+            if (json) {
+                console.log(JSON.stringify({ deleted: true, id }));
+                return;
+            }
+            spin.stop('Project deleted');
+            p.log.success('Project deleted.');
+        }
+        catch (err) {
+            if (err instanceof ApiError && err.status === 403) {
+                const friendly = 'Project 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 });
+        }
+    });
+}

package/dist/commands/setup.d.ts

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