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

mcp_bridge/update_manager_pypi.py

@@ -0,0 +1,297 @@
+"""
+PyPI Update Manager for Stravinsky MCP server.
+
+Checks PyPI for new versions with throttling to prevent excessive API calls.
+Logs all checks to ~/.stravinsky/update.log for debugging and monitoring.
+Non-blocking background update checks on server startup.
+"""
+
+import logging
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+# Get the logger for this module
+logger = logging.getLogger(__name__)
+
+# Import version from main module
+from mcp_bridge import __version__
+
+
+def _get_stravinsky_home() -> Path | None:
+    """Get or create ~/.stravinsky directory."""
+    home_dir = Path.home() / ".stravinsky"
+    try:
+        home_dir.mkdir(parents=True, exist_ok=True)
+        return home_dir
+    except Exception as e:
+        logger.warning(f"Failed to create ~/.stravinsky directory: {e}")
+        return None
+
+
+def _get_last_check_time() -> datetime | None:
+    """
+    Read the last update check time from ~/.stravinsky/update.log.
+
+    Returns:
+        datetime of last check, or None if file doesn't exist or is invalid
+    """
+    try:
+        home_dir = _get_stravinsky_home()
+        if not home_dir:
+            return None
+
+        update_log = home_dir / "update.log"
+        if not update_log.exists():
+            return None
+
+        # Read the last line (most recent check)
+        with open(update_log) as f:
+            lines = f.readlines()
+            if not lines:
+                return None
+
+            last_line = lines[-1].strip()
+            if not last_line:
+                return None
+
+            # Parse format: YYYY-MM-DD HH:MM:SS | VERSION_CHECK | ...
+            parts = last_line.split(" | ")
+            if len(parts) < 1:
+                return None
+
+            timestamp_str = parts[0]
+            last_check = datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S")
+            return last_check
+
+    except Exception as e:
+        logger.debug(f"Failed to read last check time: {e}")
+        return None
+
+
+def _should_check(last_check_time: datetime | None) -> bool:
+    """
+    Determine if enough time has passed since the last check.
+
+    Args:
+        last_check_time: datetime of last check, or None
+
+    Returns:
+        True if 24+ hours have passed or no prior check exists
+    """
+    if last_check_time is None:
+        return True
+
+    now = datetime.now()
+    time_since_last_check = now - last_check_time
+
+    # Check if 24+ hours have passed
+    return time_since_last_check >= timedelta(hours=24)
+
+
+def _get_pypi_version() -> str | None:
+    """
+    Fetch the latest version of stravinsky from PyPI.
+
+    Uses: pip index versions stravinsky
+
+    Returns:
+        Version string (e.g., "0.3.10"), or None if unable to fetch
+    """
+    try:
+        # Run: pip index versions stravinsky
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "index", "versions", "stravinsky"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            logger.debug(f"pip index versions failed: {result.stderr}")
+            return None
+
+        # Parse output: first line is "Available versions: X.Y.Z, A.B.C, ..."
+        output = result.stdout.strip()
+        if not output:
+            logger.debug("pip index versions returned empty output")
+            return None
+
+        # Extract available versions line
+        lines = output.split("\n")
+        for line in lines:
+            if line.startswith("Available versions:"):
+                # Format: "Available versions: 0.3.10, 0.3.9, 0.3.8, ..."
+                versions_part = line.replace("Available versions:", "").strip()
+                versions = [v.strip() for v in versions_part.split(",")]
+
+                if versions:
+                    latest = versions[0]
+                    logger.debug(f"Latest version on PyPI: {latest}")
+                    return latest
+
+        logger.debug(f"Could not parse pip output: {output}")
+        return None
+
+    except subprocess.TimeoutExpired:
+        logger.warning("pip index versions timed out after 10 seconds")
+        return None
+    except Exception as e:
+        logger.debug(f"Failed to fetch PyPI version: {e}")
+        return None
+
+
+def _compare_versions(current: str, latest: str) -> bool:
+    """
+    Compare semantic versions.
+
+    Args:
+        current: Current version string (e.g., "0.3.9")
+        latest: Latest version string (e.g., "0.3.10")
+
+    Returns:
+        True if latest > current, False otherwise
+    """
+    try:
+        # Parse versions as tuples of integers
+        current_parts = [int(x) for x in current.split(".")]
+        latest_parts = [int(x) for x in latest.split(".")]
+
+        # Pad shorter version with zeros
+        max_len = max(len(current_parts), len(latest_parts))
+        current_parts += [0] * (max_len - len(current_parts))
+        latest_parts += [0] * (max_len - len(latest_parts))
+
+        # Tuple comparison works element-by-element
+        return tuple(latest_parts) > tuple(current_parts)
+
+    except Exception as e:
+        logger.debug(f"Failed to compare versions '{current}' and '{latest}': {e}")
+        return False
+
+
+def _log_check(current: str, latest: str | None, status: str) -> None:
+    """
+    Log the update check to ~/.stravinsky/update.log.
+
+    Format: YYYY-MM-DD HH:MM:SS | VERSION_CHECK | current=X.Y.Z pypi=A.B.C | <status>
+
+    Args:
+        current: Current version
+        latest: Latest version from PyPI (or None)
+        status: Check status ("new_available", "up_to_date", "error", etc.)
+    """
+    try:
+        home_dir = _get_stravinsky_home()
+        if not home_dir:
+            return
+
+        update_log = home_dir / "update.log"
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        if latest:
+            log_entry = f"{timestamp} | VERSION_CHECK | current={current} pypi={latest} | {status}"
+        else:
+            log_entry = f"{timestamp} | VERSION_CHECK | current={current} pypi=unknown | {status}"
+
+        with open(update_log, "a") as f:
+            f.write(log_entry + "\n")
+
+        logger.debug(f"Logged update check: {status}")
+
+    except Exception as e:
+        logger.warning(f"Failed to log update check: {e}")
+
+
+async def check_for_updates(skip_updates: bool = False) -> dict:
+    """
+    Check PyPI for new versions of stravinsky.
+
+    Implements 24-hour throttling to prevent excessive API calls.
+    All failures are handled gracefully without raising exceptions.
+    Non-blocking - safe to run via asyncio.create_task().
+
+    Args:
+        skip_updates: If True, skip the check entirely
+
+    Returns:
+        dict with keys:
+            - status: "checked" | "skipped" | "error"
+            - current: current version (e.g., "0.3.9")
+            - latest: latest version (e.g., "0.3.10") or None
+            - update_available: bool
+            - message: str (optional, for errors)
+    """
+    try:
+        # Get current version
+        current_version = __version__
+
+        # Return early if updates are skipped
+        if skip_updates:
+            logger.debug("Update check skipped (skip_updates=True)")
+            return {
+                "status": "skipped",
+                "current": current_version,
+                "latest": None,
+                "update_available": False,
+            }
+
+        # Check if enough time has passed since last check
+        last_check_time = _get_last_check_time()
+        if not _should_check(last_check_time):
+            logger.debug("Update check throttled (24-hour limit)")
+            return {
+                "status": "skipped",
+                "current": current_version,
+                "latest": None,
+                "update_available": False,
+            }
+
+        # Fetch latest version from PyPI
+        latest_version = _get_pypi_version()
+
+        if latest_version is None:
+            logger.warning("Failed to fetch latest version from PyPI")
+            _log_check(current_version, None, "error")
+            return {
+                "status": "error",
+                "current": current_version,
+                "latest": None,
+                "update_available": False,
+                "message": "Failed to fetch version from PyPI",
+            }
+
+        # Compare versions
+        update_available = _compare_versions(current_version, latest_version)
+
+        # Determine status
+        if update_available:
+            status = "new_available"
+            logger.info(
+                f"Update available: {current_version} -> {latest_version}. "
+                f"Install with: pip install --upgrade stravinsky"
+            )
+        else:
+            status = "up_to_date"
+            logger.debug(f"Stravinsky is up to date ({current_version})")
+
+        # Log the check
+        _log_check(current_version, latest_version, status)
+
+        return {
+            "status": "checked",
+            "current": current_version,
+            "latest": latest_version,
+            "update_available": update_available,
+        }
+
+    except Exception as e:
+        logger.error(f"Unexpected error during update check: {e}", exc_info=True)
+        return {
+            "status": "error",
+            "current": __version__,
+            "latest": None,
+            "update_available": False,
+            "message": f"Update check failed: {str(e)}",
+        }

