gemkit-cli 0.2.2 → 0.3.0

package/dist/commands/init/index.js

@@ -0,0 +1,345 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { spawn, spawnSync } from 'child_process';
+import ora from 'ora';
+import { getLatestRelease, getReleaseByVersion } from '../../domains/github/releases.js';
+import { downloadRelease } from '../../domains/github/download.js';
+import { extractTarGz } from '../../services/archive.js';
+import { createMetadata, saveMetadata, isInstalled } from '../../domains/installation/metadata.js';
+import { logger } from '../../services/logger.js';
+import { brand, pc } from '../../utils/colors.js';
+import { CLI_VERSION } from '../update/index.js';
+import { getLatestNpmVersion, isUpdateAvailable } from '../../services/npm.js';
+// Package name for CLI
+const CLI_PACKAGE_NAME = 'gemkit-cli';
+/**
+ * Update CLI via npm
+ */
+function updateCli(version) {
+    const result = spawnSync('npm', ['install', '-g', `${CLI_PACKAGE_NAME}@${version}`], {
+        encoding: 'utf-8',
+        stdio: 'pipe',
+        shell: true,
+    });
+    return result.status === 0;
+}
+/**
+ * Get exclusion patterns based on installation mode
+ */
+function getExcludePatterns(mode) {
+    switch (mode) {
+        case 'gemini':
+            // Exclude Claude and generic agent folders (Gemini uses .gemini)
+            return ['.claude', '.claude/**', '.agent', '.agent/**'];
+        case 'claude':
+            // Exclude generic agent folder (Claude Code uses .claude)
+            return ['.agent', '.agent/**'];
+        case 'antigravity':
+            // Exclude Claude folder (Antigravity uses .agent)
+            return ['.claude', '.claude/**'];
+        case 'full':
+        default:
+            // No exclusions - install everything
+            return [];
+    }
+}
+/**
+ * Get mode description for display
+ */
+function getModeDescription(mode) {
+    switch (mode) {
+        case 'gemini':
+            return 'Gemini CLI (excludes .claude, .agent)';
+        case 'claude':
+            return 'Claude Code (excludes .agent)';
+        case 'antigravity':
+            return 'Antigravity (excludes .claude)';
+        case 'full':
+        default:
+            return 'Full (all files)';
+    }
+}
+/**
+ * Check if a path matches any of the exclude patterns
+ * Supports simple directory patterns like '.claude', '.claude/**'
+ */
+function shouldExclude(filePath, excludePatterns) {
+    // Normalize path separators
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    for (const pattern of excludePatterns) {
+        // Simple directory match: '.claude' or '.agent'
+        if (!pattern.includes('*')) {
+            if (normalizedPath === pattern || normalizedPath.startsWith(pattern + '/')) {
+                return true;
+            }
+        }
+        // Glob pattern: '.claude/**' means anything under .claude
+        else if (pattern.endsWith('/**')) {
+            const baseDir = pattern.slice(0, -3); // Remove '/**'
+            if (normalizedPath.startsWith(baseDir + '/')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Create a filter function for extraction based on exclude patterns
+ */
+function createExcludeFilter(excludePatterns) {
+    if (excludePatterns.length === 0) {
+        return undefined; // No filtering needed
+    }
+    return (path) => {
+        // Return true to INCLUDE the file, false to EXCLUDE
+        return !shouldExclude(path, excludePatterns);
+    };
+}
+/**
+ * Install spawn-agent extension using gemini CLI (silent - for use with spinner)
+ * Runs: gemini extensions install .gemini/extensions/spawn-agent
+ */
+async function installSpawnAgentExtensionSilent() {
+    const extensionPath = join('.gemini', 'extensions', 'spawn-agent');
+    // Check if extension directory exists
+    if (!existsSync(extensionPath)) {
+        return {
+            success: false,
+            error: `Extension directory not found: ${extensionPath}`
+        };
+    }
+    return new Promise((resolve) => {
+        const child = spawn('gemini', ['extensions', 'install', extensionPath], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+            cwd: process.cwd()
+        });
+        let stdout = '';
+        let stderr = '';
+        let resolved = false;
+        // Timeout after 30 seconds
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                child.kill();
+                resolve({
+                    success: false,
+                    error: 'Extension installation timed out'
+                });
+            }
+        }, 30000);
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                if (code === 0) {
+                    resolve({ success: true });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        error: stderr || stdout || `Exit code: ${code}`
+                    });
+                }
+            }
+        });
+        child.on('error', (err) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                resolve({
+                    success: false,
+                    error: `Failed to run gemini CLI: ${err.message}`
+                });
+            }
+        });
+    });
+}
+/**
+ * Check if spawn-agent extension is installed in Gemini
+ */
+export async function isSpawnAgentInstalled() {
+    return new Promise((resolve) => {
+        const child = spawn('gemini', ['extensions', 'list'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32'
+        });
+        let stdout = '';
+        let resolved = false;
+        // Timeout after 20 seconds
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                child.kill();
+                resolve(false);
+            }
+        }, 20000);
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.on('close', (code) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                if (code === 0) {
+                    // Check if spawn-agent appears in the output
+                    const isInstalled = stdout.toLowerCase().includes('spawn-agent');
+                    resolve(isInstalled);
+                }
+                else {
+                    resolve(false);
+                }
+            }
+        });
+        child.on('error', () => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                resolve(false);
+            }
+        });
+    });
+}
+export function registerInitCommand(cli) {
+    cli
+        .command('init', 'Initialize GemKit in project')
+        .option('--version <ver>', 'Specific version to install')
+        .option('-f, --force', 'Overwrite existing installation')
+        .option('--exclude <patterns...>', 'File patterns to exclude')
+        .option('--skip-extension', 'Skip spawn-agent extension installation')
+        .option('--full', 'Install all files (default)')
+        .option('--gemini', 'Gemini CLI mode (excludes .claude, .agent folders)')
+        .option('--claude', 'Claude Code mode (excludes .agent folder)')
+        .option('--antigravity', 'Antigravity mode (excludes .claude folder)')
+        .action(async (options) => {
+        // Determine installation mode (priority: gemini > claude > antigravity > full)
+        let mode = 'full';
+        if (options.gemini)
+            mode = 'gemini';
+        else if (options.claude)
+            mode = 'claude';
+        else if (options.antigravity)
+            mode = 'antigravity';
+        else if (options.full)
+            mode = 'full';
+        // Check if already installed
+        if (isInstalled() && !options.force) {
+            console.log();
+            logger.warn('GemKit is already installed. Use --force to reinstall.');
+            console.log();
+            return;
+        }
+        console.log();
+        console.log(pc.bold(brand.geminiPurple('Initializing GemKit')));
+        console.log();
+        console.log(`  ${brand.dim('Mode')}  ${brand.accent(getModeDescription(mode))}`);
+        console.log();
+        // Check CLI version and auto-update if available
+        const cliSpinner = ora({
+            text: 'Checking CLI version...',
+            color: 'magenta'
+        }).start();
+        try {
+            const latestCli = await getLatestNpmVersion(CLI_PACKAGE_NAME);
+            if (latestCli && isUpdateAvailable(CLI_VERSION, latestCli.version)) {
+                cliSpinner.text = `Updating CLI v${CLI_VERSION} → v${latestCli.version}...`;
+                const updated = updateCli(latestCli.version);
+                if (updated) {
+                    cliSpinner.succeed(`CLI updated v${brand.primary(CLI_VERSION)} → v${brand.primary(latestCli.version)}`);
+                }
+                else {
+                    cliSpinner.warn(`CLI v${brand.primary(CLI_VERSION)} (update to v${latestCli.version} failed)`);
+                }
+            }
+            else {
+                cliSpinner.succeed(`CLI v${brand.primary(CLI_VERSION)}`);
+            }
+        }
+        catch {
+            cliSpinner.succeed(`CLI v${brand.primary(CLI_VERSION)}`);
+        }
+        // Step 1: Fetch Kits release info
+        const fetchSpinner = ora({
+            text: 'Fetching latest Kits release...',
+            color: 'magenta'
+        }).start();
+        const release = options.version
+            ? await getReleaseByVersion(options.version)
+            : await getLatestRelease();
+        if (!release) {
+            fetchSpinner.fail('No Kits release found');
+            console.log();
+            process.exit(1);
+        }
+        fetchSpinner.succeed(`Found Kits v${brand.primary(release.version)}`);
+        // Step 2: Download Kits
+        const downloadSpinner = ora({
+            text: 'Downloading Kits...',
+            color: 'magenta'
+        }).start();
+        let tarPath;
+        try {
+            tarPath = await downloadRelease(release);
+            downloadSpinner.succeed('Kits downloaded');
+        }
+        catch (error) {
+            downloadSpinner.fail(`Kits download failed: ${error instanceof Error ? error.message : String(error)}`);
+            console.log();
+            process.exit(1);
+        }
+        // Step 3: Extract Kits
+        const excludePatterns = getExcludePatterns(mode);
+        const extractSpinner = ora({
+            text: mode === 'full' ? 'Extracting Kits...' : `Extracting Kits (${mode} mode)...`,
+            color: 'magenta'
+        }).start();
+        const extractDir = process.cwd();
+        const result = await extractTarGz({
+            source: tarPath,
+            destination: extractDir,
+            strip: 1,
+            filter: createExcludeFilter(excludePatterns),
+        });
+        if (!result.success) {
+            extractSpinner.fail(`Kits extraction failed: ${result.error}`);
+            console.log();
+            process.exit(1);
+        }
+        extractSpinner.succeed(`Extracted ${result.extractedFiles.length} files`);
+        // Save metadata
+        const metadata = createMetadata(release.version, 'local', result.extractedFiles);
+        saveMetadata(metadata);
+        console.log();
+        logger.success(`Kits v${brand.primary(release.version)} installed successfully!`);
+        // Step 4: Install spawn-agent extension (unless skipped or using non-Gemini mode)
+        const shouldInstallExtension = !options.skipExtension && (mode === 'full' || mode === 'gemini');
+        if (shouldInstallExtension) {
+            console.log();
+            const extensionSpinner = ora({
+                text: 'Installing spawn-agent extension...',
+                color: 'magenta'
+            }).start();
+            const extensionResult = await installSpawnAgentExtensionSilent();
+            if (extensionResult.success) {
+                extensionSpinner.succeed('spawn-agent extension installed in Gemini CLI');
+            }
+            else {
+                extensionSpinner.warn(`Could not install spawn-agent extension: ${extensionResult.error}`);
+                logger.info(`You can manually install it with: ${brand.primary('gemini extensions install .gemini/extensions/spawn-agent')}`);
+            }
+        }
+        else if (mode === 'claude' || mode === 'antigravity') {
+            console.log();
+            logger.info(`Skipped Gemini extension (${mode} mode).`);
+        }
+        console.log();
+        logger.info(`Run ${brand.primary('gk doctor')} to verify installation.`);
+        console.log();
+    });
+}

