cubelife 0.2.1 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # cubelife
 
-CLI for CubeLife. Give your AI agent a living pixel-art companion.
+Give your AI agent a living pixel-art companion. CLI + MCP server for Claude Code, Cursor, Windsurf, Copilot, Codex, and any MCP-compatible tool.
 
 ## Install
 
@@ -22,6 +22,52 @@ cubelife tutorial           # Guided setup (6 steps)
 cubelife status coding "Working on auth"  # Report agent state
 ```
 
+## MCP Server
+
+The CLI includes an MCP server that gives AI coding tools four capabilities: `cubelife_report`, `cubelife_complete`, `cubelife_error`, and `cubelife_status`.
+
+### Auto-configure for your tool
+
+```bash
+cubelife setup claude-code    # Claude Code
+cubelife setup cursor         # Cursor
+cubelife setup windsurf       # Windsurf
+cubelife setup copilot        # GitHub Copilot
+cubelife setup cline          # Cline
+cubelife setup codex          # Codex
+```
+
+### Manual configuration
+
+For Claude Code (`claude mcp add`):
+
+```bash
+claude mcp add cubelife -- npx cubelife mcp
+```
+
+For Cursor (`.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "cubelife": {
+      "command": "npx",
+      "args": ["cubelife", "mcp"],
+      "env": { "CUBELIFE_API_KEY": "your-key", "CUBELIFE_AGENT_ID": "your-agent-id" }
+    }
+  }
+}
+```
+
+For Windsurf, Cline, and VS Code the configuration is the same shape in their respective MCP config files.
+
+### Environment variables
+
+| Variable | Purpose |
+|----------|---------|
+| `CUBELIFE_API_KEY` | Agent API key (alternative to `cubelife init`) |
+| `CUBELIFE_AGENT_ID` | Agent ID (alternative to `cubelife init`) |
+
 ## Commands
 
 | Command | Description |
@@ -38,18 +84,9 @@ cubelife status coding "Working on auth"  # Report agent state
 | `tutorial` | Interactive setup walkthrough |
 | `doctor` | Run diagnostic checks |
 | `status [state] [detail]` | Report agent state |
+| `view` | Render your agent's creature in the terminal |
 | `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`.
+| `billing` | Manage subscription, sparks, gems, and vault |
 
 ## Global flags
 
@@ -72,6 +109,19 @@ const client = new CubeLifeClient({ apiKey: 'your-agent-key' });
 await client.report('coding', { detail: 'Building the auth flow' });
 ```
 
+## Python SDK
+
+```bash
+pip install cubelife
+```
+
+```python
+from cubelife import CubeLifeClient
+
+client = CubeLifeClient(api_key="your-agent-key")
+client.report("coding", detail="Building the auth flow")
+```
+
 ## Requirements
 
 - Node.js 18+

package/dist/commands/billing.js

@@ -53,16 +53,19 @@ export function registerBillingCommands(program) {
                     tier,
                     price: formatPrice(tier),
                     apiCalls: { today: todayUsage, limit: limits.calls },
-                    sparks: billingUser.sparks,
-                    dormancyState: billingUser.dormancyState,
+                    burstSparks: billingUser.burstSparks ?? 0,
+                    gems: billingUser.gems ?? 0,
+                    sleeping: billingUser.sleeping ?? false,
                 }));
                 return;
             }
+            const status = billingUser.sleeping ? brand.warning('sleeping') : 'active';
             const lines = [
                 `${label('Plan')}${limits.label} (${formatPrice(tier)})`,
                 `${label('API Calls')}${usageWarning(todayUsage, limits.calls)}`,
-                `${label('Sparks')}${billingUser.sparks.toLocaleString()}`,
-                `${label('Status')}${billingUser.dormancyState ?? 'active'}`,
+                `${label('Burst Sparks')}${(billingUser.burstSparks ?? 0).toLocaleString()}`,
+                `${label('Gems')}${(billingUser.gems ?? 0).toLocaleString()}`,
+                `${label('Status')}${status}`,
             ];
             console.log(panel(lines, { title: 'Billing Overview', width: 56 }));
             p.log.message(brand.muted(`Run ${brand.accent('cubelife billing usage')} for 7-day history`));
