kaizen-agentic/src/kaizen_agentic/cli.py

"""Command-line interface for Kaizen Agentic agent management."""

import sys
import click
from pathlib import Path
from typing import List, Optional

from .registry import AgentRegistry, AgentCategory
from .installer import AgentInstaller, ProjectInitializer, InstallationConfig


@click.group()
@click.version_option()
def cli():
    """Kaizen Agentic - AI agent development framework."""
    pass


@cli.command()
@click.option('--category',
              type=click.Choice([c.value for c in AgentCategory]),
              help='Filter by category')
@click.option('--verbose', '-v', is_flag=True, help='Show detailed information')
def list(category: Optional[str], verbose: bool):
    """List available agents."""
    registry = _get_registry()

    if category:
        cat_enum = AgentCategory(category)
        agents = registry.list_agents(cat_enum)
        click.echo(f"\n{category.replace('-', ' ').title()} Agents:")
        click.echo("=" * 40)
    else:
        if verbose:
            categories = registry.get_categories()
            for cat, agents in categories.items():
                click.echo(f"\n{cat.value.replace('-', ' ').title()} ({len(agents)} agents):")
                click.echo("=" * 50)
                for agent in agents:
                    click.echo(f"  • {agent.name}: {agent.description}")
            return
        else:
            agents = registry.list_agents()
            click.echo(f"\nAvailable Agents ({len(agents)} total):")
            click.echo("=" * 40)

    for agent in agents:
        if verbose:
            click.echo(f"\n{agent.name}")
            click.echo(f"  Description: {agent.description}")
            click.echo(f"  Category: {agent.category.value}")
            if agent.dependencies:
                click.echo(f"  Dependencies: {', '.join(agent.dependencies)}")
        else:
            click.echo(f"  • {agent.name}: {agent.description}")


@cli.command()
@click.argument('agents', nargs=-1, required=True)
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
@click.option('--no-backup', is_flag=True, help='Skip creating backup')
@click.option('--no-docs', is_flag=True, help='Skip updating documentation')
def install(agents: List[str], target: str, no_backup: bool, no_docs: bool):
    """Install agents into a project."""
    registry = _get_registry()
    installer = AgentInstaller(registry)

    target_path = Path(target).resolve()

    config = InstallationConfig(
        target_dir=target_path,
        claude_config_path=target_path / "CLAUDE.md",
        makefile_path=target_path / "Makefile",
        update_docs=not no_docs,
        create_backup=not no_backup
    )

    click.echo(f"Installing agents to: {target_path}")

    # Resolve and show dependencies
    resolved = registry.resolve_dependencies(list(agents))
    if len(resolved) > len(agents):
        additional = [a for a in resolved if a not in agents]
        click.echo(f"Including dependencies: {', '.join(additional)}")

    results = installer.install_agents(resolved, config)

    # Display results
    success_count = 0
    for agent_name, status in results.items():
        if status == "INSTALLED":
            click.echo(f"  ✅ {agent_name}")
            success_count += 1
        else:
            click.echo(f"  ❌ {agent_name}: {status}")

    click.echo(f"\nInstalled {success_count}/{len(results)} agents successfully")


@cli.command()
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
@click.argument('agents', nargs=-1)
def update(target: str, agents: List[str]):
    """Update installed agents."""
    registry = _get_registry()
    installer = AgentInstaller(registry)

    target_path = Path(target).resolve()

    if not agents:
        agents = installer.list_installed_agents(target_path)
        if not agents:
            click.echo("No agents installed in this project")
            return
        click.echo(f"Updating all installed agents: {', '.join(agents)}")
    else:
        click.echo(f"Updating specific agents: {', '.join(agents)}")

    results = installer.update_agents(target_path, list(agents))

    # Display results
    success_count = 0
    for agent_name, status in results.items():
        if status == "INSTALLED":
            click.echo(f"  ✅ {agent_name}")
            success_count += 1
        else:
            click.echo(f"  ❌ {agent_name}: {status}")

    click.echo(f"\nUpdated {success_count}/{len(results)} agents successfully")


