mcp-ticketer 0.1.8__py3-none-any.whl → 0.1.12__py3-none-any.whl

mcp_ticketer/cli/configure.py

@@ -0,0 +1,532 @@
+"""Interactive configuration wizard for MCP Ticketer."""
+
+import os
+import sys
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+from rich.table import Table
+
+from ..core.project_config import (
+    ConfigResolver,
+    TicketerConfig,
+    AdapterConfig,
+    ProjectConfig,
+    HybridConfig,
+    AdapterType,
+    SyncStrategy,
+    ConfigValidator
+)
+
+console = Console()
+
+
+def configure_wizard() -> None:
+    """Run interactive configuration wizard."""
+    console.print(Panel.fit(
+        "[bold cyan]MCP-Ticketer Configuration Wizard[/bold cyan]\n"
+        "Configure your ticketing system integration",
+        border_style="cyan"
+    ))
+
+    # Step 1: Choose integration mode
+    console.print("\n[bold]Step 1: Integration Mode[/bold]")
+    console.print("1. Single Adapter (recommended for most projects)")
+    console.print("2. Hybrid Mode (sync across multiple platforms)")
+
+    mode = Prompt.ask(
+        "Select mode",
+        choices=["1", "2"],
+        default="1"
+    )
+
+    if mode == "1":
+        config = _configure_single_adapter()
+    else:
+        config = _configure_hybrid_mode()
+
+    # Step 2: Choose where to save
+    console.print("\n[bold]Step 2: Configuration Scope[/bold]")
+    console.print("1. Global (all projects): ~/.mcp-ticketer/config.json")
+    console.print("2. Project-specific: .mcp-ticketer/config.json in project root")
+
+    scope = Prompt.ask(
+        "Save configuration as",
+        choices=["1", "2"],
+        default="2"
+    )
+
+    resolver = ConfigResolver()
+
+    if scope == "1":
+        # Save global
+        resolver.save_global_config(config)
+        console.print(f"\n[green]✓[/green] Configuration saved globally to {resolver.GLOBAL_CONFIG_PATH}")
+    else:
+        # Save project-specific
+        resolver.save_project_config(config)
+        config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
+        console.print(f"\n[green]✓[/green] Configuration saved to {config_path}")
+
+    # Show usage instructions
+    console.print("\n[bold]Usage:[/bold]")
+    console.print("  CLI: [cyan]mcp-ticketer create \"Task title\"[/cyan]")
+    console.print("  MCP: Configure Claude Desktop to use this adapter")
+    console.print("\nRun [cyan]mcp-ticketer configure --show[/cyan] to view your configuration")
+
+
+def _configure_single_adapter() -> TicketerConfig:
+    """Configure a single adapter."""
+    console.print("\n[bold]Select Ticketing System:[/bold]")
+    console.print("1. Linear (Modern project management)")
+    console.print("2. JIRA (Enterprise issue tracking)")
+    console.print("3. GitHub Issues (Code-integrated tracking)")
+    console.print("4. Internal/AITrackdown (File-based, no API)")
+
+    adapter_choice = Prompt.ask(
+        "Select system",
+        choices=["1", "2", "3", "4"],
+        default="1"
+    )
+
+    adapter_type_map = {
+        "1": AdapterType.LINEAR,
+        "2": AdapterType.JIRA,
+        "3": AdapterType.GITHUB,
+        "4": AdapterType.AITRACKDOWN,
+    }
+
+    adapter_type = adapter_type_map[adapter_choice]
+
+    # Configure the selected adapter
+    if adapter_type == AdapterType.LINEAR:
+        adapter_config = _configure_linear()
+    elif adapter_type == AdapterType.JIRA:
+        adapter_config = _configure_jira()
+    elif adapter_type == AdapterType.GITHUB:
+        adapter_config = _configure_github()
+    else:
+        adapter_config = _configure_aitrackdown()
+
+    # Create config
+    config = TicketerConfig(
+        default_adapter=adapter_type.value,
+        adapters={adapter_type.value: adapter_config}
+    )
+
+    return config
+
+
+def _configure_linear() -> AdapterConfig:
+    """Configure Linear adapter."""
+    console.print("\n[bold]Configure Linear Integration:[/bold]")
+
+    # API Key
+    api_key = os.getenv("LINEAR_API_KEY") or ""
+    if api_key:
+        console.print(f"[dim]Found LINEAR_API_KEY in environment[/dim]")
+        use_env = Confirm.ask("Use this API key?", default=True)
+        if not use_env:
+            api_key = ""
+
+    if not api_key:
+        api_key = Prompt.ask(
+            "Linear API Key",
+            password=True
+        )
+
+    # Team ID
+    team_id = Prompt.ask(
+        "Team ID (optional, e.g., team-abc)",
+        default=""
+    )
+
+    # Team Key
+    team_key = Prompt.ask(
+        "Team Key (optional, e.g., ENG)",
+        default=""
+    )
+
+    # Project ID
+    project_id = Prompt.ask(
+        "Project ID (optional)",
+        default=""
+    )
+
+    config_dict = {
+        "adapter": AdapterType.LINEAR.value,
+        "api_key": api_key,
+    }
+
+    if team_id:
+        config_dict["team_id"] = team_id
+    if team_key:
+        config_dict["team_key"] = team_key
+    if project_id:
+        config_dict["project_id"] = project_id
+
+    # Validate
+    is_valid, error = ConfigValidator.validate_linear_config(config_dict)
+    if not is_valid:
+        console.print(f"[red]Configuration error: {error}[/red]")
+        raise typer.Exit(1)
+
+    return AdapterConfig.from_dict(config_dict)
+
+
+def _configure_jira() -> AdapterConfig:
+    """Configure JIRA adapter."""
+    console.print("\n[bold]Configure JIRA Integration:[/bold]")
+
+    # Server URL
+    server = os.getenv("JIRA_SERVER") or ""
+    if not server:
+        server = Prompt.ask(
+            "JIRA Server URL (e.g., https://company.atlassian.net)"
+        )
+
+    # Email
+    email = os.getenv("JIRA_EMAIL") or ""
+    if not email:
+        email = Prompt.ask("JIRA User Email")
+
+    # API Token
+    api_token = os.getenv("JIRA_API_TOKEN") or ""
+    if not api_token:
+        console.print("[dim]Generate token at: https://id.atlassian.com/manage/api-tokens[/dim]")
+        api_token = Prompt.ask(
+            "JIRA API Token",
+            password=True
+        )
+
+    # Project Key
+    project_key = Prompt.ask(
+        "Default Project Key (optional, e.g., PROJ)",
+        default=""
+    )
+
+    config_dict = {
+        "adapter": AdapterType.JIRA.value,
+        "server": server.rstrip('/'),
+        "email": email,
+        "api_token": api_token,
+    }
+
+    if project_key:
+        config_dict["project_key"] = project_key
+
+    # Validate
+    is_valid, error = ConfigValidator.validate_jira_config(config_dict)
+    if not is_valid:
+        console.print(f"[red]Configuration error: {error}[/red]")
+        raise typer.Exit(1)
+
+    return AdapterConfig.from_dict(config_dict)
+
+
+def _configure_github() -> AdapterConfig:
+    """Configure GitHub adapter."""
+    console.print("\n[bold]Configure GitHub Integration:[/bold]")
+
+    # Token
+    token = os.getenv("GITHUB_TOKEN") or ""
+    if token:
+        console.print(f"[dim]Found GITHUB_TOKEN in environment[/dim]")
+        use_env = Confirm.ask("Use this token?", default=True)
+        if not use_env:
+            token = ""
+
+    if not token:
+        console.print("[dim]Create token at: https://github.com/settings/tokens/new[/dim]")
+        console.print("[dim]Required scopes: repo (or public_repo for public repos)[/dim]")
+        token = Prompt.ask(
+            "GitHub Personal Access Token",
+            password=True
+        )
+
+    # Repository Owner
+    owner = os.getenv("GITHUB_OWNER") or ""
+    if not owner:
+        owner = Prompt.ask("Repository Owner (username or org)")
+
+    # Repository Name
+    repo = os.getenv("GITHUB_REPO") or ""
+    if not repo:
+        repo = Prompt.ask("Repository Name")
+
+    config_dict = {
+        "adapter": AdapterType.GITHUB.value,
+        "token": token,
+        "owner": owner,
+        "repo": repo,
+        "project_id": f"{owner}/{repo}",  # Convenience field
+    }
+
+    # Validate
+    is_valid, error = ConfigValidator.validate_github_config(config_dict)
+    if not is_valid:
+        console.print(f"[red]Configuration error: {error}[/red]")
+        raise typer.Exit(1)
+
+    return AdapterConfig.from_dict(config_dict)
+
+
+def _configure_aitrackdown() -> AdapterConfig:
+    """Configure AITrackdown adapter."""
+    console.print("\n[bold]Configure AITrackdown (File-based):[/bold]")
+
+    base_path = Prompt.ask(
+        "Base path for ticket storage",
+        default=".aitrackdown"
+    )
+
+    config_dict = {
+        "adapter": AdapterType.AITRACKDOWN.value,
+        "base_path": base_path,
+    }
+
+    return AdapterConfig.from_dict(config_dict)
+
+
+def _configure_hybrid_mode() -> TicketerConfig:
+    """Configure hybrid mode with multiple adapters."""
+    console.print("\n[bold]Hybrid Mode Configuration[/bold]")
+    console.print("Sync tickets across multiple platforms")
+
+    # Select adapters
+    console.print("\n[bold]Select adapters to sync (comma-separated):[/bold]")
+    console.print("1. Linear")
+    console.print("2. JIRA")
+    console.print("3. GitHub")
+    console.print("4. AITrackdown")
+
+    selections = Prompt.ask(
+        "Select adapters (e.g., 1,3 for Linear and GitHub)",
+        default="1,3"
+    )
+
+    adapter_choices = [s.strip() for s in selections.split(",")]
+
+    adapter_type_map = {
+        "1": AdapterType.LINEAR,
+        "2": AdapterType.JIRA,
+        "3": AdapterType.GITHUB,
+        "4": AdapterType.AITRACKDOWN,
+    }
+
+    selected_adapters = [adapter_type_map[c] for c in adapter_choices if c in adapter_type_map]
+
+    if len(selected_adapters) < 2:
+        console.print("[red]Hybrid mode requires at least 2 adapters[/red]")
+        raise typer.Exit(1)
+
+    # Configure each adapter
+    adapters = {}
+    for adapter_type in selected_adapters:
+        console.print(f"\n[cyan]Configuring {adapter_type.value}...[/cyan]")
+
+        if adapter_type == AdapterType.LINEAR:
+            adapter_config = _configure_linear()
+        elif adapter_type == AdapterType.JIRA:
+            adapter_config = _configure_jira()
+        elif adapter_type == AdapterType.GITHUB:
+            adapter_config = _configure_github()
+        else:
+            adapter_config = _configure_aitrackdown()
+
+        adapters[adapter_type.value] = adapter_config
+
+    # Select primary adapter
+    console.print("\n[bold]Select primary adapter (source of truth):[/bold]")
+    for idx, adapter_type in enumerate(selected_adapters, 1):
+        console.print(f"{idx}. {adapter_type.value}")
+
+    primary_idx = int(Prompt.ask(
+        "Primary adapter",
+        choices=[str(i) for i in range(1, len(selected_adapters) + 1)],
+        default="1"
+    ))
+
+    primary_adapter = selected_adapters[primary_idx - 1].value
+
+    # Select sync strategy
+    console.print("\n[bold]Select sync strategy:[/bold]")
+    console.print("1. Primary Source (one-way: primary → others)")
+    console.print("2. Bidirectional (two-way sync)")
+    console.print("3. Mirror (clone tickets across all)")
+
+    strategy_choice = Prompt.ask(
+        "Sync strategy",
+        choices=["1", "2", "3"],
+        default="1"
+    )
+
+    strategy_map = {
+        "1": SyncStrategy.PRIMARY_SOURCE,
+        "2": SyncStrategy.BIDIRECTIONAL,
+        "3": SyncStrategy.MIRROR,
+    }
+
+    sync_strategy = strategy_map[strategy_choice]
+
+    # Create hybrid config
+    hybrid_config = HybridConfig(
+        enabled=True,
+        adapters=[a.value for a in selected_adapters],
+        primary_adapter=primary_adapter,
+        sync_strategy=sync_strategy
+    )
+
+    # Create full config
+    config = TicketerConfig(
+        default_adapter=primary_adapter,
+        adapters=adapters,
+        hybrid_mode=hybrid_config
+    )
+
+    return config
+
+
+def show_current_config() -> None:
+    """Show current configuration."""
+    resolver = ConfigResolver()
+
+    # Try to load configs
+    global_config = resolver.load_global_config()
+    project_config = resolver.load_project_config()
+
+    console.print("[bold]Current Configuration:[/bold]\n")
+
+    # Global config
+    if resolver.GLOBAL_CONFIG_PATH.exists():
+        console.print(f"[cyan]Global:[/cyan] {resolver.GLOBAL_CONFIG_PATH}")
+        console.print(f"  Default adapter: {global_config.default_adapter}")
+
+        if global_config.adapters:
+            table = Table(title="Global Adapters")
+            table.add_column("Adapter", style="cyan")
+            table.add_column("Configured", style="green")
+
+            for name, config in global_config.adapters.items():
+                configured = "✓" if config.enabled else "✗"
+                table.add_row(name, configured)
+
+            console.print(table)
+    else:
+        console.print("[yellow]No global configuration found[/yellow]")
+
+    # Project config
+    console.print()
+    project_config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
+    if project_config_path.exists():
+        console.print(f"[cyan]Project:[/cyan] {project_config_path}")
+        if project_config:
+            console.print(f"  Default adapter: {project_config.default_adapter}")
+
+            if project_config.adapters:
+                table = Table(title="Project Adapters")
+                table.add_column("Adapter", style="cyan")
+                table.add_column("Configured", style="green")
+
+                for name, config in project_config.adapters.items():
+                    configured = "✓" if config.enabled else "✗"
+                    table.add_row(name, configured)
+
+                console.print(table)
+
+            if project_config.hybrid_mode and project_config.hybrid_mode.enabled:
+                console.print("\n[bold]Hybrid Mode:[/bold] Enabled")
+                console.print(f"  Adapters: {', '.join(project_config.hybrid_mode.adapters)}")
+                console.print(f"  Primary: {project_config.hybrid_mode.primary_adapter}")
+                console.print(f"  Strategy: {project_config.hybrid_mode.sync_strategy.value}")
+    else:
+        console.print("[yellow]No project-specific configuration found[/yellow]")
+
+    # Show resolved config for current project
+    console.print("\n[bold]Resolved Configuration (for current project):[/bold]")
+    resolved = resolver.resolve_adapter_config()
+
+    table = Table()
+    table.add_column("Key", style="cyan")
+    table.add_column("Value", style="white")
+
+    for key, value in resolved.items():
+        # Hide sensitive values
+        if any(s in key.lower() for s in ["token", "key", "password"]) and value:
+            value = "***"
+        table.add_row(key, str(value))
+
+    console.print(table)
+
+
+def set_adapter_config(
+    adapter: Optional[str] = None,
+    api_key: Optional[str] = None,
+    project_id: Optional[str] = None,
+    team_id: Optional[str] = None,
+    global_scope: bool = False,
+    **kwargs
+) -> None:
+    """Set specific adapter configuration values.
+
+    Args:
+        adapter: Adapter type to set as default
+        api_key: API key/token
+        project_id: Project ID
+        team_id: Team ID (Linear)
+        global_scope: Save to global config instead of project
+        **kwargs: Additional adapter-specific options
+    """
+    resolver = ConfigResolver()
+
+    # Load appropriate config
+    if global_scope:
+        config = resolver.load_global_config()
+    else:
+        config = resolver.load_project_config() or TicketerConfig()
+
+    # Update default adapter
+    if adapter:
+        config.default_adapter = adapter
+        console.print(f"[green]✓[/green] Default adapter set to: {adapter}")
+
+    # Update adapter-specific settings
+    updates = {}
+    if api_key:
+        updates["api_key"] = api_key
+    if project_id:
+        updates["project_id"] = project_id
+    if team_id:
+        updates["team_id"] = team_id
+
+    updates.update(kwargs)
+
+    if updates:
+        target_adapter = adapter or config.default_adapter
+
+        # Get or create adapter config
+        if target_adapter not in config.adapters:
+            config.adapters[target_adapter] = AdapterConfig(
+                adapter=target_adapter,
+                **updates
+            )
+        else:
+            # Update existing
+            existing = config.adapters[target_adapter].to_dict()
+            existing.update(updates)
+            config.adapters[target_adapter] = AdapterConfig.from_dict(existing)
+
+        console.print(f"[green]✓[/green] Updated {target_adapter} configuration")
+
+    # Save config
+    if global_scope:
+        resolver.save_global_config(config)
+        console.print(f"[dim]Saved to {resolver.GLOBAL_CONFIG_PATH}[/dim]")
+    else:
+        resolver.save_project_config(config)
+        config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
+        console.print(f"[dim]Saved to {config_path}[/dim]")

mcp_ticketer/cli/main.py

@@ -18,6 +18,9 @@ from ..core.models import SearchQuery
 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
 
 # Load environment variables
 load_dotenv()
@@ -29,6 +32,31 @@ app = typer.Typer(
 )
 console = Console()
 
+
+def version_callback(value: bool):
+    """Print version and exit."""
+    if value:
+        console.print(f"mcp-ticketer version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main_callback(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit"
+    ),
+):
+    """
+    MCP Ticketer - Universal ticket management interface.
+    """
+    pass
+
+
 # Configuration file management
 CONFIG_FILE = Path.home() / ".mcp-ticketer" / "config.json"
 
@@ -398,6 +426,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."""