mcp-ticketer 0.3.5__py3-none-any.whl → 0.12.0__py3-none-any.whl

mcp_ticketer/cli/platform_detection.py

@@ -0,0 +1,412 @@
+"""AI client platform auto-detection for mcp-ticketer.
+
+This module provides automatic detection of AI client frameworks that
+support MCP servers. It detects installation status, configuration paths,
+and scope (project/global) for each platform.
+
+Supported platforms:
+- Claude Code (project-level, ~/.claude.json)
+- Claude Desktop (global, platform-specific paths)
+- Auggie (CLI + ~/.augment/settings.json)
+- Codex (CLI + ~/.codex/config.toml)
+- Gemini (CLI + .gemini/settings.json or ~/.gemini/settings.json)
+"""
+
+import json
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class DetectedPlatform:
+    """Represents a detected AI client platform.
+
+    Attributes:
+        name: Platform identifier (e.g., "claude-code")
+        display_name: Human-readable name (e.g., "Claude Code")
+        config_path: Path to platform configuration file
+        is_installed: Whether platform is installed and usable
+        scope: Configuration scope - "project", "global", or "both"
+        executable_path: Path to CLI executable (if applicable)
+
+    """
+
+    name: str
+    display_name: str
+    config_path: Path
+    is_installed: bool
+    scope: str
+    executable_path: str | None = None
+
+
+class PlatformDetector:
+    """Detects installed AI client platforms that support MCP servers."""
+
+    @staticmethod
+    def detect_claude_code() -> DetectedPlatform | None:
+        """Detect Claude Code installation.
+
+        Claude Code uses project-level configuration stored in ~/.claude.json
+        with a projects structure that maps project paths to MCP server configs.
+
+        Returns:
+            DetectedPlatform if Claude Code config exists, None otherwise
+
+        """
+        config_path = Path.home() / ".claude.json"
+
+        # Check if config file exists
+        if not config_path.exists():
+            return None
+
+        # Validate it's valid JSON (but don't require specific structure)
+        try:
+            with config_path.open() as f:
+                content = f.read().strip()
+                if content:  # Only validate if not empty
+                    json.loads(content)
+
+            return DetectedPlatform(
+                name="claude-code",
+                display_name="Claude Code",
+                config_path=config_path,
+                is_installed=True,
+                scope="project",
+                executable_path=None,  # Claude Code doesn't have a CLI
+            )
+        except (json.JSONDecodeError, OSError):
+            # Config exists but is corrupted - still consider it "detected"
+            # but mark as not installed/usable
+            return DetectedPlatform(
+                name="claude-code",
+                display_name="Claude Code",
+                config_path=config_path,
+                is_installed=False,
+                scope="project",
+                executable_path=None,
+            )
+
+    @staticmethod
+    def detect_claude_desktop() -> DetectedPlatform | None:
+        """Detect Claude Desktop installation.
+
+        Claude Desktop uses global configuration with platform-specific paths:
+        - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
+        - Linux: ~/.config/Claude/claude_desktop_config.json
+        - Windows: %APPDATA%/Claude/claude_desktop_config.json
+
+        Returns:
+            DetectedPlatform if Claude Desktop config exists, None otherwise
+
+        """
+        # Determine platform-specific config path
+        if sys.platform == "darwin":  # macOS
+            config_path = (
+                Path.home()
+                / "Library"
+                / "Application Support"
+                / "Claude"
+                / "claude_desktop_config.json"
+            )
+        elif sys.platform == "win32":  # Windows
+            appdata = os.environ.get("APPDATA", "")
+            if not appdata:
+                return None
+            config_path = Path(appdata) / "Claude" / "claude_desktop_config.json"
+        else:  # Linux
+            config_path = (
+                Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
+            )
+
+        # Check if config file exists
+        if not config_path.exists():
+            return None
+
+        # Validate it's valid JSON
+        try:
+            with config_path.open() as f:
+                content = f.read().strip()
+                if content:  # Only validate if not empty
+                    json.loads(content)
+
+            return DetectedPlatform(
+                name="claude-desktop",
+                display_name="Claude Desktop",
+                config_path=config_path,
+                is_installed=True,
+                scope="global",
+                executable_path=None,  # Claude Desktop is a GUI app
+            )
+        except (json.JSONDecodeError, OSError):
+            # Config exists but is corrupted
+            return DetectedPlatform(
+                name="claude-desktop",
+                display_name="Claude Desktop",
+                config_path=config_path,
+                is_installed=False,
+                scope="global",
+                executable_path=None,
+            )
+
+    @staticmethod
+    def detect_auggie() -> DetectedPlatform | None:
+        """Detect Auggie installation.
+
+        Auggie requires both:
+        1. `auggie` CLI executable in PATH
+        2. Configuration file at ~/.augment/settings.json
+
+        Returns:
+            DetectedPlatform if Auggie is installed, None otherwise
+
+        """
+        # Check for CLI executable
+        executable_path = shutil.which("auggie")
+        if not executable_path:
+            return None
+
+        # Check for config file
+        config_path = Path.home() / ".augment" / "settings.json"
+
+        # Auggie is installed if CLI exists, even without config
+        is_installed = True
+
+        # If config exists, validate it
+        if config_path.exists():
+            try:
+                with config_path.open() as f:
+                    content = f.read().strip()
+                    if content:
+                        json.loads(content)
+            except (json.JSONDecodeError, OSError):
+                # Config exists but is corrupted
+                is_installed = False
+
+        return DetectedPlatform(
+            name="auggie",
+            display_name="Auggie",
+            config_path=config_path,
+            is_installed=is_installed,
+            scope="global",
+            executable_path=executable_path,
+        )
+
+    @staticmethod
+    def detect_codex() -> DetectedPlatform | None:
+        """Detect Codex installation.
+
+        Codex requires both:
+        1. `codex` CLI executable in PATH
+        2. Configuration file at ~/.codex/config.toml
+
+        Returns:
+            DetectedPlatform if Codex is installed, None otherwise
+
+        """
+        # Check for CLI executable
+        executable_path = shutil.which("codex")
+        if not executable_path:
+            return None
+
+        # Check for config file
+        config_path = Path.home() / ".codex" / "config.toml"
+
+        # Codex is installed if CLI exists, even without config
+        is_installed = True
+
+        # If config exists, validate it exists and is readable
+        if config_path.exists():
+            try:
+                with config_path.open() as f:
+                    f.read()  # Just check if readable
+            except OSError:
+                is_installed = False
+
+        return DetectedPlatform(
+            name="codex",
+            display_name="Codex",
+            config_path=config_path,
+            is_installed=is_installed,
+            scope="global",
+            executable_path=executable_path,
+        )
+
+    @staticmethod
+    def detect_gemini(project_path: Path | None = None) -> DetectedPlatform | None:
+        """Detect Gemini installation.
+
+        Gemini supports both project-level and global configurations:
+        1. `gemini` CLI executable in PATH
+        2. Configuration at .gemini/settings.json (project) or
+           ~/.gemini/settings.json (global)
+
+        Args:
+            project_path: Optional project directory to check for project-level config
+
+        Returns:
+            DetectedPlatform if Gemini is installed, None otherwise
+
+        """
+        # Check for CLI executable
+        executable_path = shutil.which("gemini")
+        if not executable_path:
+            return None
+
+        # Check for config files (project-level first, then global)
+        project_config = None
+        global_config = Path.home() / ".gemini" / "settings.json"
+
+        if project_path:
+            project_config = project_path / ".gemini" / "settings.json"
+
+        # Determine which config exists
+        config_path = None
+        scope = "global"
+
+        if project_config and project_config.exists():
+            config_path = project_config
+            scope = "project"
+        elif global_config.exists():
+            config_path = global_config
+            scope = "global"
+        else:
+            # No config found, use global path as default
+            config_path = global_config
+
+        # Gemini is installed if CLI exists, even without config
+        is_installed = True
+
+        # If config exists, validate it
+        if config_path.exists():
+            try:
+                with config_path.open() as f:
+                    content = f.read().strip()
+                    if content:
+                        json.loads(content)
+            except (json.JSONDecodeError, OSError):
+                # Config exists but is corrupted
+                is_installed = False
+
+        # Check if both configs exist
+        if project_config and project_config.exists() and global_config.exists():
+            scope = "both"
+
+        return DetectedPlatform(
+            name="gemini",
+            display_name="Gemini",
+            config_path=config_path,
+            is_installed=is_installed,
+            scope=scope,
+            executable_path=executable_path,
+        )
+
+    @classmethod
+    def detect_all(cls, project_path: Path | None = None) -> list[DetectedPlatform]:
+        """Detect all installed AI client platforms.
+
+        Args:
+            project_path: Optional project directory for project-level detection
+
+        Returns:
+            List of detected platforms (empty if none found)
+
+        Examples:
+            >>> detector = PlatformDetector()
+            >>> platforms = detector.detect_all()
+            >>> for platform in platforms:
+            ...     print(f"{platform.display_name}: {platform.is_installed}")
+            Claude Code: True
+            Claude Desktop: False
+
+            >>> # With project path for Gemini detection
+            >>> platforms = detector.detect_all(Path("/home/user/project"))
+            >>> gemini = next(p for p in platforms if p.name == "gemini")
+            >>> print(gemini.scope)  # "project" or "global" or "both"
+
+        """
+        detected = []
+
+        # Detect Claude Code
+        claude_code = cls.detect_claude_code()
+        if claude_code:
+            detected.append(claude_code)
+
+        # Detect Claude Desktop
+        claude_desktop = cls.detect_claude_desktop()
+        if claude_desktop:
+            detected.append(claude_desktop)
+
+        # Detect Auggie
+        auggie = cls.detect_auggie()
+        if auggie:
+            detected.append(auggie)
+
+        # Detect Codex
+        codex = cls.detect_codex()
+        if codex:
+            detected.append(codex)
+
+        # Detect Gemini (with project path support)
+        gemini = cls.detect_gemini(project_path=project_path)
+        if gemini:
+            detected.append(gemini)
+
+        return detected
+
+
+def get_platform_by_name(
+    platform_name: str, project_path: Path | None = None
+) -> DetectedPlatform | None:
+    """Get detection result for a specific platform by name.
+
+    Args:
+        platform_name: Platform identifier (e.g., "claude-code", "auggie")
+        project_path: Optional project directory for project-level detection
+
+    Returns:
+        DetectedPlatform if found, None if platform doesn't exist or isn't installed
+
+    Examples:
+        >>> platform = get_platform_by_name("claude-code")
+        >>> if platform and platform.is_installed:
+        ...     print(f"Config at: {platform.config_path}")
+
+    """
+    detector = PlatformDetector()
+
+    # Map platform names to detection methods
+    detection_map = {
+        "claude-code": detector.detect_claude_code,
+        "claude-desktop": detector.detect_claude_desktop,
+        "auggie": detector.detect_auggie,
+        "codex": detector.detect_codex,
+        "gemini": lambda: detector.detect_gemini(project_path),
+    }
+
+    detect_func = detection_map.get(platform_name)
+    if not detect_func:
+        return None
+
+    return detect_func()
+
+
+def is_platform_installed(platform_name: str, project_path: Path | None = None) -> bool:
+    """Check if a specific platform is installed and usable.
+
+    Args:
+        platform_name: Platform identifier (e.g., "claude-code", "auggie")
+        project_path: Optional project directory for project-level detection
+
+    Returns:
+        True if platform is installed and has valid configuration
+
+    Examples:
+        >>> if is_platform_installed("claude-code"):
+        ...     print("Claude Code is installed and configured")
+
+    """
+    platform = get_platform_by_name(platform_name, project_path)
+    return platform is not None and platform.is_installed

