mcp-ticketer 0.3.5__py3-none-any.whl → 0.12.0__py3-none-any.whl

mcp_ticketer/cli/discover.py

@@ -1,12 +1,18 @@
 """CLI command for auto-discovering configuration from .env files."""
 
 from pathlib import Path
-from typing import Optional
 
 import typer
 from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
 
 from ..core.env_discovery import DiscoveredAdapter, EnvDiscovery
+from ..core.onepassword_secrets import (
+    OnePasswordConfig,
+    OnePasswordSecretsLoader,
+    check_op_cli_status,
+)
 from ..core.project_config import (
     AdapterConfig,
     ConfigResolver,
@@ -93,7 +99,7 @@ def _display_discovered_adapter(
 
 @app.command()
 def show(
-    project_path: Optional[Path] = typer.Option(
+    project_path: Path | None = typer.Option(
         None,
         "--path",
         "-p",
@@ -148,7 +154,7 @@ def show(
 
 @app.command()
 def save(
-    adapter: Optional[str] = typer.Option(
+    adapter: str | None = typer.Option(
         None, "--adapter", "-a", help="Which adapter to save (defaults to recommended)"
     ),
     global_config: bool = typer.Option(
@@ -157,7 +163,7 @@ def save(
     dry_run: bool = typer.Option(
         False, "--dry-run", help="Show what would be saved without saving"
     ),
-    project_path: Optional[Path] = typer.Option(
+    project_path: Path | None = typer.Option(
         None,
         "--path",
         "-p",
@@ -182,7 +188,7 @@ def save(
         console.print(
             "[dim]Make sure your .env file contains adapter credentials[/dim]"
         )
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     # Determine which adapter to save
     if adapter:
@@ -192,13 +198,13 @@ def save(
             console.print(
                 f"[dim]Available: {', '.join(a.adapter_type for a in result.adapters)}[/dim]"
             )
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
     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)
+            raise typer.Exit(1) from None
 
         console.print(
             f"[bold]Using recommended adapter:[/bold] {discovered_adapter.adapter_type}"
@@ -217,7 +223,7 @@ def save(
         console.print(
             "[dim]Fix the configuration in your .env file and try again[/dim]"
         )
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     if dry_run:
         console.print("\n[yellow]Dry run - no changes made[/yellow]")
@@ -240,14 +246,15 @@ def save(
     # Add to config
     config.adapters[discovered_adapter.adapter_type] = adapter_config
 
-    # Save
+    # Save (always to project config for security)
     try:
+        resolver.save_project_config(config, proj_path)
+        config_location = proj_path / resolver.PROJECT_CONFIG_SUBPATH
+
         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(
+                "[yellow]Note: Global config deprecated for security. Saved to project config instead.[/yellow]"
+            )
 
         console.print(f"\n[green]✅ Configuration saved to:[/green] {config_location}")
         console.print(
@@ -256,12 +263,12 @@ def save(
 
     except Exception as e:
         console.print(f"\n[red]Failed to save configuration:[/red] {e}")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
 
 @app.command()
 def interactive(
-    project_path: Optional[Path] = typer.Option(
+    project_path: Path | None = typer.Option(
         None,
         "--path",
         "-p",
@@ -284,7 +291,7 @@ def interactive(
             console.print(f"  ✅ {env_file}")
     else:
         console.print("[red]No .env files found[/red]")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     # Show discovered adapters
     if not result.adapters:
@@ -292,7 +299,7 @@ def interactive(
         console.print(
             "[dim]Make sure your .env file contains adapter credentials[/dim]"
         )
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     console.print("\n[bold]Detected adapter configurations:[/bold]")
     for i, adapter in enumerate(result.adapters, 1):
@@ -332,7 +339,7 @@ def interactive(
     if choice in [1, 2]:
         if not primary:
             console.print("[red]No recommended adapter found[/red]")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
         adapters_to_save = [primary]
         default_adapter = primary.adapter_type
     elif choice == 3:
@@ -348,7 +355,7 @@ def interactive(
             default_adapter = selected.adapter_type
         else:
             console.print("[red]Invalid choice[/red]")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
     else:  # choice == 4
         adapters_to_save = result.adapters
         default_adapter = (
@@ -389,22 +396,281 @@ def interactive(
 
         console.print(f"  ✅ Added {discovered_adapter.adapter_type}")
 
-    # Save
+    # Save (always to project config for security)
     try:
+        resolver.save_project_config(config, proj_path)
+        config_location = proj_path / resolver.PROJECT_CONFIG_SUBPATH
+
         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(
+                "[yellow]Note: Global config deprecated for security. Saved to project config instead.[/yellow]"
+            )
 
         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) from None
+
+
+@app.command(name="1password-status")
+def onepassword_status() -> None:
+    """Check 1Password CLI installation and authentication status."""
+    console.print(
+        Panel.fit(
+            "[bold cyan]1Password CLI Status[/bold cyan]\n"
+            "Checking 1Password integration...",
+            border_style="cyan",
+        )
+    )
+
+    status = check_op_cli_status()
+
+    # Create status table
+    table = Table(title="1Password CLI Status")
+    table.add_column("Component", style="cyan")
+    table.add_column("Status", style="white")
+
+    # CLI installed
+    if status["installed"]:
+        table.add_row(
+            "CLI Installed", f"[green]✓ Yes[/green] (version {status['version']})"
+        )
+    else:
+        table.add_row("CLI Installed", "[red]✗ No[/red]")
+        console.print(table)
+        console.print(
+            "\n[yellow]Install 1Password CLI:[/yellow]\n"
+            "  macOS: brew install 1password-cli\n"
+            "  Linux: See https://developer.1password.com/docs/cli/get-started/\n"
+            "  Windows: See https://developer.1password.com/docs/cli/get-started/"
+        )
+        return
+
+    # Authentication
+    if status["authenticated"]:
+        table.add_row("Authentication", "[green]✓ Signed in[/green]")
+
+        # Show accounts
+        if status["accounts"]:
+            for account in status["accounts"]:
+                account_url = account.get("url", "N/A")
+                account_email = account.get("email", "N/A")
+                table.add_row("  Account", f"{account_email} ({account_url})")
+    else:
+        table.add_row("Authentication", "[yellow]⚠ Not signed in[/yellow]")
+
+    console.print(table)
+
+    if not status["authenticated"]:
+        console.print("\n[yellow]Sign in to 1Password:[/yellow]\n" "  Run: op signin\n")
+    else:
+        console.print(
+            "\n[green]✓ 1Password CLI is ready to use![/green]\n\n"
+            "You can now use .env files with op:// secret references.\n"
+            "Run 'mcp-ticketer discover 1password-template' to create template files."
+        )
+
+
+@app.command(name="1password-template")
+def onepassword_template(
+    adapter: str = typer.Argument(
+        ...,
+        help="Adapter type (linear, github, jira, aitrackdown)",
+    ),
+    vault: str = typer.Option(
+        "Development",
+        "--vault",
+        "-v",
+        help="1Password vault name for secret references",
+    ),
+    item: str | None = typer.Option(
+        None,
+        "--item",
+        "-i",
+        help="1Password item name (defaults to adapter name)",
+    ),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (defaults to .env.1password)",
+    ),
+) -> None:
+    """Create a .env template file with 1Password secret references.
+
+    This creates a template file that uses op:// secret references,
+    which can be used with: op run --env-file=.env.1password -- <command>
+
+    Examples:
+        # Create Linear template
+        mcp-ticketer discover 1password-template linear
+
+        # Create GitHub template with custom vault
+        mcp-ticketer discover 1password-template github --vault=Production
+
+        # Create template with custom item name
+        mcp-ticketer discover 1password-template jira --item="JIRA API Keys"
+
+    """
+    # Check if op CLI is available
+    status = check_op_cli_status()
+    if not status["installed"]:
+        console.print(
+            "[red]1Password CLI not installed.[/red]\n\n"
+            "Install it first:\n"
+            "  macOS: brew install 1password-cli\n"
+            "  Other: https://developer.1password.com/docs/cli/get-started/"
+        )
         raise typer.Exit(1)
 
+    # Set default output path
+    if output is None:
+        output = Path(f".env.1password.{adapter.lower()}")
+
+    # Create loader and generate template
+    loader = OnePasswordSecretsLoader(OnePasswordConfig())
+    loader.create_template_file(output, adapter, vault, item)
+
+    console.print(
+        Panel.fit(
+            f"[bold green]✓ Template created![/bold green]\n\n"
+            f"File: {output}\n"
+            f"Vault: {vault}\n"
+            f"Item: {item or adapter.upper()}\n\n"
+            f"[bold]Next steps:[/bold]\n"
+            f"1. Create item '{item or adapter.upper()}' in 1Password vault '{vault}'\n"
+            f"2. Add the required fields to the item\n"
+            f"3. Test with: op run --env-file={output} -- mcp-ticketer discover show\n"
+            f"4. Save config: op run --env-file={output} -- mcp-ticketer discover save",
+            border_style="green",
+        )
+    )
+
+    # Show template contents
+    console.print("\n[bold]Template contents:[/bold]\n")
+    console.print(Panel(output.read_text(), border_style="dim"))
+
+
+@app.command(name="1password-test")
+def onepassword_test(
+    env_file: Path = typer.Option(
+        ".env.1password",
+        "--file",
+        "-f",
+        help="Path to .env file with op:// references",
+    ),
+) -> None:
+    """Test 1Password secret resolution from .env file.
+
+    This command loads secrets from the specified .env file and
+    displays the resolved values (with sensitive data masked).
+
+    Example:
+        mcp-ticketer discover 1password-test --file=.env.1password.linear
+
+    """
+    # Check if file exists
+    if not env_file.exists():
+        console.print(f"[red]File not found:[/red] {env_file}")
+        raise typer.Exit(1)
+
+    # Check if op CLI is available and authenticated
+    status = check_op_cli_status()
+    if not status["installed"]:
+        console.print("[red]1Password CLI not installed.[/red]")
+        raise typer.Exit(1)
+
+    if not status["authenticated"]:
+        console.print(
+            "[red]1Password CLI not authenticated.[/red]\n\n" "Run: op signin"
+        )
+        raise typer.Exit(1)
+
+    console.print(
+        Panel.fit(
+            f"[bold cyan]Testing 1Password Secret Resolution[/bold cyan]\n"
+            f"File: {env_file}",
+            border_style="cyan",
+        )
+    )
+
+    # Load secrets
+    loader = OnePasswordSecretsLoader(OnePasswordConfig())
+
+    try:
+        secrets = loader.load_secrets_from_env_file(env_file)
+
+        # Display resolved secrets
+        table = Table(title="Resolved Secrets")
+        table.add_column("Variable", style="cyan")
+        table.add_column("Value", style="green")
+
+        for key, value in secrets.items():
+            # Mask sensitive values
+            display_value = _mask_sensitive(value, key)
+            table.add_row(key, display_value)
+
+        console.print(table)
+
+        console.print(
+            f"\n[green]✓ Successfully resolved {len(secrets)} secrets![/green]"
+        )
+
+        # Test discovery with these secrets
+        console.print("\n[bold]Testing configuration discovery...[/bold]")
+        EnvDiscovery(enable_1password=False)  # Already resolved
+
+        # Temporarily write resolved secrets to test discovery
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".env", delete=False) as tmp:
+            for key, value in secrets.items():
+                tmp.write(f"{key}={value}\n")
+            tmp_path = Path(tmp.name)
+
+        try:
+            # Mock the env file loading by directly providing secrets
+            from ..core.env_discovery import DiscoveryResult
+
+            DiscoveryResult()
+
+            # Try to detect adapters from the resolved secrets
+            from ..core.env_discovery import EnvDiscovery as ED
+
+            ed = ED(enable_1password=False)
+            ed.project_path = Path.cwd()
+
+            # Manually detect from secrets dict
+            linear_adapter = ed._detect_linear(secrets, str(env_file))
+            if linear_adapter:
+                console.print("\n[green]✓ Detected Linear configuration[/green]")
+                _display_discovered_adapter(linear_adapter, ed)
+
+            github_adapter = ed._detect_github(secrets, str(env_file))
+            if github_adapter:
+                console.print("\n[green]✓ Detected GitHub configuration[/green]")
+                _display_discovered_adapter(github_adapter, ed)
+
+            jira_adapter = ed._detect_jira(secrets, str(env_file))
+            if jira_adapter:
+                console.print("\n[green]✓ Detected JIRA configuration[/green]")
+                _display_discovered_adapter(jira_adapter, ed)
+        finally:
+            tmp_path.unlink()
+
+    except Exception as e:
+        console.print(f"\n[red]Failed to resolve secrets:[/red] {e}")
+        console.print(
+            "\n[yellow]Troubleshooting:[/yellow]\n"
+            "1. Check that the item exists in 1Password\n"
+            "2. Verify the vault name is correct\n"
+            "3. Ensure all field names match\n"
+            f"4. Run: op inject --in-file={env_file} (to see detailed errors)"
+        )
+        raise typer.Exit(1) from None
+
 
 if __name__ == "__main__":
     app()

mcp_ticketer/cli/gemini_configure.py

@@ -2,11 +2,12 @@
 
 import json
 from pathlib import Path
-from typing import Literal, Optional
+from typing import Literal
 
 from rich.console import Console
 
-from .mcp_configure import find_mcp_ticketer_binary, load_project_config
+from .mcp_configure import load_project_config
+from .python_detection import get_mcp_ticketer_python
 
 console = Console()
 
@@ -73,19 +74,21 @@ def save_gemini_config(config_path: Path, config: dict) -> None:
 
 
 def create_gemini_server_config(
-    binary_path: str, project_config: dict, cwd: Optional[str] = None
+    python_path: str, project_config: dict, project_path: str | None = None
 ) -> dict:
     """Create Gemini MCP server configuration for mcp-ticketer.
 
     Args:
-        binary_path: Path to mcp-ticketer binary
+        python_path: Path to Python executable in mcp-ticketer venv
         project_config: Project configuration from .mcp-ticketer/config.json
-        cwd: Working directory for server (optional)
+        project_path: Project directory path (optional)
 
     Returns:
         Gemini MCP server configuration dict
 
     """
+    # Use Python module invocation pattern (works regardless of where package is installed)
+
     # Get adapter configuration
     adapter = project_config.get("default_adapter", "aitrackdown")
     adapters_config = project_config.get("adapters", {})
@@ -94,9 +97,9 @@ def create_gemini_server_config(
     # Build environment variables
     env_vars = {}
 
-    # Add PYTHONPATH if running from development environment
-    if cwd:
-        env_vars["PYTHONPATH"] = str(Path(cwd) / "src")
+    # Add PYTHONPATH for project context
+    if project_path:
+        env_vars["PYTHONPATH"] = project_path
 
     # Add adapter type
     env_vars["MCP_TICKETER_ADAPTER"] = adapter
@@ -105,9 +108,9 @@ def create_gemini_server_config(
     if adapter == "aitrackdown":
         # Set base path for local adapter
         base_path = adapter_config.get("base_path", ".aitrackdown")
-        if cwd:
-            # Use absolute path if cwd is provided
-            env_vars["MCP_TICKETER_BASE_PATH"] = str(Path(cwd) / base_path)
+        if project_path:
+            # Use absolute path if project_path is provided
+            env_vars["MCP_TICKETER_BASE_PATH"] = str(Path(project_path) / base_path)
         else:
             env_vars["MCP_TICKETER_BASE_PATH"] = base_path
 
@@ -135,10 +138,15 @@ def create_gemini_server_config(
         if "project_key" in adapter_config:
             env_vars["JIRA_PROJECT_KEY"] = adapter_config["project_key"]
 
+    # Use Python module invocation pattern
+    args = ["-m", "mcp_ticketer.mcp.server"]
+    if project_path:
+        args.append(project_path)
+
     # Create server configuration with Gemini-specific options
     config = {
-        "command": binary_path,
-        "args": ["serve"],
+        "command": python_path,
+        "args": args,
         "env": env_vars,
         "timeout": 15000,  # 15 seconds timeout
         "trust": False,  # Don't trust by default (security)
@@ -147,6 +155,72 @@ def create_gemini_server_config(
     return config
 
 
+def remove_gemini_mcp(
+    scope: Literal["project", "user"] = "project", dry_run: bool = False
+) -> None:
+    """Remove mcp-ticketer from Gemini CLI configuration.
+
+    Args:
+        scope: Configuration scope - "project" or "user"
+        dry_run: Show what would be removed without making changes
+
+    """
+    # Step 1: Find Gemini config location
+    config_type = "user-level" if scope == "user" else "project-level"
+    console.print(f"[cyan]🔍 Removing {config_type} Gemini CLI configuration...[/cyan]")
+
+    gemini_config_path = find_gemini_config(scope)
+    console.print(f"[dim]Config location: {gemini_config_path}[/dim]")
+
+    # Step 2: Check if config file exists
+    if not gemini_config_path.exists():
+        console.print(
+            f"[yellow]⚠ No configuration found at {gemini_config_path}[/yellow]"
+        )
+        console.print("[dim]mcp-ticketer is not configured for Gemini CLI[/dim]")
+        return
+
+    # Step 3: Load existing Gemini configuration
+    gemini_config = load_gemini_config(gemini_config_path)
+
+    # Step 4: Check if mcp-ticketer is configured
+    if "mcp-ticketer" not in gemini_config.get("mcpServers", {}):
+        console.print("[yellow]⚠ mcp-ticketer is not configured[/yellow]")
+        console.print(f"[dim]No mcp-ticketer entry found in {gemini_config_path}[/dim]")
+        return
+
+    # Step 5: Show what would be removed (dry run or actual removal)
+    if dry_run:
+        console.print("\n[cyan]DRY RUN - Would remove:[/cyan]")
+        console.print("  Server name: mcp-ticketer")
+        console.print(f"  From: {gemini_config_path}")
+        console.print(f"  Scope: {config_type}")
+        return
+
+    # Step 6: Remove mcp-ticketer from configuration
+    del gemini_config["mcpServers"]["mcp-ticketer"]
+
+    # Step 7: Save updated configuration
+    try:
+        save_gemini_config(gemini_config_path, gemini_config)
+        console.print("\n[green]✓ Successfully removed mcp-ticketer[/green]")
+        console.print(f"[dim]Configuration updated: {gemini_config_path}[/dim]")
+
+        # Next steps
+        console.print("\n[bold cyan]Next Steps:[/bold cyan]")
+        if scope == "user":
+            console.print("1. Gemini CLI global configuration updated")
+            console.print("2. mcp-ticketer will no longer be available in any project")
+        else:
+            console.print("1. Gemini CLI project configuration updated")
+            console.print("2. mcp-ticketer will no longer be available in this project")
+        console.print("3. Restart Gemini CLI if currently running")
+
+    except Exception as e:
+        console.print(f"\n[red]✗ Failed to update configuration:[/red] {e}")
+        raise
+
+
 def configure_gemini_mcp(
     scope: Literal["project", "user"] = "project", force: bool = False
 ) -> None:
@@ -157,18 +231,22 @@ def configure_gemini_mcp(
         force: Overwrite existing configuration
 
     Raises:
-        FileNotFoundError: If binary or project config not found
+        FileNotFoundError: If Python executable or project config not found
         ValueError: If configuration is invalid
 
     """
-    # Step 1: Find mcp-ticketer binary
-    console.print("[cyan]🔍 Finding mcp-ticketer binary...[/cyan]")
+    # Step 1: Find Python executable
+    console.print("[cyan]🔍 Finding mcp-ticketer Python executable...[/cyan]")
     try:
-        binary_path = find_mcp_ticketer_binary()
-        console.print(f"[green]✓[/green] Found: {binary_path}")
-    except FileNotFoundError as e:
-        console.print(f"[red]✗[/red] {e}")
-        raise
+        python_path = get_mcp_ticketer_python()
+        console.print(f"[green]✓[/green] Found: {python_path}")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Could not find Python executable: {e}")
+        raise FileNotFoundError(
+            "Could not find mcp-ticketer Python executable. "
+            "Please ensure mcp-ticketer is installed.\n"
+            "Install with: pip install mcp-ticketer or pipx install mcp-ticketer"
+        ) from e
 
     # Step 2: Load project configuration
     console.print("\n[cyan]📖 Reading project configuration...[/cyan]")
@@ -200,9 +278,11 @@ def configure_gemini_mcp(
             console.print("[yellow]⚠ Overwriting existing configuration[/yellow]")
 
     # Step 6: Create mcp-ticketer server config
-    cwd = str(Path.cwd()) if scope == "project" else None
+    project_path = str(Path.cwd()) if scope == "project" else None
     server_config = create_gemini_server_config(
-        binary_path=binary_path, project_config=project_config, cwd=cwd
+        python_path=python_path,
+        project_config=project_config,
+        project_path=project_path,
     )
 
     # Step 7: Update Gemini configuration
@@ -221,11 +301,12 @@ def configure_gemini_mcp(
         console.print("\n[bold]Configuration Details:[/bold]")
         console.print("  Server name: mcp-ticketer")
         console.print(f"  Adapter: {adapter}")
-        console.print(f"  Binary: {binary_path}")
+        console.print(f"  Python: {python_path}")
+        console.print("  Command: python -m mcp_ticketer.mcp.server")
         console.print(f"  Timeout: {server_config['timeout']}ms")
         console.print(f"  Trust: {server_config['trust']}")
-        if cwd:
-            console.print(f"  Working directory: {cwd}")
+        if project_path:
+            console.print(f"  Project path: {project_path}")
         if "env" in server_config:
             console.print(
                 f"  Environment variables: {list(server_config['env'].keys())}"