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

mcp_ticketer/cli/mcp_configure.py

@@ -2,63 +2,43 @@
 
 import json
 import os
-import shutil
 import sys
 from pathlib import Path
-from typing import Optional
 
 from rich.console import Console
 
+from .python_detection import get_mcp_ticketer_python
+
 console = Console()
 
 
-def find_mcp_ticketer_binary() -> str:
-    """Find the mcp-ticketer binary path.
+def load_env_file(env_path: Path) -> dict[str, str]:
+    """Load environment variables from .env file.
 
-    Returns:
-        Path to mcp-ticketer binary
+    Args:
+        env_path: Path to .env file
 
-    Raises:
-        FileNotFoundError: If binary not found
+    Returns:
+        Dict of environment variable key-value pairs
 
     """
-    # Check if running from development environment
-    import mcp_ticketer
-
-    package_path = Path(mcp_ticketer.__file__).parent.parent.parent
-
-    # Check for virtual environment bin
-    possible_paths = [
-        # Development paths
-        package_path / "venv" / "bin" / "mcp-ticketer",
-        package_path / ".venv" / "bin" / "mcp-ticketer",
-        package_path / "test_venv" / "bin" / "mcp-ticketer",
-        # System installation
-        Path.home() / ".local" / "bin" / "mcp-ticketer",
-        # pipx installation
-        Path.home()
-        / ".local"
-        / "pipx"
-        / "venvs"
-        / "mcp-ticketer"
-        / "bin"
-        / "mcp-ticketer",
-    ]
-
-    # Check PATH
-    which_result = shutil.which("mcp-ticketer")
-    if which_result:
-        return which_result
-
-    # Check possible paths
-    for path in possible_paths:
-        if path.exists():
-            return str(path.resolve())
-
-    raise FileNotFoundError(
-        "Could not find mcp-ticketer binary. Please ensure mcp-ticketer is installed.\n"
-        "Install with: pip install mcp-ticketer"
-    )
+    env_vars = {}
+    if not env_path.exists():
+        return env_vars
+
+    with open(env_path) as f:
+        for line in f:
+            line = line.strip()
+            # Skip comments and empty lines
+            if not line or line.startswith("#"):
+                continue
+
+            # Parse KEY=VALUE format
+            if "=" in line:
+                key, value = line.split("=", 1)
+                env_vars[key.strip()] = value.strip()
+
+    return env_vars
 
 
 def load_project_config() -> dict:
@@ -127,28 +107,44 @@ def find_claude_mcp_config(global_config: bool = False) -> Path:
                 Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
             )
     else:
-        # Project-level configuration
-        config_path = Path.cwd() / ".mcp" / "config.json"
+        # Claude Code configuration (project-specific)
+        config_path = Path.home() / ".claude.json"
 
     return config_path
 
 
-def load_claude_mcp_config(config_path: Path) -> dict:
+def load_claude_mcp_config(config_path: Path, is_claude_code: bool = False) -> dict:
     """Load existing Claude MCP configuration or return empty structure.
 
     Args:
         config_path: Path to MCP config file
+        is_claude_code: If True, return Claude Code structure with projects
 
     Returns:
         MCP configuration dict
 
     """
     if config_path.exists():
-        with open(config_path) as f:
-            return json.load(f)
+        try:
+            with open(config_path) as f:
+                content = f.read().strip()
+                if not content:
+                    # Empty file, return default structure
+                    return {"projects": {}} if is_claude_code else {"mcpServers": {}}
+                return json.loads(content)
+        except json.JSONDecodeError as e:
+            console.print(
+                f"[yellow]⚠ Warning: Invalid JSON in {config_path}, creating new config[/yellow]"
+            )
+            console.print(f"[dim]Error: {e}[/dim]")
+            # Return default structure on parse error
+            return {"projects": {}} if is_claude_code else {"mcpServers": {}}
 
-    # Return empty structure
-    return {"mcpServers": {}}
+    # Return empty structure based on config type
+    if is_claude_code:
+        return {"projects": {}}
+    else:
+        return {"mcpServers": {}}
 
 
 def save_claude_mcp_config(config_path: Path, config: dict) -> None:
@@ -168,28 +164,33 @@ def save_claude_mcp_config(config_path: Path, config: dict) -> None:
 
 
 def create_mcp_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 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:
-        MCP server configuration dict
+        MCP server configuration dict matching Claude Code stdio pattern
 
     """
