code-muse 0.0.1__py3-none-any.whl

code_muse/uvx_detection.py

@@ -0,0 +1,241 @@
+"""Detect if Muse was launched via uvx on Windows.
+
+This module provides utilities to detect the launch method of Muse,
+specifically to handle signal differences when running via uvx on Windows.
+
+On Windows, when launched via `uvx muse`, Ctrl+C (SIGINT) gets captured
+by uvx's process handling before reaching our Python process. To work around
+this, we detect the uvx launch scenario and switch to Ctrl+K for cancellation.
+
+Note: This issue is specific to uvx.exe, NOT uv.exe. Running via `uv run`
+handles SIGINT correctly on Windows.
+
+On non-Windows platforms, this is not an issue - Ctrl+C works fine with uvx.
+"""
+
+import os
+import platform
+import sys
+from functools import lru_cache
+
+# Cache the detection result - it won't change during runtime
+_uvx_detection_cache: bool | None = None
+
+
+def _get_parent_process_name_psutil(pid: int) -> str | None:
+    """Get parent process name using psutil (if available).
+
+    Args:
+        pid: Process ID to get parent name for
+
+    Returns:
+        Parent process name (lowercase) or None if not found
+    """
+    try:
+        import psutil
+
+        proc = psutil.Process(pid)
+        parent = proc.parent()
+        if parent:
+            return parent.name().lower()
+    except Exception:
+        pass
+    return None
+
+
+def _get_parent_process_chain_psutil() -> list[str]:
+    """Get the entire parent process chain using psutil.
+
+    Returns:
+        List of process names from current process up to init/System
+    """
+    chain = []
+    try:
+        import psutil
+
+        proc = psutil.Process(os.getpid())
+        while proc:
+            chain.append(proc.name().lower())
+            parent = proc.parent()
+            if parent is None or parent.pid in (0, proc.pid):
+                break
+            proc = parent
+    except Exception:
+        pass
+    return chain
+
+
+def _get_parent_process_chain_windows_ctypes() -> list[str]:
+    """Get parent process chain on Windows using ctypes (no external deps).
+
+    This is a fallback when psutil is not available.
+
+    Returns:
+        List of process names from current process up to System
+    """
+    if platform.system() != "Windows":
+        return []
+
+    chain = []
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        # Windows API constants
+        TH32CS_SNAPPROCESS = 0x00000002
+        INVALID_HANDLE_VALUE = -1
+
+        class PROCESSENTRY32(ctypes.Structure):
+            _fields_ = [
+                ("dwSize", wintypes.DWORD),
+                ("cntUsage", wintypes.DWORD),
+                ("th32ProcessID", wintypes.DWORD),
+                ("th32DefaultHeapID", ctypes.POINTER(wintypes.ULONG)),
+                ("th32ModuleID", wintypes.DWORD),
+                ("cntThreads", wintypes.DWORD),
+                ("th32ParentProcessID", wintypes.DWORD),
+                ("pcPriClassBase", wintypes.LONG),
+                ("dwFlags", wintypes.DWORD),
+                ("szExeFile", ctypes.c_char * 260),
+            ]
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Take a snapshot of all processes
+        snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
+        if snapshot == INVALID_HANDLE_VALUE:
+            return chain
+
+        try:
+            # Build a map of PID -> (parent_pid, exe_name)
+            process_map: dict[int, tuple[int, str]] = {}
+            pe = PROCESSENTRY32()
+            pe.dwSize = ctypes.sizeof(PROCESSENTRY32)
+
+            if kernel32.Process32First(snapshot, ctypes.byref(pe)):
+                while True:
+                    pid = pe.th32ProcessID
+                    parent_pid = pe.th32ParentProcessID
+                    exe_name = pe.szExeFile.decode("utf-8", errors="ignore").lower()
+                    process_map[pid] = (parent_pid, exe_name)
+
+                    if not kernel32.Process32Next(snapshot, ctypes.byref(pe)):
+                        break
+
+            # Traverse from current PID up the parent chain
+            current_pid = os.getpid()
+            visited = set()  # Prevent infinite loops
+
+            while current_pid in process_map and current_pid not in visited:
+                visited.add(current_pid)
+                parent_pid, exe_name = process_map[current_pid]
+                chain.append(exe_name)
+
+                if parent_pid == 0 or parent_pid == current_pid:
+                    break
+                current_pid = parent_pid
+
+        finally:
+            kernel32.CloseHandle(snapshot)
+
+    except Exception:
+        pass
+
+    return chain
+
+
+def _get_parent_process_chain() -> list[str]:
+    """Get the parent process chain using best available method.
+
+    Returns:
+        List of process names from current process up to init/System
+    """
+    # Try psutil first (more reliable, cross-platform)
+    try:
+        import psutil  # noqa: F401
+
+        return _get_parent_process_chain_psutil()
+    except ImportError:
+        pass
+
+    # Fall back to ctypes on Windows
+    if platform.system() == "Windows":
+        return _get_parent_process_chain_windows_ctypes()
+
+    return []
+
+
+def _is_uvx_in_chain(chain: list[str]) -> bool:
+    """Check if uvx is in the process chain.
+
+    Note: We only check for uvx.exe, NOT uv.exe. The uv.exe binary
+    (used by `uv run`) handles SIGINT correctly on Windows, but
+    uvx.exe captures it before it reaches Python.
+
+    Args:
+        chain: List of process names (lowercase)
+
+    Returns:
+        True if uvx.exe is found in the chain
+    """
+    # Only uvx.exe has the SIGINT issue, not uv.exe
+    uvx_names = {"uvx.exe", "uvx"}
+    return any(name in uvx_names for name in chain)
+
+
+@lru_cache(maxsize=1)
+def is_launched_via_uvx() -> bool:
+    """Detect if Muse was launched via uvx.
+
+    Traverses the parent process chain to find uvx.exe or uv.exe.
+    Result is cached for the lifetime of the process.
+
+    Returns:
+        True if launched via uvx, False otherwise
+    """
+    chain = _get_parent_process_chain()
+    return _is_uvx_in_chain(chain)
+
+
+def is_windows() -> bool:
+    """Check if we're running on Windows.
+
+    Returns:
+        True if running on Windows, False otherwise
+    """
+    return platform.system() == "Windows"
+
+
+def should_use_alternate_cancel_key() -> bool:
+    """Determine if we should use an alternate cancel key (Ctrl+K) instead of Ctrl+C.
+
+    This returns True when:
+    - Running on Windows AND
+    - Launched via uvx
+
+    In this scenario, Ctrl+C is captured by uvx before reaching Python,
+    so we need to use a different key (Ctrl+K) for agent cancellation.
+
+    Returns:
+        True if alternate cancel key should be used, False otherwise
+    """
+    return is_windows() and is_launched_via_uvx()
+
+
+def get_uvx_detection_info() -> dict:
+    """Get diagnostic information about uvx detection.
+
+    Useful for debugging and testing.
+
+    Returns:
+        Dictionary with detection details
+    """
+    chain = _get_parent_process_chain()
+    return {
+        "is_windows": is_windows(),
+        "is_launched_via_uvx": is_launched_via_uvx(),
+        "should_use_alternate_cancel_key": should_use_alternate_cancel_key(),
+        "parent_process_chain": chain,
+        "current_pid": os.getpid(),
+        "python_executable": sys.executable,
+    }

