cubelife 0.2.0

package/dist/commands/setup.js

@@ -0,0 +1,453 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import * as p from '@clack/prompts';
+import { readProjectConfig } from '../lib/config.js';
+import { writeHookScript, mergeSettings, readClaudeSettings, writeClaudeSettings, detectLegacySetup, resolveProjectRoot, hookScriptPath, readJsonConfig, writeJsonConfig, buildMcpEntryWithAgent, mergeMcpServerEntry, hasStaleMcpEntry, removeMcpEntry, readYamlConfig, writeYamlConfig, buildContinueMcpEntry, mergeContinueMcpServer, hasStaleContinueEntry, removeContinueEntry, registerClaudeMcp, registerCodexMcp, } from '../lib/integration.js';
+import { vscodeGlobalStoragePath, vscodeUserPath, CLINE_EXTENSION_IDS } from '../lib/detect.js';
+import { API_BASE_URL } from '../lib/constants.js';
+import { brand } from '../ui/theme.js';
+import { isCancel } from '../ui/helpers.js';
+import { rootOpts } from '../lib/command-helpers.js';
+function displayPath(fullPath) {
+    const home = homedir();
+    return fullPath.startsWith(home) ? fullPath.replace(home, '~') : fullPath;
+}
+async function promptScopes(scopes, relativePath, json) {
+    if (json)
+        return scopes.filter((s) => s.initial !== false).map((s) => s.value);
+    const selected = await p.multiselect({
+        message: 'Where should the MCP config be installed?',
+        options: [
+            ...scopes.map((s) => ({ value: s.value, label: s.label, hint: s.hint })),
+            { value: '__custom__', label: 'Custom directory', hint: 'Specify a project root' },
+        ],
+        initialValues: scopes.filter((s) => s.initial).map((s) => s.value),
+        required: true,
+    });
+    if (isCancel(selected)) {
+        process.exit(0);
+        throw new Error('unreachable');
+    }
+    const paths = selected.filter((v) => v !== '__custom__');
+    if (selected.includes('__custom__')) {
+        const dir = await p.text({
+            message: 'Enter the project root directory:',
+            validate: (v) => { if (!v.trim())
+                return 'Path cannot be empty.'; },
+        });
+        if (isCancel(dir)) {
+            process.exit(0);
+            throw new Error('unreachable');
+        }
+        paths.push(join(dir, relativePath));
+    }
+    return [...new Set(paths)];
+}
+async function cleanStaleEntries(allScopes, selectedPaths, serverKey, json) {
+    const cleaned = [];
+    const unselected = allScopes
+        .map((s) => s.value)
+        .filter((p) => !selectedPaths.includes(p));
+    for (const path of unselected) {
+        if (await hasStaleMcpEntry(path, serverKey)) {
+            if (json) {
+                await removeMcpEntry(path, serverKey);
+                cleaned.push(path);
+            }
+            else {
+                const remove = await p.select({
+                    message: `Found stale cubelife entry in ${displayPath(path)}. This would override your new config. Remove it?`,
+                    options: [
+                        { value: true, label: 'Yes, remove it' },
+                        { value: false, label: 'No, leave it' },
+                    ],
+                    initialValue: true,
+                });
+                if (!isCancel(remove) && remove) {
+                    await removeMcpEntry(path, serverKey);
+                    cleaned.push(path);
+                }
+            }
+        }
+    }
+    return cleaned;
+}
+export function registerSetupCommands(program) {
+    const setup = program
+        .command('setup')
+        .description('Configure CubeLife integration for an AI tool');
+    setup
+        .command('claude-code')
+        .description('Set up Claude Code (MCP + hooks)')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const root = resolveProjectRoot();
+        const config = await readProjectConfig();
+        if (!config?.agentId) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'no_agent_linked' }));
+            }
+            else {
+                p.log.error(`No agent linked. Run ${brand.accent('cubelife init')} first.`);
+            }
+            process.exit(1);
+        }
+        let mode;
+        if (json) {
+            mode = 'both';
+        }
+        else {
+            const selected = await p.select({
+                message: 'What should we configure?',
+                options: [
+                    { value: 'both', label: 'Both MCP + Hooks (recommended)', hint: 'Full integration' },
+                    { value: 'mcp', label: 'MCP only', hint: 'AI-driven state reports' },
+                    { value: 'hooks', label: 'Hooks only', hint: 'Automatic tool-based state tracking' },
+                ],
+                initialValue: 'both',
+            });
+            if (isCancel(selected)) {
+                p.log.message('Setup cancelled.');
+                process.exit(0);
+            }
+            mode = selected;
+        }
+        let mcpScope = 'user';
+        if (mode === 'mcp' || mode === 'both') {
+            if (!json) {
+                const selected = await p.select({
+                    message: 'Where should the MCP server be registered?',
+                    options: [
+                        { value: 'user', label: 'Globally (recommended)', hint: 'Works in all projects' },
+                        { value: 'project', label: 'This project only', hint: displayPath(root) },
+                    ],
+                    initialValue: 'user',
+                });
+                if (isCancel(selected)) {
+                    process.exit(0);
+                    throw new Error('unreachable');
+                }
+                mcpScope = selected;
+            }
+            registerClaudeMcp(mcpScope);
+        }
+        if (mode === 'hooks' || mode === 'both') {
+            await writeHookScript();
+        }
+        const hooksSettingsPath = join(homedir(), '.claude', 'settings.json');
+        const allConflicts = [];
+        if (mode === 'hooks' || mode === 'both') {
+            const existing = await readClaudeSettings(resolve(hooksSettingsPath, '..', '..'));
+            const { settings, conflicts } = mergeSettings(existing, 'hooks');
+            await writeClaudeSettings(resolve(hooksSettingsPath, '..', '..'), settings);
+            allConflicts.push(...conflicts);
+        }
+        const legacy = detectLegacySetup(root);
+        if (json) {
+            console.log(JSON.stringify({
+                ok: true,
+                mode,
+                mcpScope,
+                conflicts: allConflicts,
+                legacy,
+                hookScript: (mode === 'hooks' || mode === 'both') ? hookScriptPath() : undefined,
+            }));
+        }
+        else {
+            if (allConflicts.length) {
+                for (const c of allConflicts) {
+                    p.log.warn(c);
+                }
+            }
+            p.log.success('Claude Code integration configured.');
+            if (mode === 'mcp' || mode === 'both') {
+                p.log.message(`  MCP: ${brand.success('cubelife')} server registered (${mcpScope} scope)`);
+            }
+            if (mode === 'hooks' || mode === 'both') {
+                p.log.message('  Hooks: tool events mapped to CubeLife states');
+                p.log.message(`  Script: ${brand.muted(hookScriptPath())}`);
+            }
+            if (legacy.length) {
+                p.log.warn(`Legacy files detected: ${legacy.join(', ')}`);
+                p.log.message(brand.muted('These can be removed. The CLI manages agent keys centrally now.'));
+            }
+            p.log.message(brand.muted('Restart Claude Code to activate.'));
+        }
+    });
+    async function requireAgent(json) {
+        const config = await readProjectConfig();
+        if (!config?.agentId) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'no_agent_linked' }));
+            }
+            else {
+                p.log.error(`No agent linked. Run ${brand.accent('cubelife init')} first.`);
+            }
+            process.exit(1);
+            throw new Error('unreachable');
+        }
+        return config.agentId;
+    }
+    async function setupMcpTool(agentId, opts, json) {
+        const { toolName, configPaths, allScopes, serverKey = 'mcpServers', restartHint } = opts;
+        const entry = buildMcpEntryWithAgent(agentId);
+        let anyReplaced = false;
+        for (const configPath of configPaths) {
+            const existing = await readJsonConfig(configPath);
+            const { config, replaced } = mergeMcpServerEntry(existing, serverKey, entry);
+            await writeJsonConfig(configPath, config);
+            if (replaced)
+                anyReplaced = true;
+        }
+        if (allScopes) {
+            await cleanStaleEntries(allScopes, configPaths, serverKey, json);
+        }
+        if (json) {
+            console.log(JSON.stringify({ ok: true, tool: toolName, configPaths, replaced: anyReplaced }));
+        }
+        else {
+            if (anyReplaced) {
+                p.log.warn('Existing cubelife MCP entry updated.');
+            }
+            p.log.success(`${toolName} integration configured.`);
+            for (const cp of configPaths) {
+                p.log.message(`  Config: ${brand.muted(displayPath(cp))}`);
+            }
+            p.log.message(brand.muted(restartHint));
+        }
+    }
+    setup
+        .command('cursor')
+        .description('Set up Cursor (MCP)')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        const root = resolveProjectRoot();
+        const cursorScopes = [
+            { value: join(root, '.cursor', 'mcp.json'), label: 'This project', hint: displayPath(root), initial: true },
+            { value: join(homedir(), '.cursor', 'mcp.json'), label: 'Globally', hint: '~/.cursor/mcp.json', initial: false },
+        ];
+        const configPaths = await promptScopes(cursorScopes, '.cursor/mcp.json', json);
+        await setupMcpTool(agentId, {
+            toolName: 'Cursor',
+            configPaths,
+            allScopes: cursorScopes,
+            restartHint: 'Restart Cursor to activate.',
+        }, json);
+    });
+    setup
+        .command('windsurf')
+        .description('Set up Windsurf (MCP)')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        await setupMcpTool(agentId, {
+            toolName: 'Windsurf',
+            configPaths: [join(homedir(), '.codeium', 'windsurf', 'mcp_config.json')],
+            restartHint: 'Restart Windsurf to activate.',
+        }, json);
+    });
+    setup
+        .command('copilot')
+        .description('Set up GitHub Copilot (MCP)')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        const root = resolveProjectRoot();
+        const copilotScopes = [
+            { value: join(root, '.vscode', 'mcp.json'), label: 'This project', hint: displayPath(root), initial: true },
+            { value: join(vscodeUserPath(), 'mcp.json'), label: 'Globally (VS Code user)', hint: displayPath(join(vscodeUserPath(), 'mcp.json')), initial: false },
+        ];
+        const configPaths = await promptScopes(copilotScopes, '.vscode/mcp.json', json);
+        await setupMcpTool(agentId, {
+            toolName: 'GitHub Copilot',
+            configPaths,
+            allScopes: copilotScopes,
+            serverKey: 'servers',
+            restartHint: 'Restart VS Code to activate.',
+        }, json);
+    });
+    function resolveClineConfigPath() {
+        const gs = vscodeGlobalStoragePath();
+        for (const extId of CLINE_EXTENSION_IDS) {
+            const dir = join(gs, extId, 'settings');
+            if (existsSync(dir)) {
+                return join(dir, 'cline_mcp_settings.json');
+            }
+        }
+        return join(gs, CLINE_EXTENSION_IDS[0], 'settings', 'cline_mcp_settings.json');
+    }
+    setup
+        .command('cline')
+        .description('Set up Cline (MCP)')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        await setupMcpTool(agentId, {
+            toolName: 'Cline',
+            configPaths: [resolveClineConfigPath()],
+            restartHint: 'Restart VS Code to activate.',
+        }, json);
+    });
+    setup
+        .command('continue')
+        .description('Set up Continue.dev (MCP)')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        const root = resolveProjectRoot();
+        const continueScopes = [
+            { value: join(homedir(), '.continue', 'config.yaml'), label: 'Globally for Continue.dev', hint: '~/.continue/config.yaml', initial: true },
+            { value: join(root, '.continue', 'config.yaml'), label: 'This project', hint: displayPath(root), initial: false },
+        ];
+        const configPaths = await promptScopes(continueScopes, '.continue/config.yaml', json);
+        let anyReplaced = false;
+        for (const configPath of configPaths) {
+            const existing = await readYamlConfig(configPath);
+            const entry = buildContinueMcpEntry(agentId);
+            const { config, replaced } = mergeContinueMcpServer(existing, entry);
+            await writeYamlConfig(configPath, config);
+            if (replaced)
+                anyReplaced = true;
+        }
+        const unselectedYaml = continueScopes
+            .map((s) => s.value)
+            .filter((p) => !configPaths.includes(p));
+        for (const path of unselectedYaml) {
+            if (await hasStaleContinueEntry(path)) {
+                if (json) {
+                    await removeContinueEntry(path);
+                }
+                else {
+                    const remove = await p.select({
+                        message: `Found stale cubelife entry in ${displayPath(path)}. This would override your new config. Remove it?`,
+                        options: [
+                            { value: true, label: 'Yes, remove it' },
+                            { value: false, label: 'No, leave it' },
+                        ],
+                        initialValue: true,
+                    });
+                    if (!isCancel(remove) && remove) {
+                        await removeContinueEntry(path);
+                    }
+                }
+            }
+        }
+        if (json) {
+            console.log(JSON.stringify({ ok: true, tool: 'Continue.dev', configPaths, replaced: anyReplaced }));
+        }
+        else {
+            if (anyReplaced) {
+                p.log.warn('Existing cubelife MCP entry updated.');
+            }
+            p.log.success('Continue.dev integration configured.');
+            for (const cp of configPaths) {
+                p.log.message(`  Config: ${brand.muted(displayPath(cp))}`);
+            }
+            p.log.message(brand.muted('Restart Continue.dev to activate.'));
+        }
+    });
+    function printMcpSnippet(agentId) {
+        p.log.message(brand.accent('MCP config (for any tool that supports it):'));
+        p.log.message('');
+        p.log.message(`  {
+    "mcpServers": {
+      "cubelife": {
+        "command": "npx",
+        "args": ["cubelife", "mcp"],
+        "env": { "CUBELIFE_AGENT_ID": "${agentId}" }
+      }
+    }
+  }`);
+    }
+    function printSdkSnippets(agentId) {
+        p.log.message('');
+        p.log.message(brand.accent('Node SDK:'));
+        p.log.message('');
+        p.log.message(`  import { CubeLifeClient } from '@cubelife/sdk';
+  const cube = new CubeLifeClient({ agentId: '${agentId}' });
+  await cube.report({ state: 'coding', detail: 'Working on feature' });`);
+        p.log.message('');
+        p.log.message(brand.accent('Python SDK:'));
+        p.log.message('');
+        p.log.message(`  from cubelife import CubeLifeClient
+  cube = CubeLifeClient(agent_id="${agentId}")
+  cube.report(state="coding", detail="Working on feature")`);
+        p.log.message('');
+        p.log.message(brand.accent('REST API:'));
+        p.log.message('');
+        p.log.message(`  curl -X POST ${API_BASE_URL}/api/v1/state \\
+    -H "Content-Type: application/json" \\
+    -H "X-Agent-Key: <your-api-key>" \\
+    -d '{"state": "coding", "detail": "Working on feature"}'`);
+    }
+    setup
+        .command('codex')
+        .description('Set up Codex CLI (MCP)')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        try {
+            const { replaced } = registerCodexMcp(agentId);
+            if (json) {
+                console.log(JSON.stringify({ ok: true, tool: 'Codex CLI', replaced }));
+            }
+            else {
+                if (replaced)
+                    p.log.warn('Existing cubelife MCP entry updated.');
+                p.log.success('Codex CLI integration configured.');
+                p.log.message(`  MCP: ${brand.success('cubelife')} server registered`);
+                p.log.message(brand.muted('Restart Codex CLI to activate.'));
+            }
+        }
+        catch {
+            if (json) {
+                console.log(JSON.stringify({ error: 'codex_mcp_failed' }));
+            }
+            else {
+                p.log.error('Failed to register MCP server. Is Codex CLI installed?');
+                p.log.message(`Install with: ${brand.accent('npm install -g @openai/codex')}`);
+            }
+            process.exit(1);
+        }
+    });
+    setup
+        .command('aider')
+        .description('Show Aider integration instructions')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        if (json) {
+            console.log(JSON.stringify({
+                ok: true,
+                tool: 'Aider',
+                type: 'instructions',
+                agentId,
+            }));
+            return;
+        }
+        p.log.message('Aider does not support MCP natively.');
+        p.log.message('Add CubeLife state reports to your Aider workflow using the SDK:');
+        printSdkSnippets(agentId);
+    });
+    setup
+        .command('manual')
+        .description('Show manual integration instructions')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const agentId = await requireAgent(json);
+        if (json) {
+            console.log(JSON.stringify({
+                ok: true,
+                tool: 'Manual',
+                type: 'instructions',
+                agentId,
+            }));
+            return;
+        }
+        p.log.message('Manual integration options:');
+        printMcpSnippet(agentId);
+        printSdkSnippets(agentId);
+    });
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,89 @@
+import * as p from '@clack/prompts';
+import { createAgentClient } from '../lib/api.js';
+import { dot, brand } from '../ui/theme.js';
+import { VALID_STATES, VALID_SENTIMENTS } from '../lib/constants.js';
+import { rootOpts, getErrorMessage, } from '../lib/command-helpers.js';
+export function registerStatusCommand(program) {
+    program
+        .command('status [state] [detail]')
+        .description('Report agent state (e.g. cubelife status coding "Working on auth")')
+        .option('--progress <value>', 'Task progress from 0 to 1')
+        .option('--sentiment <value>', 'Current sentiment (positive, negative, neutral)')
+        .action(async function (state, detail, opts) {
+        const { json, agent: agentOverride } = rootOpts(this);
+        if (!state) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'state_required', validStates: VALID_STATES }));
+            }
+            else {
+                p.log.error('State is required.');
+                p.log.message(brand.muted(`Valid states: ${VALID_STATES.join(', ')}`));
+                p.log.message(brand.muted(`Example: ${brand.accent('cubelife status coding "Working on auth"')}`));
+            }
+            process.exit(1);
+        }
+        if (!VALID_STATES.includes(state)) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'invalid_state', validStates: VALID_STATES }));
+            }
+            else {
+                p.log.error(`Invalid state: ${state}`);
+                p.log.message(brand.muted(`Valid states: ${VALID_STATES.join(', ')}`));
+            }
+            process.exit(1);
+        }
+        let progress;
+        if (opts.progress !== undefined) {
+            progress = parseFloat(opts.progress);
+            if (isNaN(progress) || progress < 0 || progress > 1) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'progress_must_be_0_to_1' }));
+                else
+                    p.log.error('Progress must be a number between 0 and 1.');
+                process.exit(1);
+            }
+        }
+        if (opts.sentiment && !VALID_SENTIMENTS.includes(opts.sentiment)) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'invalid_sentiment', validSentiments: VALID_SENTIMENTS }));
+            }
+            else {
+                p.log.error(`Invalid sentiment. Must be one of: ${VALID_SENTIMENTS.join(', ')}`);
+            }
+            process.exit(1);
+        }
+        const client = await createAgentClient(agentOverride);
+        if (!client) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'no_agent_linked' }));
+            }
+            else {
+                p.log.error(`No agent linked. Run ${brand.accent('cubelife init')} first.`);
+            }
+            process.exit(1);
+        }
+        try {
+            const reportOpts = {
+                detail: detail ?? undefined,
+                progress,
+                sentiment: opts.sentiment,
+            };
+            await client.report(state, reportOpts);
+            if (json) {
+                console.log(JSON.stringify({ ok: true }));
+            }
+            else {
+                p.log.success(`${dot.working} State updated: ${brand.primary(state)}${detail ? ` ${brand.muted(`"${detail}"`)}` : ''}`);
+            }
+        }
+        catch (err) {
+            if (json) {
+                console.log(JSON.stringify({ ok: false, error: getErrorMessage(err) }));
+            }
+            else {
+                p.log.error(getErrorMessage(err));
+            }
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/tutorial.d.ts

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

package/dist/commands/tutorial.js

@@ -0,0 +1,9 @@
+import { runTutorial } from '../lib/tutorial.js';
+export function registerTutorialCommand(program) {
+    program
+        .command('tutorial')
+        .description('Interactive setup walkthrough (6 steps)')
+        .action(async () => {
+        await runTutorial();
+    });
+}

package/dist/commands/view.d.ts

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