mcp-ticketer 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

mcp_ticketer/__version__.py

@@ -1,6 +1,6 @@
 """Version information for mcp-ticketer package."""
 
-__version__ = "0.1.13"
+__version__ = "0.1.15"
 __version_info__ = tuple(int(part) for part in __version__.split("."))
 
 # Package metadata

mcp_ticketer/cli/main.py

@@ -160,11 +160,22 @@ def get_adapter(override_adapter: Optional[str] = None, override_config: Optiona
 
 @app.command()
 def init(
-    adapter: AdapterType = typer.Option(
-        AdapterType.AITRACKDOWN,
+    adapter: Optional[str] = typer.Option(
+        None,
         "--adapter",
         "-a",
-        help="Adapter type to use"
+        help="Adapter type to use (auto-detected from .env if not specified)"
+    ),
+    project_path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        help="Project path (default: current directory)"
+    ),
+    global_config: bool = typer.Option(
+        False,
+        "--global",
+        "-g",
+        help="Save to global config instead of project-specific"
     ),
     base_path: Optional[str] = typer.Option(
         None,
@@ -213,97 +224,306 @@ def init(
         help="GitHub Personal Access Token"
     ),
 ) -> None:
-    """Initialize MCP Ticketer configuration."""
+    """Initialize mcp-ticketer for the current project.
+
+    Creates .mcp-ticketer/config.json in the current directory with
+    auto-detected or specified adapter configuration.
+
+    Examples:
+        # Auto-detect from .env.local
+        mcp-ticketer init
+
+        # Force specific adapter
+        mcp-ticketer init --adapter linear
+
+        # Initialize for different project
+        mcp-ticketer init --path /path/to/project
+
+        # Save globally (not recommended)
+        mcp-ticketer init --global
+    """
+    from pathlib import Path
+    from ..core.project_config import ConfigResolver
+    from ..core.env_discovery import discover_config
+
+    # Determine project path
+    proj_path = Path(project_path) if project_path else Path.cwd()
+
+    # Check if already initialized (unless using --global)
+    if not global_config:
+        config_path = proj_path / ".mcp-ticketer" / "config.json"
+
+        if config_path.exists():
+            if not typer.confirm(
+                f"Configuration already exists at {config_path}. Overwrite?",
+                default=False
+            ):
+                console.print("[yellow]Initialization cancelled.[/yellow]")
+                raise typer.Exit(0)
+
+    # 1. Try auto-discovery if no adapter specified
+    discovered = None
+    adapter_type = adapter
+
+    if not adapter_type:
+        console.print("[cyan]🔍 Auto-discovering configuration from .env files...[/cyan]")
+        discovered = discover_config(proj_path)
+
+        if discovered and discovered.adapters:
+            primary = discovered.get_primary_adapter()
+            if primary:
+                adapter_type = primary.adapter_type
+                console.print(f"[green]✓ Detected {adapter_type} adapter from environment files[/green]")
+
+                # Show what was discovered
+                console.print(f"\n[dim]Configuration found in: {primary.found_in}[/dim]")
+                console.print(f"[dim]Confidence: {primary.confidence:.0%}[/dim]")
+            else:
+                adapter_type = "aitrackdown"  # Fallback
+                console.print("[yellow]⚠ No credentials found, defaulting to aitrackdown[/yellow]")
+        else:
+            adapter_type = "aitrackdown"  # Fallback
+            console.print("[yellow]⚠ No .env files found, defaulting to aitrackdown[/yellow]")
+
+    # 2. Create configuration based on adapter type
     config = {
-        "default_adapter": adapter.value,
+        "default_adapter": adapter_type,
         "adapters": {}
     }
 
-    if adapter == AdapterType.AITRACKDOWN:
+    # 3. If discovered and matches adapter_type, use discovered config
+    if discovered and adapter_type != "aitrackdown":
+        discovered_adapter = discovered.get_adapter_by_type(adapter_type)
+        if discovered_adapter:
+            config["adapters"][adapter_type] = discovered_adapter.config
+
+    # 4. Handle manual configuration for specific adapters
+    if adapter_type == "aitrackdown":
         config["adapters"]["aitrackdown"] = {"base_path": base_path or ".aitrackdown"}
-    elif adapter == AdapterType.LINEAR:
-        # For Linear, we need team_id and optionally api_key
-        if not team_id:
-            console.print("[red]Error:[/red] --team-id is required for Linear adapter")
-            raise typer.Exit(1)
-
-        config["adapters"]["linear"] = {"team_id": team_id}
-
-        # Check for API key in environment or parameter
-        linear_api_key = api_key or os.getenv("LINEAR_API_KEY")
-        if not linear_api_key:
-            console.print("[yellow]Warning:[/yellow] No Linear API key provided.")
-            console.print("Set LINEAR_API_KEY environment variable or use --api-key option")
-        else:
-            config["adapters"]["linear"]["api_key"] = linear_api_key
-
-    elif adapter == AdapterType.JIRA:
-        # For JIRA, we need server, email, and API token
-        server = jira_server or os.getenv("JIRA_SERVER")
-        email = jira_email or os.getenv("JIRA_EMAIL")
-        token = api_key or os.getenv("JIRA_API_TOKEN")
-        project = jira_project or os.getenv("JIRA_PROJECT_KEY")
-
-        if not server:
-            console.print("[red]Error:[/red] JIRA server URL is required")
-            console.print("Use --jira-server or set JIRA_SERVER environment variable")
-            raise typer.Exit(1)
-
-        if not email:
-            console.print("[red]Error:[/red] JIRA email is required")
-            console.print("Use --jira-email or set JIRA_EMAIL environment variable")
-            raise typer.Exit(1)
-
-        if not token:
-            console.print("[red]Error:[/red] JIRA API token is required")
-            console.print("Use --api-key or set JIRA_API_TOKEN environment variable")
-            console.print("[dim]Generate token at: https://id.atlassian.com/manage/api-tokens[/dim]")
-            raise typer.Exit(1)
-
-        config["adapters"]["jira"] = {
-            "server": server,
-            "email": email,
-            "api_token": token
-        }
 
-        if project:
-            config["adapters"]["jira"]["project_key"] = project
+    elif adapter_type == "linear":
+        # If not auto-discovered, build from CLI params
+        if adapter_type not in config["adapters"]:
+            linear_config = {}
+
+            # Team ID
+            if team_id:
+                linear_config["team_id"] = team_id
+
+            # API Key
+            linear_api_key = api_key or os.getenv("LINEAR_API_KEY")
+            if linear_api_key:
+                linear_config["api_key"] = linear_api_key
+            elif not discovered:
+                console.print("[yellow]Warning:[/yellow] No Linear API key provided.")
+                console.print("Set LINEAR_API_KEY environment variable or use --api-key option")
+
+            if linear_config:
+                config["adapters"]["linear"] = linear_config
+
+    elif adapter_type == "jira":
+        # If not auto-discovered, build from CLI params
+        if adapter_type not in config["adapters"]:
+            server = jira_server or os.getenv("JIRA_SERVER")
+            email = jira_email or os.getenv("JIRA_EMAIL")
+            token = api_key or os.getenv("JIRA_API_TOKEN")
+            project = jira_project or os.getenv("JIRA_PROJECT_KEY")
+
+            if not server:
+                console.print("[red]Error:[/red] JIRA server URL is required")
+                console.print("Use --jira-server or set JIRA_SERVER environment variable")
+                raise typer.Exit(1)
+
+            if not email:
+                console.print("[red]Error:[/red] JIRA email is required")
+                console.print("Use --jira-email or set JIRA_EMAIL environment variable")
+                raise typer.Exit(1)
+
+            if not token:
+                console.print("[red]Error:[/red] JIRA API token is required")
+                console.print("Use --api-key or set JIRA_API_TOKEN environment variable")
+                console.print("[dim]Generate token at: https://id.atlassian.com/manage/api-tokens[/dim]")
+                raise typer.Exit(1)
+
+            jira_config = {
+                "server": server,
+                "email": email,
+                "api_token": token
+            }
+
+            if project:
+                jira_config["project_key"] = project
+
+            config["adapters"]["jira"] = jira_config
+
+    elif adapter_type == "github":
+        # If not auto-discovered, build from CLI params
+        if adapter_type not in config["adapters"]:
+            owner = github_owner or os.getenv("GITHUB_OWNER")
+            repo = github_repo or os.getenv("GITHUB_REPO")
+            token = github_token or os.getenv("GITHUB_TOKEN")
+
+            if not owner:
+                console.print("[red]Error:[/red] GitHub repository owner is required")
+                console.print("Use --github-owner or set GITHUB_OWNER environment variable")
+                raise typer.Exit(1)
+
+            if not repo:
+                console.print("[red]Error:[/red] GitHub repository name is required")
+                console.print("Use --github-repo or set GITHUB_REPO environment variable")
+                raise typer.Exit(1)
+
+            if not token:
+                console.print("[red]Error:[/red] GitHub Personal Access Token is required")
+                console.print("Use --github-token or set GITHUB_TOKEN environment variable")
+                console.print("[dim]Create token at: https://github.com/settings/tokens/new[/dim]")
+                console.print("[dim]Required scopes: repo (for private repos) or public_repo (for public repos)[/dim]")
+                raise typer.Exit(1)
+
+            config["adapters"]["github"] = {
+                "owner": owner,
+                "repo": repo,
+                "token": token
+            }
+
+    # 5. Save to appropriate location
+    if global_config:
+        # Save to ~/.mcp-ticketer/config.json
+        resolver = ConfigResolver(project_path=proj_path)
+        config_file_path = resolver.GLOBAL_CONFIG_PATH
+        config_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(config_file_path, 'w') as f:
+            json.dump(config, f, indent=2)
+
+        console.print(f"[green]✓ Initialized with {adapter_type} adapter[/green]")
+        console.print(f"[dim]Global configuration saved to {config_file_path}[/dim]")
+    else:
+        # Save to ./.mcp-ticketer/config.json (PROJECT-SPECIFIC)
+        config_file_path = proj_path / ".mcp-ticketer" / "config.json"
+        config_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(config_file_path, 'w') as f:
+            json.dump(config, f, indent=2)
+
+        console.print(f"[green]✓ Initialized with {adapter_type} adapter[/green]")
+        console.print(f"[dim]Project configuration saved to {config_file_path}[/dim]")
+
+        # Add .mcp-ticketer to .gitignore if not already there
+        gitignore_path = proj_path / ".gitignore"
+        if gitignore_path.exists():
+            gitignore_content = gitignore_path.read_text()
+            if ".mcp-ticketer" not in gitignore_content:
+                with open(gitignore_path, 'a') as f:
+                    f.write("\n# MCP Ticketer\n.mcp-ticketer/\n")
+                console.print("[dim]✓ Added .mcp-ticketer/ to .gitignore[/dim]")
         else:
-            console.print("[yellow]Warning:[/yellow] No default project key specified")
-            console.print("You may need to specify project key for some operations")
-
-    elif adapter == AdapterType.GITHUB:
-        # For GitHub, we need owner, repo, and token
-        owner = github_owner or os.getenv("GITHUB_OWNER")
-        repo = github_repo or os.getenv("GITHUB_REPO")
-        token = github_token or os.getenv("GITHUB_TOKEN")
-
-        if not owner:
-            console.print("[red]Error:[/red] GitHub repository owner is required")
-            console.print("Use --github-owner or set GITHUB_OWNER environment variable")
-            raise typer.Exit(1)
-
-        if not repo:
-            console.print("[red]Error:[/red] GitHub repository name is required")
-            console.print("Use --github-repo or set GITHUB_REPO environment variable")
-            raise typer.Exit(1)
-
-        if not token:
-            console.print("[red]Error:[/red] GitHub Personal Access Token is required")
-            console.print("Use --github-token or set GITHUB_TOKEN environment variable")
-            console.print("[dim]Create token at: https://github.com/settings/tokens/new[/dim]")
-            console.print("[dim]Required scopes: repo (for private repos) or public_repo (for public repos)[/dim]")
-            raise typer.Exit(1)
-
-        config["adapters"]["github"] = {
-            "owner": owner,
-            "repo": repo,
-            "token": token
-        }
-
-    save_config(config)
-    console.print(f"[green]✓[/green] Initialized with {adapter.value} adapter")
-    console.print(f"[dim]Configuration saved to {CONFIG_FILE}[/dim]")
+            # Create .gitignore if it doesn't exist
+            with open(gitignore_path, 'w') as f:
+                f.write("# MCP Ticketer\n.mcp-ticketer/\n")
+            console.print("[dim]✓ Created .gitignore with .mcp-ticketer/[/dim]")
+
+
+@app.command()
+def install(
+    adapter: Optional[str] = typer.Option(
+        None,
+        "--adapter",
+        "-a",
+        help="Adapter type to use (auto-detected from .env if not specified)"
+    ),
+    project_path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        help="Project path (default: current directory)"
+    ),
+    global_config: bool = typer.Option(
+        False,
+        "--global",
+        "-g",
+        help="Save to global config instead of project-specific"
+    ),
+    base_path: Optional[str] = typer.Option(
+        None,
+        "--base-path",
+        "-p",
+        help="Base path for ticket storage (AITrackdown only)"
+    ),
+    api_key: Optional[str] = typer.Option(
+        None,
+        "--api-key",
+        help="API key for Linear or API token for JIRA"
+    ),
+    team_id: Optional[str] = typer.Option(
+        None,
+        "--team-id",
+        help="Linear team ID (required for Linear adapter)"
+    ),
+    jira_server: Optional[str] = typer.Option(
+        None,
+        "--jira-server",
+        help="JIRA server URL (e.g., https://company.atlassian.net)"
+    ),
+    jira_email: Optional[str] = typer.Option(
+        None,
+        "--jira-email",
+        help="JIRA user email for authentication"
+    ),
+    jira_project: Optional[str] = typer.Option(
+        None,
+        "--jira-project",
+        help="Default JIRA project key"
+    ),
+    github_owner: Optional[str] = typer.Option(
+        None,
+        "--github-owner",
+        help="GitHub repository owner"
+    ),
+    github_repo: Optional[str] = typer.Option(
+        None,
+        "--github-repo",
+        help="GitHub repository name"
+    ),
+    github_token: Optional[str] = typer.Option(
+        None,
+        "--github-token",
+        help="GitHub Personal Access Token"
+    ),
+) -> None:
+    """Initialize mcp-ticketer for the current project (alias for init).
+
+    This command is synonymous with 'init' and provides the same functionality.
+    Creates .mcp-ticketer/config.json in the current directory with
+    auto-detected or specified adapter configuration.
+
+    Examples:
+        # Auto-detect from .env.local
+        mcp-ticketer install
+
+        # Force specific adapter
+        mcp-ticketer install --adapter linear
+
+        # Initialize for different project
+        mcp-ticketer install --path /path/to/project
+
+        # Save globally (not recommended)
+        mcp-ticketer install --global
+    """
+    # Call init with all parameters
+    init(
+        adapter=adapter,
+        project_path=project_path,
+        global_config=global_config,
+        base_path=base_path,
+        api_key=api_key,
+        team_id=team_id,
+        jira_server=jira_server,
+        jira_email=jira_email,
+        jira_project=jira_project,
+        github_owner=github_owner,
+        github_repo=github_repo,
+        github_token=github_token,
+    )
 
 
 @app.command("set")
@@ -915,7 +1135,7 @@ def check(
 
 
 @app.command()
-def mcp(
+def serve(
     adapter: Optional[AdapterType] = typer.Option(
         None,
         "--adapter",
@@ -928,7 +1148,11 @@ def mcp(
         help="Base path for AITrackdown adapter"
     ),
 ):
-    """Start MCP server for JSON-RPC communication over stdio."""
+    """Start MCP server for JSON-RPC communication over stdio.
+
+    This command is used by Claude Code/Desktop when connecting to the MCP server.
+    You typically don't need to run this manually - use 'mcp-ticketer mcp' to configure.
+    """
     from ..mcp.server import MCPTicketServer
 
     # Load configuration
@@ -974,6 +1198,38 @@ def mcp(
         sys.exit(1)
 
 
+@app.command()
+def mcp(
+    global_config: bool = typer.Option(
+        False,
+        "--global",
+        "-g",
+        help="Configure Claude Desktop instead of project-level"
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Overwrite existing configuration"
+    ),
+):
+    """Configure Claude Code to use mcp-ticketer MCP server.
+
+    Reads configuration from .mcp-ticketer/config.json and updates
+    Claude Code's MCP settings accordingly.
+
+    By default, configures project-level (.mcp/config.json).
+    Use --global to configure Claude Desktop instead.
+    """
+    from ..cli.mcp_configure import configure_claude_mcp
+
+    try:
+        configure_claude_mcp(global_config=global_config, force=force)
+    except Exception as e:
+        console.print(f"[red]✗ Configuration failed:[/red] {e}")
+        raise typer.Exit(1)
+
+
 def main():
     """Main entry point."""
     app()

mcp_ticketer/cli/mcp_configure.py

@@ -0,0 +1,285 @@
+"""MCP configuration for Claude Code integration."""
+
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+
+console = Console()
+
+
+def find_mcp_ticketer_binary() -> str:
+    """Find the mcp-ticketer binary path.
+
+    Returns:
+        Path to mcp-ticketer binary
+
+    Raises:
+        FileNotFoundError: If binary not found
+    """
+    # Check if running from development environment
+    import mcp_ticketer
+    package_path = Path(mcp_ticketer.__file__).parent.parent.parent
+
+    # Check for virtual environment bin
+    possible_paths = [
+        # Development paths
+        package_path / "venv" / "bin" / "mcp-ticketer",
+        package_path / ".venv" / "bin" / "mcp-ticketer",
+        package_path / "test_venv" / "bin" / "mcp-ticketer",
+        # System installation
+        Path.home() / ".local" / "bin" / "mcp-ticketer",
+        # pipx installation
+        Path.home() / ".local" / "pipx" / "venvs" / "mcp-ticketer" / "bin" / "mcp-ticketer",
+    ]
+
+    # Check PATH
+    which_result = shutil.which("mcp-ticketer")
+    if which_result:
+        return which_result
+
+    # Check possible paths
+    for path in possible_paths:
+        if path.exists():
+            return str(path.resolve())
+
+    raise FileNotFoundError(
+        "Could not find mcp-ticketer binary. Please ensure mcp-ticketer is installed.\n"
+        "Install with: pip install mcp-ticketer"
+    )
+
+
+def load_project_config() -> dict:
+    """Load mcp-ticketer project configuration.
+
+    Returns:
+        Project configuration dict
+
+    Raises:
+        FileNotFoundError: If config not found
+        ValueError: If config is invalid
+    """
+    # Check for project-specific config first
+    project_config_path = Path.cwd() / ".mcp-ticketer" / "config.json"
+
+    if not project_config_path.exists():
+        # Check global config
+        global_config_path = Path.home() / ".mcp-ticketer" / "config.json"
+        if global_config_path.exists():
+            project_config_path = global_config_path
+        else:
+            raise FileNotFoundError(
+                "No mcp-ticketer configuration found.\n"
+                "Run 'mcp-ticketer init' to create configuration."
+            )
+
+    with open(project_config_path, "r") as f:
+        config = json.load(f)
+
+    # Validate config
+    if "default_adapter" not in config:
+        raise ValueError("Invalid config: missing 'default_adapter'")
+
+    return config
+
+
+def find_claude_mcp_config(global_config: bool = False) -> Path:
+    """Find or create Claude Code MCP configuration file.
+
+    Args:
+        global_config: If True, use Claude Desktop config instead of project-level
+
+    Returns:
+        Path to MCP configuration file
+    """
+    if global_config:
+        # Claude Desktop configuration
+        if sys.platform == "darwin":  # macOS
+            config_path = Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+        elif sys.platform == "win32":  # Windows
+            config_path = Path(os.environ.get("APPDATA", "")) / "Claude" / "claude_desktop_config.json"
+        else:  # Linux
+            config_path = Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
+    else:
+        # Project-level configuration
+        config_path = Path.cwd() / ".mcp" / "config.json"
+
+    return config_path
+
+
+def load_claude_mcp_config(config_path: Path) -> dict:
+    """Load existing Claude MCP configuration or return empty structure.
+
+    Args:
+        config_path: Path to MCP config file
+
+    Returns:
+        MCP configuration dict
+    """
+    if config_path.exists():
+        with open(config_path, "r") as f:
+            return json.load(f)
+
+    # Return empty structure
+    return {"mcpServers": {}}
+
+
+def save_claude_mcp_config(config_path: Path, config: dict) -> None:
+    """Save Claude MCP configuration to file.
+
+    Args:
+        config_path: Path to MCP config file
+        config: Configuration to save
+    """
+    # Ensure directory exists
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write with formatting
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+
+def create_mcp_server_config(
+    binary_path: str,
+    project_config: dict,
+    cwd: Optional[str] = None
+) -> dict:
+    """Create MCP server configuration for mcp-ticketer.
+
+    Args:
+        binary_path: Path to mcp-ticketer binary
+        project_config: Project configuration from .mcp-ticketer/config.json
+        cwd: Working directory for server (optional)
+
+    Returns:
+        MCP server configuration dict
+    """
+    config = {
+        "command": binary_path,
+        "args": ["serve"],  # Use 'serve' command to start MCP server
+    }
+
+    # Add working directory if provided
+    if cwd:
+        config["cwd"] = cwd
+
+    # Add environment variables based on adapter
+    adapter = project_config.get("default_adapter", "aitrackdown")
+    adapters_config = project_config.get("adapters", {})
+    adapter_config = adapters_config.get(adapter, {})
+
+    env_vars = {}
+
+    # Add adapter-specific environment variables
+    if adapter == "linear" and "api_key" in adapter_config:
+        env_vars["LINEAR_API_KEY"] = adapter_config["api_key"]
+    elif adapter == "github" and "token" in adapter_config:
+        env_vars["GITHUB_TOKEN"] = adapter_config["token"]
+    elif adapter == "jira":
+        if "api_token" in adapter_config:
+            env_vars["JIRA_API_TOKEN"] = adapter_config["api_token"]
+        if "email" in adapter_config:
+            env_vars["JIRA_EMAIL"] = adapter_config["email"]
+
+    if env_vars:
+        config["env"] = env_vars
+
+    return config
+
+
+def configure_claude_mcp(global_config: bool = False, force: bool = False) -> None:
+    """Configure Claude Code to use mcp-ticketer.
+
+    Args:
+        global_config: Configure Claude Desktop instead of project-level
+        force: Overwrite existing configuration
+
+    Raises:
+        FileNotFoundError: If binary or project config not found
+        ValueError: If configuration is invalid
+    """
+    # Step 1: Find mcp-ticketer binary
+    console.print("[cyan]🔍 Finding mcp-ticketer binary...[/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
+
+    # Step 2: Load project configuration
+    console.print("\n[cyan]📖 Reading project configuration...[/cyan]")
+    try:
+        project_config = load_project_config()
+        adapter = project_config.get("default_adapter", "aitrackdown")
+        console.print(f"[green]✓[/green] Adapter: {adapter}")
+    except (FileNotFoundError, ValueError) as e:
+        console.print(f"[red]✗[/red] {e}")
+        raise
+
+    # Step 3: Find Claude MCP config location
+    config_type = "Claude Desktop" if global_config else "project-level"
+    console.print(f"\n[cyan]🔧 Configuring {config_type} MCP...[/cyan]")
+
+    mcp_config_path = find_claude_mcp_config(global_config)
+    console.print(f"[dim]Config location: {mcp_config_path}[/dim]")
+
+    # Step 4: Load existing MCP configuration
+    mcp_config = load_claude_mcp_config(mcp_config_path)
+
+    # Step 5: Check if mcp-ticketer already configured
+    if "mcp-ticketer" in mcp_config.get("mcpServers", {}):
+        if not force:
+            console.print("[yellow]⚠ mcp-ticketer is already configured[/yellow]")
+            console.print("[dim]Use --force to overwrite existing configuration[/dim]")
+            return
+        else:
+            console.print("[yellow]⚠ Overwriting existing configuration[/yellow]")
+
+    # Step 6: Create mcp-ticketer server config
+    cwd = str(Path.cwd()) if not global_config else None
+    server_config = create_mcp_server_config(
+        binary_path=binary_path,
+        project_config=project_config,
+        cwd=cwd
+    )
+
+    # Step 7: Update MCP configuration
+    if "mcpServers" not in mcp_config:
+        mcp_config["mcpServers"] = {}
+
+    mcp_config["mcpServers"]["mcp-ticketer"] = server_config
+
+    # Step 8: Save configuration
+    try:
+        save_claude_mcp_config(mcp_config_path, mcp_config)
+        console.print(f"\n[green]✓ Successfully configured mcp-ticketer[/green]")
+        console.print(f"[dim]Configuration saved to: {mcp_config_path}[/dim]")
+
+        # Print configuration details
+        console.print("\n[bold]Configuration Details:[/bold]")
+        console.print(f"  Server name: mcp-ticketer")
+        console.print(f"  Adapter: {adapter}")
+        console.print(f"  Binary: {binary_path}")
+        if cwd:
+            console.print(f"  Working directory: {cwd}")
+        if "env" in server_config:
+            console.print(f"  Environment variables: {list(server_config['env'].keys())}")
+
+        # Next steps
+        console.print("\n[bold cyan]Next Steps:[/bold cyan]")
+        if global_config:
+            console.print("1. Restart Claude Desktop")
+            console.print("2. Open a conversation")
+        else:
+            console.print("1. Restart Claude Code")
+            console.print("2. Open this project in Claude Code")
+        console.print("3. mcp-ticketer tools will be available in the MCP menu")
+
+    except Exception as e:
+        console.print(f"\n[red]✗ Failed to save configuration:[/red] {e}")
+        raise

mcp_ticketer/core/project_config.py

@@ -414,7 +414,7 @@ class ConfigResolver:
     ) -> Dict[str, Any]:
         """Resolve adapter configuration with hierarchical precedence.
 
-        Precedence (highest to lowest):
+        Resolution order (highest to lowest priority):
         1. CLI overrides
         2. Environment variables (os.getenv)
         3. Project-specific config (.mcp-ticketer/config.json)
@@ -432,7 +432,7 @@ class ConfigResolver:
         global_config = self.load_global_config()
         project_config = self.load_project_config()
 
-        # Determine which adapter to use
+        # Determine which adapter to use (check project config first)
         if adapter_name:
             target_adapter = adapter_name
         elif project_config and project_config.default_adapter:
@@ -452,7 +452,7 @@ class ConfigResolver:
         # Start with empty config
         resolved_config = {"adapter": target_adapter}
 
-        # 1. Apply global adapter config
+        # 1. Apply global adapter config (LOWEST PRIORITY)
         if target_adapter in global_config.adapters:
             global_adapter_config = global_config.adapters[target_adapter].to_dict()
             resolved_config.update(global_adapter_config)
@@ -473,7 +473,7 @@ class ConfigResolver:
                         f"Applied auto-discovered config from {discovered_adapter.found_in}"
                     )
 
-        # 3. Apply project-specific config if exists
+        # 3. Apply project-specific config (HIGHER PRIORITY - overrides global and .env)
         if project_config:
             # Check if this project has specific adapter config
             project_path_str = str(self.project_path)
@@ -486,11 +486,11 @@ class ConfigResolver:
                 proj_global_adapter_config = project_config.adapters[target_adapter].to_dict()
                 resolved_config.update(proj_global_adapter_config)
 
-        # 4. Apply environment variable overrides (os.getenv)
+        # 4. Apply environment variable overrides (os.getenv - HIGHER PRIORITY)
         env_overrides = self._get_env_overrides(target_adapter)
         resolved_config.update(env_overrides)
 
-        # 5. Apply CLI overrides
+        # 5. Apply CLI overrides (HIGHEST PRIORITY)
         if cli_overrides:
             resolved_config.update(cli_overrides)
 

{mcp_ticketer-0.1.13.dist-info → mcp_ticketer-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-ticketer
-Version: 0.1.13
+Version: 0.1.15
 Summary: Universal ticket management interface for AI agents with MCP support
 Author-email: MCP Ticketer Team <support@mcp-ticketer.io>
 Maintainer-email: MCP Ticketer Team <support@mcp-ticketer.io>

{mcp_ticketer-0.1.13.dist-info → mcp_ticketer-0.1.15.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mcp_ticketer/__init__.py,sha256=ayPQdFr6msypD06_G96a1H0bdFCT1m1wDtv8MZBpY4I,496
-mcp_ticketer/__version__.py,sha256=_43DgubrWUqhaLrhYbn9KefWfUiLWjH_hMHmCrgw1Tc,1115
+mcp_ticketer/__version__.py,sha256=OaT1sLIF9tJvQbLP2vx2vOgiGiMS2mbt4EzloZeALPo,1115
 mcp_ticketer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_ticketer/adapters/__init__.py,sha256=K_1egvhHb5F_7yFceUx2YzPGEoc7vX-q8dMVaS4K6gw,356
 mcp_ticketer/adapters/aitrackdown.py,sha256=gqS_N6VGLoG5itUu17ANG5SefaAITYoW-t2xL9SrY-Y,15372
@@ -12,7 +12,8 @@ mcp_ticketer/cache/memory.py,sha256=gTzv-xF7qGfiYVUjG7lnzo0ZcqgXQajMl4NAYUcaytg,
 mcp_ticketer/cli/__init__.py,sha256=YeljyLtv906TqkvRuEPhmKO-Uk0CberQ9I6kx1tx2UA,88
 mcp_ticketer/cli/configure.py,sha256=etFutvc0QpaVDMOsZiiN7wKuaT98Od1Tj9W6lsEWw5A,16351
 mcp_ticketer/cli/discover.py,sha256=putWrGcctUH8K0fOMtr9MZA9VnWoXzbtoe7mXSkDxhg,13156
-mcp_ticketer/cli/main.py,sha256=3NAHRr5Q4nCExbyQ6YIiUxn1nyqi_e4TBgR8OuMhHqk,30461
+mcp_ticketer/cli/main.py,sha256=HxvlZb4ZGxWoqOLwp2eIoS9Ie7C8LF-gShdnwolqVrE,39135
+mcp_ticketer/cli/mcp_configure.py,sha256=1WbBdF25OvxfAGcjxtYa9xmBOGEPQu-wh_nkefmWjMQ,9352
 mcp_ticketer/cli/migrate_config.py,sha256=iZIstnlr9vkhiW_MlnSyJOkMi4KHQqrZ6Hz1ECD_VUk,6045
 mcp_ticketer/cli/queue_commands.py,sha256=f3pEHKZ43dBHEIoCBvdfvjfMB9_WJltps9ATwTzorY0,8160
 mcp_ticketer/cli/utils.py,sha256=NxsS91vKA8xZnDXKU2y0Gcyc4I_ctRyJj-wT7Xd1Q_Q,18589
@@ -23,7 +24,7 @@ mcp_ticketer/core/env_discovery.py,sha256=SPoyq_y5j-3gJG5gYNVjCIIrbdzimOdDbTYySm
 mcp_ticketer/core/http_client.py,sha256=RM9CEMNcuRb-FxhAijmM_FeBMgxgh1OII9HIPBdJue0,13855
 mcp_ticketer/core/mappers.py,sha256=8I4jcqDqoQEdWlteDMpVeVF3Wo0fDCkmFPRr8oNv8gA,16933
 mcp_ticketer/core/models.py,sha256=GhuTitY6t_QlqfEUvWT6Q2zvY7qAtx_SQyCMMn8iYkk,6473
-mcp_ticketer/core/project_config.py,sha256=UqJpxAunmCvR9R_ev9ZrsLvG4engQe1OFQBEmcRx9cs,22254
+mcp_ticketer/core/project_config.py,sha256=VVSeCwuESuemL-iC4fqbPrJxR4i5k5fhUpujnY7MCZA,22389
 mcp_ticketer/core/registry.py,sha256=fwje0fnjp0YKPZ0SrVWk82SMNLs7CD0JlHQmx7SigNo,3537
 mcp_ticketer/mcp/__init__.py,sha256=Bvzof9vBu6VwcXcIZK8RgKv6ycRV9tDlO-9TUmd8zqQ,122
 mcp_ticketer/mcp/server.py,sha256=TDuU8ChZC2QYSRo0uGHkVReblTf--hriOjxo-pSAF_Y,34068
@@ -33,9 +34,9 @@ mcp_ticketer/queue/manager.py,sha256=79AH9oUxdBXH3lmJ3kIlFf2GQkWHL6XB6u5JqVWPq60
 mcp_ticketer/queue/queue.py,sha256=z4aivQCtsH5_OUr2OfXSfnFKzugTahNnwHw0LS3ZhZc,11549
 mcp_ticketer/queue/run_worker.py,sha256=HFoykfDpOoz8OUxWbQ2Fka_UlGrYwjPVZ-DEimGFH9o,802
 mcp_ticketer/queue/worker.py,sha256=cVjHR_kfnGKAkiUg0HuXCnbKeKNBBEuj0XZHgIuIn4k,14017
-mcp_ticketer-0.1.13.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
-mcp_ticketer-0.1.13.dist-info/METADATA,sha256=29lPCGuZI3U_pdIoRYH3C5h4Xn3DaZo-AfKDXQX7IYs,11211
-mcp_ticketer-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_ticketer-0.1.13.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
-mcp_ticketer-0.1.13.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
-mcp_ticketer-0.1.13.dist-info/RECORD,,
+mcp_ticketer-0.1.15.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
+mcp_ticketer-0.1.15.dist-info/METADATA,sha256=VYRxHsh-APXWl3wdmdNSfiniYI84jQwFiVaZ9Y5oOBA,11211
+mcp_ticketer-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_ticketer-0.1.15.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
+mcp_ticketer-0.1.15.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
+mcp_ticketer-0.1.15.dist-info/RECORD,,