gemkit-cli 0.2.3 → 0.3.1

package/dist/commands/doctor/index.js

@@ -0,0 +1,243 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { spawn } from 'child_process';
+import ora from 'ora';
+import { getLocalGeminiDir, getAgentsDir, getExtensionsDir } from '../../utils/paths.js';
+import { loadMetadata } from '../../domains/installation/metadata.js';
+import { brand, pc } from '../../utils/colors.js';
+/**
+ * Check if spawn-agent extension is installed in Gemini CLI
+ * by running: gemini extensions list
+ */
+async function checkSpawnAgentInstalled() {
+    return new Promise((resolve) => {
+        const child = spawn('gemini', ['extensions', 'list'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32'
+        });
+        let stdout = '';
+        let stderr = '';
+        let resolved = false;
+        // Timeout after 20 seconds (gemini CLI can be slow)
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                child.kill();
+                resolve({
+                    installed: false,
+                    error: 'Check timed out'
+                });
+            }
+        }, 20000);
+        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) {
+                    // Check if spawn-agent appears in the output
+                    const isInstalled = stdout.toLowerCase().includes('spawn-agent');
+                    resolve({ installed: isInstalled });
+                }
+                else {
+                    resolve({
+                        installed: false,
+                        error: stderr || 'Failed to check extensions'
+                    });
+                }
+            }
+        });
+        child.on('error', (err) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                resolve({
+                    installed: false,
+                    error: `Gemini CLI not available: ${err.message}`
+                });
+            }
+        });
+    });
+}
+/**
+ * Check if Gemini CLI is available
+ */
+async function checkGeminiCli() {
+    return new Promise((resolve) => {
+        const child = spawn('gemini', ['--version'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32'
+        });
+        let stdout = '';
+        let resolved = false;
+        // Timeout after 15 seconds (gemini CLI can be slow to start)
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                child.kill();
+                resolve({ available: false, error: 'Timed out' });
+            }
+        }, 15000);
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.on('close', (code) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                if (code === 0) {
+                    const version = stdout.trim().split('\n')[0] || 'unknown';
+                    resolve({ available: true, version });
+                }
+                else {
+                    resolve({ available: false, error: 'Command failed' });
+                }
+            }
+        });
+        child.on('error', (err) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                resolve({ available: false, error: err.message });
+            }
+        });
+    });
+}
+export function registerDoctorCommand(cli) {
+    cli
+        .command('doctor', 'Check installation health')
+        .option('--fix', 'Attempt to fix issues')
+        .action(async (options) => {
+        console.log();
+        console.log(pc.bold(brand.geminiPurple('GemKit Health Check')));
+        console.log();
+        let issues = 0;
+        let warnings = 0;
+        // Results storage for display after all checks
+        const results = [];
+        // Check Node.js version (sync - instant)
+        const nodeVersion = process.version;
+        const major = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+        if (major >= 18) {
+            results.push({ icon: brand.success('✓'), message: `Node.js ${nodeVersion}` });
+        }
+        else {
+            results.push({ icon: brand.error('✗'), message: `Node.js ${nodeVersion} ${brand.error('(requires >= 18)')}` });
+            issues++;
+        }
+        // Check Gemini CLI (async - with spinner)
+        const geminiSpinner = ora({
+            text: 'Checking Gemini CLI...',
+            color: 'magenta'
+        }).start();
+        const geminiCheck = await checkGeminiCli();
+        geminiSpinner.stop();
+        if (geminiCheck.available) {
+            results.push({ icon: brand.success('✓'), message: `Gemini CLI ${brand.dim(`(${geminiCheck.version})`)}` });
+        }
+        else {
+            results.push({ icon: brand.error('✗'), message: `Gemini CLI not found ${brand.dim(`(${geminiCheck.error})`)}` });
+            issues++;
+        }
+        // Check .gemini directory (sync)
+        const geminiDir = getLocalGeminiDir();
+        if (existsSync(geminiDir)) {
+            results.push({ icon: brand.success('✓'), message: '.gemini directory exists' });
+        }
+        else {
+            results.push({ icon: brand.error('✗'), message: '.gemini directory missing' });
+            issues++;
+        }
+        // Check agents directory (sync)
+        const agentsDir = getAgentsDir();
+        if (existsSync(agentsDir)) {
+            results.push({ icon: brand.success('✓'), message: 'Agents directory exists' });
+        }
+        else {
+            results.push({ icon: brand.warn('○'), message: 'Agents directory missing' });
+            warnings++;
+        }
+        // Check extensions directory (sync)
+        const extensionsDir = getExtensionsDir();
+        if (existsSync(extensionsDir)) {
+            results.push({ icon: brand.success('✓'), message: 'Extensions directory exists' });
+        }
+        else {
+            results.push({ icon: brand.warn('○'), message: 'Extensions directory missing' });
+            warnings++;
+        }
+        // Check spawn-agent extension directory exists locally (sync)
+        const spawnAgentDir = join(extensionsDir, 'spawn-agent');
+        if (existsSync(spawnAgentDir)) {
+            results.push({ icon: brand.success('✓'), message: 'spawn-agent extension files present' });
+        }
+        else {
+            results.push({ icon: brand.warn('○'), message: 'spawn-agent extension files missing' });
+            warnings++;
+        }
+        // Check spawn-agent extension is installed in Gemini CLI (async - with spinner)
+        if (geminiCheck.available) {
+            const extensionSpinner = ora({
+                text: 'Checking spawn-agent extension...',
+                color: 'magenta'
+            }).start();
+            const spawnAgentCheck = await checkSpawnAgentInstalled();
+            extensionSpinner.stop();
+            if (spawnAgentCheck.installed) {
+                results.push({ icon: brand.success('✓'), message: 'spawn-agent extension installed in Gemini' });
+            }
+            else {
+                results.push({
+                    icon: brand.error('✗'),
+                    message: 'spawn-agent extension NOT installed in Gemini',
+                    hint: spawnAgentCheck.error
+                        ? `${spawnAgentCheck.error}\n    Run: gemini extensions install .gemini/extensions/spawn-agent`
+                        : 'Run: gemini extensions install .gemini/extensions/spawn-agent'
+                });
+                issues++;
+            }
+        }
+        // Check metadata (sync)
+        const metadata = loadMetadata();
+        if (metadata) {
+            results.push({ icon: brand.success('✓'), message: `Installation metadata ${brand.primary(`(v${metadata.version})`)}` });
+        }
+        else {
+            results.push({ icon: brand.warn('○'), message: 'Installation metadata missing' });
+            warnings++;
+        }
+        // Display all results
+        for (const result of results) {
+            console.log(`  ${result.icon} ${result.message}`);
+            if (result.hint) {
+                for (const line of result.hint.split('\n')) {
+                    console.log(`    ${brand.dim(line)}`);
+                }
+            }
+        }
+        // Summary
+        console.log();
+        if (issues === 0 && warnings === 0) {
+            console.log(brand.success('All checks passed!'));
+        }
+        else if (issues === 0) {
+            console.log(brand.success(`All critical checks passed! ${brand.dim(`(${warnings} warning${warnings > 1 ? 's' : ''})`)}`));
+        }
+        else {
+            console.log(brand.error(`${issues} issue(s) found.`));
+            if (warnings > 0) {
+                console.log(brand.warn(`${warnings} warning(s).`));
+            }
+            console.log();
+            console.log('To fix issues:');
+            console.log(`  ${brand.dim('1.')} Run ${brand.primary('gk init')} to install GemKit`);
+            console.log(`  ${brand.dim('2.')} Run ${brand.primary('gemini extensions install .gemini/extensions/spawn-agent')} to install extension`);
+        }
+        console.log();
+    });
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Extension command - Manage GemKit extensions
+ */
+import type { CAC } from 'cac';
+export declare function registerExtensionCommand(cli: CAC): void;

package/dist/commands/extension/index.js

@@ -0,0 +1,52 @@
+/**
+ * Extension command - Manage GemKit extensions
+ */
+import { existsSync, readdirSync } from 'fs';
+import { getExtensionsDir } from '../../utils/paths.js';
+import { logger } from '../../services/logger.js';
+import { brand, pc } from '../../utils/colors.js';
+export function registerExtensionCommand(cli) {
+    const extension = cli.command('extension <subcommand>', 'Extension management').alias('ext');
+    // Subcommands
+    extension.example('gk extension list   # List installed extensions');
+    extension.action(async (subcommand) => {
+        const sub = subcommand || 'list';
+        switch (sub) {
+            case 'list':
+                await handleList();
+                break;
+            default:
+                console.log();
+                logger.error(`Unknown subcommand: ${sub}`);
+                console.log();
+                process.exit(1);
+        }
+    });
+}
+async function handleList() {
+    const extDir = getExtensionsDir();
+    if (!existsSync(extDir)) {
+        console.log();
+        logger.info('No extensions directory found.');
+        console.log();
+        return;
+    }
+    const extensions = readdirSync(extDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+    if (extensions.length === 0) {
+        console.log();
+        logger.info('No extensions installed.');
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(pc.bold(brand.geminiPurple('Installed Extensions')));
+    console.log();
+    for (const e of extensions) {
+        console.log(`  ${brand.success('✓')} ${brand.primary(e)}`);
+    }
+    console.log();
+    console.log(brand.dim(`  Total: ${extensions.length} extensions`));
+    console.log();
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Command registry for GemKit CLI
+ */
+import type { CAC } from 'cac';
+export declare function registerCommands(cli: CAC): void;

package/dist/commands/index.js

@@ -0,0 +1,37 @@
+/**
+ * Command registry for GemKit CLI
+ */
+import { registerInitCommand } from './init/index.js';
+import { registerUpdateCommand } from './update/index.js';
+import { registerVersionsCommand } from './versions/index.js';
+import { registerDoctorCommand } from './doctor/index.js';
+import { registerConfigCommand } from './config/index.js';
+import { registerCacheCommand } from './cache/index.js';
+import { registerNewCommand } from './new/index.js';
+import { registerAgentCommand } from './agent/index.js';
+import { registerSessionCommand } from './session/index.js';
+import { registerPlanCommand } from './plan/index.js';
+import { registerTokensCommand } from './tokens/index.js';
+import { registerExtensionCommand } from './extension/index.js';
+import { registerCatalogCommand } from './catalog/index.js';
+import { registerPasteCommand } from './paste/index.js';
+import { registerConvertCommand } from './convert/index.js';
+import { registerOfficeCommand } from './office/index.js';
+export function registerCommands(cli) {
+    registerInitCommand(cli);
+    registerUpdateCommand(cli);
+    registerVersionsCommand(cli);
+    registerDoctorCommand(cli);
+    registerConfigCommand(cli);
+    registerCacheCommand(cli);
+    registerNewCommand(cli);
+    registerAgentCommand(cli);
+    registerSessionCommand(cli);
+    registerPlanCommand(cli);
+    registerTokensCommand(cli);
+    registerExtensionCommand(cli);
+    registerCatalogCommand(cli);
+    registerPasteCommand(cli);
+    registerConvertCommand(cli);
+    registerOfficeCommand(cli);
+}

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

@@ -0,0 +1,6 @@
+import type { CAC } from 'cac';
+/**
+ * Check if spawn-agent extension is installed in Gemini
+ */
+export declare function isSpawnAgentInstalled(): Promise<boolean>;
+export declare function registerInitCommand(cli: CAC): void;