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

mcp_bridge/native_watcher.py

@@ -0,0 +1,118 @@
+"""
+Native Watcher Integration - Rust-based file watching.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import subprocess
+import threading
+from pathlib import Path
+from typing import Optional, Callable
+
+logger = logging.getLogger(__name__)
+
+class NativeFileWatcher:
+    """
+    Python wrapper for the Rust-based stravinsky_watcher binary.
+    """
+    def __init__(self, project_path: str, on_change: Callable[[str, str], None]):
+        self.project_path = os.path.abspath(project_path)
+        self.on_change = on_change
+        self.process: Optional[subprocess.Popen] = None
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+
+    def _get_binary_path(self) -> Path:
+        """Find the stravinsky_watcher binary."""
+        # Try relative to this file
+        root_dir = Path(__file__).parent.parent
+        candidates = [
+            root_dir / "rust_native" / "target" / "release" / "stravinsky_watcher",
+            root_dir / "rust_native" / "target" / "debug" / "stravinsky_watcher",
+        ]
+        
+        for c in candidates:
+            if c.exists():
+                return c
+        
+        raise FileNotFoundError("stravinsky_watcher binary not found. Build it with cargo first.")
+
+    def start(self):
+        """Start the native watcher process in a background thread."""
+        if self.process:
+            return
+
+        binary_path = self._get_binary_path()
+        logger.info(f"Starting native watcher: {binary_path} {self.project_path}")
+        
+        self.process = subprocess.Popen(
+            [str(binary_path), self.project_path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1
+        )
+
+        self._thread = threading.Thread(target=self._read_stdout, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stop the native watcher process."""
+        self._stop_event.set()
+        
+        if self.process:
+            logger.info(f"Stopping native watcher process (PID: {self.process.pid})")
+            # Try to terminate gracefully first
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=1.0)
+            except subprocess.TimeoutExpired:
+                logger.warning(f"Native watcher (PID: {self.process.pid}) did not terminate, killing...")
+                self.process.kill()
+                try:
+                    self.process.wait(timeout=1.0)
+                except subprocess.TimeoutExpired:
+                    logger.error(f"Failed to kill native watcher (PID: {self.process.pid})")
+            
+            # Close streams
+            if self.process.stdout:
+                self.process.stdout.close()
+            if self.process.stderr:
+                self.process.stderr.close()
+                
+            self.process = None
+            
+        # Wait for reader thread to exit
+        if self._thread and self._thread.is_alive():
+            # Don't join with timeout in main thread if it might block,
+            # but since we closed stdout, the reader loop should break.
+            self._thread.join(timeout=1.0)
+            if self._thread.is_alive():
+                logger.warning("Native watcher reader thread did not exit cleanly")
+            self._thread = None
+
+    def _read_stdout(self):
+        """Read JSON events from the watcher's stdout."""
+        if not self.process or not self.process.stdout:
+            return
+
+        for line in self.process.stdout:
+            if self._stop_event.is_set():
+                break
+            
+            line = line.strip()
+            if not line or not line.startswith("{"):
+                continue
+
+            try:
+                event = json.loads(line)
+                change_type = event.get("type", "unknown")
+                path = event.get("path", "")
+                self.on_change(change_type, path)
+            except json.JSONDecodeError:
+                logger.error(f"Failed to decode watcher event: {line}")
+
+    def is_running(self) -> bool:
+        return self.process is not None and self.process.poll() is None

mcp_bridge/notifications.py

@@ -0,0 +1,150 @@
+"""
+Desktop Notifications Manager for Stravinsky.
+
+Provides cross-platform desktop notifications (macOS, Linux, Windows)
+for long-running operations like codebase indexing.
+
+Supports:
+- Non-blocking async notifications
+- Platform-specific backends
+- Notification queuing
+"""
+
+import logging
+import platform
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationManager:
+    """
+    Cross-platform desktop notification manager.
+    
+    Provides non-blocking notifications with automatic platform detection.
+    """
+    
+    def __init__(self, app_name: str = "Stravinsky"):
+        self.app_name = app_name
+        self.system = platform.system()
+    
+    def _get_notification_command(
+        self, 
+        title: str, 
+        message: str, 
+        sound: bool = True
+    ) -> list | None:
+        """Get platform-specific notification command."""
+        if self.system == "Darwin":  # macOS
+            script = f'display notification "{message}" with title "{title}"'
+            if sound:
+                script += ' sound name "Glass"'
+            return ["osascript", "-e", script]
+        
+        elif self.system == "Linux":
+            cmd = ["notify-send", "--app-name", self.app_name, title, message]
+            if sound:
+                cmd.extend(["--urgency=normal"])
+            return cmd
+        
+        elif self.system == "Windows":
+            ps_script = f"""
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
+
+$template = @"
+<toast>
+    <visual>
+        <binding template="ToastGeneric">
+            <text>{title}</text>
+            <text>{message}</text>
+        </binding>
+    </visual>
+</toast>
+"@
+
+$xml = New-Object Windows.Data.Xml.Dom.XmlDocument
+$xml.LoadXml($template)
+$toast = New-Object Windows.UI.Notifications.ToastNotification $xml
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("{self.app_name}").Show($toast)
+"""
+            return ["powershell", "-Command", ps_script]
+        
+        return None
+    
+    def _send_notification_sync(
+        self,
+        title: str,
+        message: str,
+        sound: bool = True
+    ) -> bool:
+        """Send notification synchronously (blocking)."""
+        cmd = self._get_notification_command(title, message, sound)
+        
+        if not cmd:
+            logger.warning(
+                f"[Notifications] Desktop notifications not supported on {self.system}"
+            )
+            return False
+        
+        try:
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            logger.debug(f"[Notifications] Sent: {title}")
+            return True
+        except FileNotFoundError:
+            logger.warning(f"[Notifications] Command not found: {cmd[0]}")
+            return False
+        except Exception as e:
+            logger.error(f"[Notifications] Failed to send notification: {e}")
+            return False
+    
+    async def notify_reindex_start(self, project_path: str) -> bool:
+        """Notify that codebase reindexing has started."""
+        path = Path(project_path).name or Path(project_path).parent.name
+        title = "Codebase Indexing Started"
+        message = f"Indexing {path}..."
+        return self._send_notification_sync(title, message, sound=True)
+    
+    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)
+        time_taken = stats.get("time_taken", 0)
+        
+        title = "Codebase Indexing Complete"
+        message = f"Indexed {indexed} chunks, pruned {pruned} stale entries in {time_taken}s"
+        
+        return self._send_notification_sync(title, message, sound=True)
+    
+    async def notify_reindex_error(self, error_message: str) -> bool:
+        """Notify that codebase reindexing failed."""
+        title = "Codebase Indexing Failed"
+        # Truncate long error messages
+        message = error_message[:100] + "..." if len(error_message) > 100 else error_message
+        
+        return self._send_notification_sync(title, message, sound=True)
+
+
+# Global singleton instance
+_notification_manager: NotificationManager | None = None
+
+
+def get_notification_manager() -> NotificationManager:
+    """Get or create the global notification manager instance."""
+    global _notification_manager
+    if _notification_manager is None:
+        _notification_manager = NotificationManager()
+    return _notification_manager
+
+
+def reset_notification_manager() -> None:
+    """Reset the global notification manager (for testing)."""
+    global _notification_manager
+    _notification_manager = None

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.