@cli.command()
@click.argument('agents', nargs=-1, required=True)
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
def remove(agents: List[str], target: str):
    """Remove agents from a project."""
    registry = _get_registry()
    installer = AgentInstaller(registry)

    target_path = Path(target).resolve()

    click.echo(f"Removing agents from: {target_path}")
    results = installer.remove_agents(list(agents), target_path)

    # Display results
    for agent_name, status in results.items():
        if status == "REMOVED":
            click.echo(f"  ✅ {agent_name}")
        elif status == "NOT_FOUND":
            click.echo(f"  ⚠️  {agent_name}: Not installed")
        else:
            click.echo(f"  ❌ {agent_name}: {status}")


@cli.command()
@click.argument('project_name')
@click.option('--template', '-t', default='python-basic',
              help='Project template (python-basic, python-web, python-cli, python-data)')
@click.option('--agents', '-a', help='Comma-separated list of agents to install')
@click.option('--parent-dir', default='.', help='Parent directory for project (default: current)')
def init(project_name: str, template: str, agents: Optional[str], parent_dir: str):
    """Initialize a new project with agents."""
    registry = _get_registry()
    initializer = ProjectInitializer(registry)

    project_path = Path(parent_dir) / project_name

    if project_path.exists():
        click.echo(f"Error: Directory {project_path} already exists")
        sys.exit(1)

    # Parse agent list
    agent_list = None
    if agents:
        agent_list = [a.strip() for a in agents.split(',')]

    click.echo(f"Initializing project: {project_name}")
    click.echo(f"Template: {template}")

    # Show available templates
    templates = registry.get_agent_templates()
    if template not in templates:
        click.echo(f"Error: Unknown template '{template}'")
        click.echo(f"Available templates: {', '.join(templates.keys())}")
        sys.exit(1)

    if not agent_list:
        agent_list = templates[template]
        click.echo(f"Using template agents: {', '.join(agent_list)}")
    else:
        click.echo(f"Using custom agents: {', '.join(agent_list)}")

    results = initializer.init_project(project_path, template, agent_list, project_name)

    # Display results
    success_count = sum(1 for status in results.values() if status == "INSTALLED")
    click.echo(f"\nProject initialized with {success_count}/{len(results)} agents")

    click.echo("\nNext steps:")
    click.echo(f"  cd {project_name}")
    click.echo("  make setup-complete  # Set up development environment")
    click.echo("  make test           # Run tests")


@cli.command()
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
def validate(target: str):
    """Validate agents in a project."""
    registry = _get_registry()
    installer = AgentInstaller(registry)

    target_path = Path(target).resolve()

    # Validate registry agents
    click.echo("Validating agent registry...")
    registry_errors = registry.validate_agents()

    if registry_errors:
        click.echo("Registry validation errors:")
        for agent, errors in registry_errors.items():
            click.echo(f"  {agent}:")
            for error in errors:
                click.echo(f"    ❌ {error}")
    else:
        click.echo("  ✅ Registry validation passed")

    # Validate installed agents
    click.echo(f"\nValidating installed agents in: {target_path}")
    install_errors = installer.validate_installation(target_path)

    if install_errors:
        click.echo("Installation validation errors:")
        for agent, errors in install_errors.items():
            click.echo(f"  {agent}:")
            for error in errors:
                click.echo(f"    ❌ {error}")
    else:
        click.echo("  ✅ Installation validation passed")

    # Show installed agents
    installed = installer.list_installed_agents(target_path)
    if installed:
        click.echo(f"\nInstalled agents ({len(installed)}):")
        for agent in installed:
            click.echo(f"  • {agent}")
    else:
        click.echo("\nNo agents installed in this project")


@cli.command()
def templates():
    """List available project templates."""
    registry = _get_registry()
    templates = registry.get_agent_templates()

    click.echo("Available Project Templates:")
    click.echo("=" * 40)

    for template_name, agent_list in templates.items():
        click.echo(f"\n{template_name}:")
        click.echo(f"  Agents ({len(agent_list)}): {', '.join(agent_list)}")


