mcp-ticketer 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

mcp_ticketer/__version__.py

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

mcp_ticketer/cli/adapter_diagnostics.py

@@ -0,0 +1,384 @@
+"""Adapter diagnostics and configuration validation."""
+
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from ..core import AdapterRegistry
+from ..core.env_discovery import discover_config
+
+
+def diagnose_adapter_configuration(console: Console) -> None:
+    """Diagnose adapter configuration and provide recommendations.
+    
+    Args:
+        console: Rich console for output
+    """
+    console.print("\n[bold blue]🔍 MCP Ticketer Adapter Configuration Diagnostics[/bold blue]\n")
+
+    # 1. Check .env files
+    _check_env_files(console)
+    
+    # 2. Check configuration files
+    _check_configuration_files(console)
+    
+    # 3. Check adapter discovery
+    _check_adapter_discovery(console)
+    
+    # 4. Test adapter instantiation
+    _test_adapter_instantiation(console)
+    
+    # 5. Provide recommendations
+    _provide_recommendations(console)
+
+
+def _check_env_files(console: Console) -> None:
+    """Check .env files for configuration."""
+    console.print("[bold]1. .env File Configuration[/bold]")
+
+    # Load .env files
+    from ..mcp.server import _load_env_configuration
+    env_config = _load_env_configuration()
+
+    # Check for .env files
+    env_files = [".env.local", ".env"]
+
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("File", style="cyan")
+    table.add_column("Status", style="green")
+    table.add_column("Variables Found", style="yellow")
+
+    for env_file in env_files:
+        env_path = Path.cwd() / env_file
+        if env_path.exists():
+            try:
+                # Count variables in file
+                var_count = 0
+                with open(env_path, 'r') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#') and '=' in line:
+                            var_count += 1
+
+                status = "✅ Found"
+                variables = f"{var_count} variables"
+            except Exception:
+                status = "⚠️ Error reading"
+                variables = "Unknown"
+        else:
+            status = "❌ Missing"
+            variables = "N/A"
+
+        table.add_row(env_file, status, variables)
+
+    console.print(table)
+
+    # Show discovered configuration
+    if env_config:
+        console.print(f"\n[green]✅ Discovered adapter: {env_config['adapter_type']}[/green]")
+        config_keys = list(env_config['adapter_config'].keys())
+        console.print(f"[dim]Configuration keys: {config_keys}[/dim]")
+    else:
+        console.print("\n[yellow]⚠️ No adapter configuration found in .env files[/yellow]")
+
+    console.print()
+
+
+def _check_configuration_files(console: Console) -> None:
+    """Check configuration files."""
+    console.print("[bold]2. Configuration Files[/bold]")
+    
+    config_files = [
+        (".env.local", "Local environment file (highest priority)"),
+        (".env", "Environment file"),
+        (".mcp-ticketer/config.json", "Project configuration"),
+        (str(Path.home() / ".mcp-ticketer" / "config.json"), "Global configuration"),
+    ]
+    
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("File", style="cyan")
+    table.add_column("Description", style="white")
+    table.add_column("Status", style="green")
+    table.add_column("Size", style="yellow")
+    
+    for file_path, description in config_files:
+        path = Path(file_path)
+        if path.exists():
+            try:
+                size = path.stat().st_size
+                status = "✅ Found"
+                size_str = f"{size} bytes"
+            except Exception:
+                status = "⚠️ Error"
+                size_str = "Unknown"
+        else:
+            status = "❌ Missing"
+            size_str = "N/A"
+            
+        table.add_row(str(path), description, status, size_str)
+    
+    console.print(table)
+    console.print()
+
+
+def _check_adapter_discovery(console: Console) -> None:
+    """Check adapter discovery from configuration."""
+    console.print("[bold]3. Adapter Discovery[/bold]")
+    
+    try:
+        # Discover configuration
+        discovered = discover_config(Path.cwd())
+        
+        if discovered and discovered.adapters:
+            primary = discovered.get_primary_adapter()
+            
+            table = Table(show_header=True, header_style="bold magenta")
+            table.add_column("Adapter", style="cyan")
+            table.add_column("Confidence", style="white")
+            table.add_column("Source", style="green")
+            table.add_column("Status", style="yellow")
+            
+            for adapter_info in discovered.adapters:
+                confidence = f"{adapter_info.confidence:.0%}"
+                status = "✅ Primary" if adapter_info == primary else "⚪ Available"
+                
+                table.add_row(
+                    adapter_info.adapter_type,
+                    confidence,
+                    adapter_info.found_in,
+                    status
+                )
+            
+            console.print(table)
+            
+            if primary:
+                console.print(f"\n[green]✅ Primary adapter detected: {primary.adapter_type}[/green]")
+                console.print(f"[dim]Source: {primary.found_in}[/dim]")
+                console.print(f"[dim]Confidence: {primary.confidence:.0%}[/dim]")
+            else:
+                console.print("\n[yellow]⚠️ No primary adapter detected[/yellow]")
+        else:
+            console.print("[red]❌ No adapters discovered[/red]")
+            console.print("[dim]This usually means no credentials are configured[/dim]")
+    
+    except Exception as e:
+        console.print(f"[red]❌ Error during discovery: {e}[/red]")
+    
+    console.print()
+
+
+def _test_adapter_instantiation(console: Console) -> None:
+    """Test adapter instantiation."""
+    console.print("[bold]4. Adapter Instantiation Test[/bold]")
+
+    # Determine which adapter to test from .env files
+    from ..mcp.server import _load_env_configuration
+    env_config = _load_env_configuration()
+
+    if env_config:
+        adapter_type = env_config["adapter_type"]
+        config = env_config["adapter_config"]
+    else:
+        # Try to discover from existing discovery system
+        try:
+            discovered = discover_config(Path.cwd())
+            if discovered and discovered.adapters:
+                primary = discovered.get_primary_adapter()
+                if primary:
+                    adapter_type = primary.adapter_type
+                    # Build config from discovery
+                    from ..mcp.server import _build_adapter_config_from_env_vars
+                    config = _build_adapter_config_from_env_vars(adapter_type, {})
+                else:
+                    adapter_type = "aitrackdown"
+                    config = {"base_path": ".aitrackdown"}
+            else:
+                adapter_type = "aitrackdown"
+                config = {"base_path": ".aitrackdown"}
+        except Exception:
+            adapter_type = "aitrackdown"
+            config = {"base_path": ".aitrackdown"}
+
+    console.print(f"Testing adapter: [cyan]{adapter_type}[/cyan]")
+    console.print(f"Configuration keys: [yellow]{list(config.keys())}[/yellow]")
+
+    try:
+        # Try to instantiate adapter
+        adapter = AdapterRegistry.get_adapter(adapter_type, config)
+
+        console.print(f"[green]✅ Adapter instantiated successfully: {adapter.__class__.__name__}[/green]")
+
+        # Test basic functionality
+        if hasattr(adapter, 'validate_credentials'):
+            try:
+                is_valid, error_msg = adapter.validate_credentials()
+                if is_valid:
+                    console.print("[green]✅ Credentials validation passed[/green]")
+                else:
+                    console.print(f"[red]❌ Credentials validation failed: {error_msg}[/red]")
+            except Exception as e:
+                console.print(f"[yellow]⚠️ Credentials validation error: {e}[/yellow]")
+
+    except Exception as e:
+        console.print(f"[red]❌ Adapter instantiation failed: {e}[/red]")
+
+        # Provide specific guidance based on adapter type
+        if adapter_type == "linear":
+            console.print("\n[yellow]Linear adapter requires in .env/.env.local:[/yellow]")
+            console.print("• LINEAR_API_KEY=your_api_key")
+            console.print("• LINEAR_TEAM_ID=your_team_id (or LINEAR_TEAM_KEY=your_team_key)")
+        elif adapter_type == "github":
+            console.print("\n[yellow]GitHub adapter requires in .env/.env.local:[/yellow]")
+            console.print("• GITHUB_TOKEN=your_token")
+            console.print("• GITHUB_OWNER=your_username")
+            console.print("• GITHUB_REPO=your_repository")
+        elif adapter_type == "jira":
+            console.print("\n[yellow]JIRA adapter requires in .env/.env.local:[/yellow]")
+            console.print("• JIRA_SERVER=your_server_url")
+            console.print("• JIRA_EMAIL=your_email")
+            console.print("• JIRA_API_TOKEN=your_token")
+
+    console.print()
+
+
+def _provide_recommendations(console: Console) -> None:
+    """Provide configuration recommendations."""
+    console.print("[bold]5. Recommendations[/bold]")
+
+    # Check .env configuration
+    from ..mcp.server import _load_env_configuration
+    env_config = _load_env_configuration()
+
+    recommendations = []
+
+    if not env_config:
+        recommendations.append(
+            "Create .env.local or .env file with adapter configuration"
+        )
+        recommendations.append(
+            "Add MCP_TICKETER_ADAPTER=linear (or github, jira) to specify adapter type"
+        )
+    else:
+        adapter_type = env_config["adapter_type"]
+        config = env_config["adapter_config"]
+
+        # Check for incomplete configurations
+        if adapter_type == "linear":
+            if not config.get("api_key"):
+                recommendations.append("Add LINEAR_API_KEY to .env file")
+            if not config.get("team_id") and not config.get("team_key"):
+                recommendations.append("Add LINEAR_TEAM_ID or LINEAR_TEAM_KEY to .env file")
+
+        elif adapter_type == "github":
+            missing = []
+            if not config.get("token"):
+                missing.append("GITHUB_TOKEN")
+            if not config.get("owner"):
+                missing.append("GITHUB_OWNER")
+            if not config.get("repo"):
+                missing.append("GITHUB_REPO")
+            if missing:
+                recommendations.append(f"Add missing GitHub variables to .env: {', '.join(missing)}")
+
+        elif adapter_type == "jira":
+            missing = []
+            if not config.get("server"):
+                missing.append("JIRA_SERVER")
+            if not config.get("email"):
+                missing.append("JIRA_EMAIL")
+            if not config.get("api_token"):
+                missing.append("JIRA_API_TOKEN")
+            if missing:
+                recommendations.append(f"Add missing JIRA variables to .env: {', '.join(missing)}")
+
+    if recommendations:
+        for i, rec in enumerate(recommendations, 1):
+            console.print(f"{i}. [yellow]{rec}[/yellow]")
+    else:
+        console.print("[green]✅ Configuration looks good![/green]")
+
+    # Show .env file examples
+    console.print("\n[bold].env File Examples:[/bold]")
+    console.print("• Linear: [cyan]echo 'MCP_TICKETER_ADAPTER=linear\\nLINEAR_API_KEY=your_key\\nLINEAR_TEAM_ID=your_team' > .env.local[/cyan]")
+    console.print("• GitHub: [cyan]echo 'MCP_TICKETER_ADAPTER=github\\nGITHUB_TOKEN=your_token\\nGITHUB_OWNER=user\\nGITHUB_REPO=repo' > .env.local[/cyan]")
+
+    console.print("\n[bold]Quick Setup Commands:[/bold]")
+    console.print("• For Linear: [cyan]mcp-ticketer init linear[/cyan]")
+    console.print("• For GitHub: [cyan]mcp-ticketer init github[/cyan]")
+    console.print("• For JIRA: [cyan]mcp-ticketer init jira[/cyan]")
+    console.print("• For local files: [cyan]mcp-ticketer init aitrackdown[/cyan]")
+
+    console.print("\n[bold]Test Configuration:[/bold]")
+    console.print("• Run diagnostics: [cyan]mcp-ticketer diagnose[/cyan]")
+    console.print("• Test ticket creation: [cyan]mcp-ticketer create 'Test ticket'[/cyan]")
+    console.print("• List tickets: [cyan]mcp-ticketer list[/cyan]")
+
+
+def get_adapter_status() -> Dict[str, Any]:
+    """Get current adapter status for programmatic use.
+
+    Returns:
+        Dictionary with adapter status information
+    """
+    status = {
+        "adapter_type": None,
+        "configuration_source": None,
+        "credentials_valid": False,
+        "error_message": None,
+        "recommendations": []
+    }
+
+    try:
+        # Check .env files first
+        from ..mcp.server import _load_env_configuration
+        env_config = _load_env_configuration()
+
+        if env_config:
+            adapter_type = env_config["adapter_type"]
+            config = env_config["adapter_config"]
+            status["configuration_source"] = ".env files"
+        else:
+            # Try discovery system
+            discovered = discover_config(Path.cwd())
+            if discovered and discovered.adapters:
+                primary = discovered.get_primary_adapter()
+                if primary:
+                    adapter_type = primary.adapter_type
+                    status["configuration_source"] = primary.found_in
+                    # Build basic config
+                    from ..mcp.server import _build_adapter_config_from_env_vars
+                    config = _build_adapter_config_from_env_vars(adapter_type, {})
+                else:
+                    adapter_type = "aitrackdown"
+                    config = {"base_path": ".aitrackdown"}
+                    status["configuration_source"] = "default"
+            else:
+                adapter_type = "aitrackdown"
+                config = {"base_path": ".aitrackdown"}
+                status["configuration_source"] = "default"
+
+        status["adapter_type"] = adapter_type
+
+        # Test adapter instantiation
+        adapter = AdapterRegistry.get_adapter(adapter_type, config)
+
+        # Test credentials if possible
+        if hasattr(adapter, 'validate_credentials'):
+            is_valid, error_msg = adapter.validate_credentials()
+            status["credentials_valid"] = is_valid
+            if not is_valid:
+                status["error_message"] = error_msg
+        else:
+            status["credentials_valid"] = True  # Assume valid if no validation method
+
+    except Exception as e:
+        status["error_message"] = str(e)
+        status["recommendations"].append("Check .env file configuration and credentials")
+
+    return status