package/dist/commands/new/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * New command - Create a new GemKit project
+ */
+import type { CAC } from 'cac';
+export declare function registerNewCommand(cli: CAC): void;

package/dist/commands/new/index.js

@@ -0,0 +1,49 @@
+/**
+ * New command - Create a new GemKit project
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getLatestRelease } from '../../domains/github/index.js';
+import { downloadRelease } from '../../domains/github/download.js';
+import { extractTarGz } from '../../services/archive.js';
+import { logger } from '../../services/logger.js';
+import { brand, pc } from '../../utils/colors.js';
+export function registerNewCommand(cli) {
+    cli
+        .command('new <name>', 'Create a new project from starter kit')
+        .action(async (name) => {
+        const destDir = join(process.cwd(), name);
+        if (existsSync(destDir)) {
+            console.log();
+            logger.error(`Directory already exists: ${name}`);
+            console.log();
+            process.exit(1);
+        }
+        console.log();
+        console.log(pc.bold(brand.geminiPurple('Creating New Project')));
+        console.log();
+        logger.info(`Name: ${brand.primary(name)}`);
+        const latest = await getLatestRelease();
+        if (!latest) {
+            logger.error('Failed to fetch latest starter kit.');
+            console.log();
+            process.exit(1);
+        }
+        logger.info(`Fetching latest starter kit (v${latest.version})...`);
+        const tarPath = await downloadRelease(latest);
+        const result = await extractTarGz({
+            source: tarPath,
+            destination: destDir,
+            strip: 1,
+        });
+        if (result.success) {
+            console.log();
+            logger.success(`Project ${brand.primary(name)} created successfully!`);
+            console.log(`\nNext steps:\n  cd ${brand.primary(name)}\n  gk init\n`);
+        }
+        else {
+            logger.error(`Failed to create project: ${result.error}`);
+            console.log();
+        }
+    });
+}

package/dist/commands/office/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Agent Office command - Gamified visualization for multi-agent workflows
+ */
+import type { CAC } from 'cac';
+export declare function registerOfficeCommand(cli: CAC): void;

