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

mcp_ticketer/cli/codex_configure.py

@@ -4,19 +4,15 @@ Codex CLI only supports global configuration at ~/.codex/config.toml.
 Unlike Claude Code and Gemini CLI, there is no project-level configuration support.
 """
 
-import sys
 from pathlib import Path
-from typing import Any, Optional
-
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    import tomli as tomllib
+from typing import Any
 
 import tomli_w
+import tomllib
 from rich.console import Console
 
-from .mcp_configure import find_mcp_ticketer_binary, load_project_config
+from .mcp_configure import load_project_config
+from .python_detection import get_mcp_ticketer_python
 
 console = Console()
 
@@ -78,19 +74,21 @@ def save_codex_config(config_path: Path, config: dict[str, Any]) -> None:
 
 
 def create_codex_server_config(
-    binary_path: str, project_config: dict, cwd: Optional[str] = None
+    python_path: str, project_config: dict, project_path: str | None = None
 ) -> dict[str, Any]:
     """Create Codex MCP server configuration for mcp-ticketer.
 
     Args:
-        binary_path: Path to mcp-ticketer binary
+        python_path: Path to Python executable in mcp-ticketer venv
         project_config: Project configuration from .mcp-ticketer/config.json
-        cwd: Working directory for server (optional, not used for global config)
+        project_path: Project directory path (optional, not used for global config)
 
     Returns:
         Codex MCP server configuration dict
 
     """
+    # Use Python module invocation pattern (works regardless of where package is installed)
+
     # Get adapter configuration
     adapter = project_config.get("default_adapter", "aitrackdown")
     adapters_config = project_config.get("adapters", {})
@@ -99,9 +97,9 @@ def create_codex_server_config(
     # Build environment variables
     env_vars: dict[str, str] = {}
 
-    # Add PYTHONPATH if running from development environment
-    if cwd:
-        env_vars["PYTHONPATH"] = str(Path(cwd) / "src")
+    # Add PYTHONPATH for project context
+    if project_path:
+        env_vars["PYTHONPATH"] = project_path
 
     # Add adapter type
     env_vars["MCP_TICKETER_ADAPTER"] = adapter
@@ -110,9 +108,9 @@ def create_codex_server_config(
     if adapter == "aitrackdown":
         # Set base path for local adapter
         base_path = adapter_config.get("base_path", ".aitrackdown")
-        if cwd:
-            # Use absolute path if cwd is provided
-            env_vars["MCP_TICKETER_BASE_PATH"] = str(Path(cwd) / base_path)
+        if project_path:
+            # Use absolute path if project_path is provided
+            env_vars["MCP_TICKETER_BASE_PATH"] = str(Path(project_path) / base_path)
         else:
             env_vars["MCP_TICKETER_BASE_PATH"] = base_path
 
@@ -140,17 +138,158 @@ def create_codex_server_config(
         if "project_key" in adapter_config:
             env_vars["JIRA_PROJECT_KEY"] = adapter_config["project_key"]
 
+    # Use Python module invocation pattern
+    args = ["-m", "mcp_ticketer.mcp.server"]
+    if project_path:
+        args.append(project_path)
+
     # Create server configuration with Codex-specific structure
-    # NOTE: Codex uses nested dict structure for env vars
     config: dict[str, Any] = {
-        "command": binary_path,
-        "args": ["serve"],
+        "command": python_path,
+        "args": args,
         "env": env_vars,
     }
 
     return config
 
 
+def _test_configuration(adapter: str, project_config: dict) -> bool:
+    """Test the configuration by validating adapter credentials.
+
+    Args:
+        adapter: Adapter type (linear, github, jira, aitrackdown)
+        project_config: Project configuration dict
+
+    Returns:
+        True if validation passed, False otherwise
+
+    """
+    try:
+        from ..core import AdapterRegistry
+
+        # Get adapter configuration
+        adapters_config = project_config.get("adapters", {})
+        adapter_config = adapters_config.get(adapter, {})
+
+        # Test adapter instantiation
+        console.print(f"  Testing {adapter} adapter...")
+
+        try:
+            adapter_instance = AdapterRegistry.get_adapter(adapter, adapter_config)
+            console.print("  [green]✓[/green] Adapter instantiated successfully")
+
+            # Test credentials if validation method exists
+            if hasattr(adapter_instance, "validate_credentials"):
+                console.print(f"  Validating {adapter} credentials...")
+                is_valid, error_msg = adapter_instance.validate_credentials()
+
+                if is_valid:
+                    console.print("  [green]✓[/green] Credentials are valid")
+                    return True
+                else:
+                    console.print(
+                        f"  [red]✗[/red] Credential validation failed: {error_msg}"
+                    )
+                    return False
+            else:
+                # No validation method, assume valid
+                console.print(
+                    f"  [yellow]○[/yellow] No credential validation available for {adapter}"
+                )
+                return True
+
+        except Exception as e:
+            console.print(f"  [red]✗[/red] Adapter instantiation failed: {e}")
+
+            # Provide helpful error messages based on adapter type
+            if adapter == "linear":
+                console.print(
+                    "\n  [yellow]Linear requires:[/yellow] LINEAR_API_KEY and LINEAR_TEAM_ID"
+                )
+            elif adapter == "github":
+                console.print(
+                    "\n  [yellow]GitHub requires:[/yellow] GITHUB_TOKEN, GITHUB_OWNER, GITHUB_REPO"
+                )
+            elif adapter == "jira":
+                console.print(
+                    "\n  [yellow]JIRA requires:[/yellow] JIRA_SERVER, JIRA_EMAIL, JIRA_API_TOKEN"
+                )
+
+            return False
+
+    except Exception as e:
+        console.print(f"  [red]✗[/red] Configuration test error: {e}")
+        return False
+
+
+def remove_codex_mcp(dry_run: bool = False) -> None:
+    """Remove mcp-ticketer from Codex CLI configuration.
+
+    IMPORTANT: Codex CLI ONLY supports global configuration at ~/.codex/config.toml.
+    This will remove mcp-ticketer from the global configuration.
+
+    Args:
+        dry_run: Show what would be removed without making changes
+
+    """
+    # Step 1: Find Codex config location (always global)
+    console.print("[cyan]🔍 Removing Codex CLI global configuration...[/cyan]")
+    console.print(
+        "[yellow]⚠ Note: Codex CLI only supports global configuration[/yellow]"
+    )
+
+    codex_config_path = find_codex_config()
+    console.print(f"[dim]Config location: {codex_config_path}[/dim]")
+
+    # Step 2: Check if config file exists
+    if not codex_config_path.exists():
+        console.print(
+            f"[yellow]⚠ No configuration found at {codex_config_path}[/yellow]"
+        )
+        console.print("[dim]mcp-ticketer is not configured for Codex CLI[/dim]")
+        return
+
+    # Step 3: Load existing Codex configuration
+    codex_config = load_codex_config(codex_config_path)
+
+    # Step 4: Check if mcp-ticketer is configured
+    # NOTE: Use underscore mcp_servers, not camelCase
+    mcp_servers = codex_config.get("mcp_servers", {})
+    if "mcp-ticketer" not in mcp_servers:
+        console.print("[yellow]⚠ mcp-ticketer is not configured[/yellow]")
+        console.print(f"[dim]No mcp-ticketer entry found in {codex_config_path}[/dim]")
+        return
+
+    # Step 5: Show what would be removed (dry run or actual removal)
+    if dry_run:
+        console.print("\n[cyan]DRY RUN - Would remove:[/cyan]")
+        console.print("  Server name: mcp-ticketer")
+        console.print(f"  From: {codex_config_path}")
+        console.print("  Scope: Global (all sessions)")
+        return
+
+    # Step 6: Remove mcp-ticketer from configuration
+    del codex_config["mcp_servers"]["mcp-ticketer"]
+
+    # Step 7: Save updated configuration
+    try:
+        save_codex_config(codex_config_path, codex_config)
+        console.print("\n[green]✓ Successfully removed mcp-ticketer[/green]")
+        console.print(f"[dim]Configuration updated: {codex_config_path}[/dim]")
+
+        # Next steps
+        console.print("\n[bold cyan]Next Steps:[/bold cyan]")
+        console.print("1. [bold]Restart Codex CLI[/bold] (required for changes)")
+        console.print("2. mcp-ticketer will no longer be available via MCP")
+        console.print(
+            "\n[yellow]⚠ Note: This removes global configuration affecting all Codex sessions[/yellow]"
+        )
+
+    except Exception as e:
+        console.print(f"\n[red]✗ Failed to update configuration:[/red] {e}")
+        raise
+
+
 def configure_codex_mcp(force: bool = False) -> None:
     """Configure Codex CLI to use mcp-ticketer.
 
