stravinsky 0.4.18__py3-none-any.whl → 0.4.66__py3-none-any.whl

mcp_bridge/notifications.py

@@ -14,7 +14,6 @@ import logging
 import platform
 import subprocess
 from pathlib import Path
-from typing import Dict, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -35,7 +34,7 @@ class NotificationManager:
         title: str, 
         message: str, 
         sound: bool = True
-    ) -> Optional[list]:
+    ) -> list | None:
         """Get platform-specific notification command."""
         if self.system == "Darwin":  # macOS
             script = f'display notification "{message}" with title "{title}"'
@@ -113,7 +112,7 @@ $toast = New-Object Windows.UI.Notifications.ToastNotification $xml
         message = f"Indexing {path}..."
         return self._send_notification_sync(title, message, sound=True)
     
-    async def notify_reindex_complete(self, stats: Dict) -> bool:
+    async def notify_reindex_complete(self, stats: dict) -> bool:
         """Notify that codebase reindexing is complete."""
         indexed = stats.get("indexed", 0)
         pruned = stats.get("pruned", 0)
@@ -134,7 +133,7 @@ $toast = New-Object Windows.UI.Notifications.ToastNotification $xml
 
 
 # Global singleton instance
-_notification_manager: Optional[NotificationManager] = None
+_notification_manager: NotificationManager | None = None
 
 
 def get_notification_manager() -> NotificationManager:

mcp_bridge/orchestrator/enums.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class OrchestrationPhase(Enum):
+    CLASSIFY = "classify"
+    CONTEXT = "context"
+    WISDOM = "wisdom"
+    PLAN = "plan"
+    VALIDATE = "validate"
+    DELEGATE = "delegate"
+    EXECUTE = "execute"
+    VERIFY = "verify"

mcp_bridge/orchestrator/router.py