mcp_bridge/utils/cache.py

@@ -0,0 +1,82 @@
+import time
+import os
+import threading
+from typing import Any, Dict, Optional, Tuple
+
+class IOCache:
+    """
+    Lightweight, thread-safe in-memory cache for I/O operations.
+    Supports TTL-based expiration and manual invalidation.
+    """
+    _instance = None
+    _lock = threading.Lock()
+
+    def __init__(self, ttl: float = 5.0):
+        self.ttl = ttl
+        self._cache: Dict[str, Tuple[Any, float]] = {}
+        self._cache_lock = threading.Lock()
+
+    @classmethod
+    def get_instance(cls):
+        """Get the singleton instance of IOCache."""
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = cls()
+        return cls._instance
+
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> None:
+        """
+        Store a value in the cache.
+        
+        Args:
+            key: Cache key (e.g., file path or command).
+            value: Data to cache.
+            ttl: Optional override for the default TTL.
+        """
+        expiry = time.time() + (ttl if ttl is not None else self.ttl)
+        with self._cache_lock:
+            self._cache[key] = (value, expiry)
+
+    def get(self, key: str) -> Optional[Any]:
+        """
+        Retrieve a value from the cache if it hasn't expired.
+        
+        Returns:
+            The cached value, or None if missing or expired.
+        """
+        with self._cache_lock:
+            if key not in self._cache:
+                return None
+            
+            value, expiry = self._cache[key]
+            if time.time() > expiry:
+                del self._cache[key]
+                return None
+            
+            return value
+
+    def invalidate(self, key: str) -> None:
+        """Remove a specific key from the cache."""
+        with self._cache_lock:
+            if key in self._cache:
+                del self._cache[key]
+
+    def invalidate_path(self, path: str) -> None:
+        """
+        Invalidate all cache entries related to a specific file path.
+        Matches keys for read_file, list_dir, etc.
+        """
+        # Use realpath to resolve symlinks (crucial for macOS /var -> /private/var)
+        abs_path = os.path.realpath(path)
+        with self._cache_lock:
+            keys_to_del = [
+                k for k in self._cache.keys() 
+                if abs_path in k
+            ]
+            for k in keys_to_del:
+                del self._cache[k]
+
+    def clear(self) -> None:
+        """Clear all cached entries."""
+        with self._cache_lock:
+            self._cache.clear()

