@rlabs-inc/gemini-mcp 0.6.3 → 0.7.1

package/dist/cli/commands/research.js

@@ -0,0 +1,147 @@
+/**
+ * Research Command
+ *
+ * Deep research agent for comprehensive investigation.
+ * gemini research "your research question"
+ */
+import { parseArgs } from 'node:util';
+import { initGeminiClient, startDeepResearch, checkDeepResearch } 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 research', 'Deep research agent'));
+    print('');
+    print(theme.colors.primary('Usage:'));
+    print(`  gemini research ${theme.colors.muted('"your research question"')}`);
+    print('');
+    print(theme.colors.primary('Options:'));
+    print(`  ${theme.colors.highlight('--format, -f')}  ${theme.colors.muted('Output format: report, outline, brief (default: report)')}`);
+    print(`  ${theme.colors.highlight('--wait, -w')}    ${theme.colors.muted('Wait for completion (can take 5-60 mins)')}`);
+    print(`  ${theme.colors.highlight('--help, -h')}    ${theme.colors.muted('Show this help')}`);
+    print('');
+    print(theme.colors.primary('Examples:'));
+    print(theme.colors.muted('  gemini research "MCP ecosystem and best practices"'));
+    print(theme.colors.muted('  gemini research "AI coding assistants comparison" --format outline'));
+    print(theme.colors.muted('  gemini research "Bun vs Node.js performance" --wait'));
+    print('');
+    print(theme.colors.warning(`${theme.symbols.warning} Deep research typically takes 5-20 minutes (max 60 min)`));
+}
+export async function researchCommand(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            help: { type: 'boolean', short: 'h', default: false },
+            format: { type: 'string', short: 'f', default: 'report' },
+            wait: { type: 'boolean', short: 'w', default: false },
+        },
+        allowPositionals: true,
+    });
+    if (values.help) {
+        showHelp();
+        return;
+    }
+    // Get query from positional args
+    const query = positionals.join(' ');
+    if (!query) {
+        printError('No research question provided');
+        printMuted('Usage: gemini research "your question"');
+        process.exit(1);
+    }
+    const theme = t();
+    const s = spinner();
+    const format = values.format;
+    const shouldWait = values.wait;
+    try {
+        // Suppress logger output for CLI
+        setupLogger('quiet');
+        // Initialize Gemini client
+        s.start('Connecting to Gemini...');
+        await initGeminiClient();
+        // Build the research prompt with format
+        let researchPrompt = query;
+        if (format && format !== 'report') {
+            researchPrompt = `${query}\n\nFormat the output as: ${format}`;
+        }
+        // Start the research
+        s.update('Starting deep research agent...');
+        const result = await startDeepResearch(researchPrompt);
+        s.success('Research started!');
+        print('');
+        // Show research info
+        const infoLines = [
+            `${theme.colors.primary('Research ID:')} ${result.id}`,
+            `${theme.colors.primary('Query:')} ${query.substring(0, 60)}${query.length > 60 ? '...' : ''}`,
+            `${theme.colors.primary('Format:')} ${format}`,
+            `${theme.colors.primary('Status:')} ${theme.colors.warning('In Progress')}`,
+        ];
+        print(box(infoLines, { title: 'Deep Research' }));
+        print('');
+        if (!shouldWait) {
+            // Not waiting - give instructions
+            print(theme.colors.info(`${theme.symbols.info} Research is running in the background.`));
+            print('');
+            print('To check status:');
+            print(theme.colors.muted(`  gemini research-status ${result.id}`));
+            print('');
+            print(theme.colors.muted('Research typically takes 5-20 minutes (max 60 min).'));
+            print(theme.colors.muted('Results will be saved to your configured output directory.'));
+            return;
+        }
+        // Wait for completion
+        print(theme.colors.info(`${theme.symbols.info} Waiting for research to complete...`));
+        print(theme.colors.muted('This may take 5-60 minutes. Press Ctrl+C to exit (research continues in background).'));
+        print('');
+        const p = progress({ total: 100, showEta: false });
+        p.start('Researching');
+        let lastStatus = 'pending';
+        let attempts = 0;
+        const maxAttempts = 180; // 30 seconds * 180 = 90 minutes max
+        const pollInterval = 30000; // 30 seconds
+        while (attempts < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            attempts++;
+            // Update progress (fake progress since we don't know actual %)
+            const fakeProgress = Math.min(95, attempts * 2);
+            p.update(fakeProgress, `Researching (${Math.floor(attempts * 0.5)}m)`);
+            try {
+                const status = await checkDeepResearch(result.id);
+                if (status.status === 'completed') {
+                    p.done('Research complete!');
+                    print('');
+                    // Show the results
+                    if (status.outputs && status.outputs.length > 0) {
+                        const resultText = status.outputs[status.outputs.length - 1].text || 'No text output';
+                        print(theme.colors.primary('Research Results:'));
+                        print('');
+                        print(resultText);
+                    }
+                    if (status.savedPath) {
+                        print('');
+                        printSuccess(`Full response saved to: ${status.savedPath}`);
+                    }
+                    return;
+                }
+                else if (status.status === 'failed') {
+                    p.fail('Research failed');
+                    printError(status.error || 'Unknown error');
+                    process.exit(1);
+                }
+                lastStatus = status.status;
+            }
+            catch (error) {
+                // Polling error - continue trying
+                console.error('Polling error:', error);
+            }
+        }
+        // Timed out
+        p.fail('Research timed out');
+        printWarning('Research is still running. Check status later:');
+        print(theme.colors.muted(`  gemini research-status ${result.id}`));
+    }
+    catch (error) {
+        s.error('Research failed');
+        printError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/cli/commands/search.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Search Command
+ *
+ * Real-time web search powered by Gemini + Google Search.
+ * gemini search "your query"
+ */
+export declare function searchCommand(argv: string[]): Promise<void>;

package/dist/cli/commands/search.js

@@ -0,0 +1,152 @@
+/**
+ * Search Command
+ *
+ * Real-time web search powered by Gemini + Google Search.
+ * gemini search "your query"
+ */
+import { parseArgs } from 'node:util';
+import { GoogleGenAI } from '@google/genai';
+import { setupLogger } from '../../utils/logger.js';
+import { spinner, print, printError, printMuted, t, header } from '../ui/index.js';
+function showHelp() {
+    const theme = t();
+    print(header('gemini search', 'Real-time web search'));
+    print('');
+    print(theme.colors.primary('Usage:'));
+    print(`  gemini search ${theme.colors.muted('"your query"')}`);
+    print('');
+    print(theme.colors.primary('Options:'));
+    print(`  ${theme.colors.highlight('--no-citations')}  ${theme.colors.muted('Hide inline citations')}`);
+    print(`  ${theme.colors.highlight('--help, -h')}      ${theme.colors.muted('Show this help')}`);
+    print('');
+    print(theme.colors.primary('Examples:'));
+    print(theme.colors.muted('  gemini search "latest news about AI"'));
+    print(theme.colors.muted('  gemini search "weather in São Paulo"'));
+    print(theme.colors.muted('  gemini search "MCP Model Context Protocol"'));
+}
+/**
+ * Add inline citations to text based on grounding metadata
+ */
+function addCitations(text, supports, chunks) {
+    if (!supports || !chunks || supports.length === 0) {
+        return text;
+    }
+    // Sort supports by endIndex in descending order to avoid shifting issues
+    const sortedSupports = [...supports].sort((a, b) => (b.segment?.endIndex ?? 0) - (a.segment?.endIndex ?? 0));
+    let result = text;
+    for (const support of sortedSupports) {
+        const endIndex = support.segment?.endIndex;
+        if (endIndex === undefined || !support.groundingChunkIndices?.length) {
+            continue;
+        }
+        const citationLinks = support.groundingChunkIndices
+            .map((i) => {
+            const uri = chunks[i]?.web?.uri;
+            const title = chunks[i]?.web?.title;
+            if (uri) {
+                return `[${title || i + 1}](${uri})`;
+            }
+            return null;
+        })
+            .filter(Boolean);
+        if (citationLinks.length > 0) {
+            const citationString = ' ' + citationLinks.join(', ');
+            result = result.slice(0, endIndex) + citationString + result.slice(endIndex);
+        }
+    }
+    return result;
+}
+export async function searchCommand(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            help: { type: 'boolean', short: 'h', default: false },
+            'no-citations': { type: 'boolean', default: false },
+        },
+        allowPositionals: true,
+    });
+    if (values.help) {
+        showHelp();
+        return;
+    }
+    // Get query from positional args
+    const query = positionals.join(' ');
+    if (!query) {
+        printError('No search query provided');
+        printMuted('Usage: gemini search "your query"');
+        process.exit(1);
+    }
+    const theme = t();
+    const s = spinner();
+    const returnCitations = !values['no-citations'];
+    try {
+        // Suppress logger output for CLI
+        setupLogger('quiet');
+        const apiKey = process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            throw new Error('GEMINI_API_KEY not set');
+        }
+        s.start('Searching the web...');
+        const genAI = new GoogleGenAI({ apiKey });
+        const model = process.env.GEMINI_PRO_MODEL || 'gemini-3-pro-preview';
+        // Execute with Google Search tool enabled
+        const response = await genAI.models.generateContent({
+            model,
+            contents: query,
+            config: {
+                tools: [{ googleSearch: {} }],
+            },
+        });
+        const candidate = response.candidates?.[0];
+        if (!candidate) {
+            throw new Error('No response from search');
+        }
+        let responseText = response.text || '';
+        const groundingMetadata = candidate.groundingMetadata;
+        // Build response with citations if requested
+        const sources = [];
+        if (returnCitations && groundingMetadata) {
+            const supports = groundingMetadata.groundingSupports || [];
+            const chunks = groundingMetadata.groundingChunks || [];
+            if (supports.length > 0 && chunks.length > 0) {
+                responseText = addCitations(responseText, supports, chunks);
+            }
+            // Collect unique sources
+            const seenUrls = new Set();
+            for (const chunk of chunks) {
+                if (chunk.web?.uri && !seenUrls.has(chunk.web.uri)) {
+                    seenUrls.add(chunk.web.uri);
+                    sources.push({
+                        title: chunk.web.title || 'Source',
+                        url: chunk.web.uri,
+                    });
+                }
+            }
+        }
+        s.success('Search complete');
+        print('');
+        // Display the response
+        print(responseText);
+        print('');
+        // Display sources if available
+        if (sources.length > 0) {
+            print(theme.colors.muted('─'.repeat(40)));
+            print(theme.colors.primary('Sources:'));
+            for (const source of sources) {
+                print(`  ${theme.symbols.bullet} ${theme.colors.info(source.title)}`);
+                print(`    ${theme.colors.muted(source.url)}`);
+            }
+        }
+        // Show search queries used
+        if (groundingMetadata?.webSearchQueries?.length) {
+            print('');
+            print(theme.colors.muted(`Searches: ${groundingMetadata.webSearchQueries.join(', ')}`));
+        }
+        print('');
+    }
+    catch (error) {
+        s.error('Search failed');
+        printError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/cli/commands/speak.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Speak Command
+ *
+ * Text-to-speech with multiple voices.
+ * gemini speak "your text" --voice Kore
+ */
+export declare function speakCommand(argv: string[]): Promise<void>;

package/dist/cli/commands/speak.js

@@ -0,0 +1,168 @@
+/**
+ * Speak Command
+ *
+ * Text-to-speech with multiple voices.
+ * gemini speak "your text" --voice Kore
+ */
+import { parseArgs } from 'node:util';
+import { GoogleGenAI, Modality } from '@google/genai';
+import { setupLogger } from '../../utils/logger.js';
+import { getOutputDir } from '../../gemini-client.js';
+import { spinner, print, printError, printSuccess, printMuted, t, header, box } from '../ui/index.js';
+import { join } from 'node:path';
+// Available voices
+const VOICES = [
+    'Zephyr', 'Puck', 'Charon', 'Kore', 'Fenrir', 'Leda', 'Orus', 'Aoede',
+    'Callirrhoe', 'Autonoe', 'Enceladus', 'Iapetus', 'Umbriel', 'Algieba',
+    'Despina', 'Erinome', 'Algenib', 'Rasalgethi', 'Laomedeia', 'Achernar',
+    'Alnilam', 'Schedar', 'Gacrux', 'Pulcherrima', 'Achird', 'Zubenelgenubi',
+    'Vindemiatrix', 'Sadachbia', 'Sadaltager', 'Sulafat'
+];
+function showHelp() {
+    const theme = t();
+    print(header('gemini speak', 'Text-to-speech'));
+    print('');
+    print(theme.colors.primary('Usage:'));
+    print(`  gemini speak ${theme.colors.muted('"your text"')} [options]`);
+    print('');
+    print(theme.colors.primary('Options:'));
+    print(`  ${theme.colors.highlight('--voice, -v')}    ${theme.colors.muted('Voice to use (default: Kore)')}`);
+    print(`  ${theme.colors.highlight('--output, -o')}   ${theme.colors.muted('Output file path')}`);
+    print(`  ${theme.colors.highlight('--style, -s')}    ${theme.colors.muted('Speaking style (e.g., "cheerfully", "sadly")')}`);
+    print(`  ${theme.colors.highlight('--list-voices')} ${theme.colors.muted('List all available voices')}`);
+    print(`  ${theme.colors.highlight('--help, -h')}     ${theme.colors.muted('Show this help')}`);
+    print('');
+    print(theme.colors.primary('Popular Voices:'));
+    print(theme.colors.muted('  Kore     - Firm, authoritative'));
+    print(theme.colors.muted('  Puck     - Upbeat, energetic'));
+    print(theme.colors.muted('  Zephyr   - Bright, clear'));
+    print(theme.colors.muted('  Charon   - Informative, calm'));
+    print(theme.colors.muted('  Aoede    - Breezy, light'));
+    print('');
+    print(theme.colors.primary('Examples:'));
+    print(theme.colors.muted('  gemini speak "Hello world!" --voice Puck'));
+    print(theme.colors.muted('  gemini speak "Important message" -v Kore -o message.mp3'));
+    print(theme.colors.muted('  gemini speak "Exciting news!" --style "enthusiastically"'));
+    print(theme.colors.muted('  gemini speak --list-voices'));
+}
+function listVoices() {
+    const theme = t();
+    print(header('Available Voices', '30 TTS voices'));
+    print('');
+    // Group voices into columns
+    const cols = 5;
+    const rows = Math.ceil(VOICES.length / cols);
+    for (let row = 0; row < rows; row++) {
+        let line = '  ';
+        for (let col = 0; col < cols; col++) {
+            const idx = row + col * rows;
+            if (idx < VOICES.length) {
+                const voice = VOICES[idx];
+                line += voice.padEnd(16);
+            }
+        }
+        print(theme.colors.muted(line));
+    }
+    print('');
+}
+export async function speakCommand(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            help: { type: 'boolean', short: 'h', default: false },
+            voice: { type: 'string', short: 'v', default: 'Kore' },
+            output: { type: 'string', short: 'o' },
+            style: { type: 'string', short: 's' },
+            'list-voices': { type: 'boolean', default: false },
+        },
+        allowPositionals: true,
+    });
+    if (values.help) {
+        showHelp();
+        return;
+    }
+    if (values['list-voices']) {
+        listVoices();
+        return;
+    }
+    // Get text from positional args
+    const text = positionals.join(' ');
+    if (!text) {
+        printError('No text provided');
+        printMuted('Usage: gemini speak "your text"');
+        process.exit(1);
+    }
+    const theme = t();
+    const s = spinner();
+    const voice = values.voice;
+    const style = values.style;
+    // Validate voice
+    if (!VOICES.includes(voice)) {
+        printError(`Unknown voice: ${voice}`);
+        printMuted(`Run 'gemini speak --list-voices' to see available voices`);
+        process.exit(1);
+    }
+    try {
+        // Suppress logger output for CLI
+        setupLogger('quiet');
+        const apiKey = process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            throw new Error('GEMINI_API_KEY not set');
+        }
+        s.start(`Generating speech with ${voice}...`);
+        const genAI = new GoogleGenAI({ apiKey });
+        // Build prompt with optional style
+        let prompt = text;
+        if (style) {
+            prompt = `Say this ${style}: "${text}"`;
+        }
+        // Generate speech
+        const response = await genAI.models.generateContent({
+            model: 'gemini-2.5-flash-preview-tts',
+            contents: prompt,
+            config: {
+                responseModalities: [Modality.AUDIO],
+                speechConfig: {
+                    voiceConfig: {
+                        prebuiltVoiceConfig: {
+                            voiceName: voice,
+                        },
+                    },
+                },
+            },
+        });
+        // Extract audio data
+        const candidate = response.candidates?.[0];
+        if (!candidate?.content?.parts?.[0]) {
+            throw new Error('No audio generated');
+        }
+        const part = candidate.content.parts[0];
+        if (!('inlineData' in part) || !part.inlineData?.data) {
+            throw new Error('No audio data in response');
+        }
+        // Determine output path
+        const outputPath = values.output ||
+            join(getOutputDir(), `speech-${Date.now()}.mp3`);
+        // Save audio file
+        const audioBuffer = Buffer.from(part.inlineData.data, 'base64');
+        await Bun.write(outputPath, audioBuffer);
+        s.success('Speech generated!');
+        print('');
+        // Show info
+        const infoLines = [
+            `${theme.colors.primary('Voice:')} ${voice}`,
+            `${theme.colors.primary('Text:')} ${text.substring(0, 50)}${text.length > 50 ? '...' : ''}`,
+            style ? `${theme.colors.primary('Style:')} ${style}` : null,
+            `${theme.colors.primary('File:')} ${outputPath}`,
+            `${theme.colors.primary('Size:')} ${(audioBuffer.length / 1024).toFixed(1)} KB`,
+        ].filter(Boolean);
+        print(box(infoLines, { title: 'Text-to-Speech' }));
+        print('');
+        printSuccess(`Audio saved to: ${outputPath}`);
+    }
+    catch (error) {
+        s.error('Speech generation failed');
+        printError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/cli/commands/tokens.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tokens Command
+ *
+ * Count tokens in text or files.
+ * gemini tokens "your text"
+ * gemini tokens @file.txt
+ */
+export declare function tokensCommand(argv: string[]): Promise<void>;

package/dist/cli/commands/tokens.js

@@ -0,0 +1,105 @@
+/**
+ * Tokens Command
+ *
+ * Count tokens in text or files.
+ * gemini tokens "your text"
+ * gemini tokens @file.txt
+ */
+import { parseArgs } from 'node:util';
+import { initGeminiClient, countTokens } from '../../gemini-client.js';
+import { setupLogger } from '../../utils/logger.js';
+import { spinner, print, printError, printMuted, t, header, box } from '../ui/index.js';
+function showHelp() {
+    const theme = t();
+    print(header('gemini tokens', 'Count tokens in text or files'));
+    print('');
+    print(theme.colors.primary('Usage:'));
+    print(`  gemini tokens ${theme.colors.muted('"your text"')}`);
+    print(`  gemini tokens ${theme.colors.muted('@file.txt')}`);
+    print('');
+    print(theme.colors.primary('Options:'));
+    print(`  ${theme.colors.highlight('--model, -m')}  ${theme.colors.muted('Model for tokenization: pro, flash (default: flash)')}`);
+    print(`  ${theme.colors.highlight('--help, -h')}   ${theme.colors.muted('Show this help')}`);
+    print('');
+    print(theme.colors.primary('Examples:'));
+    print(theme.colors.muted('  gemini tokens "Hello, world!"'));
+    print(theme.colors.muted('  gemini tokens @README.md'));
+    print(theme.colors.muted('  gemini tokens @src/index.ts --model pro'));
+}
+export async function tokensCommand(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            help: { type: 'boolean', short: 'h', default: false },
+            model: { type: 'string', short: 'm', default: 'flash' },
+        },
+        allowPositionals: true,
+    });
+    if (values.help) {
+        showHelp();
+        return;
+    }
+    // Get input from positional args
+    const input = positionals.join(' ');
+    if (!input) {
+        printError('No text or file provided');
+        printMuted('Usage: gemini tokens "your text" or gemini tokens @file.txt');
+        process.exit(1);
+    }
+    const theme = t();
+    const s = spinner();
+    try {
+        // Suppress logger output for CLI
+        setupLogger('quiet');
+        // Check if input is a file reference
+        let text;
+        let source;
+        if (input.startsWith('@')) {
+            const filePath = input.slice(1);
+            s.start(`Reading ${filePath}...`);
+            const file = Bun.file(filePath);
+            const exists = await file.exists();
+            if (!exists) {
+                s.error(`File not found: ${filePath}`);
+                process.exit(1);
+            }
+            text = await file.text();
+            source = filePath;
+        }
+        else {
+            text = input;
+            source = 'text input';
+        }
+        // Initialize Gemini client
+        s.update('Connecting to Gemini...');
+        await initGeminiClient();
+        // Count tokens
+        s.update('Counting tokens...');
+        const model = values.model;
+        const result = await countTokens(text, model);
+        s.success('Token count complete');
+        print('');
+        // Display results in a nice box
+        const lines = [
+            `${theme.colors.primary('Source:')} ${source}`,
+            `${theme.colors.primary('Model:')} ${model}`,
+            `${theme.colors.primary('Tokens:')} ${theme.colors.highlight(result.totalTokens.toLocaleString())}`,
+        ];
+        // Add character count for context
+        lines.push(`${theme.colors.muted('Characters:')} ${text.length.toLocaleString()}`);
+        // Estimate cost (rough estimates based on typical pricing)
+        // Input: ~$0.075 per 1M tokens for Flash, ~$1.25 per 1M tokens for Pro
+        const costPer1M = model === 'flash' ? 0.075 : 1.25;
+        const estimatedCost = (result.totalTokens / 1_000_000) * costPer1M;
+        if (estimatedCost > 0.0001) {
+            lines.push(`${theme.colors.muted('Est. cost:')} $${estimatedCost.toFixed(6)}`);
+        }
+        print(box(lines, { title: 'Token Count' }));
+        print('');
+    }
+    catch (error) {
+        s.error('Token count failed');
+        printError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/cli/commands/video.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Video Command
+ *
+ * Generate videos with Gemini's Veo model.
+ * gemini video "a cat playing piano"
+ */
+export declare function videoCommand(argv: string[]): Promise<void>;