@@ -0,0 +1,165 @@
+from dataclasses import dataclass
+
+from ..routing.config import load_routing_config
+from ..routing.provider_state import get_provider_tracker
+from ..routing.task_classifier import TaskType, classify_and_route
+from ..routing.model_tiers import get_oauth_fallback_chain
+from .enums import OrchestrationPhase
+
+
+@dataclass
+class ModelConfig:
+    planning_model: str = "gemini-3-pro"  # Default smart
+    execution_model: str = "gemini-3-flash"  # Default fast
+
+
+class Router:
+    """
+    Intelligent model router with multi-provider fallback and task-based routing.
+
+    Features:
+    - Automatic fallback when providers hit rate limits
+    - Task-based routing to optimal models (code gen → OpenAI, docs → Gemini)
+    - Provider state tracking with cooldown management
+    - Project-local configuration support
+    """
+
+    def __init__(self, config: ModelConfig | None = None, project_path: str = "."):
+        self.config = config or ModelConfig()
+        self.project_path = project_path
+
+        # Load routing configuration
+        self.routing_config = load_routing_config(project_path)
+
+        # Get provider state tracker singleton
+        self.provider_tracker = get_provider_tracker()
+
+    def select_model(
+        self,
+        phase: OrchestrationPhase,
+        task_type: TaskType | None = None,
+        prompt: str | None = None,
+    ) -> str:
+        """
+        Selects the best model for the given phase and task type.
+
+        Args:
+            phase: Orchestration phase (PLAN, EXECUTE, etc.)
+            task_type: Optional task type override (CODE_GENERATION, DEBUGGING, etc.)
+            prompt: Optional prompt text for automatic task classification
+
+        Returns:
+            Model identifier string (e.g., "gemini-3-flash", "gpt-5.2-codex")
+        """
+        # If task_type is provided or can be inferred, use task-based routing
+        if task_type or prompt:
+            # classify_and_route returns (TaskType, provider, model) tuple
+            # Extract just the TaskType
+            if task_type:
+                inferred_type = task_type
+            else:
+                # classify_and_route returns tuple: (TaskType, provider, model)
+                classification_result = classify_and_route(prompt or "")
+                inferred_type = classification_result[0]  # Extract TaskType from tuple
+
+            model = self._select_by_task_type(inferred_type)
+
+            # Check provider availability and fallback if needed
+            return self._check_availability_and_fallback(model, inferred_type)
+
+        # Fallback to phase-based routing (legacy behavior)
+        if phase in [
+            OrchestrationPhase.PLAN,
+            OrchestrationPhase.VALIDATE,
+            OrchestrationPhase.WISDOM,
+            OrchestrationPhase.VERIFY,
+        ]:
+            model = self.config.planning_model
+        else:
+            model = self.config.execution_model
+
+        return self._check_availability_and_fallback(model, None)
+
+    def _select_by_task_type(self, task_type: TaskType) -> str:
+        """
+        Select model based on task type using routing config.
+
+        Args:
+            task_type: Classified task type
+
+        Returns:
+            Primary model for this task type
+        """
+        # Look up task routing rule in config (it's a dict[str, TaskRoutingRule])
+        task_name = task_type.name.lower()
+        if task_name in self.routing_config.task_routing:
+            rule = self.routing_config.task_routing[task_name]
+            if rule.model:
+                return rule.model
+
+        # Fallback to default execution model if no rule matches
+        return self.config.execution_model
+
+    def _check_availability_and_fallback(self, model: str, task_type: TaskType | None) -> str:
+        """
+        Check provider availability and apply fallback if rate-limited.
+
+        Args:
+            model: Desired model
+            task_type: Task type (for finding appropriate fallback)
+
+        Returns:
+            Available model (original or fallback)
+        """
+        # Determine provider from model name
+        provider = self._get_provider_from_model(model)
+
+        # Check provider availability using is_available() method
+        if self.provider_tracker.is_available(provider):
+            return model
+
+        # Prefer tier-aware OAuth fallback chain when possible.
+        # Note: use_oauth=False candidates represent non-OAuth access
+        # (currently meaningful for Gemini API key fallback).
+        try:
+            oauth_chain = get_oauth_fallback_chain(provider, model)
+        except ValueError:
+            oauth_chain = []
+
+        for candidate_provider, candidate_model, use_oauth in oauth_chain:
+            if not use_oauth and candidate_provider == "gemini":
+                return candidate_model
+            if self.provider_tracker.is_available(candidate_provider):
+                return candidate_model
+
+        # Provider unavailable - use global fallback chain (legacy)
+        # NOTE: Task-specific fallbacks from routing config are not currently
+        # implemented (TaskRoutingRule doesn't have fallback_models field)
+        for fallback_provider in self.routing_config.fallback.chain:
+            if self.provider_tracker.is_available(fallback_provider):
+                # Map provider to default model
+                return self._get_default_model_for_provider(fallback_provider)
+
+        # All providers unavailable - return original model and let caller handle error
+        return model
+
+    def _get_provider_from_model(self, model: str) -> str:
+        """Extract provider name from model identifier."""
+        if "gemini" in model.lower():
+            return "gemini"
+        elif "gpt" in model.lower() or "openai" in model.lower():
+            return "openai"
+        elif "claude" in model.lower():
+            return "claude"
+        else:
+            # Default to gemini for unknown models
+            return "gemini"
+
+    def _get_default_model_for_provider(self, provider: str) -> str:
+        """Get default model for a provider."""
+        defaults = {
+            "gemini": "gemini-3-flash",
+            "openai": "gpt-5.2-codex",
+            "claude": "claude-sonnet-4.5",
+        }
+        return defaults.get(provider, "gemini-3-flash")

mcp_bridge/orchestrator/state.py

@@ -0,0 +1,32 @@
+from typing import List, Dict, Optional, Callable
+from .enums import OrchestrationPhase
+
+class OrchestratorState:
+    def __init__(self, enable_phase_gates: bool = False, approver: Optional[Callable[[], bool]] = None):
+        self.current_phase = OrchestrationPhase.CLASSIFY
+        self.history: List[OrchestrationPhase] = []
+        self.artifacts: Dict[str, str] = {}
+        self.enable_phase_gates = enable_phase_gates
+        self.approver = approver
+        
+    def transition_to(self, next_phase: OrchestrationPhase):
+        """Transitions to the next phase if requirements are met."""
+        self._validate_transition(next_phase)
+        
+        # Phase Gates
+        if self.enable_phase_gates and self.approver:
+            if not self.approver():
+                raise PermissionError(f"Transition to {next_phase} denied by user.")
+        
+        self.history.append(self.current_phase)
+        self.current_phase = next_phase
+        
+    def register_artifact(self, name: str, content: str):
+        self.artifacts[name] = content
+        
+    def _validate_transition(self, next_phase: OrchestrationPhase):
+        """Enforce strict phase requirements."""
+        # Example: Must have plan before validation
+        if next_phase == OrchestrationPhase.VALIDATE:
+            if "plan.md" not in self.artifacts and self.current_phase == OrchestrationPhase.PLAN:
+                raise ValueError("Missing artifact: plan.md is required to enter Validation phase")

