aiaddons 0.1.0__py3-none-any.whl

aiaddons/__init__.py

@@ -0,0 +1,5 @@
+"""AI Add-ons Manager (`aiaddons`)."""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

aiaddons/__main__.py

@@ -0,0 +1,6 @@
+"""Executable module entry point for `python -m aiaddons`."""
+
+from aiaddons.cli.main import app
+
+if __name__ == "__main__":
+    app()

aiaddons/agents/__init__.py

@@ -0,0 +1,16 @@
+"""Agent detection and adapters subpackage."""
+
+from aiaddons.agents.antigravity import AntigravityAdapter
+from aiaddons.agents.base import BaseAgentAdapter
+from aiaddons.agents.claude_code import ClaudeCodeAdapter
+from aiaddons.agents.codex import CodexAdapter
+from aiaddons.agents.manager import AgentDetectionManager, detect_agents
+
+__all__ = [
+    "AntigravityAdapter",
+    "BaseAgentAdapter",
+    "ClaudeCodeAdapter",
+    "CodexAdapter",
+    "AgentDetectionManager",
+    "detect_agents",
+]

aiaddons/agents/antigravity.py

@@ -0,0 +1,106 @@
+"""Antigravity CLI agent detection adapter."""
+
+from pathlib import Path
+
+from aiaddons.agents.utils import find_executable, run_version_command
+from aiaddons.core.models.agent import AgentCapability, AgentDetectionResult, Scope
+
+
+class AntigravityAdapter:
+    """Adapter for detecting and configuring Antigravity CLI."""
+
+    agent_id: str = "antigravity"
+    name: str = "Antigravity CLI"
+    capabilities: list[AgentCapability] = [AgentCapability.MCP, AgentCapability.SKILL]
+
+    def supports_capability(self, capability: AgentCapability) -> bool:
+        """Check if Antigravity CLI supports the given capability."""
+        return capability in self.capabilities
+
+    def get_config_path(self, scope: Scope, project_path: Path | None = None) -> Path | None:
+        """Get the configuration path for Antigravity CLI based on scope."""
+        if scope == Scope.GLOBAL:
+            global_mcp = Path.home() / ".gemini" / "config" / "mcp_config.json"
+            if global_mcp.exists():
+                return global_mcp
+            global_config_dir = Path.home() / ".gemini" / "config"
+            if global_config_dir.exists():
+                return global_mcp
+            global_gemini_dir = Path.home() / ".gemini"
+            if global_gemini_dir.exists():
+                return global_mcp
+            return global_mcp
+
+        base_dir = project_path if project_path is not None else Path.cwd()
+        ws_mcp = base_dir / ".agents" / "mcp_config.json"
+        if ws_mcp.exists():
+            return ws_mcp
+        ws_agents = base_dir / ".agents"
+        if ws_agents.exists():
+            return ws_mcp
+        return ws_mcp
+
+    def get_skill_directory(self, scope: Scope, project_path: Path | None = None) -> Path:
+        """Get the skill installation directory for Antigravity CLI based on scope."""
+        if scope == Scope.GLOBAL:
+            return Path.home() / ".gemini" / "config" / "skills"
+        base_dir = project_path if project_path is not None else Path.cwd()
+        return base_dir / ".agents" / "skills"
+
+    def detect(self, project_path: Path | None = None) -> AgentDetectionResult:
+        """Detect Antigravity CLI installation status, binary path, version, and config location."""
+        exec_path = find_executable("agy")
+        if exec_path is None:
+            exec_path = find_executable("antigravity")
+
+        global_config = self.get_config_path(Scope.GLOBAL)
+        workspace_config = self.get_config_path(Scope.WORKSPACE, project_path=project_path)
+
+        base_dir = project_path if project_path is not None else Path.cwd()
+        has_global = (
+            (global_config is not None and global_config.exists())
+            or (Path.home() / ".gemini").exists()
+        )
+        has_workspace = (
+            (workspace_config is not None and workspace_config.exists())
+            or (base_dir / ".agents").exists()
+            or (base_dir / "AGENTS.md").exists()
+            or (base_dir / "GEMINI.md").exists()
+        )
+        installed = (exec_path is not None) or has_global or has_workspace
+
+        version: str | None = None
+        detection_error: str | None = None
+
+        if exec_path is not None:
+            try:
+                cmd_name = exec_path.name
+                if cmd_name.lower().endswith(".exe"):
+                    cmd_name = cmd_name[:-4]
+                version = run_version_command(cmd_name)
+            except Exception as exc:
+                detection_error = f"Error running version command: {exc}"
+
+        active_config = (
+            workspace_config
+            if (has_workspace and workspace_config and workspace_config.exists())
+            else (
+                global_config
+                if (has_global and global_config and global_config.exists())
+                else (workspace_config or global_config)
+            )
+        )
+
+        return AgentDetectionResult(
+            agent_id=self.agent_id,
+            name=self.name,
+            installed=installed,
+            version=version,
+            executable_path=str(exec_path) if exec_path else None,
+            global_config_path=str(global_config) if global_config else None,
+            workspace_config_path=str(workspace_config) if workspace_config else None,
+            config_path=str(active_config) if active_config else None,
+            supported_scopes=[Scope.GLOBAL, Scope.WORKSPACE],
+            capabilities=list(self.capabilities),
+            detection_error=detection_error,
+        )