@cli.command()
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
def status(target: str):
    """Show status of agents in a project."""
    registry = _get_registry()
    installer = AgentInstaller(registry)

    target_path = Path(target).resolve()

    click.echo(f"Project: {target_path.name}")
    click.echo(f"Path: {target_path}")
    click.echo("=" * 50)

    # Check if agents directory exists
    agents_dir = target_path / "agents"
    if not agents_dir.exists():
        click.echo("❌ No agents directory found")
        click.echo("\nRun 'kaizen-agentic init' to initialize a new project")
        click.echo("or 'kaizen-agentic install <agents>' to add agents")
        return

    # List installed agents
    installed = installer.list_installed_agents(target_path)
    if installed:
        click.echo(f"✅ Agents installed ({len(installed)}):")

        # Group by category
        categories = {}
        for agent_name in installed:
            agent = registry.get_agent(agent_name)
            if agent:
                cat = agent.category.value
                if cat not in categories:
                    categories[cat] = []
                categories[cat].append(agent_name)
            else:
                if "unknown" not in categories:
                    categories["unknown"] = []
                categories["unknown"].append(agent_name)

        for category, agents in categories.items():
            click.echo(f"\n  {category.replace('-', ' ').title()}:")
            for agent in agents:
                click.echo(f"    • {agent}")
    else:
        click.echo("❌ No agents installed")

    # Check for configuration files
    click.echo("\nConfiguration files:")
    config_files = ["CLAUDE.md", "Makefile", "pyproject.toml", ".gitignore"]
    for config_file in config_files:
        file_path = target_path / config_file
        if file_path.exists():
            click.echo(f"  ✅ {config_file}")
        else:
            click.echo(f"  ❌ {config_file}")


@cli.command()
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
@click.option('--detailed', '-d', is_flag=True, help='Show detailed analysis')
def detect(target: str, detailed: bool):
    """Detect existing agent systems in a project."""
    from .detection import AgentSystemDetector

    target_path = Path(target).resolve()

    if not target_path.exists():
        click.echo(f"Error: Directory not found: {target_path}")
        sys.exit(1)

    click.echo(f"Detecting agent systems in: {target_path}")
    click.echo("=" * 50)

    detector = AgentSystemDetector()
    result = detector.detect_agent_systems(target_path)

    # Show detected systems
    if result.detected_systems:
        click.echo(f"\n🔍 Detected Agent Systems ({len(result.detected_systems)}):")
        for system in result.detected_systems:
            click.echo(f"  • {system.value}")
    else:
        click.echo("\n🔍 No existing agent systems detected")

    # Show detected agents
    if result.agents:
        click.echo(f"\n🤖 Detected Agents ({len(result.agents)}):")
        for agent in result.agents:
            status = "✅" if agent.can_migrate else "⚠️"
            click.echo(f"  {status} {agent.name} ({agent.type.value})")
            if detailed and agent.description:
                click.echo(f"     {agent.description}")
            if not agent.can_migrate and agent.migration_notes:
                click.echo(f"     Note: {agent.migration_notes}")

    # Show config files
    if result.config_files:
        click.echo(f"\n📄 Configuration Files ({len(result.config_files)}):")
        for config_file in result.config_files:
            click.echo(f"  • {config_file.relative_to(target_path)}")

    # Show conflicts
    if result.conflicts:
        click.echo(f"\n⚠️  Potential Conflicts ({len(result.conflicts)}):")
        for agent1, agent2, reason in result.conflicts:
            click.echo(f"  • {agent1} vs {agent2}: {reason}")

    # Show integration strategy
    if result.integration_strategy:
        click.echo(f"\n💡 Recommended Integration Strategy: {result.integration_strategy}")

    # Show migration recommendations
    if result.migration_recommendations:
        click.echo(f"\n📋 Migration Recommendations:")
        for recommendation in result.migration_recommendations:
            if recommendation.startswith("  "):
                click.echo(f"  {recommendation}")
            else:
                click.echo(f"  • {recommendation}")

    if not result.detected_systems:
        click.echo(f"\n✨ This project is ready for Kaizen Agentic installation!")
        click.echo(f"   Run: kaizen-agentic install <agent-names>")


