@rlabs-inc/gemini-mcp 0.6.2 → 0.7.0

package/dist/cli/ui/theme.js

@@ -0,0 +1,200 @@
+/**
+ * Theme System for Gemini CLI
+ *
+ * Provides beautiful, consistent styling across all CLI output.
+ * Default theme adapts to terminal colors.
+ */
+import { cyan, magenta, green, red, yellow, blue, brightBlack, white, brightCyan, hex, dim, bold, } from './colors.js';
+// Terminal theme - adapts to user's terminal colors
+export const terminalTheme = {
+    name: 'terminal',
+    colors: {
+        primary: cyan,
+        secondary: magenta,
+        success: green,
+        error: red,
+        warning: yellow,
+        info: blue,
+        muted: brightBlack,
+        text: white,
+        highlight: brightCyan,
+    },
+    symbols: {
+        success: '✓',
+        error: '✗',
+        warning: '⚠',
+        info: 'ℹ',
+        spinner: ['◐', '◓', '◑', '◒'],
+        arrow: '→',
+        bullet: '•',
+        pointer: '❯',
+        star: '★',
+    },
+    box: {
+        topLeft: '┌',
+        topRight: '┐',
+        bottomLeft: '└',
+        bottomRight: '┘',
+        horizontal: '─',
+        vertical: '│',
+    },
+};
+// Neon theme - cyberpunk vibes
+export const neonTheme = {
+    name: 'neon',
+    colors: {
+        primary: hex('#ff00ff'), // Hot pink
+        secondary: hex('#00ffff'), // Cyan
+        success: hex('#39ff14'), // Neon green
+        error: hex('#ff3131'), // Neon red
+        warning: hex('#ffff00'), // Neon yellow
+        info: hex('#00bfff'), // Deep sky blue
+        muted: hex('#666666'),
+        text: hex('#ffffff'),
+        highlight: hex('#ff6ec7'), // Pink
+    },
+    symbols: {
+        success: '◆',
+        error: '◆',
+        warning: '◆',
+        info: '◆',
+        spinner: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+        arrow: '▸',
+        bullet: '▪',
+        pointer: '▶',
+        star: '✦',
+    },
+    box: {
+        topLeft: '╔',
+        topRight: '╗',
+        bottomLeft: '╚',
+        bottomRight: '╝',
+        horizontal: '═',
+        vertical: '║',
+    },
+};
+// Minimal theme - subtle, mostly monochrome
+export const minimalTheme = {
+    name: 'minimal',
+    colors: {
+        primary: white,
+        secondary: brightBlack,
+        success: green,
+        error: red,
+        warning: yellow,
+        info: brightBlack,
+        muted: dim,
+        text: white,
+        highlight: bold,
+    },
+    symbols: {
+        success: '+',
+        error: 'x',
+        warning: '!',
+        info: '-',
+        spinner: ['-', '\\', '|', '/'],
+        arrow: '>',
+        bullet: '-',
+        pointer: '>',
+        star: '*',
+    },
+    box: {
+        topLeft: '+',
+        topRight: '+',
+        bottomLeft: '+',
+        bottomRight: '+',
+        horizontal: '-',
+        vertical: '|',
+    },
+};
+// Ocean theme - blues and teals
+export const oceanTheme = {
+    name: 'ocean',
+    colors: {
+        primary: hex('#00ced1'), // Dark turquoise
+        secondary: hex('#4682b4'), // Steel blue
+        success: hex('#20b2aa'), // Light sea green
+        error: hex('#ff6347'), // Tomato
+        warning: hex('#ffa500'), // Orange
+        info: hex('#87ceeb'), // Sky blue
+        muted: hex('#708090'), // Slate gray
+        text: hex('#e0ffff'), // Light cyan
+        highlight: hex('#00ffff'), // Aqua
+    },
+    symbols: {
+        success: '●',
+        error: '●',
+        warning: '●',
+        info: '●',
+        spinner: ['∙∙∙', '●∙∙', '∙●∙', '∙∙●', '∙●∙', '●∙∙'],
+        arrow: '➜',
+        bullet: '○',
+        pointer: '➤',
+        star: '✧',
+    },
+    box: {
+        topLeft: '╭',
+        topRight: '╮',
+        bottomLeft: '╰',
+        bottomRight: '╯',
+        horizontal: '─',
+        vertical: '│',
+    },
+};
+// Forest theme - greens and earth tones
+export const forestTheme = {
+    name: 'forest',
+    colors: {
+        primary: hex('#228b22'), // Forest green
+        secondary: hex('#8b4513'), // Saddle brown
+        success: hex('#32cd32'), // Lime green
+        error: hex('#dc143c'), // Crimson
+        warning: hex('#daa520'), // Goldenrod
+        info: hex('#6b8e23'), // Olive drab
+        muted: hex('#696969'), // Dim gray
+        text: hex('#f5f5dc'), // Beige
+        highlight: hex('#98fb98'), // Pale green
+    },
+    symbols: {
+        success: '✓',
+        error: '✗',
+        warning: '⚡',
+        info: '❧',
+        spinner: ['🌱', '🌿', '🌳', '🌲'],
+        arrow: '➔',
+        bullet: '❀',
+        pointer: '➣',
+        star: '❁',
+    },
+    box: {
+        topLeft: '┏',
+        topRight: '┓',
+        bottomLeft: '┗',
+        bottomRight: '┛',
+        horizontal: '━',
+        vertical: '┃',
+    },
+};
+// All available themes
+export const themes = {
+    terminal: terminalTheme,
+    neon: neonTheme,
+    minimal: minimalTheme,
+    ocean: oceanTheme,
+    forest: forestTheme,
+};
+// Current active theme (default to terminal)
+let currentTheme = terminalTheme;
+export function setTheme(themeName) {
+    const theme = themes[themeName];
+    if (theme) {
+        currentTheme = theme;
+    }
+}
+export function getTheme() {
+    return currentTheme;
+}
+// Convenience function to get themed colors
+export function t() {
+    return currentTheme;
+}