aiaddons/agents/base.py

@@ -0,0 +1,31 @@
+"""Base agent adapter protocol defining standard interface for agent detection and configuration."""
+
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+from aiaddons.core.models.agent import AgentCapability, AgentDetectionResult, Scope
+
+
+@runtime_checkable
+class BaseAgentAdapter(Protocol):
+    """Protocol for AI coding agent detection and configuration adapters."""
+
+    agent_id: str
+    name: str
+    capabilities: list[AgentCapability]
+
+    def detect(self, project_path: Path | None = None) -> AgentDetectionResult:
+        """Detect agent installation status, binary path, version, and config location."""
+        ...
+
+    def get_config_path(self, scope: Scope, project_path: Path | None = None) -> Path | None:
+        """Get path to the agent's configuration file for the specified scope."""
+        ...
+
+    def supports_capability(self, capability: AgentCapability) -> bool:
+        """Check if this agent supports a specific integration capability."""
+        ...
+
+    def get_skill_directory(self, scope: Scope, project_path: Path | None = None) -> Path:
+        """Get canonical skill installation directory for the specified scope."""
+        ...

aiaddons/agents/claude_code.py

@@ -0,0 +1,85 @@
+"""Claude Code agent detection adapter."""
+
+from pathlib import Path
+
+from aiaddons.agents.utils import find_executable, run_version_command
+from aiaddons.core.models.agent import AgentCapability, AgentDetectionResult, Scope
+
+
+class ClaudeCodeAdapter:
+    """Adapter for detecting and configuring Claude Code."""
+
+    agent_id: str = "claude-code"
+    name: str = "Claude Code"
+    capabilities: list[AgentCapability] = [AgentCapability.MCP, AgentCapability.SKILL]
+
+    def supports_capability(self, capability: AgentCapability) -> bool:
+        """Check if Claude Code supports the given capability."""
+        return capability in self.capabilities
+
+    def get_config_path(self, scope: Scope, project_path: Path | None = None) -> Path | None:
+        """Get the configuration path for Claude Code based on scope."""
+        if scope == Scope.GLOBAL:
+            global_json = Path.home() / ".claude.json"
+            if global_json.exists():
+                return global_json
+            global_dir = Path.home() / ".claude"
+            if global_dir.exists():
+                return global_dir
+            return global_json
+
+        base_dir = project_path if project_path is not None else Path.cwd()
+        ws_json = base_dir / ".claude.json"
+        if ws_json.exists():
+            return ws_json
+        ws_dir = base_dir / ".claude"
+        if ws_dir.exists():
+            return ws_dir
+        return ws_json
+
+    def get_skill_directory(self, scope: Scope, project_path: Path | None = None) -> Path:
+        """Get the skill installation directory for Claude Code based on scope."""
+        if scope == Scope.GLOBAL:
+            return Path.home() / ".claude" / "skills"
+        base_dir = project_path if project_path is not None else Path.cwd()
+        return base_dir / ".claude" / "skills"
+
+    def detect(self, project_path: Path | None = None) -> AgentDetectionResult:
+        """Detect Claude Code installation status, binary path, version, and config location."""
+        exec_path = find_executable("claude")
+        global_config = self.get_config_path(Scope.GLOBAL)
+        workspace_config = self.get_config_path(Scope.WORKSPACE, project_path=project_path)
+
+        # Check if config exists on disk
+        has_global = global_config is not None and global_config.exists()
+        has_workspace = workspace_config is not None and workspace_config.exists()
+        installed = (exec_path is not None) or has_global or has_workspace
+
+        version: str | None = None
+        detection_error: str | None = None
+
+        if exec_path is not None:
+            try:
+                version = run_version_command("claude")
+            except Exception as exc:
+                detection_error = f"Error running version command: {exc}"
+
+        active_config = (
+            workspace_config
+            if (has_workspace and workspace_config)
+            else (global_config if (has_global and global_config) else None)
+        )
+
+        return AgentDetectionResult(
+            agent_id=self.agent_id,
+            name=self.name,
+            installed=installed,
+            version=version,
+            executable_path=str(exec_path) if exec_path else None,
+            global_config_path=str(global_config) if global_config else None,
+            workspace_config_path=str(workspace_config) if workspace_config else None,
+            config_path=str(active_config) if active_config else None,
+            supported_scopes=[Scope.GLOBAL, Scope.WORKSPACE],
+            capabilities=list(self.capabilities),
+            detection_error=detection_error,
+        )