@@ -351,7 +354,371 @@ export function registerBillingCommands(program) {
             handleCommandError({ error: err, json });
         }
     });
+    // --- Spark Packs ---
+    const sparks = billing.command('sparks').description('Buy Spark packs');
+    sparks
+        .command('list', { isDefault: true })
+        .description('List available Spark packs')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        if (json) {
+            console.log(JSON.stringify({ packs: SPARK_PACKS }));
+            return;
+        }
+        console.log(table([
+            { label: 'Pack', key: 'label', width: 10 },
+            { label: 'Sparks', key: 'sparks', width: 10 },
+            { label: 'Price', key: 'price', width: 10 },
+        ], SPARK_PACKS.map((pk) => ({ label: pk.label, sparks: pk.sparks.toLocaleString(), price: formatCents(pk.priceZarCents) }))));
+    });
+    sparks
+        .command('buy <pack>')
+        .description('Buy a Spark pack (ember|flame|blaze|inferno)')
+        .action(async function (packId) {
+        const { json, yes } = rootOpts(this);
+        const pack = SPARK_PACKS.find((pk) => pk.id === packId);
+        if (!pack) {
+            if (json)
+                console.log(JSON.stringify({ error: 'invalid_pack', valid: SPARK_PACKS.map((pk) => pk.id) }));
+            else
+                p.log.error(`Invalid pack. Valid options: ${SPARK_PACKS.map((pk) => brand.accent(pk.id)).join(', ')}`);
+            process.exit(1);
+        }
+        try {
+            await doPurchase({
+                json, yes,
+                title: `Buy ${pack.label} Spark Pack`,
+                description: `${pack.sparks} Sparks for ${formatCents(pack.priceZarCents)}`,
+                initiate: (client, email) => client.initiateTopUp({ packId: pack.id, email, callbackUrl: `${LIFE_CALLBACK_URL}?cb=billing&type=spark_topup` }),
+                verify: (client, ref) => client.verifyTopUp(ref),
+                successMsg: `${pack.sparks} Sparks added to your account`,
+            });
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Gem Packs ---
+    const gems = billing.command('gems').description('Buy Gem packs');
+    gems
+        .command('list', { isDefault: true })
+        .description('List available Gem packs')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        if (json) {
+            console.log(JSON.stringify({ packs: GEM_PACKS }));
+            return;
+        }
+        console.log(table([
+            { label: 'Pack', key: 'label', width: 10 },
+            { label: 'Gems', key: 'gems', width: 10 },
+            { label: 'Price', key: 'price', width: 10 },
+        ], GEM_PACKS.map((pk) => ({ label: pk.label, gems: pk.gems.toLocaleString(), price: formatCents(pk.priceZarCents) }))));
+    });
+    gems
+        .command('buy <pack>')
+        .description('Buy a Gem pack (shard|crystal|cluster|vein)')
+        .action(async function (packId) {
+        const { json, yes } = rootOpts(this);
+        const pack = GEM_PACKS.find((pk) => pk.id === packId);
+        if (!pack) {
+            if (json)
+                console.log(JSON.stringify({ error: 'invalid_pack', valid: GEM_PACKS.map((pk) => pk.id) }));
+            else
+                p.log.error(`Invalid pack. Valid options: ${GEM_PACKS.map((pk) => brand.accent(pk.id)).join(', ')}`);
+            process.exit(1);
+        }
+        try {
+            await doPurchase({
+                json, yes,
+                title: `Buy ${pack.label} Gem Pack`,
+                description: `${pack.gems} Gems for ${formatCents(pack.priceZarCents)}`,
+                initiate: (client, email) => client.initiateGemTopUp({ packId: pack.id, email, callbackUrl: `${LIFE_CALLBACK_URL}?cb=billing&type=gem_topup` }),
+                verify: (client, ref) => client.verifyGemTopUp(ref),
+                successMsg: `${pack.gems} Gems added to your account`,
+            });
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Vault ---
+    billing
+        .command('vault')
+        .description('Convert Burst Sparks to Gems (3:1 ratio)')
+        .option('--amount <n>', 'Number of sparks to convert')
+        .action(async function (opts) {
+        const { json, yes } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            const tier = resolveTier(billingUser.tier);
+            if (tier === 'free') {
+                if (json)
+                    console.log(JSON.stringify({ error: 'free_tier' }));
+                else
+                    p.log.error('Vaulting is available on Standard and Pro plans.');
+                process.exit(1);
+            }
+            const burstSparks = billingUser.burstSparks ?? 0;
+            if (burstSparks < 3) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'insufficient_sparks', burstSparks }));
+                else
+                    p.log.error(`Not enough Burst Sparks to vault (need at least 3, have ${burstSparks}).`);
+                process.exit(1);
+            }
+            const amount = opts.amount ? parseInt(opts.amount, 10) : undefined;
+            if (amount !== undefined && (isNaN(amount) || amount < 3 || amount > burstSparks)) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'invalid_amount' }));
+                else
+                    p.log.error(`Amount must be between 3 and ${burstSparks}.`);
+                process.exit(1);
+            }
+            const raw = amount ?? burstSparks;
+            const sparksToConvert = Math.floor(raw / 3) * 3;
+            const gemsToGain = sparksToConvert / 3;
+            if (sparksToConvert === 0) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'insufficient_sparks', burstSparks }));
+                else
+                    p.log.error(`Not enough Burst Sparks to vault (need at least 3, have ${burstSparks}).`);
+                process.exit(1);
+            }
+            if (!json && !yes) {
+                const lines = [
+                    `${label('Convert')}${sparksToConvert} Burst Sparks`,
+                    `${label('Receive')}${gemsToGain} Gems`,
+                    `${label('Remaining')}${burstSparks - sparksToConvert} Burst Sparks`,
+                ];
+                console.log(panel(lines, { title: 'Vault Conversion', width: 44 }));
+                const confirmed = await p.confirm({ message: 'Confirm vault conversion?' });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+            }
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Converting sparks to gems');
+            const result = await client.vaultSparks(sparksToConvert);
+            if (!json) {
+                spin.stop('Conversion complete');
+                p.log.success(`${result.gemsAdded} Gems added. Balance: ${result.gemsBalance} Gems, ${result.burstSparksRemaining} Burst Sparks remaining.`);
+            }
+            else {
+                console.log(JSON.stringify(result));
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Cancel ---
+    billing
+        .command('cancel')
+        .description('Cancel your subscription')
+        .action(async function () {
+        const { json, yes } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            const tier = resolveTier(billingUser.tier);
+            if (tier === 'free') {
+                if (json)
+                    console.log(JSON.stringify({ error: 'already_free' }));
+                else
+                    p.log.warn('Already on the Free plan.');
+                process.exit(1);
+            }
+            if (!json && !yes) {
+                const lines = [
+                    `${label('Current plan')}${TIER_LIMITS[tier].label} (${formatPrice(tier)})`,
+                    `${label('After cancel')}Free`,
+                ];
+                console.log(panel(lines, { title: 'Cancel Subscription', width: 44 }));
+                const confirmed = await p.confirm({ message: 'Are you sure you want to cancel?' });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Kept current plan.');
+                    return;
+                }
+            }
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Cancelling subscription');
+            await client.cancelSubscription();
+            if (!json) {
+                spin.stop('Subscription cancelled');
+                p.log.success('Your plan has been changed to Free.');
+            }
+            else {
+                console.log(JSON.stringify({ cancelled: true }));
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Downgrade Preview ---
+    billing
+        .command('downgrade-preview')
+        .description('Preview the impact of downgrading your plan')
+        .option('--target <tier>', 'Target tier (free or standard)', 'free')
+        .action(async function (opts) {
+        const { json } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Loading preview');
+            const preview = await client.getDowngradePreview(opts.target);
+            if (!json)
+                spin.stop('Preview loaded');
+            if (json) {
+                console.log(JSON.stringify(preview));
+                return;
+            }
+            const lines = [
+                `${label('Current')}${preview.currentTier}`,
+                `${label('Target')}${preview.targetTier}`,
+            ];
+            if (preview.impacts?.length) {
+                lines.push('');
+                for (const impact of preview.impacts) {
+                    const warn = impact.current > impact.limit;
+                    const line = `${impact.label}: ${impact.current} → limit ${impact.limit}`;
+                    lines.push(`  ${warn ? brand.warning(line) : line}`);
+                }
+            }
+            if (preview.lostFeatures?.length) {
+                lines.push('');
+                lines.push(brand.warning(`Features lost: ${preview.lostFeatures.join(', ')}`));
+            }
+            console.log(panel(lines, { title: 'Downgrade Preview', width: 52 }));
+            p.log.message(brand.muted(`Run ${brand.accent('cubelife billing cancel')} to proceed.`));
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Starter Pack ---
+    billing
+        .command('starter-pack')
+        .description('Buy the Starter Pack (one-time, R40)')
+        .action(async function () {
+        const { json, yes } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            if (billingUser.starterPackClaimed) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'already_claimed' }));
+                else
+                    p.log.warn('Starter Pack already claimed.');
+                process.exit(1);
+            }
+            await doPurchase({
+                json, yes, session,
+                title: 'Buy Starter Pack',
+                description: '30 Gems + exclusive item for R40.00',
+                initiate: (client2, email) => client2.initiateStarterPack({ email, callbackUrl: `${LIFE_CALLBACK_URL}?cb=billing&type=starter_pack` }),
+                verify: (client2, ref) => client2.verifyStarterPack(ref),
+                successMsg: 'Starter Pack claimed! 30 Gems and exclusive item added.',
+            });
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+}
+async function doPurchase(opts) {
+    const { json, yes, title, description, initiate, verify, successMsg } = opts;
+    const session = opts.session ?? await requireAuth();
+    const client = new AdminClient(session.token);
+    if (!json && !yes) {
+        console.log(panel([description], { title, width: 44 }));
+        const confirmed = await p.confirm({ message: 'Proceed to checkout?' });
+        if (isCancel(confirmed) || !confirmed) {
+            p.cancel('Cancelled.');
+            return;
+        }
+    }
+    const spin = p.spinner();
+    if (!json)
+        spin.start('Initiating checkout');
+    const result = await initiate(client, session.email);
+    if (!json)
+        spin.stop('Checkout ready');
+    if (json) {
+        console.log(JSON.stringify({ authorisationUrl: result.authorisationUrl, reference: result.reference }));
+    }
+    if (!json) {
+        const opened = await openBrowser(result.authorisationUrl);
+        if (opened)
+            p.log.info('Opening PayStack checkout in your browser...');
+        else
+            p.log.info('Open this URL to complete checkout:');
+        p.log.message(brand.accent(result.authorisationUrl));
+    }
+    const pollSpin = p.spinner();
+    if (!json)
+        pollSpin.start('Waiting for payment...');
+    let pollResult;
+    try {
+        pollResult = await pollVerification(client, result.reference, {
+            verify: (c, ref) => verify(c, ref),
+        });
+    }
+    catch (pollErr) {
+        if (!json)
+            pollSpin.stop('Failed');
+        throw pollErr;
+    }
+    if (pollResult.status === 'success') {
+        if (!json) {
+            pollSpin.stop('Payment confirmed');
+            p.log.success(successMsg);
+        }
+        else
+            console.log(JSON.stringify({ verified: true }));
+    }
+    else if (pollResult.status === 'timeout') {
+        if (!json) {
+            pollSpin.stop('Timed out');
+            p.log.warn('Payment verification timed out. The payment may still complete.');
+            p.log.message(brand.muted(`Reference: ${result.reference}`));
+        }
+        else {
+            console.log(JSON.stringify({ error: 'timeout', reference: result.reference }));
+        }
+    }
+    else {
+        if (!json) {
+            pollSpin.stop('Payment not completed');
+            p.log.error(`Payment ${pollResult.status}.`);
+        }
+        else
+            console.log(JSON.stringify({ error: pollResult.status }));
+    }
 }
+// --- Pack data ---
+const SPARK_PACKS = [
+    { id: 'ember', sparks: 50, priceZarCents: 4_000, label: 'Ember' },
+    { id: 'flame', sparks: 150, priceZarCents: 10_000, label: 'Flame' },
+    { id: 'blaze', sparks: 500, priceZarCents: 30_000, label: 'Blaze' },
+    { id: 'inferno', sparks: 1_500, priceZarCents: 80_000, label: 'Inferno' },
+];
+const GEM_PACKS = [
+    { id: 'shard', gems: 50, priceZarCents: 3_000, label: 'Shard' },
+    { id: 'crystal', gems: 200, priceZarCents: 10_000, label: 'Crystal' },
+    { id: 'cluster', gems: 600, priceZarCents: 25_000, label: 'Cluster' },
+    { id: 'vein', gems: 1_500, priceZarCents: 50_000, label: 'Vein' },
+];
 function featureRow(featureLabel, getValue, currentTier) {
     const lbl = brand.label(('  ' + featureLabel).padEnd(14));
     const values = TIER_ORDER.map((t) => {

package/dist/lib/api.d.ts

@@ -6,6 +6,9 @@ export type Tier = 'free' | 'standard' | 'pro';
 export interface BillingUser {
     tier: Tier;
     sparks: number;
+    burstSparks?: number;
+    gems?: number;
+    sleeping?: boolean;
     dormancyState: string;
     starterPackClaimed?: boolean;
     locale?: string;
@@ -19,14 +22,36 @@ export interface UsageDay {
 }
 export interface BillingHistoryItem {
     id: string;
-    type: 'subscription' | 'spark_topup' | 'starter_pack' | 'cosmetic';
+    type: 'subscription' | 'subscription_ended' | 'spark_topup' | 'gem_topup' | 'starter_pack' | 'cosmetic';
     product: 'world' | 'life';
     amount: number;
     currency: string;
     sparks: number | null;
+    gems: number | null;
     status: 'success' | 'failed';
     paystackReference: string;
-    createdAt: string;
+    createdAt: unknown;
+}
+export interface VaultResponse {
+    gemsAdded: number;
+    gemsBalance: number;
+    burstSparksRemaining: number;
+}
+export interface DowngradePreview {
+    currentTier: string;
+    targetTier: string;
+    impacts: Array<{
+        key: string;
+        label: string;
+        current: number;
+        limit: number;
+    }>;
+    lostFeatures: string[];
+}
+export interface TopUpRequest {
+    packId: string;
+    email: string;
+    callbackUrl: string;
 }
 export interface SubscribeRequest {
     plan: string;
@@ -138,6 +163,17 @@ export declare class AdminClient {
     getBillingHistory(limit?: number): Promise<BillingHistoryItem[]>;
     subscribe(opts: SubscribeRequest): Promise<SubscribeResponse>;
     verifyPayment(reference: string): Promise<VerifyResponse>;
+    initiateTopUp(opts: TopUpRequest): Promise<SubscribeResponse>;
+    verifyTopUp(reference: string): Promise<VerifyResponse>;
+    initiateGemTopUp(opts: TopUpRequest): Promise<SubscribeResponse>;
+    verifyGemTopUp(reference: string): Promise<VerifyResponse>;
+    initiateStarterPack(opts: Omit<TopUpRequest, 'packId'>): Promise<SubscribeResponse>;
+    verifyStarterPack(reference: string): Promise<VerifyResponse>;
+    vaultSparks(amount?: number): Promise<VaultResponse>;
+    cancelSubscription(): Promise<{
+        cancelled: boolean;
+    }>;
+    getDowngradePreview(targetTier: string): Promise<DowngradePreview>;
     listProjects(): Promise<ProjectListResponse>;
     createProject(name: string): Promise<ProjectResponse>;
     deleteProject(id: string): Promise<void>;

package/dist/lib/api.js

@@ -75,6 +75,33 @@ export class AdminClient {
     async verifyPayment(reference) {
         return this.request('POST', '/v1/billing/verify', { reference });
     }
+    async initiateTopUp(opts) {
+        return this.request('POST', '/v1/billing/topup', opts);
+    }
+    async verifyTopUp(reference) {
+        return this.request('POST', '/v1/billing/topup/verify', { reference });
+    }
+    async initiateGemTopUp(opts) {
+        return this.request('POST', '/v1/billing/gem-topup', opts);
+    }
+    async verifyGemTopUp(reference) {
+        return this.request('POST', '/v1/billing/gem-topup/verify', { reference });
+    }
+    async initiateStarterPack(opts) {
+        return this.request('POST', '/v1/billing/starter-pack', opts);
+    }
+    async verifyStarterPack(reference) {
+        return this.request('POST', '/v1/billing/starter-pack/verify', { reference });
+    }
+    async vaultSparks(amount) {
+        return this.request('POST', '/v1/billing/vault', amount ? { amount } : {});
+    }
+    async cancelSubscription() {
+        return this.request('POST', '/v1/billing/cancel');
+    }
+    async getDowngradePreview(targetTier) {
+        return this.request('GET', `/v1/billing/downgrade-preview?targetTier=${encodeURIComponent(targetTier)}`);
+    }
     async listProjects() {
         return this.request('GET', '/v1/projects');
     }

package/dist/lib/poll.d.ts

@@ -7,5 +7,8 @@ export interface PollResult {
 export interface PollOptions {
     interval?: number;
     timeout?: number;
+    verify?: (client: AdminClient, reference: string) => Promise<{
+        verified: boolean;
+    }>;
 }
 export declare function pollVerification(client: AdminClient, reference: string, opts?: PollOptions): Promise<PollResult>;

package/dist/lib/poll.js

@@ -5,9 +5,10 @@ export async function pollVerification(client, reference, opts = {}) {
     const interval = opts.interval ?? 5_000;
     const timeout = opts.timeout ?? 300_000;
     const deadline = Date.now() + timeout;
+    const verifyFn = opts.verify ?? ((c, ref) => c.verifyPayment(ref));
     while (Date.now() < deadline) {
         try {
-            const data = await client.verifyPayment(reference);
+            const data = await verifyFn(client, reference);
             return { status: 'success', data };
         }
         catch (err) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "0.2.0";
+export declare const CLI_VERSION = "0.3.1";

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.2.0';
+export const CLI_VERSION = '0.3.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cubelife",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "CLI for CubeLife — give your AI agent a living pixel-art companion",
   "type": "module",
   "bin": {
@@ -28,8 +28,15 @@
     "pixel-art",
     "character",
     "cli",
-    "mcp"
+    "mcp",
+    "mcp-server",
+    "developer-tools",
+    "companion",
+    "claude",
+    "cursor",
+    "copilot"
   ],
+  "mcpName": "io.github.AndriesJacobus/cubelife",
   "license": "MIT",
   "repository": {
     "type": "git",