package/dist/gemini-client.d.ts

@@ -141,6 +141,7 @@ export interface DeepResearchResult {
         text?: string;
     }[];
     error?: string;
+    savedPath?: string;
 }
 /**
  * Start a deep research task

package/dist/gemini-client.js

@@ -418,14 +418,14 @@ const DEEP_RESEARCH_AGENT = 'deep-research-pro-preview-12-2025';
  */
 export async function startDeepResearch(prompt) {
     try {
-        // The Interactions API - cast to any since it may not be in SDK types yet
+        // The Interactions API is properly typed in @google/genai v1.34.0+
         const interaction = await genAI.interactions.create({
             input: prompt,
             agent: DEEP_RESEARCH_AGENT,
             background: true,
-            agentConfig: {
+            agent_config: {
                 type: 'deep-research',
-                thinkingSummaries: 'auto',
+                thinking_summaries: 'auto',
             },
         });
         return {
@@ -446,17 +446,36 @@ export async function checkDeepResearch(researchId) {
         const interaction = await genAI.interactions.get(researchId);
         const status = interaction.status || 'unknown';
         if (status === 'completed') {
+            // Save the FULL raw response to the output directory
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const outputPath = path.join(getOutputDir(), `deep-research-${timestamp}.json`);
+            const fullResponse = {
+                id: researchId,
+                status: interaction.status,
+                created: interaction.created,
+                agent: interaction.agent,
+                model: interaction.model,
+                outputs: interaction.outputs,
+                rawInteraction: interaction,
+            };
+            fs.writeFileSync(outputPath, JSON.stringify(fullResponse, null, 2));
+            logger.info(`Full deep research response saved to: ${outputPath}`);
+            // Extract text for the summary (but full data is saved)
+            const textOutputs = (interaction.outputs || [])
+                .filter((output) => 'type' in output && output.type === 'text')
+                .map(output => ({ text: output.text }));
             return {
                 id: researchId,
                 status: 'completed',
-                outputs: interaction.outputs,
+                outputs: textOutputs,
+                savedPath: outputPath,
             };
         }
-        else if (status === 'failed') {
+        else if (status === 'failed' || status === 'cancelled') {
             return {
                 id: researchId,
                 status: 'failed',
-                error: interaction.error || 'Unknown error',
+                error: 'Research task failed or was cancelled',
             };
         }
         return {
@@ -477,10 +496,18 @@ export async function followUpResearch(researchId, question) {
         const interaction = await genAI.interactions.create({
             input: question,
             model: proModelName,
-            previousInteractionId: researchId,
+            previous_interaction_id: researchId,
         });
+        // Extract text from TextContent outputs
         const outputs = interaction.outputs || [];
-        return outputs.length > 0 ? outputs[outputs.length - 1].text || 'No response' : 'No response received';
+        const textOutputs = outputs
+            .filter((output) => 'type' in output && output.type === 'text')
+            .map(output => output.text)
+            .filter((text) => !!text);
+        if (textOutputs.length > 0) {
+            return textOutputs[textOutputs.length - 1];
+        }
+        return 'No text response received';
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 /**
- * MCP Server Gemini - Integrates Google's Gemini models with Claude Code
+ * Gemini - Dual Mode Entry Point
  *
- * This MCP server provides access to Gemini models for use in Claude Code.
- * Features include direct queries, brainstorming, and analysis tools.
+ * 1. MCP Server Mode (default): `gemini-mcp` or `gemini serve`
+ * 2. CLI Mode: `gemini <command> [options]`
+ *
+ * This integrates Google's Gemini models with Claude Code (MCP)
+ * and provides a beautiful standalone CLI experience.
  */
 export {};

package/dist/index.js

@@ -1,224 +1,32 @@
 #!/usr/bin/env node
 /**
- * MCP Server Gemini - Integrates Google's Gemini models with Claude Code
+ * Gemini - Dual Mode Entry Point
  *
- * This MCP server provides access to Gemini models for use in Claude Code.
- * Features include direct queries, brainstorming, and analysis tools.
+ * 1. MCP Server Mode (default): `gemini-mcp` or `gemini serve`
+ * 2. CLI Mode: `gemini <command> [options]`
+ *
+ * This integrates Google's Gemini models with Claude Code (MCP)
+ * and provides a beautiful standalone CLI experience.
  */
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { parseArgs } from 'node:util';
-// Import tools
-import { registerQueryTool } from './tools/query.js';
-import { registerBrainstormTool } from './tools/brainstorm.js';
-import { registerAnalyzeTool } from './tools/analyze.js';
-import { registerSummarizeTool } from './tools/summarize.js';
-import { registerImageGenTool } from './tools/image-gen.js';
-import { registerImageEditTool } from './tools/image-edit.js';
-import { registerVideoGenTool } from './tools/video-gen.js';
-import { registerCodeExecTool } from './tools/code-exec.js';
-import { registerSearchTool } from './tools/search.js';
-import { registerStructuredTool } from './tools/structured.js';
-import { registerYouTubeTool } from './tools/youtube.js';
-import { registerDocumentTool } from './tools/document.js';
-import { registerUrlContextTool } from './tools/url-context.js';
-import { registerCacheTool } from './tools/cache.js';
-import { registerSpeechTool } from './tools/speech.js';
-import { registerTokenCountTool } from './tools/token-count.js';
-import { registerDeepResearchTool } from './tools/deep-research.js';
-// Import Gemini client and logger
-import { initGeminiClient } from './gemini-client.js';
-import { setupLogger, logger } from './utils/logger.js';
-// Parse command line arguments
-const { values } = parseArgs({
-    options: {
-        verbose: {
-            type: 'boolean',
-            short: 'v',
-            default: false,
-        },
-        quiet: {
-            type: 'boolean',
-            short: 'q',
-            default: false,
-        },
-        help: {
-            type: 'boolean',
-            short: 'h',
-            default: false,
-        },
-    },
-});
-// Show help if requested
-if (values.help) {
-    console.log(`
-MCP Server Gemini - Integrates Google's Gemini models with Claude Code
-
-Usage:
-  gemini-mcp [options]
-
-Options:
-  -v, --verbose    Enable verbose logging (shows all prompts and responses)
-  -q, --quiet      Run in quiet mode (minimal logging)
-  -h, --help       Show this help message
-
-Environment Variables:
-  GEMINI_API_KEY   (required) Your Google Gemini API key
-  VERBOSE          (optional) Set to "true" to enable verbose logging
-  QUIET            (optional) Set to "true" to enable quiet mode
-  GEMINI_MODEL     (optional) Default Gemini model to use
-  GEMINI_PRO_MODEL (optional) Specify Pro model variant
-  GEMINI_FLASH_MODEL (optional) Specify Flash model variant
-  `);
-    process.exit(0);
-}
-// Configure logging mode based on command line args or environment variables
-let logLevel = 'normal';
-if (values.verbose || process.env.VERBOSE === 'true') {
-    logLevel = 'verbose';
-}
-else if (values.quiet || process.env.QUIET === 'true') {
-    logLevel = 'quiet';
-}
-setupLogger(logLevel);
-// Check for required API key
-if (!process.env.GEMINI_API_KEY) {
-    logger.error('Error: GEMINI_API_KEY environment variable is required');
-    process.exit(1);
+import { runCli } from './cli/index.js';
+import { startMcpServer } from './server.js';
+// Get command line arguments
+const args = process.argv.slice(2);
+// Determine mode based on first argument
+const firstArg = args[0];
+// MCP server mode conditions:
+// 1. No arguments (default behavior for MCP)
+// 2. Explicit 'serve' command
+// 3. Legacy flags that were for MCP server
+const mcpServerFlags = ['--verbose', '-v', '--quiet', '-q', '--help', '-h'];
+const isMcpMode = args.length === 0 ||
+    firstArg === 'serve' ||
+    (args.length === 1 && mcpServerFlags.includes(firstArg));
+if (isMcpMode) {
+    // Start MCP server (existing behavior)
+    startMcpServer(args);
 }
-// Get model name from environment or use default
-// Use Gemini 3 as default (latest frontier model)
-const defaultModel = 'gemini-3-pro-preview';
-const geminiModel = process.env.GEMINI_MODEL || defaultModel;
-// Log model configuration for debugging
-logger.debug(`Model configuration:
-  - GEMINI_MODEL: ${process.env.GEMINI_MODEL || '(not set, using default)'}
-  - GEMINI_PRO_MODEL: ${process.env.GEMINI_PRO_MODEL || '(not set, using default)'}
-  - GEMINI_FLASH_MODEL: ${process.env.GEMINI_FLASH_MODEL || '(not set, using default)'}`);
-async function main() {
-    logger.info(`Starting MCP Gemini Server with model: ${geminiModel}`);
-    logger.info(`Logging mode: ${logLevel}`);
-    // Handle unexpected stdio errors
-    process.stdin.on('error', (err) => {
-        logger.error('STDIN error:', err);
-        // Don't exit, just log
-    });
-    process.stdout.on('error', (err) => {
-        logger.error('STDOUT error:', err);
-        // Don't exit, just log
-    });
-    try {
-        // Initialize Gemini client
-        await initGeminiClient();
-        // Create MCP server
-        const server = new McpServer({
-            name: 'Gemini',
-            version: '0.6.2',
-        });
-        // Register tools
-        registerQueryTool(server);
-        registerBrainstormTool(server);
-        registerAnalyzeTool(server);
-        registerSummarizeTool(server);
-        registerImageGenTool(server);
-        registerImageEditTool(server);
-        registerVideoGenTool(server);
-        registerCodeExecTool(server);
-        registerSearchTool(server);
-        registerStructuredTool(server);
-        registerYouTubeTool(server);
-        registerDocumentTool(server);
-        registerUrlContextTool(server);
-        registerCacheTool(server);
-        registerSpeechTool(server);
-        registerTokenCountTool(server);
-        registerDeepResearchTool(server);
-        // Start server with stdio transport with enhanced error handling
-        const transport = new StdioServerTransport();
-        // Set up error handling for transport with improved error recovery
-        transport.onclose = () => {
-            logger.warn('MCP transport connection closed');
-            logger.debug('Connection closed event triggered');
-            // Attempt to recover connection after brief delay with backoff strategy
-            let reconnectAttempts = 0;
-            const maxReconnectAttempts = 5;
-            const attemptReconnect = () => {
-                if (reconnectAttempts >= maxReconnectAttempts) {
-                    logger.error(`Failed to reconnect after ${maxReconnectAttempts} attempts`);
-                    return;
-                }
-                reconnectAttempts++;
-                const delay = Math.min(1000 * Math.pow(1.5, reconnectAttempts - 1), 10000);
-                logger.info(`Attempting to reconnect (${reconnectAttempts}/${maxReconnectAttempts}) after ${delay}ms...`);
-                setTimeout(() => {
-                    try {
-                        // Check if stdin/stdout are still available
-                        if (process.stdin.destroyed || process.stdout.destroyed) {
-                            logger.error('Cannot reconnect: stdin or stdout is destroyed');
-                            return;
-                        }
-                        server.connect(transport)
-                            .then(() => {
-                            logger.info('Successfully reconnected to MCP transport');
-                            reconnectAttempts = 0;
-                        })
-                            .catch(e => {
-                            logger.error('Reconnection failed:', e);
-                            attemptReconnect(); // Try again with backoff
-                        });
-                    }
-                    catch (e) {
-                        logger.error('Error during reconnection attempt:', e);
-                        attemptReconnect(); // Try again with backoff
-                    }
-                }, delay);
-            };
-            attemptReconnect();
-        };
-        transport.onerror = (error) => {
-            logger.error('MCP transport error:', error);
-            // Log detailed error information for debugging
-            if (error instanceof Error) {
-                logger.debug(`Error name: ${error.name}, message: ${error.message}`);
-                logger.debug(`Stack trace: ${error.stack}`);
-            }
-        };
-        // Set up error handling for the connection with more diagnostics
-        try {
-            // Log environment diagnostic info before connecting
-            logger.debug(`Process details - PID: ${process.pid}, Node version: ${process.version}`);
-            logger.debug(`Environment variables: API_KEY=${process.env.GEMINI_API_KEY ? 'SET' : 'NOT_SET'}, VERBOSE=${process.env.VERBOSE || 'not set'}`);
-            logger.debug(`Process stdin/stdout state - isTTY: ${process.stdin.isTTY}, ${process.stdout.isTTY}`);
-            await server.connect(transport);
-            logger.info('MCP Gemini Server running');
-        }
-        catch (err) {
-            logger.error('Failed to connect MCP server transport:', err);
-            // More detailed error logging
-            if (err instanceof Error) {
-                logger.debug(`Error stack: ${err.stack}`);
-                logger.debug(`Error details: name=${err.name}, message=${err.message}`);
-            }
-            else {
-                logger.debug(`Non-Error object thrown: ${JSON.stringify(err)}`);
-            }
-            logger.warn('Server will attempt to continue running despite connection error');
-        }
-        // Handle process termination
-        process.on('SIGINT', async () => {
-            logger.info('Shutting down MCP Gemini Server');
-            await server.close();
-            process.exit(0);
-        });
-        process.on('SIGTERM', async () => {
-            logger.info('Shutting down MCP Gemini Server');
-            await server.close();
-            process.exit(0);
-        });
-    }
-    catch (error) {
-        logger.error('Failed to start MCP Gemini Server:', error);
-        process.exit(1);
-    }
+else {
+    // Run CLI
+    runCli(args);
 }
-main();

package/dist/server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Server for Gemini
+ *
+ * Provides Gemini models as MCP tools for Claude Code integration.
+ * This is the original MCP server functionality, now modularized.
+ */
+export declare function startMcpServer(argv: string[]): Promise<void>;