stravinsky 0.1.2__py3-none-any.whl

mcp_bridge/tools/model_invoke.py

@@ -0,0 +1,233 @@
+"""
+Model invocation tools for Gemini and OpenAI.
+
+These tools use OAuth tokens from the token store to authenticate
+API requests to external model providers.
+"""
+
+import time
+
+import httpx
+
+from ..auth.token_store import TokenStore
+from ..auth.oauth import refresh_access_token as gemini_refresh, ANTIGRAVITY_HEADERS
+from ..auth.openai_oauth import refresh_access_token as openai_refresh
+
+
+async def _ensure_valid_token(token_store: TokenStore, provider: str) -> str:
+    """
+    Get a valid access token, refreshing if needed.
+    
+    Args:
+        token_store: Token store
+        provider: Provider name
+        
+    Returns:
+        Valid access token
+        
+    Raises:
+        ValueError: If not authenticated
+    """
+    # Check if token needs refresh (with 5 minute buffer)
+    if token_store.needs_refresh(provider, buffer_seconds=300):
+        token = token_store.get_token(provider)
+        
+        if not token or not token.get("refresh_token"):
+            raise ValueError(
+                f"Not authenticated with {provider}. "
+                f"Run: python -m mcp_bridge.auth.cli login {provider}"
+            )
+        
+        try:
+            if provider == "gemini":
+                result = gemini_refresh(token["refresh_token"])
+            elif provider == "openai":
+                result = openai_refresh(token["refresh_token"])
+            else:
+                raise ValueError(f"Unknown provider: {provider}")
+            
+            # Update stored token
+            token_store.set_token(
+                provider=provider,
+                access_token=result.access_token,
+                refresh_token=result.refresh_token or token["refresh_token"],
+                expires_at=time.time() + result.expires_in,
+            )
+            
+            return result.access_token
+        except Exception as e:
+            raise ValueError(
+                f"Token refresh failed: {e}. "
+                f"Run: python -m mcp_bridge.auth.cli login {provider}"
+            )
+    
+    access_token = token_store.get_access_token(provider)
+    if not access_token:
+        raise ValueError(
+            f"Not authenticated with {provider}. "
+            f"Run: python -m mcp_bridge.auth.cli login {provider}"
+        )
+    
+    return access_token
+
+
+async def invoke_gemini(
+    token_store: TokenStore,
+    prompt: str,
+    model: str = "gemini-3-flash",
+    temperature: float = 0.7,
+    max_tokens: int = 4096,
+    thinking_budget: int = 0,
+) -> str:
+    """
+    Invoke a Gemini model with the given prompt.
+
+    Uses OAuth authentication with Antigravity credentials.
+
+    Args:
+        token_store: Token store for OAuth credentials
+        prompt: The prompt to send to Gemini
+        model: Gemini model to use
+        temperature: Sampling temperature (0.0-2.0)
+        max_tokens: Maximum tokens in response
+
+    Returns:
+        The model's response text.
+
+    Raises:
+        ValueError: If not authenticated with Gemini
+        httpx.HTTPStatusError: If API request fails
+    """
+    access_token = await _ensure_valid_token(token_store, "gemini")
+
+    # Gemini API endpoint with OAuth
+    api_url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "Content-Type": "application/json",
+        **ANTIGRAVITY_HEADERS,  # Include Antigravity headers
+    }
+
+    payload = {
+        "contents": [{"parts": [{"text": prompt}]}],
+        "generationConfig": {
+            "temperature": temperature,
+            "maxOutputTokens": max_tokens,
+        },
+    }
+    
+    # Add thinking budget if supported by model/API
+    if thinking_budget > 0:
+        # For Gemini 2.0+ Thinking models
+        payload["generationConfig"]["thinkingConfig"] = {
+            "includeThoughts": True,
+            "tokenLimit": thinking_budget
+        }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            api_url,
+            headers=headers,
+            json=payload,
+            timeout=120.0,
+        )
+        
+        if response.status_code == 401:
+            raise ValueError(
+                "Gemini authentication expired. "
+                "Run: python -m mcp_bridge.auth.cli login gemini"
+            )
+        
+        response.raise_for_status()
+
+        data = response.json()
+
+        # Extract text from response
+        try:
+            candidates = data.get("candidates", [])
+            if candidates:
+                content = candidates[0].get("content", {})
+                parts = content.get("parts", [])
+                if parts:
+                    return parts[0].get("text", "")
+            return "No response generated"
+        except (KeyError, IndexError) as e:
+            return f"Error parsing response: {e}"
+
+
+async def invoke_openai(
+    token_store: TokenStore,
+    prompt: str,
+    model: str = "gpt-5.2",
+    temperature: float = 0.7,
+    max_tokens: int = 4096,
+    thinking_budget: int = 0,
+) -> str:
+    """
+    Invoke an OpenAI model with the given prompt.
+
+    Args:
+        token_store: Token store for API key
+        prompt: The prompt to send to OpenAI
+        model: OpenAI model to use
+        temperature: Sampling temperature (0.0-2.0)
+        max_tokens: Maximum tokens in response
+
+    Returns:
+        The model's response text.
+
+    Raises:
+        ValueError: If not authenticated with OpenAI
+        httpx.HTTPStatusError: If API request fails
+    """
+    access_token = await _ensure_valid_token(token_store, "openai")
+
+    # OpenAI Chat Completions API
+    api_url = "https://api.openai.com/v1/chat/completions"
+
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "Content-Type": "application/json",
+    }
+
+    payload = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": temperature,
+    }
+    
+    # Handle thinking budget for O1/O3 style models (GPT-5.2)
+    if thinking_budget > 0:
+        payload["max_completion_tokens"] = max_tokens + thinking_budget
+        # For O1, temperature must be 1.0 or omitted usually, but we'll try to pass it
+    else:
+        payload["max_tokens"] = max_tokens
+
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            api_url,
+            headers=headers,
+            json=payload,
+            timeout=120.0,
+        )
+        
+        if response.status_code == 401:
+            raise ValueError(
+                "OpenAI authentication failed. "
+                "Run: python -m mcp_bridge.auth.cli login openai"
+            )
+        
+        response.raise_for_status()
+
+        data = response.json()
+
+        # Extract text from response
+        try:
+            choices = data.get("choices", [])
+            if choices:
+                message = choices[0].get("message", {})
+                return message.get("content", "")
+            return "No response generated"
+        except (KeyError, IndexError) as e:
+            return f"Error parsing response: {e}"

