mcp-ticketer 2.0.1__py3-none-any.whl → 2.2.13__py3-none-any.whl

mcp_ticketer/cli/mcp_configure.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -13,6 +14,36 @@ from .python_detection import get_mcp_ticketer_python
 console = Console()
 
 
+def is_mcp_ticketer_in_path() -> bool:
+    """Check if mcp-ticketer command is accessible via PATH.
+
+    This is critical for native Claude CLI mode, which writes bare
+    command names like "mcp-ticketer" instead of full paths.
+
+    Returns:
+        True if mcp-ticketer can be found in PATH, False otherwise.
+
+    Examples:
+        >>> # pipx with PATH configured
+        >>> is_mcp_ticketer_in_path()
+        True
+
+        >>> # pipx without PATH configured
+        >>> is_mcp_ticketer_in_path()
+        False
+
+    """
+    result = shutil.which("mcp-ticketer") is not None
+    if result:
+        console.print("[dim]✓ mcp-ticketer found in PATH[/dim]", highlight=False)
+    else:
+        console.print(
+            "[dim]⚠ mcp-ticketer not in PATH (will use legacy JSON mode)[/dim]",
+            highlight=False,
+        )
+    return result
+
+
 def is_claude_cli_available() -> bool:
     """Check if Claude CLI is available in PATH.
 
@@ -57,45 +88,46 @@ def build_claude_mcp_command(
     # Transport: always stdio
     cmd.extend(["--transport", "stdio"])
 
-    # Environment variables (credentials)
+    # Server name - MUST come before -e flags per Claude CLI syntax:
+    # claude mcp add [options] <name> -e KEY=val... -- <command> [args...]
+    cmd.append("mcp-ticketer")
+
+    # Environment variables (credentials) - MUST come after server name
     adapters = project_config.get("adapters", {})
 
     # Linear adapter
     if "linear" in adapters:
         linear_config = adapters["linear"]
         if "api_key" in linear_config:
-            cmd.extend(["--env", f"LINEAR_API_KEY={linear_config['api_key']}"])
+            cmd.extend(["-e", f"LINEAR_API_KEY={linear_config['api_key']}"])
         if "team_id" in linear_config:
-            cmd.extend(["--env", f"LINEAR_TEAM_ID={linear_config['team_id']}"])
+            cmd.extend(["-e", f"LINEAR_TEAM_ID={linear_config['team_id']}"])
         if "team_key" in linear_config:
-            cmd.extend(["--env", f"LINEAR_TEAM_KEY={linear_config['team_key']}"])
+            cmd.extend(["-e", f"LINEAR_TEAM_KEY={linear_config['team_key']}"])
 
     # GitHub adapter
     if "github" in adapters:
         github_config = adapters["github"]
         if "token" in github_config:
-            cmd.extend(["--env", f"GITHUB_TOKEN={github_config['token']}"])
+            cmd.extend(["-e", f"GITHUB_TOKEN={github_config['token']}"])
         if "owner" in github_config:
-            cmd.extend(["--env", f"GITHUB_OWNER={github_config['owner']}"])
+            cmd.extend(["-e", f"GITHUB_OWNER={github_config['owner']}"])
         if "repo" in github_config:
-            cmd.extend(["--env", f"GITHUB_REPO={github_config['repo']}"])
+            cmd.extend(["-e", f"GITHUB_REPO={github_config['repo']}"])
 
     # JIRA adapter
     if "jira" in adapters:
         jira_config = adapters["jira"]
         if "api_token" in jira_config:
-            cmd.extend(["--env", f"JIRA_API_TOKEN={jira_config['api_token']}"])
+            cmd.extend(["-e", f"JIRA_API_TOKEN={jira_config['api_token']}"])
         if "email" in jira_config:
-            cmd.extend(["--env", f"JIRA_EMAIL={jira_config['email']}"])
+            cmd.extend(["-e", f"JIRA_EMAIL={jira_config['email']}"])
         if "url" in jira_config:
-            cmd.extend(["--env", f"JIRA_URL={jira_config['url']}"])
+            cmd.extend(["-e", f"JIRA_URL={jira_config['url']}"])
 
     # Add default adapter
     default_adapter = project_config.get("default_adapter", "aitrackdown")
-    cmd.extend(["--env", f"MCP_TICKETER_ADAPTER={default_adapter}"])
-
-    # Server label
-    cmd.append("mcp-ticketer")
+    cmd.extend(["-e", f"MCP_TICKETER_ADAPTER={default_adapter}"])
 
     # Command separator
     cmd.append("--")
@@ -118,6 +150,10 @@ def configure_claude_mcp_native(
 ) -> None:
     """Configure Claude Code using native 'claude mcp add' command.
 