package/dist/commands/office/index.js

@@ -0,0 +1,283 @@
+/**
+ * Agent Office command - Gamified visualization for multi-agent workflows
+ */
+import { startWebDashboard, OfficeEventEmitter, createInitialState, SessionFileWatcher, sessionToOfficeState, } from '../../domains/agent-office/index.js';
+import { logger } from '../../services/logger.js';
+import { brand, ui, pc } from '../../utils/colors.js';
+// ═══════════════════════════════════════════════════════════════════════════
+// HELP FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════
+function showMainHelp() {
+    console.log();
+    console.log(pc.bold(brand.geminiPurple('Agent Office')));
+    console.log();
+    console.log('Usage:');
+    console.log(`  ${brand.primary('gk office')} <subcommand> [options]`);
+    console.log();
+    console.log('Subcommands:');
+    console.log(`  ${brand.primary('start')}             Start the visualization`);
+    console.log(`  ${brand.primary('status')}            Show current office state`);
+    console.log(`  ${brand.primary('watch')}             Watch office state changes`);
+    console.log();
+    console.log('Options:');
+    console.log(`  ${brand.dim('-p, --port <n>')}    [start] Web server port (default: 3847)`);
+    console.log(`  ${brand.dim('--no-open')}         [start] Don't auto-open browser`);
+    console.log(`  ${brand.dim('--json')}            [status/watch] Output as JSON`);
+    console.log();
+    console.log('Examples:');
+    console.log(`  ${brand.dim('gk office start')}`);
+    console.log(`  ${brand.dim('gk office start --port 4000')}`);
+    console.log(`  ${brand.dim('gk office status --json')}`);
+    console.log(`  ${brand.dim('gk office watch')}`);
+    console.log();
+}
+function showStartHelp() {
+    console.log();
+    console.log(pc.bold(brand.geminiPurple('gk office start')));
+    console.log(brand.dim('Start the Agent Office web dashboard'));
+    console.log();
+    console.log('Usage:');
+    console.log(`  ${brand.primary('gk office start')} [options]`);
+    console.log();
+    console.log('Options:');
+    console.log(`  ${brand.dim('-p, --port <n>')}    Web server port (default: 3847)`);
+    console.log(`  ${brand.dim('--no-open')}         Don't auto-open browser`);
+    console.log();
+    console.log('Examples:');
+    console.log(`  ${brand.dim('gk office start')}`);
+    console.log(`  ${brand.dim('gk office start --port 4000')}`);
+    console.log(`  ${brand.dim('gk office start --port 4000 --no-open')}`);
+    console.log();
+}
+function showStatusHelp() {
+    console.log();
+    console.log(pc.bold(brand.geminiPurple('gk office status')));
+    console.log(brand.dim('Show current Agent Office state'));
+    console.log();
+    console.log('Usage:');
+    console.log(`  ${brand.primary('gk office status')} [options]`);
+    console.log();
+    console.log('Options:');
+    console.log(`  ${brand.dim('--json')}    Output as JSON`);
+    console.log();
+}
+function showWatchHelp() {
+    console.log();
+    console.log(pc.bold(brand.geminiPurple('gk office watch')));
+    console.log(brand.dim('Watch Agent Office state changes in real-time'));
+    console.log();
+    console.log('Usage:');
+    console.log(`  ${brand.primary('gk office watch')} [options]`);
+    console.log();
+    console.log('Options:');
+    console.log(`  ${brand.dim('--json')}    Output as JSON`);
+    console.log();
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// HANDLERS
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Handle start subcommand
+ */
+async function handleStart(options) {
+    console.log();
+    logger.info('Starting Agent Office...');
+    console.log();
+    try {
+        const dashboard = await startWebDashboard({
+            port: options.port || 3847,
+            autoOpen: options.open !== false,
+            onReady: (port) => {
+                logger.success(`Dashboard running at ${brand.primary(`http://localhost:${port}`)}`);
+                console.log(brand.dim('  Press Ctrl+C to stop'));
+                console.log();
+            },
+            onError: (error) => {
+                logger.error(`Error: ${error.message}`);
+            },
+        });
+        process.on('SIGINT', () => {
+            dashboard.stop();
+            console.log();
+            logger.info('Agent Office stopped.');
+            console.log();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message === 'No active session found') {
+                console.log();
+                logger.warn('No active session found.');
+                console.log(brand.dim('  Start a GemKit session first with: gk agent'));
+                console.log();
+            }
+            else {
+                logger.error(`Failed to start: ${error.message}`);
+            }
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Handle status subcommand
+ */
+function handleStatus(options) {
+    const emitter = new OfficeEventEmitter(createInitialState());
+    const watcher = new SessionFileWatcher({
+        onSessionChange: (session) => {
+            const state = sessionToOfficeState(session);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    ...state,
+                    agents: Object.fromEntries(state.agents),
+                }, null, 2));
+            }
+            else {
+                console.log();
+                console.log(pc.bold(brand.geminiPurple('Agent Office Status')));
+                console.log(ui.line());
+                console.log();
+                console.log(`  ${brand.dim('Active Plan:')}    ${state.activePlan ? brand.primary(state.activePlan) : brand.dim('(none)')}`);
+                console.log(`  ${brand.dim('Agents:')}         ${state.agents.size}`);
+                console.log(`  ${brand.dim('Inbox Items:')}    ${state.inbox.length}`);
+                console.log(`  ${brand.dim('Documents:')}      ${state.documents.length}`);
+                if (state.agents.size > 0) {
+                    console.log();
+                    console.log(brand.dim('  Agents:'));
+                    for (const [id, agent] of state.agents) {
+                        const statusColor = agent.state === 'working' ? brand.warn :
+                            agent.state === 'idle' ? brand.success : brand.dim;
+                        console.log(`    ${agent.icon} ${brand.primary(agent.role)} ${statusColor(`[${agent.state}]`)}`);
+                    }
+                }
+                console.log();
+            }
+            watcher.stop();
+            emitter.dispose();
+        },
+        onEvent: () => { }, // No-op for status
+        onError: (error) => {
+            console.log();
+            logger.error(`Error: ${error.message}`);
+            console.log();
+            process.exit(1);
+        },
+    });
+    const started = watcher.start();
+    if (!started) {
+        console.log();
+        logger.warn('No active session found.');
+        console.log(brand.dim('  Start a GemKit session first with: gk agent'));
+        console.log();
+        process.exit(1);
+    }
+}
+/**
+ * Handle watch subcommand
+ */
+function handleWatch(options) {
+    console.log();
+    logger.info('Watching Agent Office state...');
+    console.log(brand.dim('  Press Ctrl+C to stop'));
+    console.log();
+    const emitter = new OfficeEventEmitter(createInitialState());
+    const watcher = new SessionFileWatcher({
+        onSessionChange: (session) => {
+            const state = sessionToOfficeState(session);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    timestamp: new Date().toISOString(),
+                    ...state,
+                    agents: Object.fromEntries(state.agents),
+                }));
+            }
+            else {
+                const time = new Date().toLocaleTimeString();
+                console.log(`${brand.dim(time)} ${brand.info('State:')} ${state.agents.size} agents, ${state.inbox.length} inbox items`);
+            }
+        },
+        onEvent: (event) => {
+            if (options.json) {
+                console.log(JSON.stringify({ type: 'event', event }));
+            }
+            else {
+                const time = new Date().toLocaleTimeString();
+                console.log(`${brand.dim(time)} ${brand.secondary('Event:')} ${event.type}`);
+            }
+        },
+        onError: (error) => {
+            logger.error(`Error: ${error.message}`);
+        },
+    });
+    const started = watcher.start();
+    if (!started) {
+        console.log();
+        logger.warn('No active session found.');
+        console.log(brand.dim('  Start a GemKit session first with: gk agent'));
+        console.log();
+        process.exit(1);
+    }
+    process.on('SIGINT', () => {
+        watcher.stop();
+        emitter.dispose();
+        console.log();
+        logger.info('Stopped watching.');
+        console.log();
+        process.exit(0);
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// COMMAND REGISTRATION
+// ═══════════════════════════════════════════════════════════════════════════
+export function registerOfficeCommand(cli) {
+    cli
+        .command('office [subcommand]', 'Agent Office visualization (start, status, watch)')
+        .option('-p, --port <port>', '[start] Web server port', { default: 3847 })
+        .option('--no-open', "[start] Don't auto-open browser")
+        .option('--json', '[status/watch] Output as JSON')
+        .action(async (subcommand, options) => {
+        // Parse port as number
+        if (options.port) {
+            options.port = parseInt(String(options.port), 10);
+        }
+        // Handle help for subcommands
+        if (options.help || options.h) {
+            switch (subcommand) {
+                case 'start':
+                    showStartHelp();
+                    return;
+                case 'status':
+                    showStatusHelp();
+                    return;
+                case 'watch':
+                    showWatchHelp();
+                    return;
+                default:
+                    showMainHelp();
+                    return;
+            }
+        }
+        // Route to handlers
+        switch (subcommand) {
+            case 'start':
+                await handleStart(options);
+                break;
+            case 'status':
+                handleStatus(options);
+                break;
+            case 'watch':
+                handleWatch(options);
+                break;
+            case undefined:
+            case 'help':
+                showMainHelp();
+                break;
+            default:
+                console.log();
+                logger.error(`Unknown subcommand: ${subcommand}`);
+                showMainHelp();
+                process.exit(1);
+        }
+    });
+}