mcp_ticketer/cli/python_detection.py

@@ -0,0 +1,126 @@
+"""Reliable Python executable detection for mcp-ticketer.
+
+This module provides reliable detection of the Python executable for mcp-ticketer
+across different installation methods (pipx, pip, uv, direct venv).
+
+The module follows the proven pattern from mcp-vector-search:
+- Detect venv Python path reliably
+- Use `python -m mcp_ticketer.mcp.server` instead of binary paths
+- Support multiple installation methods transparently
+"""
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+
+def get_mcp_ticketer_python(project_path: Path | None = None) -> str:
+    """Get the correct Python executable for mcp-ticketer MCP server.
+
+    This function follows the mcp-vector-search pattern of using project-specific
+    venv Python for proper project isolation and dependency management.
+
+    Detection priority:
+    1. Project-local venv (.venv/bin/python) if project_path provided
+    2. Current Python executable if in pipx venv
+    3. Python from mcp-ticketer binary shebang
+    4. Current Python executable (fallback)
+
+    Args:
+        project_path: Optional project directory path to check for local venv
+
+    Returns:
+        Path to Python executable
+
+    Examples:
+        >>> # With project venv
+        >>> python_path = get_mcp_ticketer_python(Path("/home/user/my-project"))
+        >>> # Returns: "/home/user/my-project/.venv/bin/python"
+
+        >>> # Without project path (fallback to pipx)
+        >>> python_path = get_mcp_ticketer_python()
+        >>> # Returns: "/Users/user/.local/pipx/venvs/mcp-ticketer/bin/python"
+
+    """
+    # Priority 1: Check for project-local venv
+    if project_path:
+        project_venv_python = project_path / ".venv" / "bin" / "python"
+        if project_venv_python.exists():
+            return str(project_venv_python)
+
+    current_executable = sys.executable
+
+    # Priority 2: Check if we're in a pipx venv
+    if "/pipx/venvs/" in current_executable:
+        return current_executable
+
+    # Priority 3: Check mcp-ticketer binary shebang
+    mcp_ticketer_path = shutil.which("mcp-ticketer")
+    if mcp_ticketer_path:
+        try:
+            with open(mcp_ticketer_path) as f:
+                first_line = f.readline().strip()
+                if first_line.startswith("#!") and "python" in first_line:
+                    python_path = first_line[2:].strip()
+                    if os.path.exists(python_path):
+                        return python_path
+        except OSError:
+            pass
+
+    # Priority 4: Fallback to current Python
+    return current_executable
+
+
+def get_mcp_server_command(project_path: str | None = None) -> tuple[str, list[str]]:
+    """Get the complete command to run the MCP server.
+
+    Args:
+        project_path: Optional project path to pass as argument and check for venv
+
+    Returns:
+        Tuple of (python_executable, args_list)
+        Example: ("/path/to/python", ["-m", "mcp_ticketer.mcp.server", "/project/path"])
+
+    Examples:
+        >>> python, args = get_mcp_server_command("/home/user/project")
+        >>> # python: "/home/user/project/.venv/bin/python" (if .venv exists)
+        >>> # args: ["-m", "mcp_ticketer.mcp.server", "/home/user/project"]
+
+    """
+    # Convert project_path to Path object for venv detection
+    project_path_obj = Path(project_path) if project_path else None
+    python_path = get_mcp_ticketer_python(project_path=project_path_obj)
+    args = ["-m", "mcp_ticketer.mcp.server"]
+
+    if project_path:
+        args.append(str(project_path))
+
+    return python_path, args
+
+
+def validate_python_executable(python_path: str) -> bool:
+    """Validate that a Python executable can import mcp_ticketer.
+
+    Args:
+        python_path: Path to Python executable to validate
+
+    Returns:
+        True if Python can import mcp_ticketer, False otherwise
+
+    Examples:
+        >>> is_valid = validate_python_executable("/usr/bin/python3")
+        >>> # Returns: False (system Python doesn't have mcp_ticketer)
+
+    """
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            [python_path, "-c", "import mcp_ticketer.mcp.server"],
+            capture_output=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return False

