@rlabs-inc/gemini-mcp 0.6.2 → 0.7.0

package/dist/cli/commands/video.js

@@ -0,0 +1,154 @@
+/**
+ * Video Command
+ *
+ * Generate videos with Gemini's Veo model.
+ * gemini video "a cat playing piano"
+ */
+import { parseArgs } from 'node:util';
+import { initGeminiClient, startVideoGeneration, checkVideoStatus } from '../../gemini-client.js';
+import { setupLogger } from '../../utils/logger.js';
+import { spinner, progress, print, printError, printSuccess, printMuted, printWarning, t, header, box } from '../ui/index.js';
+function showHelp() {
+    const theme = t();
+    print(header('gemini video', 'Generate videos with AI'));
+    print('');
+    print(theme.colors.primary('Usage:'));
+    print(`  gemini video ${theme.colors.muted('"your prompt"')} [options]`);
+    print('');
+    print(theme.colors.primary('Options:'));
+    print(`  ${theme.colors.highlight('--ratio, -r')}    ${theme.colors.muted('Aspect ratio: 16:9, 9:16 (default: 16:9)')}`);
+    print(`  ${theme.colors.highlight('--wait, -w')}     ${theme.colors.muted('Wait for completion (can take several minutes)')}`);
+    print(`  ${theme.colors.highlight('--negative')}     ${theme.colors.muted('Things to avoid (e.g., "text, watermarks")')}`);
+    print(`  ${theme.colors.highlight('--help, -h')}     ${theme.colors.muted('Show this help')}`);
+    print('');
+    print(theme.colors.primary('Examples:'));
+    print(theme.colors.muted('  gemini video "a cat playing piano"'));
+    print(theme.colors.muted('  gemini video "sunset timelapse" --ratio 16:9 --wait'));
+    print(theme.colors.muted('  gemini video "robot dancing" -r 9:16 --negative "text, blur"'));
+    print('');
+    print(theme.colors.warning(`${theme.symbols.warning} Video generation can take 2-5 minutes`));
+}
+export async function videoCommand(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            help: { type: 'boolean', short: 'h', default: false },
+            ratio: { type: 'string', short: 'r', default: '16:9' },
+            wait: { type: 'boolean', short: 'w', default: false },
+            negative: { type: 'string' },
+        },
+        allowPositionals: true,
+    });
+    if (values.help) {
+        showHelp();
+        return;
+    }
+    // Get prompt from positional args
+    const prompt = positionals.join(' ');
+    if (!prompt) {
+        printError('No video prompt provided');
+        printMuted('Usage: gemini video "your prompt"');
+        process.exit(1);
+    }
+    const theme = t();
+    const s = spinner();
+    const ratio = values.ratio;
+    const shouldWait = values.wait;
+    const negativePrompt = values.negative;
+    // Validate ratio
+    if (ratio !== '16:9' && ratio !== '9:16') {
+        printError(`Invalid ratio: ${ratio}`);
+        printMuted('Valid ratios: 16:9, 9:16');
+        process.exit(1);
+    }
+    try {
+        // Suppress logger output for CLI
+        setupLogger('quiet');
+        // Initialize Gemini client
+        s.start('Connecting to Gemini...');
+        await initGeminiClient();
+        // Start video generation
+        s.update('Starting video generation...');
+        const result = await startVideoGeneration(prompt, {
+            aspectRatio: ratio,
+            negativePrompt,
+        });
+        if (!result.operationName) {
+            throw new Error('Failed to start video generation');
+        }
+        s.success('Video generation started!');
+        print('');
+        // Show info
+        const infoLines = [
+            `${theme.colors.primary('Operation:')} ${result.operationName}`,
+            `${theme.colors.primary('Prompt:')} ${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}`,
+            `${theme.colors.primary('Ratio:')} ${ratio}`,
+            negativePrompt ? `${theme.colors.primary('Avoid:')} ${negativePrompt}` : null,
+            `${theme.colors.primary('Status:')} ${theme.colors.warning('Processing')}`,
+        ].filter(Boolean);
+        print(box(infoLines, { title: 'Video Generation' }));
+        print('');
+        if (!shouldWait) {
+            // Not waiting - give instructions
+            print(theme.colors.info(`${theme.symbols.info} Video is being generated in the background.`));
+            print('');
+            print('Check status with the MCP tool: gemini-check-video');
+            print('');
+            print(theme.colors.muted('Video generation typically takes 2-5 minutes.'));
+            return;
+        }
+        // Wait for completion
+        print(theme.colors.info(`${theme.symbols.info} Waiting for video to complete...`));
+        print(theme.colors.muted('This typically takes 2-5 minutes. Press Ctrl+C to exit.'));
+        print('');
+        const p = progress({ total: 100, showEta: false });
+        p.start('Generating video');
+        let attempts = 0;
+        const maxAttempts = 60; // 10 seconds * 60 = 10 minutes max
+        const pollInterval = 10000; // 10 seconds
+        while (attempts < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            attempts++;
+            // Update progress (fake progress)
+            const fakeProgress = Math.min(95, attempts * 3);
+            p.update(fakeProgress, `Generating video (${attempts * 10}s)`);
+            try {
+                const status = await checkVideoStatus(result.operationName);
+                if (status.status === 'completed' && status.filePath) {
+                    p.done('Video complete!');
+                    print('');
+                    // Get file stats
+                    const file = Bun.file(status.filePath);
+                    const fileSize = file.size;
+                    const resultLines = [
+                        `${theme.colors.primary('File:')} ${status.filePath}`,
+                        `${theme.colors.primary('Size:')} ${(fileSize / (1024 * 1024)).toFixed(1)} MB`,
+                    ];
+                    print(box(resultLines, { title: 'Video Ready' }));
+                    print('');
+                    printSuccess(`Video saved to: ${status.filePath}`);
+                    print('');
+                    print(theme.colors.muted(`Open with: open "${status.filePath}"`));
+                    return;
+                }
+                else if (status.status === 'failed') {
+                    p.fail('Video generation failed');
+                    printError(status.error || 'Unknown error');
+                    process.exit(1);
+                }
+                // Still processing, continue
+            }
+            catch (error) {
+                // Polling error - continue trying
+            }
+        }
+        // Timed out
+        p.fail('Video generation timed out');
+        printWarning('Video may still be generating.');
+    }
+    catch (error) {
+        s.error('Video generation failed');
+        printError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * CLI Configuration
+ *
+ * Loads and manages CLI configuration using Bun's native file APIs.
+ * Config file: ~/.config/gemini-cli/config.json
+ */
+export interface CLIConfig {
+    theme: string;
+    outputDir: string;
+    defaultVoice: string;
+    defaultImageSize: '1K' | '2K' | '4K';
+    defaultImageRatio: string;
+    defaultVideoRatio: '16:9' | '9:16';
+    apiKey?: string;
+}
+export declare function getConfigDir(): string;
+export declare function getConfigPath(): string;
+export declare function loadConfig(): Promise<CLIConfig>;
+export declare function saveConfig(config: Partial<CLIConfig>): Promise<void>;
+export declare function getOutputDir(config: CLIConfig): string;
+export declare function getApiKey(config: CLIConfig): string | undefined;
+export declare function getConfig(): CLIConfig;
+export declare function setCachedConfig(config: CLIConfig): void;

package/dist/cli/config.js

@@ -0,0 +1,89 @@
+/**
+ * CLI Configuration
+ *
+ * Loads and manages CLI configuration using Bun's native file APIs.
+ * Config file: ~/.config/gemini-cli/config.json
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { setTheme } from './ui/index.js';
+const DEFAULT_CONFIG = {
+    theme: 'terminal',
+    outputDir: '~/Downloads',
+    defaultVoice: 'Kore',
+    defaultImageSize: '2K',
+    defaultImageRatio: '1:1',
+    defaultVideoRatio: '16:9',
+};
+// Expand ~ to home directory
+function expandPath(path) {
+    if (path.startsWith('~/')) {
+        return join(homedir(), path.slice(2));
+    }
+    return path;
+}
+// Get config directory path
+export function getConfigDir() {
+    return join(homedir(), '.config', 'gemini-cli');
+}
+// Get config file path
+export function getConfigPath() {
+    return join(getConfigDir(), 'config.json');
+}
+// Load configuration using Bun
+export async function loadConfig() {
+    const configPath = getConfigPath();
+    try {
+        const file = Bun.file(configPath);
+        const exists = await file.exists();
+        if (!exists) {
+            // Return defaults if no config file
+            return { ...DEFAULT_CONFIG };
+        }
+        const content = await file.json();
+        const config = { ...DEFAULT_CONFIG, ...content };
+        // Apply theme immediately
+        if (config.theme) {
+            setTheme(config.theme);
+        }
+        return config;
+    }
+    catch {
+        // Return defaults on any error
+        return { ...DEFAULT_CONFIG };
+    }
+}
+// Save configuration using Bun
+export async function saveConfig(config) {
+    const configPath = getConfigPath();
+    const configDir = getConfigDir();
+    // Ensure config directory exists
+    await Bun.write(join(configDir, '.keep'), ''); // Creates dir as side effect
+    // Load existing config and merge
+    const existing = await loadConfig();
+    const merged = { ...existing, ...config };
+    // Write config file
+    await Bun.write(configPath, JSON.stringify(merged, null, 2));
+}
+// Get resolved output directory
+export function getOutputDir(config) {
+    // First check env var, then config
+    const dir = process.env.GEMINI_OUTPUT_DIR || config.outputDir;
+    return expandPath(dir);
+}
+// Get API key from env or config
+export function getApiKey(config) {
+    return process.env.GEMINI_API_KEY || config.apiKey;
+}
+// Sync version for quick access (uses cache after first load)
+let cachedConfig = null;
+export function getConfig() {
+    if (!cachedConfig) {
+        // Return defaults - actual loading should be done with loadConfig()
+        return { ...DEFAULT_CONFIG };
+    }
+    return cachedConfig;
+}
+export function setCachedConfig(config) {
+    cachedConfig = config;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Gemini CLI Router
+ *
+ * Routes commands to their handlers and provides the main CLI interface.
+ */
+export declare function runCli(argv: string[]): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,180 @@
+/**
+ * Gemini CLI Router
+ *
+ * Routes commands to their handlers and provides the main CLI interface.
+ */
+import { loadConfig, setCachedConfig, getApiKey } from './config.js';
+import { setTheme, header, print, printError, printMuted, t } from './ui/index.js';
+// Import commands
+import { queryCommand } from './commands/query.js';
+import { tokensCommand } from './commands/tokens.js';
+import { searchCommand } from './commands/search.js';
+import { researchCommand } from './commands/research.js';
+import { speakCommand } from './commands/speak.js';
+import { configCommand } from './commands/config.js';
+import { imageCommand } from './commands/image.js';
+import { videoCommand } from './commands/video.js';
+const VERSION = '0.7.0';
+// Placeholder command for development
+const placeholderCommand = (name) => ({
+    name,
+    description: `${name} command (coming soon)`,
+    run: async () => {
+        printMuted(`${name} command not yet implemented`);
+    },
+});
+const commands = {
+    query: {
+        name: 'query',
+        description: 'Query Gemini directly',
+        run: queryCommand,
+    },
+    search: {
+        name: 'search',
+        description: 'Real-time web search',
+        run: searchCommand,
+    },
+    tokens: {
+        name: 'tokens',
+        description: 'Count tokens in text or files',
+        run: tokensCommand,
+    },
+    research: {
+        name: 'research',
+        description: 'Deep research agent',
+        run: researchCommand,
+    },
+    image: {
+        name: 'image',
+        description: 'Generate images',
+        run: imageCommand,
+    },
+    speak: {
+        name: 'speak',
+        description: 'Text-to-speech',
+        run: speakCommand,
+    },
+    video: {
+        name: 'video',
+        description: 'Generate videos',
+        run: videoCommand,
+    },
+    music: placeholderCommand('music'),
+    config: {
+        name: 'config',
+        description: 'Set API key and preferences',
+        run: configCommand,
+    },
+};
+function showHelp() {
+    const theme = t();
+    print(header('Gemini CLI', `AI-powered tools at your terminal (v${VERSION})`));
+    print('');
+    print(theme.colors.primary('Usage:'));
+    print(`  gemini ${theme.colors.muted('<command>')} [options]`);
+    print('');
+    print(theme.colors.primary('Commands:'));
+    print(`  ${theme.colors.highlight('query')}     ${theme.colors.muted('Query Gemini directly')}`);
+    print(`  ${theme.colors.highlight('search')}    ${theme.colors.muted('Real-time web search')}`);
+    print(`  ${theme.colors.highlight('tokens')}    ${theme.colors.muted('Count tokens in text/file')}`);
+    print(`  ${theme.colors.highlight('research')}  ${theme.colors.muted('Deep research agent')}`);
+    print(`  ${theme.colors.highlight('image')}     ${theme.colors.muted('Generate images')}`);
+    print(`  ${theme.colors.highlight('speak')}     ${theme.colors.muted('Text-to-speech')}`);
+    print(`  ${theme.colors.highlight('video')}     ${theme.colors.muted('Generate videos')}`);
+    print(`  ${theme.colors.highlight('music')}     ${theme.colors.muted('Generate music')}`);
+    print(`  ${theme.colors.highlight('config')}    ${theme.colors.muted('Set API key and preferences')}`);
+    print('');
+    print(theme.colors.primary('Options:'));
+    print(`  ${theme.colors.highlight('-h, --help')}     ${theme.colors.muted('Show this help')}`);
+    print(`  ${theme.colors.highlight('-v, --version')}  ${theme.colors.muted('Show version')}`);
+    print(`  ${theme.colors.highlight('--theme')}        ${theme.colors.muted('Set color theme (terminal, neon, minimal, ocean, forest)')}`);
+    print('');
+    print(theme.colors.primary('Examples:'));
+    print(theme.colors.muted('  gemini query "What is the meaning of life?"'));
+    print(theme.colors.muted('  gemini search "latest AI news"'));
+    print(theme.colors.muted('  gemini image "a cat in space" --size 4K'));
+    print(theme.colors.muted('  gemini research "MCP ecosystem" --format outline'));
+    print('');
+    print(theme.colors.muted(`Run 'gemini <command> --help' for command-specific options.`));
+}
+function showVersion() {
+    const theme = t();
+    print(`${theme.colors.primary('gemini')} ${theme.colors.highlight(`v${VERSION}`)}`);
+}
+export async function runCli(argv) {
+    // Load config first
+    const config = await loadConfig();
+    setCachedConfig(config);
+    // Extract global flags and find command
+    // Global flags: --theme <value>, --help/-h, --version/-v
+    let themeName = config.theme;
+    let showHelpFlag = false;
+    let showVersionFlag = false;
+    let commandName = null;
+    let commandStartIndex = 0;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--theme' && argv[i + 1]) {
+            themeName = argv[i + 1];
+            i++; // Skip the theme value
+        }
+        else if (arg === '--help' || arg === '-h') {
+            showHelpFlag = true;
+        }
+        else if (arg === '--version' || arg === '-v') {
+            showVersionFlag = true;
+        }
+        else if (!arg.startsWith('-')) {
+            // Found a command
+            commandName = arg;
+            commandStartIndex = i + 1;
+            break;
+        }
+    }
+    // Apply theme
+    setTheme(themeName);
+    // Handle version flag
+    if (showVersionFlag) {
+        showVersion();
+        return;
+    }
+    // Handle help flag or no command
+    if (showHelpFlag || !commandName) {
+        showHelp();
+        return;
+    }
+    // Get command handler
+    const command = commands[commandName];
+    if (!command) {
+        printError(`Unknown command: ${commandName}`);
+        printMuted(`Run 'gemini --help' for available commands`);
+        process.exit(1);
+    }
+    // Get command arguments (everything after the command)
+    const commandArgs = argv.slice(commandStartIndex);
+    // Check if command has --help flag (don't require API key for help)
+    const isCommandHelp = commandArgs.includes('--help') || commandArgs.includes('-h');
+    // Commands that don't need API key
+    const noApiKeyCommands = ['config'];
+    // Check for API key (only needed for actual commands, not help or config)
+    if (!isCommandHelp && !noApiKeyCommands.includes(commandName)) {
+        const apiKey = getApiKey(config);
+        if (!apiKey) {
+            printError('GEMINI_API_KEY environment variable is required');
+            printMuted('Set it with: gemini config set api-key YOUR_KEY');
+            process.exit(1);
+        }
+        // Set env var from config for gemini-client.ts to use
+        if (!process.env.GEMINI_API_KEY && apiKey) {
+            process.env.GEMINI_API_KEY = apiKey;
+        }
+    }
+    // Run command with remaining args
+    try {
+        await command.run(commandArgs);
+    }
+    catch (error) {
+        printError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/cli/ui/box.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Box Component for CLI
+ *
+ * Creates beautiful bordered boxes for headers, results, and highlights.
+ */
+export interface BoxOptions {
+    title?: string;
+    padding?: number;
+    margin?: number;
+    borderColor?: (text: string) => string;
+    titleColor?: (text: string) => string;
+    width?: number | 'auto';
+    align?: 'left' | 'center' | 'right';
+}
+export declare function box(content: string | string[], options?: BoxOptions): string;
+export declare function header(title: string, subtitle?: string): string;
+export declare function success(message: string): string;
+export declare function error(message: string): string;
+export declare function warning(message: string): string;
+export declare function info(message: string): string;

package/dist/cli/ui/box.js

@@ -0,0 +1,112 @@
+/**
+ * Box Component for CLI
+ *
+ * Creates beautiful bordered boxes for headers, results, and highlights.
+ */
+import { getTheme } from './theme.js';
+// Get terminal width safely
+function getTerminalWidth() {
+    return process.stdout.columns ?? 80;
+}
+// Strip ANSI codes for length calculation
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+// Pad string to width
+function pad(str, width, align = 'left') {
+    const visibleLength = stripAnsi(str).length;
+    const padding = width - visibleLength;
+    if (padding <= 0)
+        return str;
+    switch (align) {
+        case 'center': {
+            const left = Math.floor(padding / 2);
+            const right = padding - left;
+            return ' '.repeat(left) + str + ' '.repeat(right);
+        }
+        case 'right':
+            return ' '.repeat(padding) + str;
+        default:
+            return str + ' '.repeat(padding);
+    }
+}
+export function box(content, options = {}) {
+    const theme = getTheme();
+    const { title, padding = 1, margin = 0, borderColor = theme.colors.primary, titleColor = theme.colors.highlight, width = 'auto', align = 'left', } = options;
+    const { topLeft, topRight, bottomLeft, bottomRight, horizontal, vertical } = theme.box;
+    // Normalize content to array of lines
+    const lines = Array.isArray(content) ? content : content.split('\n');
+    // Calculate widths
+    const termWidth = getTerminalWidth();
+    const maxLineWidth = Math.max(...lines.map(l => stripAnsi(l).length));
+    const titleWidth = title ? stripAnsi(title).length + 2 : 0; // +2 for spaces around title
+    let innerWidth;
+    if (width === 'auto') {
+        innerWidth = Math.max(maxLineWidth, titleWidth) + padding * 2;
+    }
+    else {
+        innerWidth = Math.min(width, termWidth - 4) - 2; // -2 for borders
+    }
+    const marginStr = ' '.repeat(margin);
+    const paddingStr = ' '.repeat(padding);
+    // Build the box
+    const result = [];
+    // Top border with optional title
+    if (title) {
+        const titleStr = ` ${titleColor(title)} `;
+        const leftBorder = horizontal.repeat(2);
+        const rightBorderLen = innerWidth - 4 - stripAnsi(title).length;
+        const rightBorder = horizontal.repeat(Math.max(0, rightBorderLen));
+        result.push(marginStr + borderColor(topLeft + leftBorder) + titleStr + borderColor(rightBorder + topRight));
+    }
+    else {
+        result.push(marginStr + borderColor(topLeft + horizontal.repeat(innerWidth) + topRight));
+    }
+    // Content lines with padding
+    for (const line of lines) {
+        const paddedLine = pad(line, innerWidth - padding * 2, align);
+        result.push(marginStr + borderColor(vertical) + paddingStr + paddedLine + paddingStr + borderColor(vertical));
+    }
+    // Bottom border
+    result.push(marginStr + borderColor(bottomLeft + horizontal.repeat(innerWidth) + bottomRight));
+    return result.join('\n');
+}
+// Quick box variants
+export function header(title, subtitle) {
+    const theme = getTheme();
+    const content = subtitle ? [title, theme.colors.muted(subtitle)] : [title];
+    return box(content, {
+        borderColor: theme.colors.primary,
+        titleColor: theme.colors.highlight,
+        align: 'center',
+        padding: 2,
+    });
+}
+export function success(message) {
+    const theme = getTheme();
+    return box(`${theme.symbols.success} ${message}`, {
+        borderColor: theme.colors.success,
+        padding: 1,
+    });
+}
+export function error(message) {
+    const theme = getTheme();
+    return box(`${theme.symbols.error} ${message}`, {
+        borderColor: theme.colors.error,
+        padding: 1,
+    });
+}
+export function warning(message) {
+    const theme = getTheme();
+    return box(`${theme.symbols.warning} ${message}`, {
+        borderColor: theme.colors.warning,
+        padding: 1,
+    });
+}
+export function info(message) {
+    const theme = getTheme();
+    return box(`${theme.symbols.info} ${message}`, {
+        borderColor: theme.colors.info,
+        padding: 1,
+    });
+}

package/dist/cli/ui/colors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Terminal Color Utilities
+ *
+ * Uses ANSI escape codes directly for zero dependencies.
+ * Respects NO_COLOR and FORCE_COLOR environment variables.
+ * Bun handles these natively in TTY detection.
+ */
+export declare const black: (text: string) => string;
+export declare const red: (text: string) => string;
+export declare const green: (text: string) => string;
+export declare const yellow: (text: string) => string;
+export declare const blue: (text: string) => string;
+export declare const magenta: (text: string) => string;
+export declare const cyan: (text: string) => string;
+export declare const white: (text: string) => string;
+export declare const brightBlack: (text: string) => string;
+export declare const brightRed: (text: string) => string;
+export declare const brightGreen: (text: string) => string;
+export declare const brightYellow: (text: string) => string;
+export declare const brightBlue: (text: string) => string;
+export declare const brightMagenta: (text: string) => string;
+export declare const brightCyan: (text: string) => string;
+export declare const brightWhite: (text: string) => string;
+export declare const bgBlack: (text: string) => string;
+export declare const bgRed: (text: string) => string;
+export declare const bgGreen: (text: string) => string;
+export declare const bgYellow: (text: string) => string;
+export declare const bgBlue: (text: string) => string;
+export declare const bgMagenta: (text: string) => string;
+export declare const bgCyan: (text: string) => string;
+export declare const bgWhite: (text: string) => string;
+export declare const bold: (text: string) => string;
+export declare const dim: (text: string) => string;
+export declare const italic: (text: string) => string;
+export declare const underline: (text: string) => string;
+export declare const inverse: (text: string) => string;
+export declare const strikethrough: (text: string) => string;
+export declare function rgb(r: number, g: number, b: number): (text: string) => string;
+export declare function bgRgb(r: number, g: number, b: number): (text: string) => string;
+export declare function color256(code: number): (text: string) => string;
+export declare function hex(hexColor: string): (text: string) => string;
+export declare const colors: {
+    enabled: boolean;
+    reset: string;
+};
+export declare function style(...styles: Array<(text: string) => string>): (text: string) => string;