aiaddons/agents/codex.py

@@ -0,0 +1,81 @@
+"""OpenAI Codex agent detection adapter."""
+
+from pathlib import Path
+
+from aiaddons.agents.utils import find_executable, run_version_command
+from aiaddons.core.models.agent import AgentCapability, AgentDetectionResult, Scope
+
+
+class CodexAdapter:
+    """Adapter for detecting and configuring OpenAI Codex CLI."""
+
+    agent_id: str = "codex"
+    name: str = "OpenAI Codex"
+    capabilities: list[AgentCapability] = [AgentCapability.MCP, AgentCapability.SKILL]
+
+    def supports_capability(self, capability: AgentCapability) -> bool:
+        """Check if OpenAI Codex supports the given capability."""
+        return capability in self.capabilities
+
+    def get_config_path(self, scope: Scope, project_path: Path | None = None) -> Path | None:
+        """Get the configuration path for OpenAI Codex based on scope."""
+        if scope == Scope.GLOBAL:
+            global_dir = Path.home() / ".codex"
+            if global_dir.exists():
+                return global_dir
+            return global_dir
+
+        base_dir = project_path if project_path is not None else Path.cwd()
+        ws_dir = base_dir / ".codex"
+        if ws_dir.exists():
+            return ws_dir
+        ws_agents = base_dir / ".agents"
+        if ws_agents.exists():
+            return ws_agents
+        return ws_dir
+
+    def get_skill_directory(self, scope: Scope, project_path: Path | None = None) -> Path:
+        """Get the skill installation directory for OpenAI Codex based on scope."""
+        if scope == Scope.GLOBAL:
+            return Path.home() / ".codex" / "skills"
+        base_dir = project_path if project_path is not None else Path.cwd()
+        return base_dir / ".agents" / "skills"
+
+    def detect(self, project_path: Path | None = None) -> AgentDetectionResult:
+        """Detect OpenAI Codex installation status, binary path, version, and config location."""
+        exec_path = find_executable("codex")
+        global_config = self.get_config_path(Scope.GLOBAL)
+        workspace_config = self.get_config_path(Scope.WORKSPACE, project_path=project_path)
+
+        has_global = global_config is not None and global_config.exists()
+        has_workspace = workspace_config is not None and workspace_config.exists()
+        installed = (exec_path is not None) or has_global or has_workspace
+
+        version: str | None = None
+        detection_error: str | None = None
+
+        if exec_path is not None:
+            try:
+                version = run_version_command("codex")
+            except Exception as exc:
+                detection_error = f"Error running version command: {exc}"
+
+        active_config = (
+            workspace_config
+            if (has_workspace and workspace_config)
+            else (global_config if (has_global and global_config) else None)
+        )
+
+        return AgentDetectionResult(
+            agent_id=self.agent_id,
+            name=self.name,
+            installed=installed,
+            version=version,
+            executable_path=str(exec_path) if exec_path else None,
+            global_config_path=str(global_config) if global_config else None,
+            workspace_config_path=str(workspace_config) if workspace_config else None,
+            config_path=str(active_config) if active_config else None,
+            supported_scopes=[Scope.GLOBAL, Scope.WORKSPACE],
+            capabilities=list(self.capabilities),
+            detection_error=detection_error,
+        )

aiaddons/agents/manager.py