+    This method is preferred when both Claude CLI and mcp-ticketer
+    are available in PATH. It provides better integration and
+    automatic updates.
+
     Args:
         project_config: Project configuration dict
         project_path: Path to project directory
@@ -129,6 +165,9 @@ def configure_claude_mcp_native(
         subprocess.TimeoutExpired: If command times out
 
     """
+    console.print("[cyan]⚙️  Configuring MCP via native Claude CLI[/cyan]")
+    console.print("[dim]Command will be: mcp-ticketer (resolved from PATH)[/dim]")
+
     # Auto-remove before re-adding when force=True
     if force:
         console.print("[cyan]🗑️  Force mode: Removing existing configuration...[/cyan]")
@@ -159,7 +198,7 @@ def configure_claude_mcp_native(
     # Show command to user (mask sensitive values)
     masked_cmd = []
     for i, arg in enumerate(cmd):
-        if arg.startswith("--env=") or (i > 0 and cmd[i - 1] == "--env"):
+        if arg.startswith("-e=") or (i > 0 and cmd[i - 1] == "-e"):
             # Mask environment variable values
             if "=" in arg:
                 key, _ = arg.split("=", 1)
@@ -218,6 +257,69 @@ def configure_claude_mcp_native(
         raise
 
 
+def _get_adapter_env_vars() -> dict[str, str]:
+    """Get environment variables for the configured adapter from project config.
+
+    Reads credentials from .mcp-ticketer/config.json and returns them as
+    environment variables suitable for MCP server configuration.
+
+    Returns:
+        Dict of environment variables with adapter credentials
+
+    Example:
+        >>> env_vars = _get_adapter_env_vars()
+        >>> env_vars
+        {
+            'MCP_TICKETER_ADAPTER': 'github',
+            'GITHUB_TOKEN': 'ghp_...',
+            'GITHUB_OWNER': 'username',
+            'GITHUB_REPO': 'repo-name'
+        }
+
+    """
+    config_path = Path.cwd() / ".mcp-ticketer" / "config.json"
+    if not config_path.exists():
+        return {}
+
+    try:
+        with open(config_path) as f:
+            config = json.load(f)
+
+        adapter_type = config.get("default_adapter", "aitrackdown")
+        adapters = config.get("adapters", {})
+        adapter_config = adapters.get(adapter_type, {})
+
+        env_vars = {"MCP_TICKETER_ADAPTER": adapter_type}
+
+        if adapter_type == "github":
+            if token := adapter_config.get("token"):
+                env_vars["GITHUB_TOKEN"] = token
+            if owner := adapter_config.get("owner"):
+                env_vars["GITHUB_OWNER"] = owner
+            if repo := adapter_config.get("repo"):
+                env_vars["GITHUB_REPO"] = repo
+        elif adapter_type == "linear":
+            if api_key := adapter_config.get("api_key"):
+                env_vars["LINEAR_API_KEY"] = api_key
+            if team_key := adapter_config.get("team_key"):
+                env_vars["LINEAR_TEAM_KEY"] = team_key
+            elif team_id := adapter_config.get("team_id"):
+                env_vars["LINEAR_TEAM_ID"] = team_id
+        elif adapter_type == "jira":
+            if api_token := adapter_config.get("api_token"):
+                env_vars["JIRA_API_TOKEN"] = api_token
+            if server := adapter_config.get("server"):
+                env_vars["JIRA_SERVER"] = server
+            if email := adapter_config.get("email"):
+                env_vars["JIRA_EMAIL"] = email
+            if project := adapter_config.get("project_key"):
+                env_vars["JIRA_PROJECT_KEY"] = project
+
+        return env_vars
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
 def load_env_file(env_path: Path) -> dict[str, str]:
     """Load environment variables from .env file.
 
@@ -447,25 +549,23 @@ def create_mcp_server_config(
     # Environment variables below are optional fallbacks for backward compatibility
     # The FastMCP SDK server will automatically load config from the project directory
 
-    adapter = project_config.get("default_adapter", "aitrackdown")
-    adapters_config = project_config.get("adapters", {})
-    adapter_config = adapters_config.get(adapter, {})
-
     env_vars = {}
 
     # Add PYTHONPATH for project context (only for project-specific configs)
     if project_path and not is_global_config:
         env_vars["PYTHONPATH"] = project_path
 
-    # Add MCP_TICKETER_ADAPTER to identify which adapter to use (optional fallback)
-    env_vars["MCP_TICKETER_ADAPTER"] = adapter
+    # Get adapter credentials from project config
+    # This is the primary source for MCP server environment variables
+    adapter_env_vars = _get_adapter_env_vars()
+    env_vars.update(adapter_env_vars)
 
-    # Load environment variables from .env.local if it exists
+    # Load environment variables from .env.local if it exists (as override)
     if project_path:
         env_file_path = Path(project_path) / ".env.local"
         env_file_vars = load_env_file(env_file_path)
 
-        # Add relevant adapter-specific vars from .env.local
+        # Add relevant adapter-specific vars from .env.local (overrides config.json)
         adapter_env_keys = {
             "linear": ["LINEAR_API_KEY", "LINEAR_TEAM_ID", "LINEAR_TEAM_KEY"],
             "github": ["GITHUB_TOKEN", "GITHUB_OWNER", "GITHUB_REPO"],
@@ -480,24 +580,12 @@ def create_mcp_server_config(
             "aitrackdown": [],  # No specific env vars needed
         }
 
-        # Include adapter-specific env vars from .env.local
+        adapter = env_vars.get("MCP_TICKETER_ADAPTER", "aitrackdown")
+        # Include adapter-specific env vars from .env.local (overrides config.json)
         for key in adapter_env_keys.get(adapter, []):
             if key in env_file_vars:
                 env_vars[key] = env_file_vars[key]
 
-    # Fallback: Add adapter-specific environment variables from project config
-    if adapter == "linear" and "api_key" in adapter_config:
-        if "LINEAR_API_KEY" not in env_vars:
-            env_vars["LINEAR_API_KEY"] = adapter_config["api_key"]
-    elif adapter == "github" and "token" in adapter_config:
-        if "GITHUB_TOKEN" not in env_vars:
-            env_vars["GITHUB_TOKEN"] = adapter_config["token"]
-    elif adapter == "jira":
-        if "api_token" in adapter_config and "JIRA_API_TOKEN" not in env_vars:
-            env_vars["JIRA_API_TOKEN"] = adapter_config["api_token"]
-        if "email" in adapter_config and "JIRA_EMAIL" not in env_vars:
-            env_vars["JIRA_EMAIL"] = adapter_config["email"]
-
     if env_vars:
         config["env"] = env_vars
 
@@ -845,9 +933,16 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
         console.print(f"[red]✗[/red] {e}")
         raise
 
-    # Check for native CLI availability
+    # Check for native CLI availability AND PATH configuration
     console.print("\n[cyan]🔍 Checking for Claude CLI...[/cyan]")
-    if is_claude_cli_available():
+
+    # Native CLI requires both claude command AND mcp-ticketer in PATH
+    claude_cli_available = is_claude_cli_available()
+    mcp_ticketer_in_path = is_mcp_ticketer_in_path()
+
+    use_native_cli = claude_cli_available and mcp_ticketer_in_path
+
+    if use_native_cli:
         console.print("[green]✓[/green] Claude CLI found - using native command")
         console.print(
             "[dim]This provides better integration and automatic updates[/dim]"
@@ -863,13 +958,25 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
             force=force,
         )
 
-    # Fall back to JSON manipulation
-    console.print(
-        "[yellow]⚠[/yellow] Claude CLI not found - using legacy JSON configuration"
-    )
-    console.print(
-        "[dim]For better experience, install Claude CLI: https://docs.claude.ai/cli[/dim]"
-    )
+    # Fall back to reliable JSON manipulation with full paths
+    if claude_cli_available and not mcp_ticketer_in_path:
+        console.print(
+            "[yellow]⚠[/yellow] mcp-ticketer not found in PATH - using legacy JSON mode"
+        )
+        console.print(
+            "[dim]Native CLI writes bare command names that fail when not in PATH[/dim]"
+        )
+        console.print(
+            "[dim]To enable native CLI, add pipx bin directory to your PATH:[/dim]"
+        )
+        console.print('[dim]  export PATH="$HOME/.local/bin:$PATH"[/dim]')
+    elif not claude_cli_available:
+        console.print(
+            "[yellow]⚠[/yellow] Claude CLI not found - using legacy JSON configuration"
+        )
+        console.print(
+            "[dim]For better experience, install Claude CLI: https://docs.claude.ai/cli[/dim]"
+        )
 
     # Auto-remove before re-adding when force=True
     if force:
@@ -893,6 +1000,10 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
 
         console.print()  # Blank line for visual separation
 
+    # Show that we're using legacy JSON mode with full paths
+    console.print("\n[cyan]⚙️  Configuring MCP via legacy JSON mode[/cyan]")
+    console.print("[dim]This mode uses full paths for reliable operation[/dim]")
+
     # Determine project path for venv detection
     project_path = Path.cwd() if not global_config else None
 
@@ -907,6 +1018,11 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
             console.print("[dim]Using project-specific venv[/dim]")
         else:
             console.print("[dim]Using pipx/system Python[/dim]")
+
+        # Derive CLI path from Python path
+        python_dir = Path(python_path).parent
+        cli_path = str(python_dir / "mcp-ticketer")
+        console.print(f"[dim]CLI command will be: {cli_path}[/dim]")
     except Exception as e:
         console.print(f"[red]✗[/red] Could not find Python executable: {e}")
         raise FileNotFoundError(
@@ -1058,9 +1174,21 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
         if absolute_project_path:
             console.print(f"  Project path: {absolute_project_path}")
         if "env" in server_config:
-            console.print(
-                f"  Environment variables: {list(server_config['env'].keys())}"
-            )
+            env_keys = list(server_config["env"].keys())
+            console.print(f"  Environment variables: {env_keys}")
+
+            # Security warning about credentials
+            sensitive_keys = [
+                k for k in env_keys if "TOKEN" in k or "KEY" in k or "PASSWORD" in k
+            ]
+            if sensitive_keys:
+                console.print(
+                    "\n[yellow]⚠️  Security Notice:[/yellow] Configuration contains credentials"
+                )
+                console.print(f"[yellow]   Location: {mcp_config_path}[/yellow]")
+                console.print(
+                    "[yellow]   Make sure this file is excluded from version control[/yellow]"
+                )
 
         # Migration success message (if legacy config was detected)
         if is_legacy:

mcp_ticketer/cli/platform_installer.py

@@ -13,6 +13,7 @@ from rich.table import Table
 # Import for typing compatibility
 from .init_command import init
 from .platform_detection import PlatformDetector, get_platform_by_name
+from .setup_command import _update_mcp_json_credentials
 
 console = Console()
 
@@ -248,6 +249,10 @@ def install(
                 console.print(f"[cyan]Installing for {plat.display_name}...[/cyan]")
                 config_func()
                 success_count += 1
+
+                # Update credentials in parent .mcp.json for Claude platforms
+                if plat.name in ("claude-code", "claude-desktop"):
+                    _update_mcp_json_credentials(Path.cwd(), console)
             except Exception as e:
                 console.print(
                     f"[red]✗[/red]  Failed to install for {plat.display_name}: {e}"
@@ -388,6 +393,10 @@ def install(
 
         try:
             config["func"]()
+
+            # Update credentials in parent .mcp.json for Claude platforms
+            if platform in ("claude-code", "claude-desktop"):
+                _update_mcp_json_credentials(Path.cwd(), console)
         except Exception as e:
             console.print(f"[red]Installation failed: {e}[/red]")
             raise typer.Exit(1) from e

mcp_ticketer/cli/setup_command.py

@@ -332,6 +332,9 @@ def setup(
         # Check and install adapter-specific dependencies
         _check_and_install_adapter_dependencies(adapter_type, console)
 
+        # Update existing MCP configurations with new credentials
+        _update_mcp_json_credentials(proj_path, console)
+
         console.print("\n[green]✓ Adapter configuration complete[/green]\n")
     else:
         console.print("[green]✓ Step 1/2: Adapter already configured[/green]\n")
@@ -340,6 +343,9 @@ def setup(
         # This handles the case where credentials exist but defaults were never set
         _prompt_and_update_default_values(config_path, current_adapter, console)
 
+        # Update existing MCP configurations with credentials
+        _update_mcp_json_credentials(proj_path, console)
+
     # Step 3: Platform installation
     if skip_platforms:
         console.print(
@@ -352,7 +358,7 @@ def setup(
 
     # Detect available platforms
     detector = PlatformDetector()
-    detected = detector.detect_all(project_path=proj_path)
+    detected = detector.detect_all(project_path=proj_path, exclude_desktop=True)
 
     if not detected:
         console.print("[yellow]No AI platforms detected on this system.[/yellow]")
@@ -612,6 +618,156 @@ def _check_existing_platform_configs(platforms: list, proj_path: Path) -> list[s
     return configured
 
 
+def _update_mcp_json_credentials(proj_path: Path, console: Console) -> None:
+    """Update .mcp.json with adapter credentials if mcp-ticketer is already configured.
+
+    This function updates the existing MCP configuration with the latest credentials
+    from the project's .mcp-ticketer/config.json file. It also ensures .mcp.json is
+    added to .gitignore to prevent credential leaks.
+
+    Additionally, it updates the official @modelcontextprotocol/server-github MCP server
+    if found, since it also requires GITHUB_PERSONAL_ACCESS_TOKEN.
+
+    Args:
+        proj_path: Project path
+        console: Rich console for output
+
+    """
+    # Check multiple .mcp.json locations
+    new_mcp_json_path = Path.home() / ".config" / "claude" / "mcp.json"
+    old_mcp_json_path = Path.home() / ".claude.json"
+    legacy_mcp_json_path = proj_path / ".claude" / "mcp.local.json"
+    project_mcp_json_path = proj_path / ".mcp.json"
+
+    mcp_json_paths = [
+        (new_mcp_json_path, True),  # (path, is_global_mcp_config)
+        (old_mcp_json_path, False),
+        (legacy_mcp_json_path, False),
+        (project_mcp_json_path, False),
+    ]
+
+    # Also check parent directories for .mcp.json (Claude Code inheritance)
+    # This handles cases like /Users/masa/Projects/.mcp.json
+    current = proj_path.parent
+    home = Path.home()
+    checked_parents: set[Path] = set()
+    while current != home and current != current.parent:
+        parent_mcp = current / ".mcp.json"
+        if parent_mcp not in checked_parents and parent_mcp.exists():
+            mcp_json_paths.append((parent_mcp, False))
+            checked_parents.add(parent_mcp)
+        current = current.parent
+
+    # Import the helper function to get adapter credentials
+    from .mcp_configure import _get_adapter_env_vars
+
+    env_vars = _get_adapter_env_vars()
+
+    if not env_vars:
+        return
+
+    updated_count = 0
+
+    for mcp_json_path, is_global_mcp_config in mcp_json_paths:
+        if not mcp_json_path.exists():
+            continue
+
+        try:
+            with open(mcp_json_path) as f:
+                mcp_config = json.load(f)
+
+            # Check if mcp-ticketer is configured
+            mcp_servers = None
+            if is_global_mcp_config:
+                # Global mcp.json uses flat structure
+                mcp_servers = mcp_config.get("mcpServers", {})
+            else:
+                # Old structure uses projects
+                projects = mcp_config.get("projects", {})
+                project_key = str(proj_path.resolve())
+                if project_key in projects:
+                    mcp_servers = projects[project_key].get("mcpServers", {})
+                else:
+                    # Try flat structure for backward compatibility
+                    mcp_servers = mcp_config.get("mcpServers", {})
+
+            if mcp_servers is None:
+                continue
+
+            config_updated = False
+
+            # Update the mcp-ticketer server env vars if configured
+            if "mcp-ticketer" in mcp_servers:
+                current_env = mcp_servers["mcp-ticketer"].get("env", {})
+                current_env.update(env_vars)
+                mcp_servers["mcp-ticketer"]["env"] = current_env
+                config_updated = True
+
+            # Also update official @modelcontextprotocol/server-github if present
+            # This server uses GITHUB_PERSONAL_ACCESS_TOKEN instead of GITHUB_TOKEN
+            if "github" in mcp_servers and "GITHUB_TOKEN" in env_vars:
+                github_server = mcp_servers["github"]
+                # Check if it's the official GitHub MCP server (uses npx or server-github)
+                cmd = github_server.get("command", "")
+                args = github_server.get("args", [])
+                is_official_github = (
+                    cmd == "npx" and any("server-github" in str(arg) for arg in args)
+                ) or "server-github" in cmd
+
+                if is_official_github:
+                    current_env = github_server.get("env", {})
+                    # The official server uses GITHUB_PERSONAL_ACCESS_TOKEN
+                    current_env["GITHUB_PERSONAL_ACCESS_TOKEN"] = env_vars[
+                        "GITHUB_TOKEN"
+                    ]
+                    github_server["env"] = current_env
+                    config_updated = True
+                    console.print(
+                        f"[dim]  Also updated official GitHub MCP server in {mcp_json_path}[/dim]"
+                    )
+
+            if not config_updated:
+                continue
+
+            # Save updated config
+            with open(mcp_json_path, "w") as f:
+                json.dump(mcp_config, f, indent=2)
+
+            updated_count += 1
+
+        except (json.JSONDecodeError, OSError) as e:
+            console.print(
+                f"[yellow]Warning: Could not update {mcp_json_path.name}: {e}[/yellow]"
+            )
+
+    if updated_count > 0:
+        console.print(
+            f"[green]✓[/green] Updated MCP configuration with adapter credentials ({updated_count} file(s))"
+        )
+
+        # Ensure .mcp.json files are in .gitignore (only for project-local files)
+        gitignore_path = proj_path / ".gitignore"
+        patterns_to_add = [".claude/", ".mcp.json"]
+
+        if gitignore_path.exists():
+            content = gitignore_path.read_text()
+            patterns_added = []
+
+            for pattern in patterns_to_add:
+                if pattern not in content:
+                    patterns_added.append(pattern)
+
+            if patterns_added:
+                with open(gitignore_path, "a") as f:
+                    f.write("\n# MCP configuration (contains tokens)\n")
+                    for pattern in patterns_added:
+                        f.write(f"{pattern}\n")
+
+                console.print(
+                    f"[dim]✓ Added {', '.join(patterns_added)} to .gitignore[/dim]"
+                )
+
+
 def _show_setup_complete_message(console: Console, proj_path: Path) -> None:
     """Show setup complete message with next steps.