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

mcp_ticketer/cli/discover.py

@@ -0,0 +1,402 @@
+"""CLI command for auto-discovering configuration from .env files."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import print as rprint
+
+from ..core.env_discovery import EnvDiscovery, DiscoveredAdapter
+from ..core.project_config import (
+    ConfigResolver,
+    TicketerConfig,
+    AdapterConfig,
+    ConfigValidator,
+)
+
+console = Console()
+app = typer.Typer(help="Auto-discover configuration from .env files")
+
+
+def _mask_sensitive(value: str, key: str) -> str:
+    """Mask sensitive values for display.
+
+    Args:
+        value: Value to potentially mask
+        key: Key name to determine if masking needed
+
+    Returns:
+        Masked or original value
+    """
+    sensitive_keys = ["token", "key", "password", "secret", "api_token"]
+
+    # Check if key contains any sensitive pattern
+    key_lower = key.lower()
+    is_sensitive = any(pattern in key_lower for pattern in sensitive_keys)
+
+    # Don't mask team_id, team_key, project_key, etc.
+    if "team" in key_lower or "project" in key_lower:
+        is_sensitive = False
+
+    if is_sensitive and value:
+        # Show first 4 and last 4 characters
+        if len(value) > 12:
+            return f"{value[:4]}...{value[-4:]}"
+        else:
+            return "***"
+
+    return value
+
+
+def _display_discovered_adapter(adapter: DiscoveredAdapter, discovery: EnvDiscovery) -> None:
+    """Display information about a discovered adapter.
+
+    Args:
+        adapter: Discovered adapter to display
+        discovery: EnvDiscovery instance for validation
+    """
+    # Header
+    completeness = "✅ Complete" if adapter.is_complete() else "⚠️  Incomplete"
+    confidence_percent = int(adapter.confidence * 100)
+
+    console.print(
+        f"\n[bold cyan]{adapter.adapter_type.upper()}[/bold cyan] "
+        f"({completeness}, {confidence_percent}% confidence)"
+    )
+
+    # Configuration details
+    console.print(f"  [dim]Found in: {adapter.found_in}[/dim]")
+
+    for key, value in adapter.config.items():
+        if key == "adapter":
+            continue
+
+        display_value = _mask_sensitive(str(value), key)
+        console.print(f"  {key}: [green]{display_value}[/green]")
+
+    # Missing fields
+    if adapter.missing_fields:
+        console.print(f"  [yellow]Missing:[/yellow] {', '.join(adapter.missing_fields)}")
+
+    # Validation warnings
+    warnings = discovery.validate_discovered_config(adapter)
+    if warnings:
+        for warning in warnings:
+            console.print(f"  {warning}")
+
+
+@app.command()
+def show(
+    project_path: Optional[Path] = typer.Option(
+        None,
+        "--path",
+        "-p",
+        help="Project path to scan (defaults to current directory)"
+    ),
+) -> None:
+    """Show discovered configuration without saving."""
+    proj_path = project_path or Path.cwd()
+
+    console.print(f"\n[bold]🔍 Auto-discovering configuration in:[/bold] {proj_path}\n")
+
+    # Discover
+    discovery = EnvDiscovery(proj_path)
+    result = discovery.discover()
+
+    # Show env files found
+    if result.env_files_found:
+        console.print("[bold]Environment files found:[/bold]")
+        for env_file in result.env_files_found:
+            console.print(f"  ✅ {env_file}")
+    else:
+        console.print("[yellow]No .env files found[/yellow]")
+        return
+
+    # Show discovered adapters
+    if result.adapters:
+        console.print("\n[bold]Detected adapter configurations:[/bold]")
+        for adapter in sorted(result.adapters, key=lambda a: a.confidence, reverse=True):
+            _display_discovered_adapter(adapter, discovery)
+
+        # Show recommended adapter
+        primary = result.get_primary_adapter()
+        if primary:
+            console.print(
+                f"\n[bold green]Recommended adapter:[/bold green] {primary.adapter_type} "
+                f"(most complete configuration)"
+            )
+    else:
+        console.print("\n[yellow]No adapter configurations detected[/yellow]")
+        console.print("[dim]Make sure your .env file contains adapter credentials[/dim]")
+
+    # Show warnings
+    if result.warnings:
+        console.print("\n[bold yellow]Warnings:[/bold yellow]")
+        for warning in result.warnings:
+            console.print(f"  {warning}")
+
+
+@app.command()
+def save(
+    adapter: Optional[str] = typer.Option(
+        None,
+        "--adapter",
+        "-a",
+        help="Which adapter to save (defaults to recommended)"
+    ),
+    global_config: bool = typer.Option(
+        False,
+        "--global",
+        "-g",
+        help="Save to global config instead of project config"
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Show what would be saved without saving"
+    ),
+    project_path: Optional[Path] = typer.Option(
+        None,
+        "--path",
+        "-p",
+        help="Project path to scan (defaults to current directory)"
+    ),
+) -> None:
+    """Discover configuration and save to config file.
+
+    By default, saves to project-specific config (.mcp-ticketer/config.json).
+    Use --global to save to global config (~/.mcp-ticketer/config.json).
+    """
+    proj_path = project_path or Path.cwd()
+
+    console.print(f"\n[bold]🔍 Auto-discovering configuration in:[/bold] {proj_path}\n")
+
+    # Discover
+    discovery = EnvDiscovery(proj_path)
+    result = discovery.discover()
+
+    if not result.adapters:
+        console.print("[red]No adapter configurations detected[/red]")
+        console.print("[dim]Make sure your .env file contains adapter credentials[/dim]")
+        raise typer.Exit(1)
+
+    # Determine which adapter to save
+    if adapter:
+        discovered_adapter = result.get_adapter_by_type(adapter)
+        if not discovered_adapter:
+            console.print(f"[red]No configuration found for adapter: {adapter}[/red]")
+            console.print(f"[dim]Available: {', '.join(a.adapter_type for a in result.adapters)}[/dim]")
+            raise typer.Exit(1)
+    else:
+        # Use recommended adapter
+        discovered_adapter = result.get_primary_adapter()
+        if not discovered_adapter:
+            console.print("[red]Could not determine recommended adapter[/red]")
+            raise typer.Exit(1)
+
+        console.print(
+            f"[bold]Using recommended adapter:[/bold] {discovered_adapter.adapter_type}"
+        )
+
+    # Display what will be saved
+    _display_discovered_adapter(discovered_adapter, discovery)
+
+    # Validate configuration
+    is_valid, error_msg = ConfigValidator.validate(
+        discovered_adapter.adapter_type,
+        discovered_adapter.config
+    )
+
+    if not is_valid:
+        console.print(f"\n[red]Configuration validation failed:[/red] {error_msg}")
+        console.print("[dim]Fix the configuration in your .env file and try again[/dim]")
+        raise typer.Exit(1)
+
+    if dry_run:
+        console.print("\n[yellow]Dry run - no changes made[/yellow]")
+        return
+
+    # Load or create config
+    resolver = ConfigResolver(proj_path)
+
+    if global_config:
+        config = resolver.load_global_config()
+    else:
+        config = resolver.load_project_config() or TicketerConfig()
+
+    # Set default adapter
+    config.default_adapter = discovered_adapter.adapter_type
+
+    # Create adapter config
+    adapter_config = AdapterConfig.from_dict(discovered_adapter.config)
+
+    # Add to config
+    config.adapters[discovered_adapter.adapter_type] = adapter_config
+
+    # Save
+    try:
+        if global_config:
+            resolver.save_global_config(config)
+            config_location = resolver.GLOBAL_CONFIG_PATH
+        else:
+            resolver.save_project_config(config, proj_path)
+            config_location = proj_path / resolver.PROJECT_CONFIG_SUBPATH
+
+        console.print(f"\n[green]✅ Configuration saved to:[/green] {config_location}")
+        console.print(f"[green]✅ Default adapter set to:[/green] {discovered_adapter.adapter_type}")
+
+    except Exception as e:
+        console.print(f"\n[red]Failed to save configuration:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def interactive(
+    project_path: Optional[Path] = typer.Option(
+        None,
+        "--path",
+        "-p",
+        help="Project path to scan (defaults to current directory)"
+    ),
+) -> None:
+    """Interactive mode for discovering and saving configuration."""
+    proj_path = project_path or Path.cwd()
+
+    console.print(f"\n[bold]🔍 Auto-discovering configuration in:[/bold] {proj_path}\n")
+
+    # Discover
+    discovery = EnvDiscovery(proj_path)
+    result = discovery.discover()
+
+    # Show env files
+    if result.env_files_found:
+        console.print("[bold]Environment files found:[/bold]")
+        for env_file in result.env_files_found:
+            console.print(f"  ✅ {env_file}")
+    else:
+        console.print("[red]No .env files found[/red]")
+        raise typer.Exit(1)
+
+    # Show discovered adapters
+    if not result.adapters:
+        console.print("\n[red]No adapter configurations detected[/red]")
+        console.print("[dim]Make sure your .env file contains adapter credentials[/dim]")
+        raise typer.Exit(1)
+
+    console.print("\n[bold]Detected adapter configurations:[/bold]")
+    for i, adapter in enumerate(result.adapters, 1):
+        completeness = "✅" if adapter.is_complete() else "⚠️ "
+        console.print(
+            f"  {i}. {completeness} [cyan]{adapter.adapter_type}[/cyan] "
+            f"({int(adapter.confidence * 100)}% confidence)"
+        )
+
+    # Show warnings
+    if result.warnings:
+        console.print("\n[bold yellow]Warnings:[/bold yellow]")
+        for warning in result.warnings:
+            console.print(f"  {warning}")
+
+    # Ask user which adapter to save
+    primary = result.get_primary_adapter()
+    console.print(
+        f"\n[bold]Recommended:[/bold] {primary.adapter_type if primary else 'None'}"
+    )
+
+    # Prompt for selection
+    console.print("\n[bold]Select an option:[/bold]")
+    console.print("  1. Save recommended adapter to project config")
+    console.print("  2. Save recommended adapter to global config")
+    console.print("  3. Choose different adapter")
+    console.print("  4. Save all adapters")
+    console.print("  5. Cancel")
+
+    choice = typer.prompt("Enter choice", type=int, default=1)
+
+    if choice == 5:
+        console.print("[yellow]Cancelled[/yellow]")
+        return
+
+    # Determine adapters to save
+    if choice in [1, 2]:
+        if not primary:
+            console.print("[red]No recommended adapter found[/red]")
+            raise typer.Exit(1)
+        adapters_to_save = [primary]
+        default_adapter = primary.adapter_type
+    elif choice == 3:
+        # Let user choose
+        console.print("\n[bold]Available adapters:[/bold]")
+        for i, adapter in enumerate(result.adapters, 1):
+            console.print(f"  {i}. {adapter.adapter_type}")
+
+        adapter_choice = typer.prompt("Select adapter", type=int, default=1)
+        if 1 <= adapter_choice <= len(result.adapters):
+            selected = result.adapters[adapter_choice - 1]
+            adapters_to_save = [selected]
+            default_adapter = selected.adapter_type
+        else:
+            console.print("[red]Invalid choice[/red]")
+            raise typer.Exit(1)
+    else:  # choice == 4
+        adapters_to_save = result.adapters
+        default_adapter = primary.adapter_type if primary else result.adapters[0].adapter_type
+
+    # Determine save location
+    save_global = choice == 2
+
+    # Load or create config
+    resolver = ConfigResolver(proj_path)
+
+    if save_global:
+        config = resolver.load_global_config()
+    else:
+        config = resolver.load_project_config() or TicketerConfig()
+
+    # Set default adapter
+    config.default_adapter = default_adapter
+
+    # Add adapters
+    for discovered_adapter in adapters_to_save:
+        # Validate
+        is_valid, error_msg = ConfigValidator.validate(
+            discovered_adapter.adapter_type,
+            discovered_adapter.config
+        )
+
+        if not is_valid:
+            console.print(
+                f"\n[yellow]Warning:[/yellow] {discovered_adapter.adapter_type} "
+                f"validation failed: {error_msg}"
+            )
+            continue
+
+        # Create adapter config
+        adapter_config = AdapterConfig.from_dict(discovered_adapter.config)
+        config.adapters[discovered_adapter.adapter_type] = adapter_config
+
+        console.print(f"  ✅ Added {discovered_adapter.adapter_type}")
+
+    # Save
+    try:
+        if save_global:
+            resolver.save_global_config(config)
+            config_location = resolver.GLOBAL_CONFIG_PATH
+        else:
+            resolver.save_project_config(config, proj_path)
+            config_location = proj_path / resolver.PROJECT_CONFIG_SUBPATH
+
+        console.print(f"\n[green]✅ Configuration saved to:[/green] {config_location}")
+        console.print(f"[green]✅ Default adapter:[/green] {config.default_adapter}")
+
+    except Exception as e:
+        console.print(f"\n[red]Failed to save configuration:[/red] {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

mcp_ticketer/cli/main.py

@@ -19,6 +19,9 @@ from ..adapters import AITrackdownAdapter
 from ..queue import Queue, QueueStatus, WorkerManager
 from .queue_commands import app as queue_app
 from ..__version__ import __version__
+from .configure import configure_wizard, show_current_config, set_adapter_config
+from .migrate_config import migrate_config_command
+from .discover import app as discover_app
 
 # Load environment variables
 load_dotenv()
@@ -424,6 +427,85 @@ def set_config(
         console.print(f"[dim]Configuration saved to {CONFIG_FILE}[/dim]")
 
 
+@app.command("configure")
+def configure_command(
+    show: bool = typer.Option(
+        False,
+        "--show",
+        help="Show current configuration"
+    ),
+    adapter: Optional[str] = typer.Option(
+        None,
+        "--adapter",
+        help="Set default adapter type"
+    ),
+    api_key: Optional[str] = typer.Option(
+        None,
+        "--api-key",
+        help="Set API key/token"
+    ),
+    project_id: Optional[str] = typer.Option(
+        None,
+        "--project-id",
+        help="Set project ID"
+    ),
+    team_id: Optional[str] = typer.Option(
+        None,
+        "--team-id",
+        help="Set team ID (Linear)"
+    ),
+    global_scope: bool = typer.Option(
+        False,
+        "--global",
+        "-g",
+        help="Save to global config instead of project-specific"
+    ),
+) -> None:
+    """Configure MCP Ticketer integration.
+
+    Run without arguments to launch interactive wizard.
+    Use --show to display current configuration.
+    Use options to set specific values directly.
+    """
+    # Show configuration
+    if show:
+        show_current_config()
+        return
+
+    # Direct configuration
+    if any([adapter, api_key, project_id, team_id]):
+        set_adapter_config(
+            adapter=adapter,
+            api_key=api_key,
+            project_id=project_id,
+            team_id=team_id,
+            global_scope=global_scope
+        )
+        return
+
+    # Run interactive wizard
+    configure_wizard()
+
+
+@app.command("migrate-config")
+def migrate_config(
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Show what would be done without making changes"
+    ),
+) -> None:
+    """Migrate configuration from old format to new format.
+
+    This command will:
+    1. Detect old configuration format
+    2. Convert to new schema
+    3. Backup old config
+    4. Apply new config
+    """
+    migrate_config_command(dry_run=dry_run)
+
+
 @app.command("status")
 def status_command():
     """Show queue and worker status."""
@@ -784,6 +866,9 @@ def search(
 # Add queue command to main app
 app.add_typer(queue_app, name="queue")
 
+# Add discover command to main app
+app.add_typer(discover_app, name="discover")
+
 
 @app.command()
 def check(

mcp_ticketer/cli/migrate_config.py

@@ -0,0 +1,204 @@
+"""Configuration migration utilities."""
+
+import json
+import shutil
+from pathlib import Path
+from typing import Dict, Any
+from datetime import datetime
+
+from rich.console import Console
+from rich.prompt import Confirm
+
+from ..core.project_config import (
+    ConfigResolver,
+    TicketerConfig,
+    AdapterConfig,
+    AdapterType
+)
+
+console = Console()
+
+
+def migrate_config_command(dry_run: bool = False) -> None:
+    """Migrate from old config format to new format.
+
+    Args:
+        dry_run: If True, show what would be done without making changes
+    """
+    resolver = ConfigResolver()
+
+    # Check if old config exists
+    if not resolver.GLOBAL_CONFIG_PATH.exists():
+        console.print("[yellow]No configuration found to migrate[/yellow]")
+        return
+
+    # Load old config
+    try:
+        with open(resolver.GLOBAL_CONFIG_PATH, 'r') as f:
+            old_config = json.load(f)
+    except Exception as e:
+        console.print(f"[red]Failed to load config: {e}[/red]")
+        return
+
+    # Check if already in new format
+    if "adapters" in old_config and isinstance(old_config.get("adapters"), dict):
+        # Check if it looks like new format
+        if any("adapter" in v for v in old_config["adapters"].values()):
+            console.print("[green]Configuration already in new format[/green]")
+            return
+
+    console.print("[bold]Configuration Migration[/bold]\n")
+    console.print("Old format detected. This will migrate to the new schema.\n")
+
+    if dry_run:
+        console.print("[yellow]DRY RUN - No changes will be made[/yellow]\n")
+
+    # Show current config
+    console.print("[bold]Current Configuration:[/bold]")
+    console.print(json.dumps(old_config, indent=2))
+    console.print()
+
+    # Migrate
+    new_config = _migrate_old_to_new(old_config)
+
+    # Show new config
+    console.print("[bold]Migrated Configuration:[/bold]")
+    console.print(json.dumps(new_config.to_dict(), indent=2))
+    console.print()
+
+    if dry_run:
+        console.print("[yellow]This was a dry run. No changes were made.[/yellow]")
+        return
+
+    # Confirm migration
+    if not Confirm.ask("Apply migration?", default=True):
+        console.print("[yellow]Migration cancelled[/yellow]")
+        return
+
+    # Backup old config
+    backup_path = resolver.GLOBAL_CONFIG_PATH.with_suffix('.json.bak')
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    backup_path = resolver.GLOBAL_CONFIG_PATH.parent / f"config.{timestamp}.bak"
+
+    try:
+        shutil.copy(resolver.GLOBAL_CONFIG_PATH, backup_path)
+        console.print(f"[green]✓[/green] Backed up old config to: {backup_path}")
+    except Exception as e:
+        console.print(f"[red]Failed to backup config: {e}[/red]")
+        return
+
+    # Save new config
+    try:
+        resolver.save_global_config(new_config)
+        console.print(f"[green]✓[/green] Migration complete!")
+        console.print(f"[dim]New config saved to: {resolver.GLOBAL_CONFIG_PATH}[/dim]")
+    except Exception as e:
+        console.print(f"[red]Failed to save new config: {e}[/red]")
+        console.print(f"[yellow]Old config backed up at: {backup_path}[/yellow]")
+
+
+def _migrate_old_to_new(old_config: Dict[str, Any]) -> TicketerConfig:
+    """Migrate old configuration format to new format.
+
+    Old format examples:
+    {
+        "adapter": "linear",
+        "config": {"api_key": "...", "team_id": "..."}
+    }
+
+    or
+
+    {
+        "default_adapter": "linear",
+        "adapters": {
+            "linear": {"api_key": "...", "team_id": "..."}
+        }
+    }
+
+    New format:
+    {
+        "default_adapter": "linear",
+        "adapters": {
+            "linear": {
+                "adapter": "linear",
+                "api_key": "...",
+                "team_id": "..."
+            }
+        }
+    }
+
+    Args:
+        old_config: Old configuration dictionary
+
+    Returns:
+        New TicketerConfig object
+    """
+    adapters = {}
+    default_adapter = "aitrackdown"
+
+    # Case 1: Single adapter with "adapter" and "config" fields (legacy format)
+    if "adapter" in old_config and "config" in old_config:
+        adapter_type = old_config["adapter"]
+        adapter_config = old_config["config"]
+
+        # Merge type into config
+        adapter_config["adapter"] = adapter_type
+
+        # Create AdapterConfig
+        adapters[adapter_type] = AdapterConfig.from_dict(adapter_config)
+        default_adapter = adapter_type
+
+    # Case 2: New-ish format with "adapters" dict but missing "adapter" field
+    elif "adapters" in old_config:
+        default_adapter = old_config.get("default_adapter", "aitrackdown")
+
+        for name, config in old_config["adapters"].items():
+            # If config doesn't have "adapter" field, infer from name
+            if "adapter" not in config:
+                config["adapter"] = name
+
+            adapters[name] = AdapterConfig.from_dict(config)
+
+    # Case 3: Already in new format (shouldn't happen but handle it)
+    else:
+        default_adapter = old_config.get("default_adapter", "aitrackdown")
+
+    # Create new config
+    new_config = TicketerConfig(
+        default_adapter=default_adapter,
+        adapters=adapters
+    )
+
+    return new_config
+
+
+def validate_migrated_config(config: TicketerConfig) -> bool:
+    """Validate migrated configuration.
+
+    Args:
+        config: Migrated configuration
+
+    Returns:
+        True if valid, False otherwise
+    """
+    from ..core.project_config import ConfigValidator
+
+    if not config.adapters:
+        console.print("[yellow]Warning: No adapters configured[/yellow]")
+        return True
+
+    all_valid = True
+
+    for name, adapter_config in config.adapters.items():
+        adapter_dict = adapter_config.to_dict()
+        adapter_type = adapter_dict.get("adapter")
+
+        is_valid, error = ConfigValidator.validate(adapter_type, adapter_dict)
+
+        if not is_valid:
+            console.print(f"[red]✗[/red] {name}: {error}")
+            all_valid = False
+        else:
+            console.print(f"[green]✓[/green] {name}: Valid")
+
+    return all_valid