gemini-bridge 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

gemini_bridge-1.0.3.dist-info/METADATA

@@ -0,0 +1,645 @@
+Metadata-Version: 2.4
+Name: gemini-bridge
+Version: 1.0.3
+Summary: Lightweight MCP server bridging Claude Code to Google's Gemini AI via official CLI
+Author-email: Shelakh <info@shelakh.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/eLyiN/gemini-bridge
+Project-URL: Repository, https://github.com/eLyiN/gemini-bridge
+Project-URL: Issues, https://github.com/eLyiN/gemini-bridge/issues
+Keywords: mcp,gemini,ai,coding,assistant
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Dynamic: license-file
+
+# Gemini Bridge
+
+![CI Status](https://github.com/eLyiN/gemini-bridge/actions/workflows/ci.yml/badge.svg)
+![PyPI Version](https://img.shields.io/pypi/v/gemini-bridge)
+![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)
+![MCP Compatible](https://img.shields.io/badge/MCP-compatible-green.svg)
+![Gemini CLI](https://img.shields.io/badge/Gemini-CLI-blue.svg)
+
+A lightweight MCP (Model Context Protocol) server that enables AI coding assistants to interact with Google's Gemini AI through the official CLI. Works with Claude Code, Cursor, VS Code, and other MCP-compatible clients. Designed for simplicity, reliability, and seamless integration.
+
+## ✨ Features
+
+- **Direct Gemini CLI Integration**: Zero API costs using official Gemini CLI
+- **Simple MCP Tools**: Two core functions for basic queries and file analysis
+- **Stateless Operation**: No sessions, caching, or complex state management
+- **Production Ready**: Robust error handling with configurable 60-second timeouts
+- **Minimal Dependencies**: Only requires `mcp>=1.0.0` and Gemini CLI
+- **Easy Deployment**: Support for both uvx and traditional pip installation
+- **Universal MCP Compatibility**: Works with any MCP-compatible AI coding assistant
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+1. **Install Gemini CLI**:
+   ```bash
+   npm install -g @google/gemini-cli
+   ```
+
+2. **Authenticate with Gemini**:
+   ```bash
+   gemini auth login
+   ```
+
+3. **Verify installation**:
+   ```bash
+   gemini --version
+   ```
+
+### Installation
+
+**🎯 Recommended: PyPI Installation**
+```bash
+# Install from PyPI
+pip install gemini-bridge
+
+# Add to Claude Code with uvx (recommended)
+claude mcp add gemini-bridge -s user -- uvx gemini-bridge
+```
+
+**Alternative: From Source**
+```bash
+# Clone the repository
+git clone https://github.com/shelakh/gemini-bridge.git
+cd gemini-bridge
+
+# Build and install locally
+uvx --from build pyproject-build
+pip install dist/*.whl
+
+# Add to Claude Code
+claude mcp add gemini-bridge -s user -- uvx gemini-bridge
+```
+
+**Development Installation**
+```bash
+# Clone and install in development mode
+git clone https://github.com/shelakh/gemini-bridge.git
+cd gemini-bridge
+pip install -e .
+
+# Add to Claude Code (development)
+claude mcp add gemini-bridge-dev -s user -- python -m src
+```
+
+## 🌐 Multi-Client Support
+
+**Gemini Bridge works with any MCP-compatible AI coding assistant** - the same server supports multiple clients through different configuration methods.
+
+### Supported MCP Clients
+- **Claude Code** ✅ (Default)
+- **Cursor** ✅
+- **VS Code** ✅
+- **Windsurf** ✅
+- **Cline** ✅
+- **Void** ✅
+- **Cherry Studio** ✅
+- **Augment** ✅
+- **Roo Code** ✅
+- **Zencoder** ✅
+- **Any MCP-compatible client** ✅
+
+### Configuration Examples
+
+<details>
+<summary><strong>Claude Code</strong> (Default)</summary>
+
+```bash
+# Recommended installation
+claude mcp add gemini-bridge -s user -- uvx gemini-bridge
+
+# Development installation
+claude mcp add gemini-bridge-dev -s user -- python -m src
+```
+
+</details>
+
+<details>
+<summary><strong>Cursor</strong></summary>
+
+**Global Configuration** (`~/.cursor/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "gemini-bridge": {
+      "command": "uvx",
+      "args": ["gemini-bridge"],
+      "env": {}
+    }
+  }
+}
+```
+
+**Project-Specific** (`.cursor/mcp.json` in your project):
+```json
+{
+  "mcpServers": {
+    "gemini-bridge": {
+      "command": "uvx",
+      "args": ["gemini-bridge"],
+      "env": {}
+    }
+  }
+}
+```
+
+Go to: `Settings` → `Cursor Settings` → `MCP` → `Add new global MCP server`
+
+</details>
+
+<details>
+<summary><strong>VS Code</strong></summary>
+
+**Configuration** (`.vscode/mcp.json` in your workspace):
+```json
+{
+  "servers": {
+    "gemini-bridge": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["gemini-bridge"]
+    }
+  }
+}
+```
+
+**Alternative: Through Extensions**
+1. Open Extensions view (Ctrl+Shift+X)
+2. Search for MCP extensions
+3. Add custom server with command: `uvx gemini-bridge`
+
+</details>
+
+<details>
+<summary><strong>Windsurf</strong></summary>
+
+Add to your Windsurf MCP configuration:
+```json
+{
+  "mcpServers": {
+    "gemini-bridge": {
+      "command": "uvx",
+      "args": ["gemini-bridge"],
+      "env": {}
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>Cline</strong> (VS Code Extension)</summary>
+
+1. Open Cline and click **MCP Servers** in the top navigation
+2. Select **Installed** tab → **Advanced MCP Settings**
+3. Add to `cline_mcp_settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "gemini-bridge": {
+      "command": "uvx",
+      "args": ["gemini-bridge"],
+      "env": {}
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>Void</strong></summary>
+
+Go to: `Settings` → `MCP` → `Add MCP Server`
+
+```json
+{
+  "mcpServers": {
+    "gemini-bridge": {
+      "command": "uvx",
+      "args": ["gemini-bridge"],
+      "env": {}
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>Cherry Studio</strong></summary>
+
+1. Navigate to **Settings → MCP Servers → Add Server**
+2. Fill in the server details:
+   - **Name**: `gemini-bridge`
+   - **Type**: `STDIO`
+   - **Command**: `uvx`
+   - **Arguments**: `["gemini-bridge"]`
+3. Save the configuration
+
+</details>
+
+<details>
+<summary><strong>Augment</strong></summary>
+
+**Using the UI:**
+1. Click hamburger menu → **Settings** → **Tools**
+2. Click **+ Add MCP** button
+3. Enter command: `uvx gemini-bridge`
+4. Name: **Gemini Bridge**
+
+**Manual Configuration:**
+```json
+"augment.advanced": { 
+  "mcpServers": [ 
+    { 
+      "name": "gemini-bridge", 
+      "command": "uvx", 
+      "args": ["gemini-bridge"],
+      "env": {}
+    }
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary><strong>Roo Code</strong></summary>
+
+1. Go to **Settings → MCP Servers → Edit Global Config**
+2. Add to `mcp_settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "gemini-bridge": {
+      "command": "uvx",
+      "args": ["gemini-bridge"],
+      "env": {}
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>Zencoder</strong></summary>
+
+1. Go to Zencoder menu (...) → **Tools** → **Add Custom MCP**
+2. Add configuration:
+
+```json
+{
+  "command": "uvx",
+  "args": ["gemini-bridge"],
+  "env": {}
+}
+```
+
+3. Hit the **Install** button
+
+</details>
+
+<details>
+<summary><strong>Alternative Installation Methods</strong></summary>
+
+**For pip-based installations:**
+```json
+{
+  "command": "gemini-bridge",
+  "args": [],
+  "env": {}
+}
+```
+
+**For development/local testing:**
+```json
+{
+  "command": "python",
+  "args": ["-m", "src"],
+  "env": {},
+  "cwd": "/path/to/gemini-bridge"
+}
+```
+
+**For npm-style installation** (if needed):
+```json
+{
+  "command": "npx",
+  "args": ["gemini-bridge"],
+  "env": {}
+}
+```
+
+</details>
+
+### Universal Usage
+
+Once configured with any client, use the same two tools:
+
+1. **Ask general questions**: "What authentication patterns are used in this codebase?"
+2. **Analyze specific files**: "Review these auth files for security issues"
+
+**The server implementation is identical** - only the client configuration differs!
+
+## ⚙️ Configuration
+
+### Timeout Configuration
+
+By default, Gemini Bridge uses a 60-second timeout for all CLI operations. For longer queries (large files, complex analysis), you can configure a custom timeout using the `GEMINI_BRIDGE_TIMEOUT` environment variable.
+
+**Example configurations:**
+
+<details>
+<summary><strong>Claude Code</strong></summary>
+
+```bash
+# Add with custom timeout (120 seconds)
+claude mcp add gemini-bridge -s user --env GEMINI_BRIDGE_TIMEOUT=120 -- uvx gemini-bridge
+```
+
+</details>
+
+<details>
+<summary><strong>Manual Configuration (mcp_settings.json)</strong></summary>
+
+```json
+{
+  "mcpServers": {
+    "gemini-bridge": {
+      "command": "uvx",
+      "args": ["gemini-bridge"],
+      "env": {
+        "GEMINI_BRIDGE_TIMEOUT": "120"
+      }
+    }
+  }
+}
+```
+
+</details>
+
+**Timeout Options:**
+- **Default**: 60 seconds (if not configured)
+- **Range**: Any positive integer (seconds)
+- **Recommended**: 120-300 seconds for large file analysis
+- **Invalid values**: Fall back to 60 seconds with warning
+
+## 🛠️ Available Tools
+
+### `consult_gemini`
+Direct CLI bridge for simple queries.
+
+**Parameters:**
+- `query` (string): The question or prompt to send to Gemini
+- `directory` (string): Working directory for the query (default: current directory)
+- `model` (string, optional): Model to use - "flash" or "pro" (default: "flash")
+
+**Example:**
+```python
+consult_gemini(
+    query="Find authentication patterns in this codebase",
+    directory="/path/to/project",
+    model="flash"
+)
+```
+
+### `consult_gemini_with_files`
+CLI bridge with file attachments for detailed analysis.
+
+**Parameters:**
+- `query` (string): The question or prompt to send to Gemini
+- `directory` (string): Working directory for the query
+- `files` (list): List of file paths relative to the directory
+- `model` (string, optional): Model to use - "flash" or "pro" (default: "flash")
+
+**Example:**
+```python
+consult_gemini_with_files(
+    query="Analyze these auth files and suggest improvements",
+    directory="/path/to/project",
+    files=["src/auth.py", "src/models.py"],
+    model="pro"
+)
+```
+
+## 📋 Usage Examples
+
+### Basic Code Analysis
+```python
+# Simple research query
+consult_gemini(
+    query="What authentication patterns are used in this project?",
+    directory="/Users/dev/my-project"
+)
+```
+
+### Detailed File Review
+```python
+# Analyze specific files
+consult_gemini_with_files(
+    query="Review these files and suggest security improvements",
+    directory="/Users/dev/my-project",
+    files=["src/auth.py", "src/middleware.py"],
+    model="pro"
+)
+```
+
+### Multi-file Analysis
+```python
+# Compare multiple implementation files
+consult_gemini_with_files(
+    query="Compare these database implementations and recommend the best approach",
+    directory="/Users/dev/my-project",
+    files=["src/db/postgres.py", "src/db/sqlite.py", "src/db/redis.py"]
+)
+```
+
+## 🏗️ Architecture
+
+### Core Design
+- **CLI-First**: Direct subprocess calls to `gemini` command
+- **Stateless**: Each tool call is independent with no session state
+- **Fixed Timeout**: 60-second maximum execution time
+- **Simple Error Handling**: Clear error messages with fail-fast approach
+
+### Project Structure
+```
+gemini-bridge/
+├── src/
+│   ├── __init__.py              # Entry point
+│   ├── __main__.py              # Module execution entry point
+│   └── mcp_server.py            # Main MCP server implementation
+├── .github/                     # GitHub templates and workflows
+├── pyproject.toml              # Python package configuration
+├── README.md                   # This file
+├── CONTRIBUTING.md             # Contribution guidelines
+├── CODE_OF_CONDUCT.md          # Community standards
+├── SECURITY.md                 # Security policies
+├── CHANGELOG.md               # Version history
+└── LICENSE                    # MIT license
+```
+
+## 🔧 Development
+
+### Local Testing
+```bash
+# Install in development mode
+pip install -e .
+
+# Run directly
+python -m src
+
+# Test CLI availability
+gemini --version
+```
+
+### Integration with Claude Code
+The server automatically integrates with Claude Code when properly configured through the MCP protocol.
+
+## 🔍 Troubleshooting
+
+### CLI Not Available
+```bash
+# Install Gemini CLI
+npm install -g @google/gemini-cli
+
+# Authenticate
+gemini auth login
+
+# Test
+gemini --version
+```
+
+### Connection Issues
+- Verify Gemini CLI is properly authenticated
+- Check network connectivity
+- Ensure Claude Code MCP configuration is correct
+- Check that the `gemini` command is in your PATH
+
+### Timeout Issues 🔥
+
+Gemini Bridge now includes comprehensive timeout debugging. If you're experiencing timeout issues:
+
+**1. Use the Debug Tool**
+```python
+# Get detailed diagnostics about your configuration
+get_debug_info()
+```
+
+This will show:
+- Current timeout configuration
+- Gemini CLI status and version
+- Authentication status
+- Environment variables
+- System information
+
+**2. Configure Appropriate Timeout**
+
+For different operation types, recommended timeouts:
+
+- **Default operations**: 60 seconds (default)
+- **Large file analysis**: 240 seconds
+- **Complex multi-file operations**: 300+ seconds
+
+**Configuration Examples:**
+
+```bash
+# Claude Code with 4-minute timeout for large operations
+claude mcp add gemini-bridge -s user --env GEMINI_BRIDGE_TIMEOUT=240 -- uvx gemini-bridge
+
+# Environment variable (if running manually)
+export GEMINI_BRIDGE_TIMEOUT=240
+```
+
+**3. Common Timeout Scenarios**
+
+| Scenario | Recommended Timeout | Reason |
+|----------|-------------------|---------|
+| Single file < 10KB | 60s (default) | Fast processing |
+| Multiple files or large files | 240s | More content to process |
+| Complex code analysis | 300s | Deep reasoning required |
+| Very large files (>100KB) | 300-600s | Processing overhead |
+
+**4. Debugging Steps**
+
+1. **Check your configuration**:
+   ```bash
+   # Run the debug tool to see current timeout
+   # Look for "Actual timeout used" in the output
+   ```
+
+2. **Monitor logs**: The server now logs detailed timing information
+
+3. **Test with smaller queries**: If large queries timeout, break them into smaller parts
+
+4. **Verify Gemini CLI performance**: Test `gemini` directly with similar queries
+
+**5. Advanced Troubleshooting**
+
+If timeouts persist even with high timeout values:
+
+- **Network issues**: Check your internet connection
+- **Gemini CLI version**: Update with `npm install -g @google/gemini-cli@latest`  
+- **Authentication**: Re-authenticate with `gemini auth login`
+- **System resources**: Check if your system is under high load
+- **File encoding**: Ensure files are UTF-8 encoded
+- **MCP client timeout**: Some clients have their own timeout settings
+
+### Common Error Messages
+- **"CLI not available"**: Gemini CLI is not installed or not in PATH
+- **"Authentication required"**: Run `gemini auth login`
+- **"Timeout after X seconds"**: Operation took longer than configured timeout
+  - Solution: Increase `GEMINI_BRIDGE_TIMEOUT` environment variable
+  - For immediate testing: Use smaller files or simpler queries
+- **"Large content size warning"**: Files total >100KB, may need longer timeout
+- **"Very high timeout configured"**: Timeout >300s, failed operations will wait long
+
+## 🤝 Contributing
+
+We welcome contributions from the community! Please read our [Contributing Guidelines](CONTRIBUTING.md) for details on how to get started.
+
+### Quick Contributing Guide
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🔄 Version History
+
+See [CHANGELOG.md](CHANGELOG.md) for detailed version history.
+
+## 🆘 Support
+
+- **Issues**: Report bugs or request features via [GitHub Issues](https://github.com/shelakh/gemini-bridge/issues)
+- **Discussions**: Join the community discussion
+- **Documentation**: Additional docs can be created in the `docs/` directory
+
+---
+
+**Focus**: A simple, reliable bridge between Claude Code and Gemini AI through the official CLI.

gemini_bridge-1.0.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+gemini_bridge-1.0.3.dist-info/licenses/LICENSE,sha256=yTz_R8ocWu64Eubxr6vdZCKRS0dB_Pi3RbjUNn4qPxQ,1063
+src/__init__.py,sha256=w8kaouHPnS_Oe6HQHbGRn6lVKRAYJXG8C4GxqPktK0E,190
+src/__main__.py,sha256=12FoIYCXYYKu2_BYX1GS_h9E9qO41Q26B8zedRIDPBs,149
+src/mcp_server.py,sha256=T9GS8pvpCjn6csLdjUbsTPVrqs3Q9LATotIF4_Xkin8,14469
+gemini_bridge-1.0.3.dist-info/METADATA,sha256=vaefL-Mc6YXwVO9-tQJQ8s4DYhqyN0DIMbz0_DOq6UY,16223
+gemini_bridge-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gemini_bridge-1.0.3.dist-info/entry_points.txt,sha256=ygWf0B23Gygq8mW_GzPx8rxIA19RR_RH4RG2I15lU3E,43
+gemini_bridge-1.0.3.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+gemini_bridge-1.0.3.dist-info/RECORD,,

src/__init__.py

@@ -5,5 +5,5 @@ Version 1.0.0 - Production ready, radically simplified.
 
 from .mcp_server import main
 
-__version__ = "1.0.1"
+__version__ = "1.0.3"
 __all__ = ["main"]

src/mcp_server.py

@@ -1,18 +1,24 @@
 #!/usr/bin/env python3
 """
 Gemini MCP Server - Simple CLI Bridge
-Version 1.0.0
+Version 1.0.2
 A minimal MCP server to interface with Gemini AI via the gemini CLI.
 Created by @shelakh/elyin
 """
 
+import logging
 import os
 import shutil
 import subprocess
+import sys
 from typing import List, Optional
 
 from mcp.server.fastmcp import FastMCP
 
+# Configure logging for debugging timeout issues
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
 mcp = FastMCP("gemini-assistant")
 
 
@@ -40,6 +46,47 @@ def _normalize_model_name(model: Optional[str]) -> str:
     return "gemini-2.5-flash"
 
 
+def _get_timeout() -> int:
+    """
+    Get the timeout value from environment variable GEMINI_BRIDGE_TIMEOUT.
+    Defaults to 60 seconds if not set or invalid.
+    
+    Returns:
+        Timeout value in seconds (positive integer)
+    """
+    timeout_str = os.getenv("GEMINI_BRIDGE_TIMEOUT")
+    logger.debug(
+        "Reading timeout from environment: GEMINI_BRIDGE_TIMEOUT=%s", timeout_str
+    )
+
+    if not timeout_str:
+        logger.info("GEMINI_BRIDGE_TIMEOUT not set, using default 60 seconds")
+        return 60
+
+    try:
+        timeout = int(timeout_str)
+    except ValueError:
+        logger.warning(
+            "Invalid GEMINI_BRIDGE_TIMEOUT value '%s' (must be integer). Using default 60 seconds.",
+            timeout_str,
+        )
+        return 60
+
+    if timeout <= 0:
+        logger.warning(
+            "Invalid GEMINI_BRIDGE_TIMEOUT value '%s' (must be positive). Using default 60 seconds.",
+            timeout_str,
+        )
+        return 60
+
+    logger.info("Using configured timeout: %s seconds", timeout)
+    if timeout > 300:
+        logger.warning(
+            "Large timeout configured (%ss). This may cause long waits for failed operations.",
+            timeout,
+        )
+    return timeout
+
 def execute_gemini_simple(query: str, directory: str = ".", model: Optional[str] = None) -> str:
     """
     Execute gemini CLI command for simple queries without file attachments.
@@ -65,25 +112,39 @@ def execute_gemini_simple(query: str, directory: str = ".", model: Optional[str]
     cmd = ["gemini", "-m", selected_model]
     
     # Execute CLI command - simple timeout, no retries
+    timeout = _get_timeout()
+    logger.info(f"Executing Gemini CLI with timeout: {timeout}s, model: {selected_model}, directory: {directory}")
+    logger.debug(f"Query length: {len(query)} characters")
+    
     try:
         result = subprocess.run(
             cmd,
             cwd=directory,
             capture_output=True,
             text=True,
-            timeout=60,
+            timeout=timeout,
             input=query
         )
         
+        logger.debug(f"Gemini CLI completed with return code: {result.returncode}")
+        
         if result.returncode == 0:
-            return result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            output = result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            logger.info(f"Gemini CLI successful, output length: {len(output)} characters")
+            return output
         else:
-            return f"Gemini CLI Error: {result.stderr.strip()}"
+            error_msg = f"Gemini CLI Error: {result.stderr.strip()}"
+            logger.error(error_msg)
+            return error_msg
             
     except subprocess.TimeoutExpired:
-        return "Error: Gemini CLI command timed out after 60 seconds"
+        timeout_msg = f"Error: Gemini CLI command timed out after {timeout} seconds. Try increasing GEMINI_BRIDGE_TIMEOUT environment variable for large operations."
+        logger.error(timeout_msg)
+        return timeout_msg
     except Exception as e:
-        return f"Error executing Gemini CLI: {str(e)}"
+        error_msg = f"Error executing Gemini CLI: {str(e)}"
+        logger.error(error_msg)
+        return error_msg
 
 
 def execute_gemini_with_files(query: str, directory: str = ".", files: Optional[List[str]] = None, model: Optional[str] = None) -> str:
@@ -136,25 +197,44 @@ def execute_gemini_with_files(query: str, directory: str = ".", files: Optional[
     stdin_content = "\n\n".join(file_contents) + "\n\n" + query
     
     # Execute CLI command - simple timeout, no retries
+    timeout = _get_timeout()
+    total_content_size = len(stdin_content)
+    logger.info(f"Executing Gemini CLI with files, timeout: {timeout}s, model: {selected_model}, directory: {directory}")
+    logger.info(f"File count: {len(files)}, total content size: {total_content_size} characters")
+    
+    # Warn about large content that might timeout
+    if total_content_size > 100000:  # 100KB threshold
+        logger.warning(f"Large content size ({total_content_size} chars). Consider increasing timeout if you experience timeouts.")
+    
     try:
         result = subprocess.run(
             cmd,
             cwd=directory,
             capture_output=True,
             text=True,
-            timeout=60,
+            timeout=timeout,
             input=stdin_content
         )
         
+        logger.debug(f"Gemini CLI completed with return code: {result.returncode}")
+        
         if result.returncode == 0:
-            return result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            output = result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            logger.info(f"Gemini CLI successful, output length: {len(output)} characters")
+            return output
         else:
-            return f"Gemini CLI Error: {result.stderr.strip()}"
+            error_msg = f"Gemini CLI Error: {result.stderr.strip()}"
+            logger.error(error_msg)
+            return error_msg
             
     except subprocess.TimeoutExpired:
-        return "Error: Gemini CLI command timed out after 60 seconds"
+        timeout_msg = f"Error: Gemini CLI command timed out after {timeout} seconds with {len(files)} files ({total_content_size} chars). Try increasing GEMINI_BRIDGE_TIMEOUT environment variable (current: {os.getenv('GEMINI_BRIDGE_TIMEOUT', 'not set')})."
+        logger.error(timeout_msg)
+        return timeout_msg
     except Exception as e:
-        return f"Error executing Gemini CLI: {str(e)}"
+        error_msg = f"Error executing Gemini CLI: {str(e)}"
+        logger.error(error_msg)
+        return error_msg
 
 
 @mcp.tool()
@@ -206,9 +286,120 @@ def consult_gemini_with_files(
     return execute_gemini_with_files(query, directory, files, model)
 
 
+@mcp.tool()
+def get_debug_info() -> str:
+    """
+    Get diagnostic information about the Gemini Bridge configuration.
+    
+    Useful for troubleshooting timeout issues and verifying setup.
+    
+    Returns:
+        Formatted debug information including timeout configuration,
+        environment variables, and system status
+    """
+    debug_info = []
+    debug_info.append("=== Gemini Bridge Debug Information ===\n")
+    
+    # Timeout configuration
+    timeout_env = os.getenv("GEMINI_BRIDGE_TIMEOUT")
+    actual_timeout = _get_timeout()
+    debug_info.append("Timeout Configuration:")
+    debug_info.append(f"  GEMINI_BRIDGE_TIMEOUT env var: {timeout_env or 'not set'}")
+    debug_info.append(f"  Actual timeout used: {actual_timeout} seconds")
+    
+    if actual_timeout == 60 and not timeout_env:
+        debug_info.append("  ⚠️  Using default timeout. Set GEMINI_BRIDGE_TIMEOUT=240 for large operations.")
+    elif actual_timeout < 120:
+        debug_info.append("  ⚠️  Timeout may be too low for large files or complex queries.")
+    elif actual_timeout > 300:
+        debug_info.append(f"  ⚠️  Very high timeout configured. Failed operations will wait {actual_timeout}s.")
+    else:
+        debug_info.append("  ✓ Timeout looks reasonable for most operations.")
+    
+    debug_info.append("")
+    
+    # Gemini CLI status
+    gemini_path = shutil.which("gemini")
+    debug_info.append("Gemini CLI Status:")
+    debug_info.append(f"  CLI available: {'✓ Yes' if gemini_path else '✗ No'}")
+    if gemini_path:
+        debug_info.append(f"  CLI path: {gemini_path}")
+        try:
+            # Try to get version
+            result = subprocess.run(
+                ["gemini", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                version = result.stdout.strip()
+                debug_info.append(f"  CLI version: {version}")
+            else:
+                debug_info.append(f"  CLI version check failed: {result.stderr.strip()}")
+        except Exception as e:
+            debug_info.append(f"  CLI version check error: {str(e)}")
+    else:
+        debug_info.append("  ✗ Install with: npm install -g @google/gemini-cli")
+    
+    debug_info.append("")
+    # Environment details
+    debug_info.append("Environment:")
+    debug_info.append(f"  Python version: {sys.version.split()[0]}")
+    debug_info.append(f"  Current working directory: {os.getcwd()}")
+    debug_info.append(f"  PORT: {os.getenv('PORT', '8080')}")
+    
+    # Check authentication status
+    try:
+        result = subprocess.run(
+            ["gemini", "auth", "status"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            cwd="."
+        )
+        if result.returncode == 0:
+            debug_info.append("  Authentication: ✓ Logged in")
+        else:
+            debug_info.append("  Authentication: ✗ Not logged in - run 'gemini auth login'")
+    except Exception as e:
+        debug_info.append(f"  Authentication status check failed: {str(e)}")
+    
+    debug_info.append("")
+    
+    # Recent environment variables that might affect operation
+    relevant_env_vars = [
+        "GEMINI_BRIDGE_TIMEOUT", "NODE_PATH", "PATH", "HOME", 
+        "GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT"
+    ]
+    
+    debug_info.append("Relevant Environment Variables:")
+    for var in relevant_env_vars:
+        value = os.getenv(var)
+        if value:
+            # Truncate very long values
+            display_value = value[:100] + "..." if len(value) > 100 else value
+            debug_info.append(f"  {var}: {display_value}")
+        else:
+            debug_info.append(f"  {var}: not set")
+    
+    debug_info.append("")
+    debug_info.append("=== End Debug Information ===")
+    
+    return "\n".join(debug_info)
+
+
 def main():
     """Entry point for the MCP server."""
-    mcp.run()
+    port = int(os.getenv("PORT", "8080"))
+    timeout = _get_timeout()  # Log timeout configuration at startup
+    
+    logger.info(f"Starting Gemini Bridge MCP Server on port {port}")
+    logger.info(f"Configured timeout: {timeout} seconds")
+    logger.info(f"Gemini CLI available: {shutil.which('gemini') is not None}")
+    
+    # Run the MCP server with SSE transport (port is managed by the library)
+    mcp.run(transport="sse")
 
 
 if __name__ == "__main__":

gemini_bridge-1.0.1.dist-info/METADATA

@@ -1,262 +0,0 @@
-Metadata-Version: 2.4
-Name: gemini-bridge
-Version: 1.0.1
-Summary: Lightweight MCP server bridging Claude Code to Google's Gemini AI via official CLI
-Author-email: Shelakh <info@shelakh.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/eLyiN/gemini-bridge
-Project-URL: Repository, https://github.com/eLyiN/gemini-bridge
-Project-URL: Issues, https://github.com/eLyiN/gemini-bridge/issues
-Keywords: mcp,gemini,ai,coding,assistant
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: mcp>=1.0.0
-Dynamic: license-file
-
-# Gemini Bridge
-
-![CI Status](https://github.com/eLyiN/gemini-bridge/actions/workflows/ci.yml/badge.svg)
-![PyPI Version](https://img.shields.io/pypi/v/gemini-bridge)
-![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)
-![MCP Compatible](https://img.shields.io/badge/MCP-compatible-green.svg)
-A lightweight MCP (Model Context Protocol) server that enables Claude Code to interact with Google's Gemini AI through the official CLI. Designed for simplicity, reliability, and seamless integration.
-
-## ✨ Features
-
-- **Direct Gemini CLI Integration**: Zero API costs using official Gemini CLI
-- **Simple MCP Tools**: Two core functions for basic queries and file analysis
-- **Stateless Operation**: No sessions, caching, or complex state management
-- **Production Ready**: Robust error handling with configurable 60-second timeouts
-- **Minimal Dependencies**: Only requires `mcp>=1.0.0` and Gemini CLI
-- **Easy Deployment**: Support for both uvx and traditional pip installation
-
-## 🚀 Quick Start
-
-### Prerequisites
-
-1. **Install Gemini CLI**:
-   ```bash
-   npm install -g @google/gemini-cli
-   ```
-
-2. **Authenticate with Gemini**:
-   ```bash
-   gemini auth login
-   ```
-
-3. **Verify installation**:
-   ```bash
-   gemini --version
-   ```
-
-### Installation
-
-**🎯 Recommended: PyPI Installation**
-```bash
-# Install from PyPI
-pip install gemini-bridge
-
-# Add to Claude Code with uvx (recommended)
-claude mcp add gemini-bridge -s user -- uvx gemini-bridge
-```
-
-**Alternative: From Source**
-```bash
-# Clone the repository
-git clone https://github.com/shelakh/gemini-bridge.git
-cd gemini-bridge
-
-# Build and install locally
-uvx --from build pyproject-build
-pip install dist/*.whl
-
-# Add to Claude Code
-claude mcp add gemini-bridge -s user -- uvx gemini-bridge
-```
-
-**Development Installation**
-```bash
-# Clone and install in development mode
-git clone https://github.com/shelakh/gemini-bridge.git
-cd gemini-bridge
-pip install -e .
-
-# Add to Claude Code (development)
-claude mcp add gemini-bridge-dev -s user -- python -m src
-```
-
-## 🛠️ Available Tools
-
-### `consult_gemini`
-Direct CLI bridge for simple queries.
-
-**Parameters:**
-- `query` (string): The question or prompt to send to Gemini
-- `directory` (string): Working directory for the query (default: current directory)
-- `model` (string, optional): Model to use - "flash" or "pro" (default: "flash")
-
-**Example:**
-```python
-consult_gemini(
-    query="Find authentication patterns in this codebase",
-    directory="/path/to/project",
-    model="flash"
-)
-```
-
-### `consult_gemini_with_files`
-CLI bridge with file attachments for detailed analysis.
-
-**Parameters:**
-- `query` (string): The question or prompt to send to Gemini
-- `directory` (string): Working directory for the query
-- `files` (list): List of file paths relative to the directory
-- `model` (string, optional): Model to use - "flash" or "pro" (default: "flash")
-
-**Example:**
-```python
-consult_gemini_with_files(
-    query="Analyze these auth files and suggest improvements",
-    directory="/path/to/project",
-    files=["src/auth.py", "src/models.py"],
-    model="pro"
-)
-```
-
-## 📋 Usage Examples
-
-### Basic Code Analysis
-```python
-# Simple research query
-consult_gemini(
-    query="What authentication patterns are used in this project?",
-    directory="/Users/dev/my-project"
-)
-```
-
-### Detailed File Review
-```python
-# Analyze specific files
-consult_gemini_with_files(
-    query="Review these files and suggest security improvements",
-    directory="/Users/dev/my-project",
-    files=["src/auth.py", "src/middleware.py"],
-    model="pro"
-)
-```
-
-### Multi-file Analysis
-```python
-# Compare multiple implementation files
-consult_gemini_with_files(
-    query="Compare these database implementations and recommend the best approach",
-    directory="/Users/dev/my-project",
-    files=["src/db/postgres.py", "src/db/sqlite.py", "src/db/redis.py"]
-)
-```
-
-## 🏗️ Architecture
-
-### Core Design
-- **CLI-First**: Direct subprocess calls to `gemini` command
-- **Stateless**: Each tool call is independent with no session state
-- **Fixed Timeout**: 60-second maximum execution time
-- **Simple Error Handling**: Clear error messages with fail-fast approach
-
-### Project Structure
-```
-gemini-bridge/
-├── src/
-│   ├── __init__.py              # Entry point
-│   ├── __main__.py              # Module execution entry point
-│   └── mcp_server.py            # Main MCP server implementation
-├── .github/                     # GitHub templates and workflows
-├── pyproject.toml              # Python package configuration
-├── README.md                   # This file
-├── CONTRIBUTING.md             # Contribution guidelines
-├── CODE_OF_CONDUCT.md          # Community standards
-├── SECURITY.md                 # Security policies
-├── CHANGELOG.md               # Version history
-└── LICENSE                    # MIT license
-```
-
-## 🔧 Development
-
-### Local Testing
-```bash
-# Install in development mode
-pip install -e .
-
-# Run directly
-python -m src
-
-# Test CLI availability
-gemini --version
-```
-
-### Integration with Claude Code
-The server automatically integrates with Claude Code when properly configured through the MCP protocol.
-
-## 🔍 Troubleshooting
-
-### CLI Not Available
-```bash
-# Install Gemini CLI
-npm install -g @google/gemini-cli
-
-# Authenticate
-gemini auth login
-
-# Test
-gemini --version
-```
-
-### Connection Issues
-- Verify Gemini CLI is properly authenticated
-- Check network connectivity
-- Ensure Claude Code MCP configuration is correct
-- Check that the `gemini` command is in your PATH
-
-### Common Error Messages
-- **"CLI not available"**: Gemini CLI is not installed or not in PATH
-- **"Authentication required"**: Run `gemini auth login`
-- **"Timeout after 60 seconds"**: Query took too long, try breaking it into smaller parts
-
-## 🤝 Contributing
-
-We welcome contributions from the community! Please read our [Contributing Guidelines](CONTRIBUTING.md) for details on how to get started.
-
-### Quick Contributing Guide
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests if applicable
-5. Submit a pull request
-
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## 🔄 Version History
-
-See [CHANGELOG.md](CHANGELOG.md) for detailed version history.
-
-## 🆘 Support
-
-- **Issues**: Report bugs or request features via [GitHub Issues](https://github.com/shelakh/gemini-bridge/issues)
-- **Discussions**: Join the community discussion
-- **Documentation**: Additional docs can be created in the `docs/` directory
-
----
-
-**Focus**: A simple, reliable bridge between Claude Code and Gemini AI through the official CLI.

gemini_bridge-1.0.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-gemini_bridge-1.0.1.dist-info/licenses/LICENSE,sha256=yTz_R8ocWu64Eubxr6vdZCKRS0dB_Pi3RbjUNn4qPxQ,1063
-src/__init__.py,sha256=4DkVQMA4JJ2eUEDNpi3sMJh94joDfaG_52p7Dro6cQI,190
-src/__main__.py,sha256=12FoIYCXYYKu2_BYX1GS_h9E9qO41Q26B8zedRIDPBs,149
-src/mcp_server.py,sha256=SGdrmNMvpCvJseSvvMlBGvDS71RkwWS7yM4JnSPg_Yg,6871
-gemini_bridge-1.0.1.dist-info/METADATA,sha256=C6gVIb1Z2OHpAPHA8F2_Ub42E6InC3ROjZTYEfqjONI,7825
-gemini_bridge-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gemini_bridge-1.0.1.dist-info/entry_points.txt,sha256=ygWf0B23Gygq8mW_GzPx8rxIA19RR_RH4RG2I15lU3E,43
-gemini_bridge-1.0.1.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
-gemini_bridge-1.0.1.dist-info/RECORD,,