mcp_ticketer/cli/queue_commands.py

@@ -16,7 +16,7 @@ console = Console()
 def list_queue(
     status: QueueStatus = typer.Option(None, "--status", "-s", help="Filter by status"),
     limit: int = typer.Option(25, "--limit", "-l", help="Maximum items to show"),
-):
+) -> None:
     """List queue items."""
     queue = Queue()
     items = queue.list_items(status=status, limit=limit)
@@ -69,20 +69,20 @@ def list_queue(
 
 
 @app.command("retry")
-def retry_item(queue_id: str = typer.Argument(..., help="Queue ID to retry")):
+def retry_item(queue_id: str = typer.Argument(..., help="Queue ID to retry")) -> None:
     """Retry a failed queue item."""
     queue = Queue()
     item = queue.get_item(queue_id)
 
     if not item:
         console.print(f"[red]Queue item not found: {queue_id}[/red]")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     if item.status != QueueStatus.FAILED:
         console.print(
             f"[yellow]Item {queue_id} is not failed (status: {item.status})[/yellow]"
         )
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     # Reset to pending
     queue.update_status(queue_id, QueueStatus.PENDING, error_message=None)
@@ -103,7 +103,7 @@ def clear_queue(
         7, "--days", "-d", help="Clear items older than this many days"
     ),
     confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
-):
+) -> None:
     """Clear old queue items."""
     queue = Queue()
 