code_muse/version_checker.py

@@ -0,0 +1,86 @@
+"""Version checking utilities for Muse."""
+
+import httpx
+
+from code_muse.messaging import emit_info, emit_success, emit_warning, get_message_bus
+from code_muse.messaging.messages import VersionCheckMessage
+
+UVX_REFRESH_COMMAND = "uvx code-muse"
+
+
+def normalize_version(version_str):
+    if not version_str:
+        return version_str
+    version_str = version_str.lstrip("v")
+    return version_str
+
+
+def _version_tuple(version_str):
+    """Convert version string to tuple of ints for proper comparison."""
+    try:
+        return tuple(int(x) for x in version_str.split("."))
+    except ValueError, AttributeError:
+        return None
+
+
+def version_is_newer(latest, current):
+    """Return True if latest version is strictly newer than current."""
+    latest_tuple = _version_tuple(normalize_version(latest))
+    current_tuple = _version_tuple(normalize_version(current))
+    if latest_tuple is None or current_tuple is None:
+        return False
+    return latest_tuple > current_tuple
+
+
+def versions_are_equal(current, latest):
+    current_norm = normalize_version(current)
+    latest_norm = normalize_version(latest)
+    # Try numeric tuple comparison first
+    current_tuple = _version_tuple(current_norm)
+    latest_tuple = _version_tuple(latest_norm)
+    if current_tuple is not None and latest_tuple is not None:
+        return current_tuple == latest_tuple
+    # Fallback to string comparison
+    return current_norm == latest_norm
+
+
+def fetch_latest_version(package_name):
+    try:
+        response = httpx.get(f"https://pypi.org/pypi/{package_name}/json", timeout=5.0)
+        response.raise_for_status()
+        data = response.json()
+        return data["info"]["version"]
+    except Exception as e:
+        emit_warning(f"Error fetching version: {e}")
+        return None
+
+
+def default_version_mismatch_behavior(current_version):
+    # Defensive: ensure current_version is never None
+    if current_version is None:
+        current_version = "0.0.0-unknown"
+        emit_warning("Could not detect current version, using fallback")
+
+    latest_version = fetch_latest_version("code-muse")
+
+    update_available = bool(
+        latest_version and version_is_newer(latest_version, current_version)
+    )
+
+    # Emit structured version check message
+    version_msg = VersionCheckMessage(
+        current_version=current_version,
+        latest_version=latest_version or current_version,
+        update_available=update_available,
+    )
+    get_message_bus().emit(version_msg)
+
+    # Also emit plain text for legacy renderer
+    emit_info(f"Current version: {current_version}")
+
+    if update_available:
+        emit_info(f"Latest version: {latest_version}")
+        emit_warning(f"A new version of Muse is available: {latest_version}")
+        emit_success(
+            f"Run to refresh uvx and start the latest version: {UVX_REFRESH_COMMAND}"
+        )