@cli.command()
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
@click.option('--dry-run', '-n', is_flag=True, help='Show what would be done without executing')
@click.option('--auto-resolve', '-a', is_flag=True, help='Automatically resolve simple conflicts')
def migrate(target: str, dry_run: bool, auto_resolve: bool):
    """Create migration plan for integrating Kaizen agents into existing project."""
    from .migration import AgentMigrationPlanner, AgentMigrator

    target_path = Path(target).resolve()

    if not target_path.exists():
        click.echo(f"Error: Directory not found: {target_path}")
        sys.exit(1)

    click.echo(f"Creating migration plan for: {target_path}")
    click.echo("=" * 50)

    planner = AgentMigrationPlanner()
    integration_plan = planner.create_integration_plan(target_path)

    if not integration_plan.migration_plans and not integration_plan.conflict_resolutions:
        click.echo("✨ No migration needed - project is ready for Kaizen agents!")
        click.echo("   Run: kaizen-agentic install <agent-names>")
        return

    # Show migration plans
    if integration_plan.migration_plans:
        click.echo(f"\n🔄 Migration Plans ({len(integration_plan.migration_plans)}):")
        for plan in integration_plan.migration_plans:
            strategy_emoji = {
                "replace": "🔄", "extend": "🔗", "preserve": "💾",
                "merge": "🔀", "remove": "🗑️"
            }
            emoji = strategy_emoji.get(plan.strategy.value, "❓")

            click.echo(f"  {emoji} {plan.source_agent.name} ({plan.source_agent.type.value})")
            click.echo(f"     Strategy: {plan.strategy.value}")
            if plan.target_agent:
                click.echo(f"     Target: {plan.target_agent}")

            for note in plan.migration_notes:
                click.echo(f"     📝 {note}")

    # Show conflict resolutions
    if integration_plan.conflict_resolutions:
        click.echo(f"\n⚠️  Conflict Resolutions ({len(integration_plan.conflict_resolutions)}):")
        for resolution in integration_plan.conflict_resolutions:
            click.echo(f"  • {resolution.agent1} vs {resolution.agent2}")
            click.echo(f"    Resolution: {resolution.resolution.value}")
            if resolution.action_details:
                for key, value in resolution.action_details.items():
                    click.echo(f"    {key}: {value}")

    # Show integration order
    if integration_plan.integration_order:
        click.echo(f"\n📋 Integration Order:")
        for i, agent_name in enumerate(integration_plan.integration_order, 1):
            click.echo(f"  {i}. {agent_name}")

    # Show post-migration tasks
    if integration_plan.post_migration_tasks:
        click.echo(f"\n✅ Post-Migration Tasks:")
        for task in integration_plan.post_migration_tasks:
            click.echo(f"  • {task}")

    # Execute migration if requested
    if not dry_run:
        click.echo(f"\n🚀 Executing migration...")
        migrator = AgentMigrator()
        results = migrator.execute_migration(integration_plan, dry_run=False)

        click.echo(f"\n📊 Migration Results:")
        for agent, result in results.items():
            status_emoji = "✅" if "ERROR" not in result else "❌"
            click.echo(f"  {status_emoji} {agent}: {result}")

        click.echo(f"\n💾 Backup created at: {integration_plan.backup_directory}")
    else:
        click.echo(f"\n🔍 This was a dry run. Use --no-dry-run to execute the migration.")
        click.echo(f"   Backup would be created at: {integration_plan.backup_directory}")


@cli.group()
def extensions():
    """Manage agent extensions."""
    pass


@extensions.command()
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
@click.option('--base-agent', '-b', help='Filter by base agent')
def list_extensions(target: str, base_agent: Optional[str]):
    """List installed extensions."""
    from .extensions import ExtensionManager

    target_path = Path(target).resolve()
    manager = ExtensionManager(target_path)

    extensions_list = manager.list_extensions(base_agent)

    if not extensions_list:
        if base_agent:
            click.echo(f"No extensions found for agent: {base_agent}")
        else:
            click.echo("No extensions installed in this project")
        return

    click.echo(f"Extensions in {target_path}:")
    click.echo("=" * 40)

    for ext in extensions_list:
        status = "✅" if ext.enabled else "❌"
        click.echo(f"\n{status} {ext.name} (extends {ext.base_agent})")
        click.echo(f"   Type: {ext.extension_type.value}")
        click.echo(f"   Description: {ext.description}")
        click.echo(f"   Version: {ext.version}")

        if ext.custom_commands:
            click.echo(f"   Custom commands: {', '.join(ext.custom_commands.keys())}")