@@ -163,18 +302,22 @@ def configure_codex_mcp(force: bool = False) -> None:
         force: Overwrite existing configuration
 
     Raises:
-        FileNotFoundError: If binary or project config not found
+        FileNotFoundError: If Python executable or project config not found
         ValueError: If configuration is invalid
 
     """
-    # Step 1: Find mcp-ticketer binary
-    console.print("[cyan]🔍 Finding mcp-ticketer binary...[/cyan]")
+    # Step 1: Find Python executable
+    console.print("[cyan]🔍 Finding mcp-ticketer Python executable...[/cyan]")
     try:
-        binary_path = find_mcp_ticketer_binary()
-        console.print(f"[green]✓[/green] Found: {binary_path}")
-    except FileNotFoundError as e:
-        console.print(f"[red]✗[/red] {e}")
-        raise
+        python_path = get_mcp_ticketer_python()
+        console.print(f"[green]✓[/green] Found: {python_path}")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Could not find Python executable: {e}")
+        raise FileNotFoundError(
+            "Could not find mcp-ticketer Python executable. "
+            "Please ensure mcp-ticketer is installed.\n"
+            "Install with: pip install mcp-ticketer or pipx install mcp-ticketer"
+        ) from e
 
     # Step 2: Load project configuration
     console.print("\n[cyan]📖 Reading project configuration...[/cyan]")
@@ -211,9 +354,11 @@ def configure_codex_mcp(force: bool = False) -> None:
 
     # Step 6: Create mcp-ticketer server config
     # For global config, include current working directory for context
-    cwd = str(Path.cwd())
+    project_path = str(Path.cwd())
     server_config = create_codex_server_config(
-        binary_path=binary_path, project_config=project_config, cwd=cwd
+        python_path=python_path,
+        project_config=project_config,
+        project_path=project_path,
     )
 
     # Step 7: Update Codex configuration
@@ -232,14 +377,25 @@ def configure_codex_mcp(force: bool = False) -> None:
         console.print("\n[bold]Configuration Details:[/bold]")
         console.print("  Server name: mcp-ticketer")
         console.print(f"  Adapter: {adapter}")
-        console.print(f"  Binary: {binary_path}")
+        console.print(f"  Python: {python_path}")
+        console.print("  Command: python -m mcp_ticketer.mcp.server")
         console.print("  Scope: global (Codex only supports global config)")
-        console.print(f"  Working directory: {cwd}")
+        console.print(f"  Project path: {project_path}")
         if "env" in server_config:
             console.print(
                 f"  Environment variables: {list(server_config['env'].keys())}"
             )
 
+        # Step 9: Test configuration
+        console.print("\n[cyan]🧪 Testing configuration...[/cyan]")
+        test_success = _test_configuration(adapter, project_config)
+
+        if not test_success:
+            console.print(
+                "[yellow]⚠ Configuration saved but validation failed. "
+                "Please check your credentials and settings.[/yellow]"
+            )
+
         # Next steps
         console.print("\n[bold cyan]Next Steps:[/bold cyan]")
         console.print("1. [bold]Restart Codex CLI[/bold] (required for changes)")

mcp_ticketer/cli/configure.py

@@ -1,7 +1,7 @@
 """Interactive configuration wizard for MCP Ticketer."""
 
 import os
-from typing import Optional
+from typing import Any
 
 import typer
 from rich.console import Console
@@ -46,24 +46,25 @@ def configure_wizard() -> None:
 
     # Step 2: Choose where to save
     console.print("\n[bold]Step 2: Configuration Scope[/bold]")
-    console.print("1. Global (all projects): ~/.mcp-ticketer/config.json")
-    console.print("2. Project-specific: .mcp-ticketer/config.json in project root")
+    console.print(
+        "1. Project-specific (recommended): .mcp-ticketer/config.json in project root"
+    )
+    console.print("2. Legacy global (deprecated): saves to project config for security")
 
-    scope = Prompt.ask("Save configuration as", choices=["1", "2"], default="2")
+    scope = Prompt.ask("Save configuration as", choices=["1", "2"], default="1")
 
     resolver = ConfigResolver()
 
-    if scope == "1":
-        # Save global
-        resolver.save_global_config(config)
+    # Always save to project config (global config removed for security)
+    resolver.save_project_config(config)
+    config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
+
+    if scope == "2":
         console.print(
-            f"\n[green]✓[/green] Configuration saved globally to {resolver.GLOBAL_CONFIG_PATH}"
+            "[yellow]Note: Global config is deprecated for security. Saving to project config instead.[/yellow]"
         )
-    else:
-        # Save project-specific
-        resolver.save_project_config(config)
-        config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
-        console.print(f"\n[green]✓[/green] Configuration saved to {config_path}")
+
+    console.print(f"\n[green]✓[/green] Configuration saved to {config_path}")
 
     # Show usage instructions
     console.print("\n[bold]Usage:[/bold]")
@@ -154,7 +155,7 @@ def _configure_linear() -> AdapterConfig:
     is_valid, error = ConfigValidator.validate_linear_config(config_dict)
     if not is_valid:
         console.print(f"[red]Configuration error: {error}[/red]")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     return AdapterConfig.from_dict(config_dict)
 
@@ -198,7 +199,7 @@ def _configure_jira() -> AdapterConfig:
     is_valid, error = ConfigValidator.validate_jira_config(config_dict)
     if not is_valid:
         console.print(f"[red]Configuration error: {error}[/red]")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     return AdapterConfig.from_dict(config_dict)
 
@@ -246,7 +247,7 @@ def _configure_github() -> AdapterConfig:
     is_valid, error = ConfigValidator.validate_github_config(config_dict)
     if not is_valid:
         console.print(f"[red]Configuration error: {error}[/red]")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     return AdapterConfig.from_dict(config_dict)
 
@@ -296,7 +297,7 @@ def _configure_hybrid_mode() -> TicketerConfig:
 
     if len(selected_adapters) < 2:
         console.print("[red]Hybrid mode requires at least 2 adapters[/red]")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     # Configure each adapter
     adapters = {}
@@ -366,31 +367,17 @@ def show_current_config() -> None:
     resolver = ConfigResolver()
 
     # Try to load configs
-    global_config = resolver.load_global_config()
     project_config = resolver.load_project_config()
 
     console.print("[bold]Current Configuration:[/bold]\n")
 
-    # Global config
-    if resolver.GLOBAL_CONFIG_PATH.exists():
-        console.print(f"[cyan]Global:[/cyan] {resolver.GLOBAL_CONFIG_PATH}")
-        console.print(f"  Default adapter: {global_config.default_adapter}")
-
-        if global_config.adapters:
-            table = Table(title="Global Adapters")
-            table.add_column("Adapter", style="cyan")
-            table.add_column("Configured", style="green")
-
-            for name, config in global_config.adapters.items():
-                configured = "✓" if config.enabled else "✗"
-                table.add_row(name, configured)
-
-            console.print(table)
-    else:
-        console.print("[yellow]No global configuration found[/yellow]")
+    # Note about global config deprecation
+    console.print(
+        "[dim]Note: Global config has been deprecated for security reasons.[/dim]"
+    )
+    console.print("[dim]All configuration is now project-specific only.[/dim]\n")
 
     # Project config
-    console.print()
     project_config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
     if project_config_path.exists():
         console.print(f"[cyan]Project:[/cyan] {project_config_path}")
@@ -440,12 +427,12 @@ def show_current_config() -> None:
 
 
 def set_adapter_config(
-    adapter: Optional[str] = None,
-    api_key: Optional[str] = None,
-    project_id: Optional[str] = None,
-    team_id: Optional[str] = None,
+    adapter: str | None = None,
+    api_key: str | None = None,
+    project_id: str | None = None,
+    team_id: str | None = None,
     global_scope: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> None:
     """Set specific adapter configuration values.
 