@@ -0,0 +1,58 @@
+"""Agent detection manager aggregating all registered AI agent adapters."""
+
+from collections.abc import Sequence
+from pathlib import Path
+
+from aiaddons.agents.antigravity import AntigravityAdapter
+from aiaddons.agents.base import BaseAgentAdapter
+from aiaddons.agents.claude_code import ClaudeCodeAdapter
+from aiaddons.agents.codex import CodexAdapter
+from aiaddons.core.models.agent import AgentDetectionResult
+
+
+class AgentDetectionManager:
+    """Manager component for detecting installed AI coding agents."""
+
+    def __init__(self, adapters: Sequence[BaseAgentAdapter] | None = None) -> None:
+        if adapters is None:
+            self._adapters: list[BaseAgentAdapter] = [
+                ClaudeCodeAdapter(),
+                CodexAdapter(),
+                AntigravityAdapter(),
+            ]
+        else:
+            self._adapters = list(adapters)
+
+    def register_adapter(self, adapter: BaseAgentAdapter) -> None:
+        """Register a new agent adapter."""
+        self._adapters.append(adapter)
+
+    def get_adapter(self, agent_id: str) -> BaseAgentAdapter | None:
+        """Retrieve registered adapter for a given agent ID."""
+        aid = agent_id.lower()
+        for adapter in self._adapters:
+            if adapter.agent_id.lower() == aid:
+                return adapter
+        return None
+
+    def detect_agents(self, project_path: Path | None = None) -> dict[str, AgentDetectionResult]:
+        """Detect all registered agents and return results mapped by agent ID."""
+        results: dict[str, AgentDetectionResult] = {}
+        for adapter in self._adapters:
+            try:
+                results[adapter.agent_id] = adapter.detect(project_path=project_path)
+            except Exception as exc:
+                results[adapter.agent_id] = AgentDetectionResult(
+                    agent_id=adapter.agent_id,
+                    name=adapter.name,
+                    installed=False,
+                    capabilities=list(adapter.capabilities),
+                    detection_error=f"Unexpected detection error: {exc}",
+                )
+        return results
+
+
+def detect_agents(project_path: Path | None = None) -> dict[str, AgentDetectionResult]:
+    """Convenience function to run agent detection with default adapters."""
+    manager = AgentDetectionManager()
+    return manager.detect_agents(project_path=project_path)

aiaddons/agents/utils.py

@@ -0,0 +1,48 @@
+"""Helper utilities for agent detection and CLI binary version parsing."""
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+
+def find_executable(name: str) -> Path | None:
+    """Find executable in system PATH using shutil.which, returning absolute Path or None."""
+    found = shutil.which(name)
+    if found:
+        return Path(found)
+    return None
+
+
+def parse_version_output(output: str) -> str | None:
+    """Extract a SemVer-like version string from raw command output."""
+    if not output:
+        return None
+    match = re.search(r"v?(\d+\.\d+\.\d+(?:-[\w.-]+)?)", output)
+    if match:
+        return match.group(1)
+    return None
+
+
+def run_version_command(
+    cmd: str, args: list[str] | None = None, timeout_seconds: float = 5.0
+) -> str | None:
+    """Safely run executable version command without shell=True and return parsed version."""
+    executable_path = find_executable(cmd)
+    if executable_path is None:
+        return None
+
+    full_cmd = [str(executable_path)] + (args if args is not None else ["--version"])
+
+    try:
+        res = subprocess.run(
+            full_cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            check=False,
+        )
+        output_text = res.stdout if res.stdout else res.stderr
+        return parse_version_output(output_text)
+    except (subprocess.SubprocessError, OSError, ValueError):
+        return None

aiaddons/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI subpackage for aiaddons."""
+
+from aiaddons.cli.main import app
+
+__all__ = ["app"]

aiaddons/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands subpackage."""

aiaddons/cli/commands/agents.py

@@ -0,0 +1,74 @@
+"""CLI command for listing and detecting AI coding agents."""
+
+import json
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from aiaddons.agents.manager import detect_agents
+
+console = Console()
+
+
+def _get_symbols() -> tuple[str, str]:
+    """Return platform and encoding safe status symbols."""
+    try:
+        "✓".encode(sys.stdout.encoding or "utf-8")
+        return "✓", "✗"
+    except (UnicodeEncodeError, AttributeError, TypeError):
+        return "+", "-"
+
+
+def agents_command(
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        "-j",
+        help="Output raw detection results in JSON format.",
+    ),
+    project_path: Path | None = typer.Option(
+        None,
+        "--project-path",
+        "-p",
+        help="Specify custom project directory for detection.",
+    ),
+) -> None:
+    """List detected AI coding agents and their installation status."""
+    results = detect_agents(project_path=project_path)
+
+    if json_output:
+        serialized = {k: v.model_dump() for k, v in results.items()}
+        sys.stdout.write(json.dumps(serialized, indent=2) + "\n")
+        sys.stdout.flush()
+        return
+
+    console.print("\n[bold cyan]AI Coding Agents[/bold cyan]\n")
+    check_sym, cross_sym = _get_symbols()
+
+    for _agent_id, res in results.items():
+        if res.installed:
+            console.print(f"[bold green]{check_sym}[/bold green] [bold]{res.name}[/bold]")
+            if res.version:
+                console.print(f"  [dim]Version:[/dim] {res.version}")
+            else:
+                console.print("  [dim]Version:[/dim] [yellow]Unknown[/yellow]")
+
+            if res.executable_path:
+                console.print(f"  [dim]Path:[/dim] {res.executable_path}")
+
+            if res.config_path:
+                console.print(f"  [dim]Config:[/dim] {res.config_path}")
+
+            if res.capabilities:
+                caps_str = ", ".join(c.value for c in res.capabilities)
+                console.print(f"  [dim]Capabilities:[/dim] {caps_str}")
+        else:
+            console.print(f"[bold red]{cross_sym}[/bold red] [bold]{res.name}[/bold]")
+            console.print("  [dim]Not installed[/dim]")
+
+        if res.detection_error:
+            console.print(f"  [red]Detection Note:[/red] {res.detection_error}")
+
+        console.print()