mcp_bridge/orchestrator/visualization.py

@@ -0,0 +1,14 @@
+from .enums import OrchestrationPhase
+
+def format_phase_progress(current_phase: OrchestrationPhase) -> str:
+    """Formats the current phase as a progress string."""
+    phases = list(OrchestrationPhase)
+    total = len(phases)
+    
+    # Find index (1-based)
+    try:
+        index = phases.index(current_phase) + 1
+    except ValueError:
+        index = 0
+        
+    return f"[Phase {index}/{total}: {current_phase.name}]"

mcp_bridge/orchestrator/wisdom.py

@@ -0,0 +1,34 @@
+import os
+from pathlib import Path
+
+class WisdomLoader:
+    def __init__(self, wisdom_path: str = ".stravinsky/wisdom.md"):
+        self.wisdom_path = wisdom_path
+        
+    def load_wisdom(self) -> str:
+        """Loads project wisdom/learnings."""
+        if os.path.exists(self.wisdom_path):
+            try:
+                with open(self.wisdom_path, "r") as f:
+                    return f.read()
+            except Exception:
+                return ""
+        return ""
+
+class CritiqueGenerator:
+    def generate_critique_prompt(self, plan_content: str) -> str:
+        """Generates a prompt for self-critique."""
+        return f"""
+You are currently in the CRITIQUE phase.
+Review the following plan and identify potential weaknesses.
+
+PLAN:
+{plan_content}
+
+INSTRUCTIONS:
+1. List 3 ways this plan could fail (edge cases, race conditions, missing context).
+2. Check if it violates any items in the 'Wisdom' file (if provided).
+3. Propose specific improvements.
+
+Respond with your critique.
+"""

mcp_bridge/prompts/__init__.py

@@ -1,12 +1,5 @@
 # Agent prompts module