mcp_bridge/utils/process.py

@@ -0,0 +1,71 @@
+import asyncio
+import os
+from dataclasses import dataclass
+from typing import Optional, List, Union
+
+@dataclass
+class ProcessResult:
+    returncode: int
+    stdout: str
+    stderr: str
+
+async def async_execute(
+    cmd: Union[str, List[str]], 
+    cwd: Optional[str] = None, 
+    timeout: Optional[float] = None
+) -> ProcessResult:
+    """
+    Execute a subprocess asynchronously.
+    
+    Args:
+        cmd: Command string or list of arguments.
+        cwd: Working directory.
+        timeout: Maximum execution time in seconds.
+        
+    Returns:
+        ProcessResult containing exit code, stdout, and stderr.
+        
+    Raises:
+        asyncio.TimeoutError: If the process exceeds the timeout.
+    """
+    if isinstance(cmd, str):
+        # Use shell wrapper for string commands
+        process = await asyncio.create_subprocess_exec(
+            "bash", "-c", cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd
+        )
+    else:
+        # Use direct execution for list of arguments
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd
+        )
+    
+    try:
+        if timeout:
+            stdout_bytes, stderr_bytes = await asyncio.wait_for(process.communicate(), timeout=timeout)
+        else:
+            stdout_bytes, stderr_bytes = await process.communicate()
+            
+    except asyncio.TimeoutError:
+        try:
+            # Kill process group if started with bash
+            if isinstance(cmd, str):
+                process.kill()
+            else:
+                process.kill()
+        except ProcessLookupError:
+            pass # Already gone
+        # Wait for it to actually die to avoid zombies
+        await process.wait()
+        raise
+        
+    return ProcessResult(
+        returncode=process.returncode if process.returncode is not None else 0,
+        stdout=stdout_bytes.decode('utf-8', errors='replace'),
+        stderr=stderr_bytes.decode('utf-8', errors='replace')
+    )

mcp_bridge/utils/session_state.py