aiaddons/cli/commands/compatibility.py

@@ -0,0 +1,110 @@
+"""CLI command for checking add-on compatibility against detected AI coding agents."""
+
+import json
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from aiaddons.agents.manager import AgentDetectionManager
+from aiaddons.core.compatibility.engine import CompatibilityEngine
+from aiaddons.core.models.agent import Scope
+from aiaddons.registry.registry import Registry
+
+console = Console()
+
+
+def _get_symbols() -> tuple[str, str]:
+    """Return platform-safe symbols for checkmark and cross mark."""
+    try:
+        "✓".encode(sys.stdout.encoding or "utf-8")
+        return "✓", "✗"
+    except Exception:
+        return "+", "-"
+
+
+def check_command(
+    addon_id: str = typer.Argument(..., help="Add-on ID to evaluate compatibility for."),
+    scope: str = typer.Option(
+        "workspace",
+        "--scope",
+        "-s",
+        help="Requested installation scope (global or workspace).",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        "-j",
+        help="Output evaluation results in JSON format.",
+    ),
+    registry_dir: Path | None = typer.Option(
+        None,
+        "--registry-dir",
+        "-r",
+        help="Path to custom registry directory.",
+    ),
+) -> None:
+    """Evaluate compatibility of an add-on against all detected AI coding agents (read-only)."""
+    try:
+        req_scope = Scope.from_str(scope)
+    except ValueError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1) from e
+
+    registry, _ = Registry.load_auto(custom_dir=registry_dir)
+
+    manifest = registry.get(addon_id)
+    if not manifest:
+        console.print(f"[bold red]Error:[/bold red] Add-on '{addon_id}' not found in registry.")
+        raise typer.Exit(code=1)
+
+    manager = AgentDetectionManager()
+    detected_agents = list(manager.detect_agents().values())
+
+    engine = CompatibilityEngine(registry=registry)
+    results = engine.evaluate_all(
+        manifest, detected_agents, requested_scope=req_scope, registry=registry
+    )
+
+    if json_output:
+        serialized = [r.model_dump() for r in results]
+        sys.stdout.write(json.dumps(serialized, indent=2) + "\n")
+        sys.stdout.flush()
+        return
+
+    sym_ok, sym_fail = _get_symbols()
+
+    console.print(
+        f"\n[bold cyan]Compatibility Evaluation for '{manifest.name}' ({manifest.id})[/bold cyan]"
+    )
+    console.print(f"[bold]Requested Scope:[/bold] {req_scope.value}\n")
+
+    for r in results:
+        status_str = (
+            f"[bold green]{sym_ok} Compatible[/bold green]"
+            if r.compatible
+            else f"[bold red]{sym_fail} Incompatible[/bold red]"
+        )
+        console.print(f"[bold]{r.agent_name}[/bold] ({r.agent_id}): {status_str}")
+
+        for reason in r.reasons:
+            color = "green" if r.compatible else "yellow"
+            console.print(f"  [{color}]• {reason}[/{color}]")
+
+        if r.missing_requirements:
+            console.print("  [bold red]Missing Requirements:[/bold red]")
+            for req in r.missing_requirements:
+                console.print(f"    - {req}")
+
+        if r.unsupported_requirements:
+            console.print("  [bold red]Unsupported Requirements:[/bold red]")
+            for unsupp in r.unsupported_requirements:
+                console.print(f"    - {unsupp}")
+
+        if r.warnings:
+            console.print("  [bold yellow]Warnings:[/bold yellow]")
+            for warn in r.warnings:
+                console.print(f"    - {warn}")
+
+        console.print()