@extensions.command()
@click.argument('name')
@click.argument('base_agent')
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
@click.option('--description', '-d', help='Extension description')
@click.option('--template', default='basic', help='Template type (basic, advanced)')
def create(name: str, base_agent: str, target: str, description: Optional[str], template: str):
    """Create a new agent extension."""
    from .extensions import ExtensionManager, ExtensionType, create_extension_template

    target_path = Path(target).resolve()
    manager = ExtensionManager(target_path)

    # Generate template
    template_content = create_extension_template(name, base_agent, target_path, template)

    # Save template to file
    template_dir = target_path / ".kaizen" / "extensions" / name
    template_dir.mkdir(parents=True, exist_ok=True)

    template_file = template_dir / "template.md"
    template_file.write_text(template_content)

    # Create basic extension
    manager.create_extension(
        name=name,
        base_agent=base_agent,
        extension_type=ExtensionType.FUNCTIONAL_EXTENSION,
        description=description or f"Custom extension for {base_agent}"
    )

    click.echo(f"✅ Created extension: {name}")
    click.echo(f"   Base agent: {base_agent}")
    click.echo(f"   Template saved to: {template_file}")
    click.echo(f"   Edit the configuration and run: kaizen-agentic extensions enable {name}")


@extensions.command()
@click.argument('name')
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
def enable(name: str, target: str):
    """Enable an extension."""
    from .extensions import ExtensionManager

    target_path = Path(target).resolve()
    manager = ExtensionManager(target_path)

    if manager.enable_extension(name):
        click.echo(f"✅ Enabled extension: {name}")
    else:
        click.echo(f"❌ Extension not found: {name}")


@extensions.command()
@click.argument('name')
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
def disable(name: str, target: str):
    """Disable an extension."""
    from .extensions import ExtensionManager

    target_path = Path(target).resolve()
    manager = ExtensionManager(target_path)

    if manager.disable_extension(name):
        click.echo(f"❌ Disabled extension: {name}")
    else:
        click.echo(f"❌ Extension not found: {name}")


@extensions.command()
@click.argument('name')
@click.option('--target', '-t', default='.', help='Target directory (default: current)')
@click.confirmation_option(prompt='Are you sure you want to remove this extension?')
def remove(name: str, target: str):
    """Remove an extension."""
    from .extensions import ExtensionManager

    target_path = Path(target).resolve()
    manager = ExtensionManager(target_path)

    if manager.remove_extension(name):
        click.echo(f"🗑️  Removed extension: {name}")
    else:
        click.echo(f"❌ Extension not found: {name}")


def _get_registry() -> AgentRegistry:
    """Get the agent registry."""
    # Try to find agents directory
    current_dir = Path.cwd()

    # Check if we're in a kaizen-agentic project
    if (current_dir / "agents").exists():
        agents_dir = current_dir / "agents"
    elif (current_dir / "src" / "kaizen_agentic").exists():
        # We're in the kaizen-agentic repo itself
        agents_dir = current_dir / "agents"
    else:
        # Try to find installed package
        try:
            import kaizen_agentic
            package_dir = Path(kaizen_agentic.__file__).parent.parent.parent
            agents_dir = package_dir / "agents"
            if not agents_dir.exists():
                # Try relative to package
                agents_dir = Path(kaizen_agentic.__file__).parent / "data" / "agents"
        except ImportError:
            click.echo("Error: Could not find agents directory")
            click.echo("Make sure you're in a kaizen-agentic project or have the package installed")
            sys.exit(1)

    if not agents_dir.exists():
        click.echo(f"Error: Agents directory not found: {agents_dir}")
        sys.exit(1)

    return AgentRegistry(agents_dir)


if __name__ == '__main__':
    cli()