mcp_ticketer/cli/main.py

@@ -317,13 +317,161 @@ def get_adapter(
     return AdapterRegistry.get_adapter(adapter_type, adapter_config)
 
 
+def _prompt_for_adapter_selection(console: Console) -> str:
+    """Interactive prompt for adapter selection.
+
+    Args:
+        console: Rich console for output
+
+    Returns:
+        Selected adapter type
+    """
+    console.print("\n[bold blue]🚀 MCP Ticketer Setup[/bold blue]")
+    console.print("Choose which ticket system you want to connect to:\n")
+
+    # Define adapter options with descriptions
+    adapters = [
+        {
+            "name": "linear",
+            "title": "Linear",
+            "description": "Modern project management (linear.app)",
+            "requirements": "API key and team ID"
+        },
+        {
+            "name": "github",
+            "title": "GitHub Issues",
+            "description": "GitHub repository issues",
+            "requirements": "Personal access token, owner, and repo"
+        },
+        {
+            "name": "jira",
+            "title": "JIRA",
+            "description": "Atlassian JIRA project management",
+            "requirements": "Server URL, email, and API token"
+        },
+        {
+            "name": "aitrackdown",
+            "title": "Local Files (AITrackdown)",
+            "description": "Store tickets in local files (no external service)",
+            "requirements": "None - works offline"
+        }
+    ]
+
+    # Display options
+    for i, adapter in enumerate(adapters, 1):
+        console.print(f"[cyan]{i}.[/cyan] [bold]{adapter['title']}[/bold]")
+        console.print(f"   {adapter['description']}")
+        console.print(f"   [dim]Requirements: {adapter['requirements']}[/dim]\n")
+
+    # Get user selection
+    while True:
+        try:
+            choice = typer.prompt(
+                "Select adapter (1-4)",
+                type=int,
+                default=1
+            )
+            if 1 <= choice <= len(adapters):
+                selected_adapter = adapters[choice - 1]
+                console.print(f"\n[green]✓ Selected: {selected_adapter['title']}[/green]")
+                return selected_adapter["name"]
+            else:
+                console.print(f"[red]Please enter a number between 1 and {len(adapters)}[/red]")
+        except (ValueError, typer.Abort):
+            console.print("[yellow]Setup cancelled.[/yellow]")
+            raise typer.Exit(0)
+
+
+@app.command()
+def setup(
+    adapter: Optional[str] = typer.Option(
+        None,
+        "--adapter",
+        "-a",
+        help="Adapter type to use (interactive prompt 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:
+    """Interactive setup wizard for MCP Ticketer (alias for init).
+
+    This command provides a user-friendly setup experience with prompts
+    to guide you through configuring MCP Ticketer for your preferred
+    ticket management system. It's identical to 'init' and 'install'.
+
+    Examples:
+        # Run interactive setup
+        mcp-ticketer setup
+
+        # Setup with specific adapter
+        mcp-ticketer setup --adapter linear
+
+        # Setup for different project
+        mcp-ticketer setup --path /path/to/project
+    """
+    # 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()
 def init(
     adapter: Optional[str] = typer.Option(
         None,
         "--adapter",
         "-a",
-        help="Adapter type to use (auto-detected from .env if not specified)",
+        help="Adapter type to use (interactive prompt if not specified)",
     ),
     project_path: Optional[str] = typer.Option(
         None, "--path", help="Project path (default: current directory)"
@@ -369,11 +517,17 @@ def init(
 ) -> None:
     """Initialize mcp-ticketer for the current project.
 
+    This command sets up MCP Ticketer configuration with interactive prompts
+    to guide you through the process. It auto-detects adapter configuration
+    from .env files or prompts for interactive setup if no configuration is found.
+
     Creates .mcp-ticketer/config.json in the current directory with
     auto-detected or specified adapter configuration.
 
+    Note: 'setup' and 'install' are synonyms for this command.
+
     Examples:
-        # Auto-detect from .env.local
+        # Interactive setup (same as 'setup' and 'install')
         mcp-ticketer init
 
         # Force specific adapter
@@ -414,32 +568,60 @@ def init(
         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
+        # First try our improved .env configuration loader
+        from ..mcp.server import _load_env_configuration
+        env_config = _load_env_configuration()
+
+        if env_config:
+            adapter_type = env_config["adapter_type"]
             console.print(
-                "[yellow]⚠ No .env files found, defaulting to aitrackdown[/yellow]"
+                f"[green]✓ Detected {adapter_type} adapter from environment files[/green]"
             )
 
+            # Show what was discovered
+            console.print(f"\n[dim]Configuration found in: .env files[/dim]")
+            console.print(f"[dim]Confidence: 100%[/dim]")
+
+            # Ask user to confirm auto-detected adapter
+            if not typer.confirm(
+                f"Use detected {adapter_type} adapter?",
+                default=True,
+            ):
+                adapter_type = None  # Will trigger interactive selection
+        else:
+            # Fallback to old discovery system for backward compatibility
+            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]")
+
+                    # Ask user to confirm auto-detected adapter
+                    if not typer.confirm(
+                        f"Use detected {adapter_type} adapter?",
+                        default=True,
+                    ):
+                        adapter_type = None  # Will trigger interactive selection
+                else:
+                    adapter_type = None  # Will trigger interactive selection
+            else:
+                adapter_type = None  # Will trigger interactive selection
+
+        # If no adapter determined, show interactive selection
+        if not adapter_type:
+            adapter_type = _prompt_for_adapter_selection(console)
+
     # 2. Create configuration based on adapter type
     config = {"default_adapter": adapter_type, "adapters": {}}
 
@@ -462,59 +644,99 @@ def init(
         }
 
     elif adapter_type == "linear":
-        # If not auto-discovered, build from CLI params
+        # If not auto-discovered, build from CLI params or prompt
         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 not linear_api_key and not discovered:
+                console.print("\n[bold]Linear Configuration[/bold]")
+                console.print("You need a Linear API key to connect to Linear.")
+                console.print("[dim]Get your API key at: https://linear.app/settings/api[/dim]\n")
+
+                linear_api_key = typer.prompt(
+                    "Enter your Linear API key",
+                    hide_input=True
+                )
+
             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:
-                linear_config["type"] = "linear"
-                config["adapters"]["linear"] = linear_config
+            # Team ID
+            linear_team_id = team_id or os.getenv("LINEAR_TEAM_ID")
+            if not linear_team_id and not discovered:
+                console.print("\nYou need your Linear team ID.")
+                console.print("[dim]Find it in Linear settings or team URL[/dim]\n")
+
+                linear_team_id = typer.prompt("Enter your Linear team ID")
+
+            if linear_team_id:
+                linear_config["team_id"] = linear_team_id
+
+            if not linear_config.get("api_key") or not linear_config.get("team_id"):
+                console.print("[red]Error:[/red] Linear requires both API key and team ID")
+                console.print("Run 'mcp-ticketer init --adapter linear' with proper credentials")
+                raise typer.Exit(1)
+
+            linear_config["type"] = "linear"
+            config["adapters"]["linear"] = linear_config
 
     elif adapter_type == "jira":
-        # If not auto-discovered, build from CLI params
+        # If not auto-discovered, build from CLI params or prompt
         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")
 
+            # Interactive prompts for missing values
+            if not server and not discovered:
+                console.print("\n[bold]JIRA Configuration[/bold]")
+                console.print("Enter your JIRA server details.\n")
+
+                server = typer.prompt(
+                    "JIRA server URL (e.g., https://company.atlassian.net)"
+                )
+
+            if not email and not discovered:
+                email = typer.prompt("Your JIRA email address")
+
+            if not token and not discovered:
+                console.print("\nYou need a JIRA API token.")
+                console.print("[dim]Generate one at: https://id.atlassian.com/manage/api-tokens[/dim]\n")
+
+                token = typer.prompt(
+                    "Enter your JIRA API token",
+                    hide_input=True
+                )
+
+            if not project and not discovered:
+                project = typer.prompt(
+                    "Default JIRA project key (optional, press Enter to skip)",
+                    default="",
+                    show_default=False
+                )
+
+            # Validate required fields
             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}
+            jira_config = {
+                "server": server,
+                "email": email,
+                "api_token": token,
+                "type": "jira"
+            }
 
             if project:
                 jira_config["project_key"] = project
@@ -522,45 +744,50 @@ def init(
             config["adapters"]["jira"] = jira_config
 
     elif adapter_type == "github":
-        # If not auto-discovered, build from CLI params
+        # If not auto-discovered, build from CLI params or prompt
         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")
 
+            # Interactive prompts for missing values
+            if not owner and not discovered:
+                console.print("\n[bold]GitHub Configuration[/bold]")
+                console.print("Enter your GitHub repository details.\n")
+
+                owner = typer.prompt("GitHub repository owner (username or organization)")
+
+            if not repo and not discovered:
+                repo = typer.prompt("GitHub repository name")
+
+            if not token and not discovered:
+                console.print("\nYou need a GitHub Personal Access Token.")
+                console.print("[dim]Create one at: https://github.com/settings/tokens/new[/dim]")
+                console.print("[dim]Required scopes: repo (for private repos) or public_repo (for public repos)[/dim]\n")
+
+                token = typer.prompt(
+                    "Enter your GitHub Personal Access Token",
+                    hide_input=True
+                )
+
+            # Validate required fields
             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]"
-                )
+                console.print("[red]Error:[/red] GitHub Personal Access Token is required")
                 raise typer.Exit(1)
 
             config["adapters"]["github"] = {
                 "owner": owner,
                 "repo": repo,
                 "token": token,
+                "type": "github"
             }
 
     # 5. Save to appropriate location
@@ -600,6 +827,48 @@ def init(
                 f.write("# MCP Ticketer\n.mcp-ticketer/\n")
             console.print("[dim]✓ Created .gitignore with .mcp-ticketer/[/dim]")
 
+    # Show next steps
+    _show_next_steps(console, adapter_type, config_file_path)
+
+
+def _show_next_steps(console: Console, adapter_type: str, config_file_path: Path) -> None:
+    """Show helpful next steps after initialization.
+
+    Args:
+        console: Rich console for output
+        adapter_type: Type of adapter that was configured
+        config_file_path: Path to the configuration file
+    """
+    console.print("\n[bold green]🎉 Setup Complete![/bold green]")
+    console.print(f"MCP Ticketer is now configured to use {adapter_type.title()}.\n")
+
+    console.print("[bold]Next Steps:[/bold]")
+    console.print("1. [cyan]Test your configuration:[/cyan]")
+    console.print("   mcp-ticketer diagnose")
+    console.print("\n2. [cyan]Create a test ticket:[/cyan]")
+    console.print("   mcp-ticketer create 'Test ticket from MCP Ticketer'")
+
+    if adapter_type != "aitrackdown":
+        console.print(f"\n3. [cyan]Verify the ticket appears in {adapter_type.title()}[/cyan]")
+
+        if adapter_type == "linear":
+            console.print("   Check your Linear workspace for the new ticket")
+        elif adapter_type == "github":
+            console.print("   Check your GitHub repository's Issues tab")
+        elif adapter_type == "jira":
+            console.print("   Check your JIRA project for the new ticket")
+    else:
+        console.print("\n3. [cyan]Check local ticket storage:[/cyan]")
+        console.print("   ls .aitrackdown/")
+
+    console.print("\n4. [cyan]Configure MCP clients (optional):[/cyan]")
+    console.print("   mcp-ticketer mcp claude    # For Claude Code")
+    console.print("   mcp-ticketer mcp auggie    # For Auggie")
+    console.print("   mcp-ticketer mcp gemini    # For Gemini CLI")
+
+    console.print(f"\n[dim]Configuration saved to: {config_file_path}[/dim]")
+    console.print("[dim]Run 'mcp-ticketer --help' for more commands[/dim]")
+
 
 @app.command()
 def install(
@@ -653,12 +922,12 @@ def install(
 ) -> 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.
+    This command is synonymous with 'init' and 'setup' - all three provide
+    identical functionality with interactive prompts to guide you through
+    configuring MCP Ticketer for your preferred ticket management system.
 
     Examples:
-        # Auto-detect from .env.local
+        # Interactive setup (same as 'init' and 'setup')
         mcp-ticketer install
 
         # Force specific adapter
@@ -1548,6 +1817,9 @@ def check(queue_id: str = typer.Argument(..., help="Queue ID to check")):
         console.print(f"\nRetry Count: {item.retry_count}")
 
 
+
+
+
 @app.command()
 def serve(
     adapter: Optional[AdapterType] = typer.Option(
@@ -1575,16 +1847,27 @@ def serve(
     # Load configuration (respects project-specific config in cwd)
     config = load_config()
 
-    # Determine adapter type
-    adapter_type = (
-        adapter.value if adapter else config.get("default_adapter", "aitrackdown")
-    )
-
-    # Get adapter configuration
-    adapters_config = config.get("adapters", {})
-    adapter_config = adapters_config.get(adapter_type, {})
+    # Determine adapter type with priority: CLI arg > .env files > config > default
+    if adapter:
+        # Priority 1: Command line argument
+        adapter_type = adapter.value
+        # Get base config from config file
+        adapters_config = config.get("adapters", {})
+        adapter_config = adapters_config.get(adapter_type, {})
+    else:
+        # Priority 2: .env files
+        from ..mcp.server import _load_env_configuration
+        env_config = _load_env_configuration()
+        if env_config:
+            adapter_type = env_config["adapter_type"]
+            adapter_config = env_config["adapter_config"]
+        else:
+            # Priority 3: Configuration file
+            adapter_type = config.get("default_adapter", "aitrackdown")
+            adapters_config = config.get("adapters", {})
+            adapter_config = adapters_config.get(adapter_type, {})
 
-    # Override with command line options if provided
+    # Override with command line options if provided (highest priority)
     if base_path and adapter_type == "aitrackdown":
         adapter_config["base_path"] = base_path
 

mcp_ticketer/core/env_discovery.py

@@ -454,11 +454,32 @@ class EnvDiscovery:
         """
         base_path = self._find_key_value(env_vars, AITRACKDOWN_PATH_PATTERNS)
 
-        # Also check if .aitrackdown directory exists
+        # Check for explicit MCP_TICKETER_ADAPTER setting
+        explicit_adapter = env_vars.get("MCP_TICKETER_ADAPTER")
+        if explicit_adapter and explicit_adapter != "aitrackdown":
+            # If another adapter is explicitly set, don't detect aitrackdown
+            return None
+
+        # Check if .aitrackdown directory exists
         aitrackdown_dir = self.project_path / ".aitrackdown"
+
+        # Only detect aitrackdown if:
+        # 1. There's an explicit base_path setting, OR
+        # 2. There's a .aitrackdown directory AND no other adapter variables are present
+        has_other_adapter_vars = (
+            any(key.startswith("LINEAR_") for key in env_vars) or
+            any(key.startswith("GITHUB_") for key in env_vars) or
+            any(key.startswith("JIRA_") for key in env_vars)
+        )
+
         if not base_path and not aitrackdown_dir.exists():
             return None
 
+        if not base_path and has_other_adapter_vars:
+            # Don't detect aitrackdown if other adapter variables are present
+            # unless explicitly configured
+            return None
+
         config: dict[str, Any] = {
             "adapter": AdapterType.AITRACKDOWN.value,
         }
@@ -468,8 +489,15 @@ class EnvDiscovery:
         else:
             config["base_path"] = ".aitrackdown"
 
-        # AITrackdown has no required external credentials
-        confidence = 1.0 if aitrackdown_dir.exists() else 0.7
+        # Lower confidence when other adapter variables are present
+        if has_other_adapter_vars:
+            confidence = 0.3  # Low confidence when other adapters are configured
+        elif base_path:
+            confidence = 1.0  # High confidence when explicitly configured
+        elif aitrackdown_dir.exists():
+            confidence = 0.8  # Medium confidence when directory exists
+        else:
+            confidence = 0.5  # Low confidence as fallback
 
         return DiscoveredAdapter(
             adapter_type=AdapterType.AITRACKDOWN.value,

mcp_ticketer/mcp/server.py

@@ -1652,56 +1652,191 @@ async def main():
     # Load configuration
     import json
     import logging
+    import os
     from pathlib import Path
 
     logger = logging.getLogger(__name__)
 
-    # ONLY read from project-local config, never from user home
-    config_file = Path.cwd() / ".mcp-ticketer" / "config.json"
-    if config_file.exists():
-        # Validate config is within project
-        try:
-            if not config_file.resolve().is_relative_to(Path.cwd().resolve()):
-                logger.error(
-                    f"Security violation: Config file {config_file} "
-                    "is not within project directory"
-                )
-                raise ValueError(
-                    f"Security violation: Config file {config_file} "
-                    "is not within project directory"
-                )
-        except (ValueError, RuntimeError):
-            # is_relative_to may raise ValueError in some cases
-            pass
+    # Initialize defaults
+    adapter_type = "aitrackdown"
+    adapter_config = {"base_path": ".aitrackdown"}
+
+    # Priority 1: Check .env files (highest priority for MCP)
+    env_config = _load_env_configuration()
+    if env_config and env_config.get("adapter_type"):
+        adapter_type = env_config["adapter_type"]
+        adapter_config = env_config["adapter_config"]
+        logger.info(f"Using adapter from .env files: {adapter_type}")
+        logger.info(f"Built adapter config from .env: {list(adapter_config.keys())}")
+    else:
+        # Priority 2: Check project-local config file
+        config_file = Path.cwd() / ".mcp-ticketer" / "config.json"
+        if config_file.exists():
+            # Validate config is within project
+            try:
+                if not config_file.resolve().is_relative_to(Path.cwd().resolve()):
+                    logger.error(
+                        f"Security violation: Config file {config_file} "
+                        "is not within project directory"
+                    )
+                    raise ValueError(
+                        f"Security violation: Config file {config_file} "
+                        "is not within project directory"
+                    )
+            except (ValueError, RuntimeError):
+                # is_relative_to may raise ValueError in some cases
+                pass
 
-        try:
-            with open(config_file) as f:
-                config = json.load(f)
-                adapter_type = config.get("default_adapter", "aitrackdown")
-                # Get adapter-specific config
-                adapters_config = config.get("adapters", {})
-                adapter_config = adapters_config.get(adapter_type, {})
-                # Fallback to legacy config format
-                if not adapter_config and "config" in config:
-                    adapter_config = config["config"]
-                logger.info(
-                    f"Loaded MCP configuration from project-local: {config_file}"
-                )
-        except (OSError, json.JSONDecodeError) as e:
-            logger.warning(f"Could not load project config: {e}, using defaults")
+            try:
+                with open(config_file) as f:
+                    config = json.load(f)
+                    adapter_type = config.get("default_adapter", "aitrackdown")
+                    # Get adapter-specific config
+                    adapters_config = config.get("adapters", {})
+                    adapter_config = adapters_config.get(adapter_type, {})
+                    # Fallback to legacy config format
+                    if not adapter_config and "config" in config:
+                        adapter_config = config["config"]
+                    logger.info(
+                        f"Loaded MCP configuration from project-local: {config_file}"
+                    )
+            except (OSError, json.JSONDecodeError) as e:
+                logger.warning(f"Could not load project config: {e}, using defaults")
+                adapter_type = "aitrackdown"
+                adapter_config = {"base_path": ".aitrackdown"}
+        else:
+            # Priority 3: Default to aitrackdown
+            logger.info("No configuration found, defaulting to aitrackdown adapter")
             adapter_type = "aitrackdown"
             adapter_config = {"base_path": ".aitrackdown"}
-    else:
-        # Default to aitrackdown with local base path
-        logger.info("No project-local config found, defaulting to aitrackdown adapter")
-        adapter_type = "aitrackdown"
-        adapter_config = {"base_path": ".aitrackdown"}
+
+    # Log final configuration for debugging
+    logger.info(f"Starting MCP server with adapter: {adapter_type}")
+    logger.debug(f"Adapter config keys: {list(adapter_config.keys())}")
 
     # Create and run server
     server = MCPTicketServer(adapter_type, adapter_config)
     await server.run()
 
 
+def _load_env_configuration() -> Optional[dict[str, Any]]:
+    """Load adapter configuration from .env files.
+
+    Checks .env.local first (highest priority), then .env.
+
+    Returns:
+        Dictionary with 'adapter_type' and 'adapter_config' keys, or None if no config found
+    """
+    from pathlib import Path
+
+    # Check for .env files in order of preference
+    env_files = [".env.local", ".env"]
+    env_vars = {}
+
+    for env_file in env_files:
+        env_path = Path.cwd() / env_file
+        if env_path.exists():
+            try:
+                # Parse .env file manually to avoid external dependencies
+                with open(env_path, 'r') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#') and '=' in line:
+                            key, value = line.split('=', 1)
+                            key = key.strip()
+                            value = value.strip().strip('"').strip("'")
+                            if value:  # Only add non-empty values
+                                env_vars[key] = value
+            except Exception:
+                continue
+
+    if not env_vars:
+        return None
+
+    # Determine adapter type and build config
+    adapter_type = env_vars.get("MCP_TICKETER_ADAPTER")
+    if not adapter_type:
+        # Auto-detect based on available keys
+        if any(key.startswith("LINEAR_") for key in env_vars):
+            adapter_type = "linear"
+        elif any(key.startswith("GITHUB_") for key in env_vars):
+            adapter_type = "github"
+        elif any(key.startswith("JIRA_") for key in env_vars):
+            adapter_type = "jira"
+        else:
+            return None
+
+    # Build adapter-specific configuration
+    adapter_config = _build_adapter_config_from_env_vars(adapter_type, env_vars)
+
+    if not adapter_config:
+        return None
+
+    return {
+        "adapter_type": adapter_type,
+        "adapter_config": adapter_config
+    }
+
+
+def _build_adapter_config_from_env_vars(adapter_type: str, env_vars: dict[str, str]) -> dict[str, Any]:
+    """Build adapter configuration from parsed environment variables.
+
+    Args:
+        adapter_type: Type of adapter to configure
+        env_vars: Dictionary of environment variables from .env files
+
+    Returns:
+        Dictionary of adapter configuration
+    """
+    config = {}
+
+    if adapter_type == "linear":
+        # Linear adapter configuration
+        if env_vars.get("LINEAR_API_KEY"):
+            config["api_key"] = env_vars["LINEAR_API_KEY"]
+        if env_vars.get("LINEAR_TEAM_ID"):
+            config["team_id"] = env_vars["LINEAR_TEAM_ID"]
+        if env_vars.get("LINEAR_TEAM_KEY"):
+            config["team_key"] = env_vars["LINEAR_TEAM_KEY"]
+        if env_vars.get("LINEAR_API_URL"):
+            config["api_url"] = env_vars["LINEAR_API_URL"]
+
+    elif adapter_type == "github":
+        # GitHub adapter configuration
+        if env_vars.get("GITHUB_TOKEN"):
+            config["token"] = env_vars["GITHUB_TOKEN"]
+        if env_vars.get("GITHUB_OWNER"):
+            config["owner"] = env_vars["GITHUB_OWNER"]
+        if env_vars.get("GITHUB_REPO"):
+            config["repo"] = env_vars["GITHUB_REPO"]
+
+    elif adapter_type == "jira":
+        # JIRA adapter configuration
+        if env_vars.get("JIRA_SERVER"):
+            config["server"] = env_vars["JIRA_SERVER"]
+        if env_vars.get("JIRA_EMAIL"):
+            config["email"] = env_vars["JIRA_EMAIL"]
+        if env_vars.get("JIRA_API_TOKEN"):
+            config["api_token"] = env_vars["JIRA_API_TOKEN"]
+        if env_vars.get("JIRA_PROJECT_KEY"):
+            config["project_key"] = env_vars["JIRA_PROJECT_KEY"]
+
+    elif adapter_type == "aitrackdown":
+        # AITrackdown adapter configuration
+        base_path = env_vars.get("MCP_TICKETER_BASE_PATH", ".aitrackdown")
+        config["base_path"] = base_path
+        config["auto_create_dirs"] = True
+
+    # Add any generic overrides
+    if env_vars.get("MCP_TICKETER_API_KEY"):
+        config["api_key"] = env_vars["MCP_TICKETER_API_KEY"]
+
+    return config
+
+
+
+
+
 # Add diagnostic handler methods to MCPTicketServer class
 async def _handle_system_health(self, arguments: dict[str, Any]) -> dict[str, Any]:
     """Handle system health check."""

{mcp_ticketer-0.2.0.dist-info → mcp_ticketer-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-ticketer
-Version: 0.2.0
+Version: 0.3.1
 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.2.0.dist-info → mcp_ticketer-0.3.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mcp_ticketer/__init__.py,sha256=Xx4WaprO5PXhVPbYi1L6tBmwmJMkYS-lMyG4ieN6QP0,717
-mcp_ticketer/__version__.py,sha256=9j49fzPH9jSgtpm7Tgb5_MiRjdY95EWDMnBbiisOXqM,1117
+mcp_ticketer/__version__.py,sha256=hTsAyUEYaGHMTOcqUuCMjSc3y7Sywx_V8sgWryJLRsY,1117
 mcp_ticketer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_ticketer/adapters/__init__.py,sha256=B5DFllWn23hkhmrLykNO5uMMSdcFuuPHXyLw_jyFzuE,358
 mcp_ticketer/adapters/aitrackdown.py,sha256=stlbge8K6w-EyQkw_vEQNSXQgCOWN5tOlQUgGWZQNMQ,17936
@@ -16,6 +16,7 @@ mcp_ticketer/adapters/linear/types.py,sha256=VuGPu1Z5jGHtbI2zkCyL5YFnwQNukGW-UV7
 mcp_ticketer/cache/__init__.py,sha256=Xcd-cKnt-Cx7jBzvfzUUUPaGkmyXFi5XUFWw3Z4b7d4,138
 mcp_ticketer/cache/memory.py,sha256=2yBqGi9i0SanlUhJoOC7nijWjoMa3_ntPe-V-AV-LfU,5042
 mcp_ticketer/cli/__init__.py,sha256=l9Q8iKmfGkTu0cssHBVqNZTsL4eAtFzOB25AED_0G6g,89
+mcp_ticketer/cli/adapter_diagnostics.py,sha256=t7RyesBRSyJBoVvft2scdNRcugJDIWvqYS9NszPV5ok,14820
 mcp_ticketer/cli/auggie_configure.py,sha256=MXKzLtqe3K_UTQ2GacHAWbvf_B0779KL325smiAKE0Q,8212
 mcp_ticketer/cli/codex_configure.py,sha256=xDppHouT6_-cYXswyAggoPX5bSlRXMvCoM_x9PQ-42A,9086
 mcp_ticketer/cli/configure.py,sha256=BsA_pSHQMQS0t1bJO_wMM8LWsd5sWJDASjEPRHvwC18,16198
@@ -23,7 +24,7 @@ mcp_ticketer/cli/diagnostics.py,sha256=AC7cMQHVWdHfrYH2Y1tkhmRezM2-mID5E_Dhfil7F
 mcp_ticketer/cli/discover.py,sha256=AF_qlQc1Oo0UkWayoF5pmRChS5J3fJjH6f2YZzd_k8w,13188
 mcp_ticketer/cli/gemini_configure.py,sha256=ZNSA1lBW-itVToza-JxW95Po7daVXKiZAh7lp6pmXMU,9343
 mcp_ticketer/cli/linear_commands.py,sha256=b5v4c9uBNPwj_vdy314JkLZbyC1fXU6IcY2VoG0z7gI,17193
-mcp_ticketer/cli/main.py,sha256=9e83BCxds9AESIYueK1VjeJ96H7AvRbvPiMYwd4EeKs,62258
+mcp_ticketer/cli/main.py,sha256=blViBOtv9HbRUkuAPlb7CstyH3nt90vxgEHIZcdGls8,73130
 mcp_ticketer/cli/mcp_configure.py,sha256=RzV50UjXgOmvMp-9S0zS39psuvjffVByaMrqrUaAGAM,9594
 mcp_ticketer/cli/migrate_config.py,sha256=MYsr_C5ZxsGg0P13etWTWNrJ_lc6ElRCkzfQADYr3DM,5956
 mcp_ticketer/cli/queue_commands.py,sha256=mm-3H6jmkUGJDyU_E46o9iRpek8tvFCm77F19OtHiZI,7884
@@ -32,7 +33,7 @@ mcp_ticketer/cli/utils.py,sha256=bGoLcqsNsv7YMjVeWc9tlqKQC5zeOmWZp7wEfe0JfzM,229
 mcp_ticketer/core/__init__.py,sha256=eXovsaJymQRP2AwOBuOy6mFtI3I68D7gGenZ5V-IMqo,349
 mcp_ticketer/core/adapter.py,sha256=q64LxOInIno7EIbmuxItf8KEsd-g9grCs__Z4uwZHto,10273
 mcp_ticketer/core/config.py,sha256=hvn8RoN2BSmYzESKqCvcpKleX0PrGiHVQ5v35nX12Mc,19241
-mcp_ticketer/core/env_discovery.py,sha256=It62C97UBt96CgVbZCql5NQtONmCHMkX3c8W2kEl-Qk,18716
+mcp_ticketer/core/env_discovery.py,sha256=m2x3K8hrd0_nzmSGZn5EYUnED7MI2qxcWHTp6ns880o,19970
 mcp_ticketer/core/env_loader.py,sha256=fX8EpHcAJxxhPJ-XY5BD8HlLs-Y9jdlQ24Qtt5ylBNo,12032
 mcp_ticketer/core/exceptions.py,sha256=78tzV3Muc7E_UhEIByF0NtsPe1I0lFVrbpdDNX56kQg,3737
 mcp_ticketer/core/http_client.py,sha256=s5ikMiwEJ8TJjNn73wu3gv3OdAtyBEpAqPnSroRMW2k,13971
@@ -41,7 +42,7 @@ mcp_ticketer/core/models.py,sha256=a_2AbL3NlN0pfdZad-hXus_zb4bSi9zISHcsNYl0sng,1
 mcp_ticketer/core/project_config.py,sha256=yYxlgxjcEPeOwx-b-SXFpe0k9pW9xzBRAK72PsItG-o,23346
 mcp_ticketer/core/registry.py,sha256=ShYLDPE62KFJpB0kj_zFyQzRxSH3LkQEEuo1jaakb1k,3483
 mcp_ticketer/mcp/__init__.py,sha256=Y05eTzsPk0wH8yKNIM-ekpGjgSDO0bQr0EME-vOP4GE,123
-mcp_ticketer/mcp/server.py,sha256=vs0WR9_KhDaYyhrkbTuTsEThT0bMj6gwuFmAxmzCxwU,76377
+mcp_ticketer/mcp/server.py,sha256=PCNerYqLMq5et3ZYAIdd_q_-4LGLBhDuvPAYTuWxDiQ,81351
 mcp_ticketer/queue/__init__.py,sha256=1YIaCpZpFqPcqvDEQXiEvDLiw94DXRdCJkBaVIFQrms,231
 mcp_ticketer/queue/__main__.py,sha256=gc_tE9NUdK07OJfTZuD4t6KeBD_vxFQIhknGTQUG_jk,109
 mcp_ticketer/queue/health_monitor.py,sha256=aQrlBzfbLWu8-fV2b5CuHs4oqyTqGGcntKIHM3r-dDI,11844
@@ -50,9 +51,9 @@ mcp_ticketer/queue/queue.py,sha256=jSAkYNEIbNH1cbYuF8s6eFuZmXqn8WHXx3mbfMU2Ud8,1
 mcp_ticketer/queue/run_worker.py,sha256=F7anuhdkgZF9lXZntHuJ7rEzuEkAfAZO1qvGh3R57bw,1033
 mcp_ticketer/queue/ticket_registry.py,sha256=k8FYg2cFYsI4POb94-o-fTrIVr-ttfi60r0O5YhJYck,15321
 mcp_ticketer/queue/worker.py,sha256=zXJpyhRJ99be0VLaez3YPtC9OU17vVNu5qhr1dCGaLg,19992
-mcp_ticketer-0.2.0.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
-mcp_ticketer-0.2.0.dist-info/METADATA,sha256=bvHYuQNE5HYIEgM2BlrpPwCesfgm3jWiax7lwTNGGB0,13219
-mcp_ticketer-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_ticketer-0.2.0.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
-mcp_ticketer-0.2.0.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
-mcp_ticketer-0.2.0.dist-info/RECORD,,
+mcp_ticketer-0.3.1.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
+mcp_ticketer-0.3.1.dist-info/METADATA,sha256=7MkHCRw1QYtKKRfHVQ2oUMW3syEXGilHV5y-Ooud4xQ,13219
+mcp_ticketer-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_ticketer-0.3.1.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
+mcp_ticketer-0.3.1.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
+mcp_ticketer-0.3.1.dist-info/RECORD,,