@@ -0,0 +1,51 @@
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+STATE_DIR = Path.home() / ".stravinsky" / "state"
+
+
+def ensure_state_dir():
+    """Ensure the state directory exists."""
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def get_session_state_path(session_id: str) -> Path:
+    """Get the path to the state file for a given session."""
+    ensure_state_dir()
+    # Sanitize session_id to avoid path traversal
+    safe_id = "".join(c for c in session_id if c.isalnum() or c in ("-", "_"))
+    return STATE_DIR / f"session_{safe_id}.json"
+
+
+def get_session_state(session_id: Optional[str] = None) -> dict[str, Any]:
+    """Get the state for a session."""
+    if session_id is None:
+        session_id = get_current_session_id()
+
+    path = get_session_state_path(session_id)
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return {}
+
+
+def update_session_state(updates: dict[str, Any], session_id: Optional[str] = None):
+    """Update the state for a session."""
+    if session_id is None:
+        session_id = get_current_session_id()
+
+    state = get_session_state(session_id)
+    state.update(updates)
+    state["updated_at"] = time.time()
+    path = get_session_state_path(session_id)
+    path.write_text(json.dumps(state, indent=2))
+
+
+def get_current_session_id() -> str:
+    """Get the current session ID from environment or default."""
+    return os.environ.get("CLAUDE_SESSION_ID", "default")

mcp_bridge/utils/truncation.py

@@ -0,0 +1,76 @@
+from enum import Enum
+from typing import Optional
+import logging
+
+try:
+    import stravinsky_native
+    from stravinsky_native import truncator
+    NATIVE_AVAILABLE = True
+except ImportError:
+    NATIVE_AVAILABLE = False
+    logging.warning("stravinsky_native not found. Native truncation unavailable.")
+
+class TruncationStrategy(Enum):
+    MIDDLE = "middle"
+    TAIL = "tail"
+    AUTO_TAIL = "auto_tail" # New line-based strategy
+
+def truncate_output(
+    text: str, 
+    limit: int = 20000, 
+    strategy: TruncationStrategy = TruncationStrategy.MIDDLE,
+    custom_guidance: Optional[str] = None
+) -> str:
+    """
+    Truncates text to a specific limit using the chosen strategy. 
+    
+    Args:
+        text: The string to truncate.
+        limit: Max characters allowed.
+        strategy: How to truncate (MIDDLE or TAIL).
+        custom_guidance: Optional extra message for the agent.
+    """
+    if len(text) <= limit:
+        return text
+
+    # Standard guidance messages
+    guidance = "\n\n[Output truncated. "
+    if custom_guidance:
+        guidance += custom_guidance + " "
+    
+    if strategy == TruncationStrategy.TAIL:
+        # Show the END of the file
+        truncated_text = text[-limit:]
+        msg = f"{guidance}Showing last {limit} characters. Use offset/limit parameters to read specific parts of the file.]"
+        return f"... [TRUNCATED] ...\n{truncated_text}{msg}"
+    
+    else:  # MIDDLE strategy
+        # Show start and end, snip the middle
+        half_limit = limit // 2
+        start_part = text[:half_limit]
+        end_part = text[-half_limit:]
+        msg = f"{guidance}Showing first and last {half_limit} characters. Use offset/limit parameters to read specific parts of the file.]"
+        return f"{start_part}\n\n[... content truncated ...]\n\n{end_part}{msg}"
+
+def auto_tail_logs(content: str, head_lines: int = 100, tail_lines: int = 100) -> str:
+    """
+    Smart truncation for logs using native Rust implementation.
+    Keeps the first N lines (setup/config) and last M lines (recent errors).
+    """
+    if NATIVE_AVAILABLE:
+        try:
+            return truncator.auto_tail(content, head_lines, tail_lines)
+        except Exception as e:
+            logging.error(f"Native truncation failed: {e}")
+            # Fallback to python implementation
+            
+    # Python fallback
+    lines = content.splitlines()
+    if len(lines) <= head_lines + tail_lines:
+        return content
+        
+    head = "\n".join(lines[:head_lines])
+    tail = "\n".join(lines[-tail_lines:])
+    hidden = len(lines) - (head_lines + tail_lines)
+    
+    return f"{head}\n\n<... {hidden} lines truncated (fallback) ...>\n\n{tail}"