mcp_bridge/tools/project_context.py

@@ -0,0 +1,141 @@
+"""
+Project Context and System Health Tools.
+
+Provides the agent with environmental awareness (Git, Rules, Todos)
+and ensures all required dependencies are installed and authenticated.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..auth.token_store import TokenStore
+
+
+async def get_project_context(project_path: Optional[str] = None) -> str:
+    """
+    Summarize project environment: Git status, local rules, and pending todos.
+    
+    Args:
+        project_path: Path to the project root
+        
+    Returns:
+        Formatted summary of the project context.
+    """
+    root = Path(project_path) if project_path else Path.cwd()
+    context = []
+
+    # 1. Git Information
+    context.append("### 🌿 Git Context")
+    try:
+        branch = subprocess.check_output(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"], 
+            stderr=subprocess.DEVNULL, text=True
+        ).strip()
+        status = subprocess.check_output(
+            ["git", "status", "--short"], 
+            stderr=subprocess.DEVNULL, text=True
+        ).strip()
+        
+        context.append(f"**Branch**: `{branch}`")
+        if status:
+            files_changed = len(status.split("\n"))
+            context.append(f"**Status**: {files_changed} files modified (staged/unstaged)")
+        else:
+            context.append("**Status**: Clean")
+    except Exception:
+        context.append("**Status**: Not a git repository")
+
+    # 2. Local Rules (.claude/rules/)
+    rules_dir = root / ".claude" / "rules"
+    if rules_dir.exists():
+        context.append("\n### 📜 Local Project Rules")
+        rule_files = list(rules_dir.glob("*.md"))
+        if rule_files:
+            for rf in rule_files:
+                try:
+                    content = rf.read_text().strip()
+                    context.append(f"#### {rf.name}\n{content}")
+                except Exception:
+                    continue
+        else:
+            context.append("_No specific rules found in .claude/rules/_")
+
+    # 3. Pending Todos
+    context.append("\n### 📝 Pending Todos (Top 20)")
+    try:
+        # Search for [ ] in code files, excluding common noise directories
+        todo_cmd = [
+            "rg", "--line-number", "--no-heading", "--column",
+            "--glob", "!.git/*", "--glob", "!node_modules/*",
+            "--glob", "!.venv/*",
+            r"\[ \]", str(root)
+        ]
+        todo_output = subprocess.check_output(
+            todo_cmd, stderr=subprocess.DEVNULL, text=True
+        ).strip()
+        
+        if todo_output:
+            lines = todo_output.split("\n")[:20]
+            for line in lines:
+                context.append(f"- {line}")
+            if len(todo_output.split("\n")) > 20:
+                context.append("_(... and more)_")
+        else:
+            context.append("_No pending [ ] markers found._")
+    except Exception:
+        context.append("_Ripgrep not found or error searching for todos._")
+
+    return "\n".join(context)
+
+
+async def get_system_health() -> str:
+    """
+    Comprehensive check of system dependencies and authentication status.
+    
+    Returns:
+        Checklist of system health.
+    """
+    health = ["## 🏥 Stravinsky System Health Report\n"]
+    
+    # 1. CLI Dependencies
+    health.append("### 🛠️ CLI Dependencies")
+    dependencies = {
+        "rg": "ripgrep",
+        "fd": "fd-find",
+        "sg": "ast-grep",
+        "gh": "GitHub CLI",
+        "ruff": "Python Linter",
+        "tsc": "TypeScript Compiler",
+        "git": "Git"
+    }
+    
+    for cmd, name in dependencies.items():
+        path = shutil.which(cmd)
+        status = "✅" if path else "❌"
+        health.append(f"- {status} **{name}** (`{cmd}`): {'Installed' if path else 'MISSING'}")
+
+    # 2. Authentication Status
+    health.append("\n### 🔑 Provider Authentication")
+    token_store = TokenStore()
+    providers = ["gemini", "openai"]
+    
+    for p in providers:
+        has_token = token_store.has_valid_token(p)
+        status = "✅" if has_token else "❌"
+        health.append(f"- {status} **{p.capitalize()}**: {'Authenticated' if has_token else 'NOT LOGGED IN'}")
+
+    # 3. Environment
+    health.append("\n### 🐍 Environment")
+    health.append(f"- **Python**: `{sys.version.split()[0]}`")
+    health.append(f"- **Virtualenv**: `{os.environ.get('VIRTUAL_ENV', 'None')}`")
+    
+    health.append("\n---")
+    health.append("**Resolution Guide**:")
+    health.append("- For missing CLI tools: Use `brew install` or `npm install -g` as appropriate.")
+    health.append("- For Auth: Run `python -m mcp_bridge.auth.cli login [provider]`.")
+    
+    return "\n".join(health)

mcp_bridge/tools/session_manager.py

@@ -0,0 +1,302 @@
+"""
+Session Manager Tools
+
+Tools for navigating and searching Claude Code session history.
+Sessions are stored in ~/.claude/projects/ as JSONL files.
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+def get_sessions_directory() -> Path:
+    """Get the Claude sessions directory."""
+    return Path.home() / ".claude" / "projects"
+
+
+def list_sessions(
+    project_path: str | None = None,
+    limit: int = 20,
+    from_date: str | None = None,
+    to_date: str | None = None,
+) -> str:
+    """
+    List Claude Code sessions with optional filtering.
+    
+    Args:
+        project_path: Filter by project path
+        limit: Maximum sessions to return
+        from_date: Filter from date (ISO format)
+        to_date: Filter until date (ISO format)
+        
+    Returns:
+        Formatted list of sessions.
+    """
+    sessions_dir = get_sessions_directory()
+    if not sessions_dir.exists():
+        return "No sessions directory found"
+    
+    sessions = []
+    
+    # Walk through project directories
+    for project_dir in sessions_dir.iterdir():
+        if not project_dir.is_dir():
+            continue
+        
+        # Check project path filter
+        if project_path:
+            # Project dirs are hashed, so we'd need a mapping
+            # For now, skip this filter
+            pass
+        
+        # Find session files
+        for session_file in project_dir.glob("*.jsonl"):
+            try:
+                stat = session_file.stat()
+                mtime = datetime.fromtimestamp(stat.st_mtime)
+                
+                # Date filters
+                if from_date:
+                    from_dt = datetime.fromisoformat(from_date)
+                    if mtime < from_dt:
+                        continue
+                if to_date:
+                    to_dt = datetime.fromisoformat(to_date)
+                    if mtime > to_dt:
+                        continue
+                
+                sessions.append({
+                    "id": session_file.stem,
+                    "path": str(session_file),
+                    "project": project_dir.name,
+                    "modified": mtime.isoformat(),
+                    "size": stat.st_size,
+                })
+            except Exception:
+                continue
+    
+    # Sort by modified time, newest first
+    sessions.sort(key=lambda s: s["modified"], reverse=True)
+    sessions = sessions[:limit]
+    
+    if not sessions:
+        return "No sessions found"
+    
+    lines = [f"Found {len(sessions)} sessions:\n"]
+    for s in sessions:
+        lines.append(f"  {s['id'][:12]}... ({s['modified'][:10]})")
+    
+    return "\n".join(lines)
+
+
+def read_session(
+    session_id: str,
+    limit: int | None = None,
+    include_metadata: bool = False,
+) -> str:
+    """
+    Read messages from a session.
+    
+    Args:
+        session_id: Session ID (filename stem)
+        limit: Maximum messages to read
+        include_metadata: Include message metadata
+        
+    Returns:
+        Formatted session content.
+    """
+    sessions_dir = get_sessions_directory()
+    
+    # Find session file
+    session_file = None
+    for project_dir in sessions_dir.iterdir():
+        if not project_dir.is_dir():
+            continue
+        candidate = project_dir / f"{session_id}.jsonl"
+        if candidate.exists():
+            session_file = candidate
+            break
+        # Also check partial matches
+        for f in project_dir.glob(f"{session_id}*.jsonl"):
+            session_file = f
+            break
+    
+    if not session_file or not session_file.exists():
+        return f"Session not found: {session_id}"
+    
+    messages = []
+    try:
+        with open(session_file) as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        msg = json.loads(line)
+                        messages.append(msg)
+                    except json.JSONDecodeError:
+                        continue
+    except Exception as e:
+        return f"Error reading session: {e}"
+    
+    if limit and limit > 0:
+        messages = messages[:limit]
+    
+    if not messages:
+        return "Session is empty"
+    
+    lines = [f"Session: {session_id}\nMessages: {len(messages)}\n"]
+    
+    for i, msg in enumerate(messages[:50]):  # Limit display
+        role = msg.get("role", "unknown")
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            content = " ".join(str(c.get("text", "")) for c in content if isinstance(c, dict))
+        content = content[:200] + "..." if len(content) > 200 else content
+        lines.append(f"[{i+1}] {role}: {content}")
+    
+    if len(messages) > 50:
+        lines.append(f"\n... and {len(messages) - 50} more messages")
+    
+    return "\n".join(lines)
+
+
+def search_sessions(
+    query: str,
+    session_id: str | None = None,
+    case_sensitive: bool = False,
+    limit: int = 20,
+) -> str:
+    """
+    Search across session messages.
+    
+    Args:
+        query: Search query
+        session_id: Search in specific session only
+        case_sensitive: Case-sensitive search
+        limit: Maximum results
+        
+    Returns:
+        Search results with context.
+    """
+    sessions_dir = get_sessions_directory()
+    results = []
+    
+    search_query = query if case_sensitive else query.lower()
+    
+    # Find session files to search
+    session_files = []
+    for project_dir in sessions_dir.iterdir():
+        if not project_dir.is_dir():
+            continue
+        
+        if session_id:
+            for f in project_dir.glob(f"{session_id}*.jsonl"):
+                session_files.append(f)
+        else:
+            session_files.extend(project_dir.glob("*.jsonl"))
+    
+    for session_file in session_files[:50]:  # Limit sessions to search
+        try:
+            with open(session_file) as f:
+                for line_num, line in enumerate(f):
+                    if not line.strip():
+                        continue
+                    
+                    check_line = line if case_sensitive else line.lower()
+                    if search_query in check_line:
+                        try:
+                            msg = json.loads(line)
+                            content = msg.get("content", "")
+                            if isinstance(content, list):
+                                content = " ".join(
+                                    str(c.get("text", "")) for c in content if isinstance(c, dict)
+                                )
+                            
+                            results.append({
+                                "session": session_file.stem[:12],
+                                "line": line_num,
+                                "role": msg.get("role", "unknown"),
+                                "snippet": content[:150],
+                            })
+                            
+                            if len(results) >= limit:
+                                break
+                        except json.JSONDecodeError:
+                            continue
+        except Exception:
+            continue
+        
+        if len(results) >= limit:
+            break
+    
+    if not results:
+        return f"No results for: {query}"
+    
+    lines = [f"Found {len(results)} matches for '{query}':\n"]
+    for r in results:
+        lines.append(f"  [{r['session']}] {r['role']}: {r['snippet']}...")
+    
+    return "\n".join(lines)
+
+
+def get_session_info(session_id: str) -> str:
+    """
+    Get metadata about a session.
+    
+    Args:
+        session_id: Session ID
+        
+    Returns:
+        Session metadata and statistics.
+    """
+    sessions_dir = get_sessions_directory()
+    
+    # Find session file
+    session_file = None
+    for project_dir in sessions_dir.iterdir():
+        if not project_dir.is_dir():
+            continue
+        for f in project_dir.glob(f"{session_id}*.jsonl"):
+            session_file = f
+            break
+        if session_file:
+            break
+    
+    if not session_file or not session_file.exists():
+        return f"Session not found: {session_id}"
+    
+    try:
+        stat = session_file.stat()
+        message_count = 0
+        user_count = 0
+        assistant_count = 0
+        
+        with open(session_file) as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        msg = json.loads(line)
+                        message_count += 1
+                        role = msg.get("role", "")
+                        if role == "user":
+                            user_count += 1
+                        elif role == "assistant":
+                            assistant_count += 1
+                    except json.JSONDecodeError:
+                        continue
+        
+        lines = [
+            f"Session: {session_id}",
+            f"File: {session_file}",
+            f"Size: {stat.st_size / 1024:.1f} KB",
+            f"Modified: {datetime.fromtimestamp(stat.st_mtime).isoformat()}",
+            f"Messages: {message_count}",
+            f"  User: {user_count}",
+            f"  Assistant: {assistant_count}",
+        ]
+        return "\n".join(lines)
+        
+    except Exception as e:
+        return f"Error: {e}"