+    # Use Python module invocation pattern (works regardless of where package is installed)
+    args = ["-m", "mcp_ticketer.mcp.server"]
+
+    # Add project path if provided
+    if project_path:
+        args.append(project_path)
+
+    # REQUIRED: Add "type": "stdio" for Claude Code compatibility
     config = {
-        "command": binary_path,
-        "args": ["serve"],  # Use 'serve' command to start MCP server
+        "type": "stdio",
+        "command": python_path,
+        "args": args,
     }
 
-    # Add working directory if provided
-    if cwd:
-        config["cwd"] = cwd
-
     # Add environment variables based on adapter
     adapter = project_config.get("default_adapter", "aitrackdown")
     adapters_config = project_config.get("adapters", {})
@@ -197,15 +198,49 @@ def create_mcp_server_config(
 
     env_vars = {}
 
-    # Add adapter-specific environment variables
+    # Add PYTHONPATH for project context
+    if project_path:
+        env_vars["PYTHONPATH"] = project_path
+
+    # Add MCP_TICKETER_ADAPTER to identify which adapter to use
+    env_vars["MCP_TICKETER_ADAPTER"] = adapter
+
+    # Load environment variables from .env.local if it exists
+    if project_path:
+        env_file_path = Path(project_path) / ".env.local"
+        env_file_vars = load_env_file(env_file_path)
+
+        # Add relevant adapter-specific vars from .env.local
+        adapter_env_keys = {
+            "linear": ["LINEAR_API_KEY", "LINEAR_TEAM_ID", "LINEAR_TEAM_KEY"],
+            "github": ["GITHUB_TOKEN", "GITHUB_OWNER", "GITHUB_REPO"],
+            "jira": [
+                "JIRA_ACCESS_USER",
+                "JIRA_ACCESS_TOKEN",
+                "JIRA_ORGANIZATION_ID",
+                "JIRA_URL",
+                "JIRA_EMAIL",
+                "JIRA_API_TOKEN",
+            ],
+            "aitrackdown": [],  # No specific env vars needed
+        }
+
+        # Include adapter-specific env vars from .env.local
+        for key in adapter_env_keys.get(adapter, []):
+            if key in env_file_vars:
+                env_vars[key] = env_file_vars[key]
+
+    # Fallback: Add adapter-specific environment variables from project config
     if adapter == "linear" and "api_key" in adapter_config:
-        env_vars["LINEAR_API_KEY"] = adapter_config["api_key"]
+        if "LINEAR_API_KEY" not in env_vars:
+            env_vars["LINEAR_API_KEY"] = adapter_config["api_key"]
     elif adapter == "github" and "token" in adapter_config:
-        env_vars["GITHUB_TOKEN"] = adapter_config["token"]
+        if "GITHUB_TOKEN" not in env_vars:
+            env_vars["GITHUB_TOKEN"] = adapter_config["token"]
     elif adapter == "jira":
-        if "api_token" in adapter_config:
+        if "api_token" in adapter_config and "JIRA_API_TOKEN" not in env_vars:
             env_vars["JIRA_API_TOKEN"] = adapter_config["api_token"]
-        if "email" in adapter_config:
+        if "email" in adapter_config and "JIRA_EMAIL" not in env_vars:
             env_vars["JIRA_EMAIL"] = adapter_config["email"]
 
     if env_vars:
@@ -214,6 +249,108 @@ def create_mcp_server_config(
     return config
 
 
+def remove_claude_mcp(global_config: bool = False, dry_run: bool = False) -> None:
+    """Remove mcp-ticketer from Claude Code/Desktop configuration.
+
+    Args:
+        global_config: Remove from Claude Desktop instead of project-level
+        dry_run: Show what would be removed without making changes
+
+    """
+    # Step 1: Find Claude MCP config location
+    config_type = "Claude Desktop" if global_config else "Claude Code"
+    console.print(f"[cyan]🔍 Removing {config_type} MCP configuration...[/cyan]")
+
+    mcp_config_path = find_claude_mcp_config(global_config)
+    console.print(f"[dim]Primary config: {mcp_config_path}[/dim]")
+
+    # Get absolute project path for Claude Code
+    absolute_project_path = str(Path.cwd().resolve()) if not global_config else None
+
+    # Step 2: Check if config file exists
+    if not mcp_config_path.exists():
+        console.print(f"[yellow]⚠ No configuration found at {mcp_config_path}[/yellow]")
+        console.print("[dim]mcp-ticketer is not configured for this platform[/dim]")
+        return
+
+    # Step 3: Load existing MCP configuration
+    is_claude_code = not global_config
+    mcp_config = load_claude_mcp_config(mcp_config_path, is_claude_code=is_claude_code)
+
+    # Step 4: Check if mcp-ticketer is configured
+    is_configured = False
+    if is_claude_code:
+        # Check Claude Code structure: .projects[path].mcpServers["mcp-ticketer"]
+        if absolute_project_path:
+            projects = mcp_config.get("projects", {})
+            project_config_entry = projects.get(absolute_project_path, {})
+            is_configured = "mcp-ticketer" in project_config_entry.get("mcpServers", {})
+    else:
+        # Check Claude Desktop structure: .mcpServers["mcp-ticketer"]
+        is_configured = "mcp-ticketer" in mcp_config.get("mcpServers", {})
+
+    if not is_configured:
+        console.print("[yellow]⚠ mcp-ticketer is not configured[/yellow]")
+        console.print(f"[dim]No mcp-ticketer entry found in {mcp_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: {mcp_config_path}")
+        if absolute_project_path:
+            console.print(f"  Project: {absolute_project_path}")
+        return
+
+    # Step 6: Remove mcp-ticketer from configuration
+    if is_claude_code and absolute_project_path:
+        # Remove from Claude Code structure
+        del mcp_config["projects"][absolute_project_path]["mcpServers"]["mcp-ticketer"]
+
+        # Clean up empty structures
+        if not mcp_config["projects"][absolute_project_path]["mcpServers"]:
+            del mcp_config["projects"][absolute_project_path]["mcpServers"]
+        if not mcp_config["projects"][absolute_project_path]:
+            del mcp_config["projects"][absolute_project_path]
+
+        # Also remove from legacy location if it exists
+        legacy_config_path = Path.cwd() / ".claude" / "mcp.local.json"
+        if legacy_config_path.exists():
+            try:
+                legacy_config = load_claude_mcp_config(
+                    legacy_config_path, is_claude_code=False
+                )
+                if "mcp-ticketer" in legacy_config.get("mcpServers", {}):
+                    del legacy_config["mcpServers"]["mcp-ticketer"]
+                    save_claude_mcp_config(legacy_config_path, legacy_config)
+                    console.print("[dim]✓ Removed from legacy config as well[/dim]")
+            except Exception as e:
+                console.print(f"[dim]⚠ Could not remove from legacy config: {e}[/dim]")
+    else:
+        # Remove from Claude Desktop structure
+        del mcp_config["mcpServers"]["mcp-ticketer"]
+
+    # Step 7: Save updated configuration
+    try:
+        save_claude_mcp_config(mcp_config_path, mcp_config)
+        console.print("\n[green]✓ Successfully removed mcp-ticketer[/green]")
+        console.print(f"[dim]Configuration updated: {mcp_config_path}[/dim]")
+
+        # Next steps
+        console.print("\n[bold cyan]Next Steps:[/bold cyan]")
+        if global_config:
+            console.print("1. Restart Claude Desktop")
+            console.print("2. mcp-ticketer will no longer be available in MCP menu")
+        else:
+            console.print("1. Restart Claude Code")
+            console.print("2. mcp-ticketer will no longer be available in this project")
+
+    except Exception as e:
+        console.print(f"\n[red]✗ Failed to update configuration:[/red] {e}")
+        raise
+
+
 def configure_claude_mcp(global_config: bool = False, force: bool = False) -> None:
     """Configure Claude Code to use mcp-ticketer.
 
@@ -222,18 +359,31 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
         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]")
+    # Determine project path for venv detection
+    project_path = Path.cwd() if not global_config else None
+
+    # Step 1: Find Python executable (project-specific if available)
+    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(project_path=project_path)
+        console.print(f"[green]✓[/green] Found: {python_path}")
+
+        # Show if using project venv or fallback
+        if project_path and str(project_path / ".venv") in python_path:
+            console.print("[dim]Using project-specific venv[/dim]")
+        else:
+            console.print("[dim]Using pipx/system Python[/dim]")
+    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]")
@@ -246,17 +396,34 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
         raise
 
     # Step 3: Find Claude MCP config location
-    config_type = "Claude Desktop" if global_config else "project-level"
+    config_type = "Claude Desktop" if global_config else "Claude Code"
     console.print(f"\n[cyan]🔧 Configuring {config_type} MCP...[/cyan]")
 
     mcp_config_path = find_claude_mcp_config(global_config)
-    console.print(f"[dim]Config location: {mcp_config_path}[/dim]")
+    console.print(f"[dim]Primary config: {mcp_config_path}[/dim]")
+
+    # Get absolute project path for Claude Code
+    absolute_project_path = str(Path.cwd().resolve()) if not global_config else None
 
     # Step 4: Load existing MCP configuration
-    mcp_config = load_claude_mcp_config(mcp_config_path)
+    is_claude_code = not global_config
+    mcp_config = load_claude_mcp_config(mcp_config_path, is_claude_code=is_claude_code)
 
     # Step 5: Check if mcp-ticketer already configured
-    if "mcp-ticketer" in mcp_config.get("mcpServers", {}):
+    already_configured = False
+    if is_claude_code:
+        # Check Claude Code structure: .projects[path].mcpServers["mcp-ticketer"]
+        if absolute_project_path:
+            projects = mcp_config.get("projects", {})
+            project_config_entry = projects.get(absolute_project_path, {})
+            already_configured = "mcp-ticketer" in project_config_entry.get(
+                "mcpServers", {}
+            )
+    else:
+        # Check Claude Desktop structure: .mcpServers["mcp-ticketer"]
+        already_configured = "mcp-ticketer" in mcp_config.get("mcpServers", {})
+
+    if already_configured:
         if not force:
             console.print("[yellow]⚠ mcp-ticketer is already configured[/yellow]")
             console.print("[dim]Use --force to overwrite existing configuration[/dim]")
@@ -265,16 +432,55 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
             console.print("[yellow]⚠ Overwriting existing configuration[/yellow]")
 
     # Step 6: Create mcp-ticketer server config
-    cwd = str(Path.cwd()) if not global_config else None
     server_config = create_mcp_server_config(
-        binary_path=binary_path, project_config=project_config, cwd=cwd
+        python_path=python_path,
+        project_config=project_config,
+        project_path=absolute_project_path,
     )
 
-    # Step 7: Update MCP configuration
-    if "mcpServers" not in mcp_config:
-        mcp_config["mcpServers"] = {}
-
-    mcp_config["mcpServers"]["mcp-ticketer"] = server_config
+    # Step 7: Update MCP configuration based on platform
+    if is_claude_code:
+        # Claude Code: Write to ~/.claude.json with project-specific path
+        if absolute_project_path:
+            # Ensure projects structure exists
+            if "projects" not in mcp_config:
+                mcp_config["projects"] = {}
+
+            # Ensure project entry exists
+            if absolute_project_path not in mcp_config["projects"]:
+                mcp_config["projects"][absolute_project_path] = {}
+
+            # Ensure mcpServers for this project exists
+            if "mcpServers" not in mcp_config["projects"][absolute_project_path]:
+                mcp_config["projects"][absolute_project_path]["mcpServers"] = {}
+
+            # Add mcp-ticketer configuration
+            mcp_config["projects"][absolute_project_path]["mcpServers"][
+                "mcp-ticketer"
+            ] = server_config
+
+            # Also write to backward-compatible location for older Claude Code versions
+            legacy_config_path = Path.cwd() / ".claude" / "mcp.local.json"
+            console.print(f"[dim]Legacy config: {legacy_config_path}[/dim]")
+
+            try:
+                legacy_config = load_claude_mcp_config(
+                    legacy_config_path, is_claude_code=False
+                )
+                if "mcpServers" not in legacy_config:
+                    legacy_config["mcpServers"] = {}
+                legacy_config["mcpServers"]["mcp-ticketer"] = server_config
+                save_claude_mcp_config(legacy_config_path, legacy_config)
+                console.print("[dim]✓ Backward-compatible config also written[/dim]")
+            except Exception as e:
+                console.print(
+                    f"[dim]⚠ Could not write legacy config (non-fatal): {e}[/dim]"
+                )
+    else:
+        # Claude Desktop: Write to platform-specific config
+        if "mcpServers" not in mcp_config:
+            mcp_config["mcpServers"] = {}
+        mcp_config["mcpServers"]["mcp-ticketer"] = server_config
 
     # Step 8: Save configuration
     try:
@@ -286,9 +492,10 @@ def configure_claude_mcp(global_config: bool = False, force: bool = False) -> No
         console.print("\n[bold]Configuration Details:[/bold]")
         console.print("  Server name: mcp-ticketer")
         console.print(f"  Adapter: {adapter}")
-        console.print(f"  Binary: {binary_path}")
-        if cwd:
-            console.print(f"  Working directory: {cwd}")
+        console.print(f"  Python: {python_path}")
+        console.print("  Command: python -m mcp_ticketer.mcp.server")
+        if absolute_project_path:
+            console.print(f"  Project path: {absolute_project_path}")
         if "env" in server_config:
             console.print(
                 f"  Environment variables: {list(server_config['env'].keys())}"

mcp_ticketer/cli/migrate_config.py

@@ -22,14 +22,17 @@ def migrate_config_command(dry_run: bool = False) -> None:
     """
     resolver = ConfigResolver()
 
+    # Get project config path (project-local only for security)
+    project_config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
+
     # Check if old config exists
-    if not resolver.GLOBAL_CONFIG_PATH.exists():
+    if not project_config_path.exists():
         console.print("[yellow]No configuration found to migrate[/yellow]")
         return
 
     # Load old config
     try:
-        with open(resolver.GLOBAL_CONFIG_PATH) as f:
+        with open(project_config_path) as f:
             old_config = json.load(f)
     except Exception as e:
         console.print(f"[red]Failed to load config: {e}[/red]")
@@ -71,22 +74,23 @@ def migrate_config_command(dry_run: bool = False) -> None:
         return
 
     # Backup old config
-    backup_path = resolver.GLOBAL_CONFIG_PATH.with_suffix(".json.bak")
+    project_config_path = resolver.project_path / resolver.PROJECT_CONFIG_SUBPATH
+    backup_path = project_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"
+    backup_path = project_config_path.parent / f"config.{timestamp}.bak"
 
     try:
-        shutil.copy(resolver.GLOBAL_CONFIG_PATH, backup_path)
+        shutil.copy(project_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
+    # Save new config (to project-local config)
     try:
-        resolver.save_global_config(new_config)
+        resolver.save_project_config(new_config)
         console.print("[green]✓[/green] Migration complete!")
-        console.print(f"[dim]New config saved to: {resolver.GLOBAL_CONFIG_PATH}[/dim]")
+        console.print(f"[dim]New config saved to: {project_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]")

mcp_ticketer/cli/platform_commands.py

@@ -0,0 +1,123 @@
+"""Platform-specific command groups."""
+
+import typer
+
+# Import platform-specific command modules
+from .linear_commands import app as linear_app
+
+# Create main platform command group
+app = typer.Typer(
+    name="platform",
+    help="Platform-specific commands (Linear, JIRA, GitHub, AITrackdown)",
+)
+
+# Register Linear commands
+app.add_typer(linear_app, name="linear")
+
+# Create placeholder apps for other platforms
+
+# JIRA platform commands (placeholder)
+jira_app = typer.Typer(
+    name="jira",
+    help="JIRA-specific workspace and project management",
+)
+
+
+@jira_app.command("projects")
+def jira_list_projects() -> None:
+    """List JIRA projects (placeholder - not yet implemented)."""
+    from rich.console import Console
+
+    console = Console()
+    console.print("[yellow]JIRA platform commands are not yet implemented.[/yellow]")
+    console.print(
+        "Use the generic ticket commands for JIRA operations:\n"
+        "  mcp-ticketer ticket create 'My ticket'\n"
+        "  mcp-ticketer ticket list"
+    )
+
+
+@jira_app.command("configure")
+def jira_configure() -> None:
+    """Configure JIRA adapter (placeholder - not yet implemented)."""
+    from rich.console import Console
+
+    console = Console()
+    console.print("[yellow]JIRA platform commands are not yet implemented.[/yellow]")
+    console.print("Use 'mcp-ticketer init --adapter jira' to configure JIRA adapter.")
+
+
+# GitHub platform commands (placeholder)
+github_app = typer.Typer(
+    name="github",
+    help="GitHub-specific repository and issue management",
+)
+
+
+@github_app.command("repos")
+def github_list_repos() -> None:
+    """List GitHub repositories (placeholder - not yet implemented)."""
+    from rich.console import Console
+
+    console = Console()
+    console.print("[yellow]GitHub platform commands are not yet implemented.[/yellow]")
+    console.print(
+        "Use the generic ticket commands for GitHub operations:\n"
+        "  mcp-ticketer ticket create 'My issue'\n"
+        "  mcp-ticketer ticket list"
+    )
+
+
+@github_app.command("configure")
+def github_configure() -> None:
+    """Configure GitHub adapter (placeholder - not yet implemented)."""
+    from rich.console import Console
+
+    console = Console()
+    console.print("[yellow]GitHub platform commands are not yet implemented.[/yellow]")
+    console.print(
+        "Use 'mcp-ticketer init --adapter github' to configure GitHub adapter."
+    )
+
+
+# AITrackdown platform commands (placeholder)
+aitrackdown_app = typer.Typer(
+    name="aitrackdown",
+    help="AITrackdown-specific local file management",
+)
+
+
+@aitrackdown_app.command("info")
+def aitrackdown_info() -> None:
+    """Show AITrackdown storage information (placeholder - not yet implemented)."""
+    from rich.console import Console
+
+    console = Console()
+    console.print(
+        "[yellow]AITrackdown platform commands are not yet implemented.[/yellow]"
+    )
+    console.print(
+        "Use the generic ticket commands for AITrackdown operations:\n"
+        "  mcp-ticketer ticket create 'My ticket'\n"
+        "  mcp-ticketer ticket list"
+    )
+
+
+@aitrackdown_app.command("configure")
+def aitrackdown_configure() -> None:
+    """Configure AITrackdown adapter (placeholder - not yet implemented)."""
+    from rich.console import Console
+
+    console = Console()
+    console.print(
+        "[yellow]AITrackdown platform commands are not yet implemented.[/yellow]"
+    )
+    console.print(
+        "Use 'mcp-ticketer init --adapter aitrackdown' to configure AITrackdown adapter."
+    )
+
+
+# Register all platform command groups
+app.add_typer(jira_app, name="jira")
+app.add_typer(github_app, name="github")
+app.add_typer(aitrackdown_app, name="aitrackdown")