mcp-ticketer 0.1.12__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

@@ -21,6 +21,7 @@ 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()
@@ -865,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/core/__init__.py

@@ -1,6 +1,6 @@
 """Core models and abstractions for MCP Ticketer."""
 
-from .models import Epic, Task, Comment, TicketState, Priority
+from .models import Epic, Task, Comment, TicketState, Priority, TicketType
 from .adapter import BaseAdapter
 from .registry import AdapterRegistry
 
@@ -10,6 +10,7 @@ __all__ = [
     "Comment",
     "TicketState",
     "Priority",
+    "TicketType",
     "BaseAdapter",
     "AdapterRegistry",
 ]

mcp_ticketer/core/adapter.py

@@ -1,8 +1,8 @@
 """Base adapter abstract class for ticket systems."""
 
 from abc import ABC, abstractmethod
-from typing import List, Optional, Dict, Any, TypeVar, Generic
-from .models import Epic, Task, Comment, SearchQuery, TicketState
+from typing import List, Optional, Dict, Any, TypeVar, Generic, Union
+from .models import Epic, Task, Comment, SearchQuery, TicketState, TicketType
 
 # Generic type for tickets
 T = TypeVar("T", Epic, Task)
@@ -206,6 +206,159 @@ class BaseAdapter(ABC, Generic[T]):
                 return False
         return current_state.can_transition_to(target_state)
 
+    # Epic/Issue/Task Hierarchy Methods
+
+    async def create_epic(
+        self,
+        title: str,
+        description: Optional[str] = None,
+        **kwargs
+    ) -> Optional[Epic]:
+        """Create epic (top-level grouping).
+
+        Args:
+            title: Epic title
+            description: Epic description
+            **kwargs: Additional adapter-specific fields
+
+        Returns:
+            Created epic or None if failed
+        """
+        epic = Epic(
+            title=title,
+            description=description,
+            ticket_type=TicketType.EPIC,
+            **{k: v for k, v in kwargs.items() if k in Epic.__fields__}
+        )
+        result = await self.create(epic)
+        if isinstance(result, Epic):
+            return result
+        return None
+
+    async def get_epic(self, epic_id: str) -> Optional[Epic]:
+        """Get epic by ID.
+
+        Args:
+            epic_id: Epic identifier
+
+        Returns:
+            Epic if found, None otherwise
+        """
+        # Default implementation - subclasses should override for platform-specific logic
+        result = await self.read(epic_id)
+        if isinstance(result, Epic):
+            return result
+        return None
+
+    async def list_epics(self, **kwargs) -> List[Epic]:
+        """List all epics.
+
+        Args:
+            **kwargs: Adapter-specific filter parameters
+
+        Returns:
+            List of epics
+        """
+        # Default implementation - subclasses should override
+        filters = kwargs.copy()
+        filters["ticket_type"] = TicketType.EPIC
+        results = await self.list(filters=filters)
+        return [r for r in results if isinstance(r, Epic)]
+
+    async def create_issue(
+        self,
+        title: str,
+        description: Optional[str] = None,
+        epic_id: Optional[str] = None,
+        **kwargs
+    ) -> Optional[Task]:
+        """Create issue, optionally linked to epic.
+
+        Args:
+            title: Issue title
+            description: Issue description
+            epic_id: Optional parent epic ID
+            **kwargs: Additional adapter-specific fields
+
+        Returns:
+            Created issue or None if failed
+        """
+        task = Task(
+            title=title,
+            description=description,
+            ticket_type=TicketType.ISSUE,
+            parent_epic=epic_id,
+            **{k: v for k, v in kwargs.items() if k in Task.__fields__}
+        )
+        return await self.create(task)
+
+    async def list_issues_by_epic(self, epic_id: str) -> List[Task]:
+        """List all issues in epic.
+
+        Args:
+            epic_id: Epic identifier
+
+        Returns:
+            List of issues belonging to epic
+        """
+        # Default implementation - subclasses should override for efficiency
+        filters = {"parent_epic": epic_id, "ticket_type": TicketType.ISSUE}
+        results = await self.list(filters=filters)
+        return [r for r in results if isinstance(r, Task) and r.is_issue()]
+
+    async def create_task(
+        self,
+        title: str,
+        parent_id: str,
+        description: Optional[str] = None,
+        **kwargs
+    ) -> Optional[Task]:
+        """Create task as sub-ticket of parent issue.
+
+        Args:
+            title: Task title
+            parent_id: Required parent issue ID
+            description: Task description
+            **kwargs: Additional adapter-specific fields
+
+        Returns:
+            Created task or None if failed
+
+        Raises:
+            ValueError: If parent_id is not provided
+        """
+        if not parent_id:
+            raise ValueError("Tasks must have a parent_id (issue)")
+
+        task = Task(
+            title=title,
+            description=description,
+            ticket_type=TicketType.TASK,
+            parent_issue=parent_id,
+            **{k: v for k, v in kwargs.items() if k in Task.__fields__}
+        )
+
+        # Validate hierarchy before creating
+        errors = task.validate_hierarchy()
+        if errors:
+            raise ValueError(f"Invalid task hierarchy: {'; '.join(errors)}")
+
+        return await self.create(task)
+
+    async def list_tasks_by_issue(self, issue_id: str) -> List[Task]:
+        """List all tasks under an issue.
+
+        Args:
+            issue_id: Issue identifier
+
+        Returns:
+            List of tasks belonging to issue
+        """
+        # Default implementation - subclasses should override for efficiency
+        filters = {"parent_issue": issue_id, "ticket_type": TicketType.TASK}
+        results = await self.list(filters=filters)
+        return [r for r in results if isinstance(r, Task) and r.is_task()]
+
     async def close(self) -> None:
         """Close adapter and cleanup resources."""
         pass