-from . import stravinsky
-from . import delphi
-from . import dewey
-from . import explore
-from . import frontend
-from . import document_writer
-from . import multimodal
-from . import planner
+from . import delphi, dewey, document_writer, explore, frontend, multimodal, planner, stravinsky
 
 __all__ = [
     "stravinsky",

mcp_bridge/prompts/dewey.py

@@ -44,7 +44,7 @@ Your job: Answer questions about open-source libraries by finding **EVIDENCE** w
 
 ---
 
-## PHASE 0: REQUEST CLASSIFICATION (MANDATORY FIRST STEP)
+## PHASE 0: REQUEST CLASSIFICATION (MANDATORY FUWT STEP)
 
 Classify EVERY request into one of these categories before taking action:
 

mcp_bridge/prompts/planner.py

@@ -13,8 +13,6 @@ Key capabilities:
 - Structured plan output for orchestrator consumption
 """
 
-from typing import Optional
-
 
 PLANNER_ROLE = """<Role>
 You are "Planner" - a pre-implementation planning specialist.
@@ -177,8 +175,8 @@ Before finalizing plan, verify:
 
 def get_planner_prompt(
     task_description: str,
-    project_context: Optional[str] = None,
-    existing_patterns: Optional[str] = None,
+    project_context: str | None = None,
+    existing_patterns: str | None = None,
 ) -> str:
     """
     Generate the complete planner prompt.

mcp_bridge/prompts/stravinsky.py

@@ -12,8 +12,6 @@ Key naming conventions (Stravinsky equivalents):
 - agent_spawn (not call-omo-agent) - spawn background agents
 """
 
-from typing import Optional
-
 # Core role definition
 STRAVINSKY_ROLE_SECTION = """<Role>
 You are "Stravinsky" - Powerful AI Agent with orchestration capabilities from Stravinsky MCP.
@@ -36,7 +34,7 @@ Named after the composer known for revolutionary orchestration.
 </Role>"""
 
 
-STRAVINSKY_PHASE0_STEP1_3 = """### Step 0: Check Skills FIRST (BLOCKING)
+STRAVINSKY_PHASE0_STEP1_3 = """### Step 0: Check Skills FUWT (BLOCKING)
 
 **Before ANY classification or action, scan for matching skills.**
 
@@ -54,7 +52,7 @@ Skills are specialized workflows. When relevant, they handle the task better tha
 
 | Type | Signal | Action |
 |------|--------|--------|
-| **Skill Match** | Matches skill trigger phrase | **INVOKE skill FIRST** via `skill_get` tool |
+| **Skill Match** | Matches skill trigger phrase | **INVOKE skill FUWT** via `skill_get` tool |
 | **Trivial** | Single file, known location, direct answer | Direct tools only (UNLESS Key Trigger applies) |
 | **Explicit** | Specific file/line, clear command | Execute directly |
 | **Exploratory** | "How does X work?", "Find Y" | Fire explore (1-3) + tools in parallel |
@@ -159,7 +157,7 @@ STOP searching when:
 **DO NOT over-explore. Time is precious.**"""
 
 
-STRAVINSKY_PHASE2B_PRE_IMPLEMENTATION = """## ⚠️ CRITICAL: PARALLEL-FIRST WORKFLOW
+STRAVINSKY_PHASE2B_PRE_IMPLEMENTATION = """## ⚠️ CRITICAL: PARALLEL-FUWT WORKFLOW
 
 **BLOCKING REQUIREMENT**: For implementation tasks, your response structure MUST be:
 
@@ -204,54 +202,78 @@ todowrite([todo1, todo2, todo3])
 4. THEN mark todos complete"""
 
 
-STRAVINSKY_DELEGATION_PROMPT_STRUCTURE = """### Delegation Prompt Structure (MANDATORY - ALL 7 sections):
+STRAVINSKY_DELEGATION_PROMPT_STRUCTURE = """### Delegation Prompt Structure (RECOMMENDED - 5 KEY SECTIONS):
 
-When delegating via `agent_spawn`, your prompt MUST include ALL 7 sections:
+When delegating via `agent_spawn`, your prompt SHOULD include these sections:
 
 ```
-1. TASK: Atomic, specific goal (one sentence)
+1. TASK: Clear, natural language description of what needs to be found/analyzed
 2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED TOOLS: Explicit tool whitelist (Read, Grep, Glob, etc.)
-4. MUST DO: Exhaustive requirements list
-5. MUST NOT DO: Forbidden actions (prevent rogue behavior)
-6. CONTEXT: File paths, existing patterns, constraints
-7. SUCCESS CRITERIA: How to verify completion
+3. MUST DO: Exhaustive requirements list
+4. MUST NOT DO: Forbidden actions (prevent rogue behavior)
+5. CONTEXT: File paths, existing patterns, constraints (if known)
 ```
 
-**Example Delegation Prompt:**
+**❌ WRONG - Over-Prescribing Tools:**
 ```
 ## TASK
 Find all API endpoint definitions in the auth module.
 
-## EXPECTED OUTCOME
-List of endpoints with: path, method, handler function, file location.
-
 ## REQUIRED TOOLS
-Read, Grep, Glob
+Read, Grep, Glob  # ❌ DON'T PRESCRIBE TOOLS - agents choose optimal approach
+
+## MUST DO
+- Use grep_search to find "def" patterns  # ❌ TOO SPECIFIC
+```
+
+**✅ CORRECT - Natural Language + Trust Agent Intelligence:**
+```
+## TASK
+Find and explain all API endpoint definitions in the auth module, including their request/response patterns and how they connect to each other.
+
+## EXPECTED OUTCOME
+Complete list of endpoints with: path, method, handler function, file location, and architectural notes on how they integrate.
 
 ## MUST DO
-- Search in src/auth/ directory
-- Include path parameters
-- Report line numbers
+- Search in src/auth/ directory and related integration points
+- Include path parameters and query string handling
+- Report exact line numbers for each endpoint
+- Explain the authentication flow across endpoints
 
 ## MUST NOT DO
 - Modify any files
-- Search outside src/auth/
+- Skip integration patterns (how endpoints call each other)
 
 ## CONTEXT
 Project uses FastAPI. Auth endpoints handle login, logout, token refresh.
+This is a CONCEPTUAL/ARCHITECTURAL query - the agent should use semantic_search + grep for comprehensive coverage.
 
 ## SUCCESS CRITERIA
-All endpoints documented with complete paths and handlers.
+All endpoints documented with complete paths, handlers, AND architectural understanding of how they work together.
 ```
 
+**WHY THIS WORKS BETTER:**
+- ✅ Explore agent has `semantic_search` in its toolset and knows when to use it
+- ✅ Natural language tasks → agent classifies as SEMANTIC → uses semantic_search
+- ✅ Agent combines semantic_search (concepts) + grep_search (exact matches) automatically
+- ❌ "REQUIRED TOOLS: grep_search" → blocks semantic_search even for conceptual queries
+
+**TRUST THE AGENTS:**
+The explore agent already has comprehensive tool selection logic:
+- Semantic queries → semantic_search (primary)
+- Exact syntax → grep_search
+- Code structure → ast_grep_search
+- Symbol navigation → LSP tools
+
+Let them choose the optimal search strategy based on your TASK description, not prescriptive tool lists.
+
 AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS:
 - DOES IT WORK AS EXPECTED?
 - DOES IT FOLLOW THE EXISTING CODEBASE PATTERN?
 - EXPECTED RESULT CAME OUT?
 - DID THE AGENT FOLLOW "MUST DO" AND "MUST NOT DO" REQUIREMENTS?
 
-**Vague prompts = rejected. Be exhaustive.**"""
+**Natural language task descriptions = agent intelligence. Tool prescriptions = micromanagement.**"""
 
 
 STRAVINSKY_GITHUB_WORKFLOW = """### GitHub Workflow (CRITICAL - When mentioned in issues/PRs):
@@ -358,7 +380,7 @@ If verification fails:
 
 STRAVINSKY_KEY_TRIGGERS = """### Key Triggers (check BEFORE classification):
 
-**BLOCKING: Check skills FIRST before any action.**
+**BLOCKING: Check skills FUWT before any action.**
 If a skill matches, invoke it IMMEDIATELY via `skill_get` tool.
 
 - External library/source mentioned -> fire `dewey` background via `agent_spawn`
@@ -472,12 +494,12 @@ Delphi is an expensive, high-quality reasoning model. Use it wisely via `agent_s
 
 | Trigger | Action |
 |---------|--------|
-| Complex architecture design | Delphi FIRST, then implement |
-| After completing significant work | Delphi FIRST, then implement |
-| 2+ failed fix attempts | Delphi FIRST, then implement |
-| Unfamiliar code patterns | Delphi FIRST, then implement |
-| Security/performance concerns | Delphi FIRST, then implement |
-| Multi-system tradeoffs | Delphi FIRST, then implement |
+| Complex architecture design | Delphi FUWT, then implement |
+| After completing significant work | Delphi FUWT, then implement |
+| 2+ failed fix attempts | Delphi FUWT, then implement |
+| Unfamiliar code patterns | Delphi FUWT, then implement |
+| Security/performance concerns | Delphi FUWT, then implement |
+| Multi-system tradeoffs | Delphi FUWT, then implement |
 
 ### WHEN NOT to Consult:
 

mcp_bridge/proxy/client.py

@@ -0,0 +1,70 @@
+import os
+import httpx
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger("stravinsky.proxy_client")
+
+PROXY_URL = os.getenv("STRAVINSKY_PROXY_URL", "http://127.0.0.1:8765")
+
+async def proxy_invoke_gemini(
+    prompt: str,
+    model: str = "gemini-3-flash",
+    temperature: float = 0.7,
+    max_tokens: int = 8192,
+    thinking_budget: int = 0,
+    image_path: Optional[str] = None,
+    agent_context: Optional[dict[str, Any]] = None
+) -> str:
+    """Routes Gemini invocation to the proxy server."""
+    payload = {
+        "prompt": prompt,
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "thinking_budget": thinking_budget,
+        "image_path": image_path,
+        "agent_context": agent_context
+    }
+    
+    async with httpx.AsyncClient(timeout=130.0) as client:
+        try:
+            response = await client.post(f"{PROXY_URL}/v1/gemini/generate", json=payload)
+            response.raise_for_status()
+            return response.json()["response"]
+        except Exception as e:
+            logger.error(f"Proxy request failed: {e}")
+            raise
+
+async def proxy_invoke_openai(
+    prompt: str,
+    model: str = "gpt-5.2-codex",
+    temperature: float = 0.7,
+    max_tokens: int = 4096,
+    thinking_budget: int = 0,
+    reasoning_effort: str = "medium",
+    agent_context: Optional[dict[str, Any]] = None
+) -> str:
+    """Routes OpenAI invocation to the proxy server."""
+    payload = {
+        "prompt": prompt,
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "thinking_budget": thinking_budget,
+        "reasoning_effort": reasoning_effort,
+        "agent_context": agent_context
+    }
+    
+    async with httpx.AsyncClient(timeout=130.0) as client:
+        try:
+            response = await client.post(f"{PROXY_URL}/v1/openai/chat", json=payload)
+            response.raise_for_status()
+            return response.json()["response"]
+        except Exception as e:
+            logger.error(f"Proxy request failed: {e}")
+            raise
+
+def is_proxy_enabled() -> bool:
+    """Checks if proxy usage is enabled via environment variable."""
+    return os.getenv("STRAVINSKY_USE_PROXY", "false").lower() == "true"