@@ -498,11 +485,13 @@ def set_adapter_config(
 
         console.print(f"[green]✓[/green] Updated {target_adapter} configuration")
 
-    # Save config
+    # Save config (always to project config for security)
+    resolver.save_project_config(config)
+    config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
+
     if global_scope:
-        resolver.save_global_config(config)
-        console.print(f"[dim]Saved to {resolver.GLOBAL_CONFIG_PATH}[/dim]")
-    else:
-        resolver.save_project_config(config)
-        config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
-        console.print(f"[dim]Saved to {config_path}[/dim]")
+        console.print(
+            "[yellow]Note: Global config deprecated for security. Saved to project config instead.[/yellow]"
+        )
+
+    console.print(f"[dim]Saved to {config_path}[/dim]")

mcp_ticketer/cli/diagnostics.py

@@ -5,14 +5,14 @@ import logging
 import sys
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import typer
 from rich.console import Console
 from rich.table import Table
 
 
-def get_config():
+def get_config() -> Any:
     """Get configuration using the real configuration system."""
     from ..core.config import ConfigurationManager
 
@@ -20,7 +20,7 @@ def get_config():
     return config_manager.load_config()
 
 
-def safe_import_registry():
+def safe_import_registry() -> type:
     """Safely import adapter registry with fallback."""
     try:
         from ..core.registry import AdapterRegistry
@@ -30,13 +30,13 @@ def safe_import_registry():
 
         class MockRegistry:
             @staticmethod
-            def get_adapter(adapter_type):
+            def get_adapter(adapter_type: str) -> None:
                 raise ImportError(f"Adapter {adapter_type} not available")
 
         return MockRegistry
 
 
-def safe_import_queue_manager():
+def safe_import_queue_manager() -> type:
     """Safely import worker manager with fallback."""
     try:
         from ..queue.manager import WorkerManager as RealWorkerManager
@@ -55,16 +55,16 @@ def safe_import_queue_manager():
         pass
 
     class MockWorkerManager:
-        def get_status(self):
+        def get_status(self) -> dict[str, Any]:
             return {"running": False, "pid": None, "status": "fallback_mode"}
 
-        def get_worker_status(self):
+        def get_worker_status(self) -> dict[str, Any]:
             return {"running": False, "pid": None, "status": "fallback_mode"}
 
-        def get_queue_stats(self):
+        def get_queue_stats(self) -> dict[str, Any]:
             return {"total": 0, "failed": 0, "pending": 0, "completed": 0}
 
-        def health_check(self):
+        def health_check(self) -> dict[str, Any]:
             return {
                 "status": "degraded",
                 "score": 50,
@@ -85,11 +85,11 @@ logger = logging.getLogger(__name__)
 class SystemDiagnostics:
     """Comprehensive system diagnostics and health reporting."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Initialize lists first
-        self.issues = []
-        self.warnings = []
-        self.successes = []
+        self.issues: list[str] = []
+        self.warnings: list[str] = []
+        self.successes: list[str] = []
 
         try:
             self.config = get_config()
@@ -611,7 +611,7 @@ class SystemDiagnostics:
 
     async def _analyze_log_directory(
         self, log_path: Path, log_analysis: dict[str, Any]
-    ):
+    ) -> None:
         """Analyze logs in a specific directory."""
         try:
             for log_file in log_path.glob("*.log"):
@@ -623,7 +623,9 @@ class SystemDiagnostics:
         except Exception as e:
             self.warnings.append(f"Could not analyze logs in {log_path}: {str(e)}")
 
-    async def _parse_log_file(self, log_file: Path, log_analysis: dict[str, Any]):
+    async def _parse_log_file(
+        self, log_file: Path, log_analysis: dict[str, Any]
+    ) -> None:
         """Parse individual log file for issues."""
         try:
             with open(log_file) as f:
@@ -672,7 +674,7 @@ class SystemDiagnostics:
 
     def _generate_recommendations(self) -> list[str]:
         """Generate actionable recommendations based on diagnosis."""
-        recommendations = []
+        recommendations: list[str] = []
 
         if self.issues:
             recommendations.append(
@@ -705,7 +707,7 @@ class SystemDiagnostics:
 
         return recommendations
 
-    def _display_diagnosis_summary(self, report: dict[str, Any]):
+    def _display_diagnosis_summary(self, report: dict[str, Any]) -> None:
         """Display a comprehensive diagnosis summary."""
         console.print("\n" + "=" * 60)
         console.print("📋 [bold green]DIAGNOSIS SUMMARY[/bold green]")
@@ -795,7 +797,7 @@ class SystemDiagnostics:
 
 
 async def run_diagnostics(
-    output_file: Optional[str] = None,
+    output_file: str | None = None,
     json_output: bool = False,
 ) -> None:
     """Run comprehensive system diagnostics."""