@@ -115,7 +115,7 @@ def clear_queue(
 
         if not typer.confirm(msg):
             console.print("[yellow]Cancelled[/yellow]")
-            raise typer.Exit(0)
+            raise typer.Exit(0) from None
 
     queue.cleanup_old(days=days)
     console.print("[green]✓[/green] Cleared old queue items")
@@ -126,7 +126,7 @@ worker_app = typer.Typer(name="worker", help="Worker management commands")
 
 
 @worker_app.command("start")
-def start_worker():
+def start_worker() -> None:
     """Start the background worker."""
     manager = WorkerManager()
 
@@ -142,11 +142,11 @@ def start_worker():
         console.print(f"PID: {status.get('pid')}")
     else:
         console.print("[red]✗[/red] Failed to start worker")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
 
 @worker_app.command("stop")
-def stop_worker():
+def stop_worker() -> None:
     """Stop the background worker."""
     manager = WorkerManager()
 
@@ -158,11 +158,11 @@ def stop_worker():
         console.print("[green]✓[/green] Worker stopped successfully")
     else:
         console.print("[red]✗[/red] Failed to stop worker")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
 
 @worker_app.command("restart")
-def restart_worker():
+def restart_worker() -> None:
     """Restart the background worker."""
     manager = WorkerManager()
 
@@ -172,11 +172,11 @@ def restart_worker():
         console.print(f"PID: {status.get('pid')}")
     else:
         console.print("[red]✗[/red] Failed to restart worker")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
 
 @worker_app.command("status")
-def worker_status():
+def worker_status() -> None:
     """Check worker status."""
     manager = WorkerManager()
     status = manager.get_status()
@@ -212,7 +212,7 @@ def worker_status():
 def worker_logs(
     lines: int = typer.Option(50, "--lines", "-n", help="Number of lines to show"),
     follow: bool = typer.Option(False, "--follow", "-f", help="Follow log output"),
-):
+) -> None:
     """View worker logs."""
     import time
     from pathlib import Path
@@ -221,7 +221,7 @@ def worker_logs(
 
     if not log_file.exists():
         console.print("[yellow]No log file found[/yellow]")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     if follow:
         # Follow mode - like tail -f

mcp_ticketer/cli/simple_health.py

@@ -150,7 +150,7 @@ def simple_health_check() -> int:
 
 
 def simple_diagnose() -> dict[str, Any]:
-    """Simple diagnosis that works without full config system."""
+    """Perform simple diagnosis without full config system."""
     console.print("\n🔍 [bold blue]MCP Ticketer Simple Diagnosis[/bold blue]")
     console.print("=" * 60)