code_muse-0.0.1.data/data/code_muse/models.json

@@ -0,0 +1,66 @@
+{
+  "wafer.ai-glm-5.1": {
+    "type": "custom_openai",
+    "provider": "wafer",
+    "name": "GLM-5.1",
+    "custom_endpoint": {
+      "url": "https://pass.wafer.ai/v1",
+      "api_key": "$WAFER_API_KEY"
+    },
+    "context_length": 200000,
+    "supported_settings": ["temperature", "seed", "top_p", "max_tokens"]
+  },
+  "wafer.ai-Qwen3.5-397B-A17B": {
+    "type": "custom_openai",
+    "provider": "wafer",
+    "name": "Qwen3.5-397B-A17B",
+    "custom_endpoint": {
+      "url": "https://pass.wafer.ai/v1",
+      "api_key": "$WAFER_API_KEY"
+    },
+    "context_length": 262144,
+    "supported_settings": ["temperature", "seed", "top_p", "max_tokens"]
+  },
+  "wafer-DeepSeek-V4-Pro": {
+    "type": "custom_openai",
+    "provider": "wafer",
+    "name": "DeepSeek-V4-Pro",
+    "custom_endpoint": {
+      "url": "https://pass.wafer.ai/v1",
+      "api_key": "$WAFER_API_KEY"
+    },
+    "context_length": 1000000,
+    "supported_settings": ["temperature", "seed", "top_p", "max_tokens"]
+  },
+  "wafer-MiniMax-M2.7": {
+    "type": "custom_openai",
+    "provider": "wafer",
+    "name": "MiniMax-M2.7",
+    "custom_endpoint": {
+      "url": "https://pass.wafer.ai/v1",
+      "api_key": "$WAFER_API_KEY"
+    },
+    "context_length": 204800,
+    "supported_settings": ["temperature", "seed", "top_p", "max_tokens"]
+  },
+  "crof-kimi-k2.5-lightning": {
+    "type": "custom_openai",
+    "provider": "crof",
+    "name": "kimi-k2.5-lightning",
+    "custom_endpoint": {
+      "url": "https://crof.ai/v1",
+      "api_key": "$CROF_API_KEY"
+    },
+    "context_length": 131072,
+    "streaming": false,
+    "strict_tools": false,
+    "supported_settings": ["temperature", "seed", "top_p"]
+  },
+  "zai-glm-5-coding": {
+    "type": "zai_coding",
+    "provider": "zai",
+    "name": "glm-5",
+    "context_length": 200000,
+    "supported_settings": ["temperature", "top_p"]
+  }
+}