ipman-cli 0.1.73__py3-none-any.whl

ipman/__init__.py

@@ -0,0 +1,5 @@
+"""IpMan - Intelligence Package Manager."""
+
+from importlib.metadata import version as _version
+
+__version__ = _version("ipman-cli")

ipman/agents/base.py

@@ -0,0 +1,85 @@
+"""Base class for Agent tool adapters."""
+
+from __future__ import annotations
+
+import subprocess
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class SkillInfo:
+    """Structured info about an installed skill."""
+
+    name: str
+    version: str = ""
+    enabled: bool = True
+    source: str = ""
+
+
+class AgentAdapter(ABC):
+    """Base adapter for an Agent tool (e.g. Claude Code, OpenClaw).
+
+    Each adapter tells IpMan:
+    - What the agent's config directory is called
+    - How to detect if the agent is installed
+    - How to initialize a fresh environment directory for the agent
+    - How to install/uninstall/list skills via agent CLI commands
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Agent identifier, e.g. 'claude-code'."""
+
+    @property
+    @abstractmethod
+    def display_name(self) -> str:
+        """Human-readable name, e.g. 'Claude Code'."""
+
+    @property
+    @abstractmethod
+    def config_dir_name(self) -> str:
+        """Name of the agent's config directory, e.g. '.claude'."""
+
+    @abstractmethod
+    def is_installed(self) -> bool:
+        """Check if this agent tool is installed on the system."""
+
+    @abstractmethod
+    def init_env_dir(self, env_path: Path) -> None:
+        """Initialize a fresh environment directory."""
+
+    def detect_in_project(self, project_path: Path) -> bool:
+        """Check if this agent is used in the given project directory."""
+        return (project_path / self.config_dir_name).exists()
+
+    # --- Skill CLI delegation (Sprint 2) ---
+
+    @abstractmethod
+    def install_skill(
+        self, name: str, **kwargs: str | None,
+    ) -> subprocess.CompletedProcess[str]:
+        """Install a skill via agent's native CLI command."""
+
+    @abstractmethod
+    def uninstall_skill(
+        self, name: str,
+    ) -> subprocess.CompletedProcess[str]:
+        """Uninstall a skill via agent's native CLI command."""
+
+    @abstractmethod
+    def list_skills(self) -> list[SkillInfo]:
+        """List installed skills via agent's native CLI command."""
+
+    def _run_cli(
+        self, args: list[str],
+    ) -> subprocess.CompletedProcess[str]:
+        """Run a CLI command and capture output."""
+        return subprocess.run(
+            args,
+            capture_output=True,
+            text=True,
+            check=False,
+        )

ipman/agents/claude_code.py

@@ -0,0 +1,75 @@
+"""Claude Code agent adapter."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+from ipman.agents.base import AgentAdapter, SkillInfo
+
+
+class ClaudeCodeAdapter(AgentAdapter):
+    """Adapter for Claude Code.
+
+    Skill operations delegate to `claude plugin` CLI commands.
+    """
+
+    @property
+    def name(self) -> str:
+        return "claude-code"
+
+    @property
+    def display_name(self) -> str:
+        return "Claude Code"
+
+    @property
+    def config_dir_name(self) -> str:
+        return ".claude"
+
+    def is_installed(self) -> bool:
+        return shutil.which("claude") is not None
+
+    def init_env_dir(self, env_path: Path) -> None:
+        """Create Claude Code environment structure."""
+        skills_dir = env_path / "skills"
+        skills_dir.mkdir(parents=True, exist_ok=True)
+
+    def install_skill(
+        self, name: str, **kwargs: str | None,
+    ) -> subprocess.CompletedProcess[str]:
+        """Install a plugin via ``claude plugin install``."""
+        args = ["claude", "plugin", "install", name]
+        scope = kwargs.get("scope")
+        if scope:
+            args.extend(["-s", scope])
+        return self._run_cli(args)
+
+    def uninstall_skill(
+        self, name: str,
+    ) -> subprocess.CompletedProcess[str]:
+        """Uninstall a plugin via ``claude plugin uninstall``."""
+        return self._run_cli(
+            ["claude", "plugin", "uninstall", name],
+        )
+
+    def list_skills(self) -> list[SkillInfo]:
+        """List installed plugins via ``claude plugin list --json``."""
+        result = self._run_cli(
+            ["claude", "plugin", "list", "--json"],
+        )
+        if result.returncode != 0:
+            return []
+        try:
+            plugins = json.loads(result.stdout)
+        except (json.JSONDecodeError, TypeError):
+            return []
+        return [
+            SkillInfo(
+                name=p.get("name", ""),
+                version=p.get("version", ""),
+                enabled=p.get("enabled", True),
+            )
+            for p in plugins
+        ]

ipman/agents/openclaw.py

@@ -0,0 +1,74 @@
+"""OpenClaw agent adapter."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+from ipman.agents.base import AgentAdapter, SkillInfo
+
+
+class OpenClawAdapter(AgentAdapter):
+    """Adapter for OpenClaw.
+
+    Skill operations delegate to ``clawhub`` CLI commands.
+    """
+
+    @property
+    def name(self) -> str:
+        return "openclaw"
+
+    @property
+    def display_name(self) -> str:
+        return "OpenClaw"
+
+    @property
+    def config_dir_name(self) -> str:
+        return ".openclaw"
+
+    def is_installed(self) -> bool:
+        return shutil.which("openclaw") is not None
+
+    def init_env_dir(self, env_path: Path) -> None:
+        """Create OpenClaw environment structure."""
+        skills_dir = env_path / "skills"
+        skills_dir.mkdir(parents=True, exist_ok=True)
+
+    def install_skill(
+        self, name: str, **kwargs: str | None,
+    ) -> subprocess.CompletedProcess[str]:
+        """Install a skill via ``clawhub install``."""
+        args = ["clawhub", "install", name]
+        hub = kwargs.get("hub")
+        if hub:
+            args.extend(["--hub", hub])
+        return self._run_cli(args)
+
+    def uninstall_skill(
+        self, name: str,
+    ) -> subprocess.CompletedProcess[str]:
+        """Uninstall a skill via ``clawhub uninstall``."""
+        return self._run_cli(
+            ["clawhub", "uninstall", name],
+        )
+
+    def list_skills(self) -> list[SkillInfo]:
+        """List installed skills via ``clawhub list --json``."""
+        result = self._run_cli(
+            ["clawhub", "list", "--json"],
+        )
+        if result.returncode != 0:
+            return []
+        try:
+            skills = json.loads(result.stdout)
+        except (json.JSONDecodeError, TypeError):
+            return []
+        return [
+            SkillInfo(
+                name=s.get("name", ""),
+                version=s.get("version", ""),
+            )
+            for s in skills
+        ]

ipman/agents/registry.py

@@ -0,0 +1,45 @@
+"""Agent adapter registry."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ipman.agents.base import AgentAdapter
+from ipman.agents.claude_code import ClaudeCodeAdapter
+from ipman.agents.openclaw import OpenClawAdapter
+
+# All known adapters, in detection priority order
+_ADAPTERS: list[AgentAdapter] = [
+    ClaudeCodeAdapter(),
+    OpenClawAdapter(),
+]
+
+
+def get_adapter(name: str) -> AgentAdapter:
+    """Get an adapter by agent name."""
+    for adapter in _ADAPTERS:
+        if adapter.name == name:
+            return adapter
+    known = ", ".join(a.name for a in _ADAPTERS)
+    msg = f"Unknown agent: '{name}'. Known agents: {known}"
+    raise ValueError(msg)
+
+
+def detect_agent(project_path: Path | None = None) -> AgentAdapter | None:
+    """Auto-detect the agent used in a project directory."""
+    if project_path is None:
+        project_path = Path.cwd()
+    for adapter in _ADAPTERS:
+        if adapter.detect_in_project(project_path):
+            return adapter
+    return None
+
+
+def detect_installed_agents() -> list[AgentAdapter]:
+    """Detect all agent tools installed on the system."""
+    return [a for a in _ADAPTERS if a.is_installed()]
+
+
+def list_known_agents() -> list[str]:
+    """Return names of all known agents."""
+    return [a.name for a in _ADAPTERS]

ipman/cli/_common.py

@@ -0,0 +1,21 @@
+"""Shared CLI utilities."""
+
+from __future__ import annotations
+
+import click
+
+from ipman.agents.base import AgentAdapter
+from ipman.agents.registry import detect_agent, get_adapter
+
+
+def resolve_agent(agent_name: str | None) -> AgentAdapter:
+    """Resolve adapter from --agent flag or auto-detection."""
+    if agent_name:
+        return get_adapter(agent_name)
+    detected = detect_agent()
+    if detected is None:
+        raise click.ClickException(
+            "No agent detected. Use --agent to specify one "
+            "(e.g. --agent claude-code)."
+        )
+    return detected

ipman/cli/env.py

@@ -0,0 +1,271 @@
+"""CLI commands for virtual environment management."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import click
+
+from ipman.agents.registry import detect_agent, get_adapter, list_known_agents
+from ipman.core.environment import (
+    Scope,
+    activate_env,
+    build_prompt_tag,
+    create_env,
+    deactivate_env,
+    delete_env,
+    generate_activate_script,
+    generate_deactivate_script,
+    get_env_status,
+    list_envs,
+)
+
+
+def _resolve_scope(project: bool, user: bool, machine: bool) -> Scope:
+    if user:
+        return Scope.USER
+    if machine:
+        return Scope.MACHINE
+    return Scope.PROJECT
+
+
+def _resolve_adapter(agent: str | None, project_path: Path) -> object:
+    """Resolve the agent adapter from --agent flag or auto-detection."""
+    if agent:
+        return get_adapter(agent)
+    detected = detect_agent(project_path)
+    if detected:
+        return detected
+    # Default to claude-code
+    return get_adapter("claude-code")
+
+
+def _detect_shell() -> str:
+    shell_path = os.environ.get("SHELL", "")
+    if "fish" in shell_path:
+        return "fish"
+    if "zsh" in shell_path or "bash" in shell_path:
+        return "bash"
+    # Windows
+    if os.environ.get("PSMODULEPATH"):
+        return "powershell"
+    return "bash"
+
+
+@click.group()
+def env() -> None:
+    """Manage virtual skill environments."""
+
+
+@env.command()
+@click.argument("name")
+@click.option("--project", "scope_project", is_flag=True, default=True,
+              help="Create in current project (default).")
+@click.option("--user", "scope_user", is_flag=True, default=False,
+              help="Create for current user.")
+@click.option("--machine", "scope_machine", is_flag=True, default=False,
+              help="Create for entire machine.")
+@click.option("--agent", default=None,
+              help=f"Agent tool to target. Known: {', '.join(list_known_agents())}")
+@click.option("--inherit", is_flag=True, default=False,
+              help="Inherit existing skills from current agent config.")
+def create(
+    name: str,
+    scope_project: bool,
+    scope_user: bool,
+    scope_machine: bool,
+    agent: str | None,
+    inherit: bool,
+) -> None:
+    """Create a new virtual skill environment."""
+    project_path = Path.cwd()
+    scope = _resolve_scope(scope_project, scope_user, scope_machine)
+    adapter = _resolve_adapter(agent, project_path)
+
+    try:
+        env_path = create_env(
+            name=name,
+            adapter=adapter,  # type: ignore[arg-type]
+            scope=scope,
+            project_path=project_path,
+            inherit=inherit,
+        )
+        click.secho(
+            f"Created environment '{name}' at {env_path}",
+            fg="green",
+        )
+        click.echo(f"  Agent: {adapter.display_name}")  # type: ignore[attr-defined]
+        click.echo(f"  Scope: {scope.value}")
+        if inherit:
+            click.echo("  Inherited existing skills.")
+        click.echo(f"\nActivate with: ipman env activate {name}")
+    except FileExistsError as e:
+        click.secho(str(e), fg="red", err=True)
+        raise SystemExit(1) from None
+
+
+@env.command()
+@click.argument("name")
+@click.option("--project", "scope_project", is_flag=True, default=True)
+@click.option("--user", "scope_user", is_flag=True, default=False)
+@click.option("--machine", "scope_machine", is_flag=True, default=False)
+def activate(
+    name: str,
+    scope_project: bool,
+    scope_user: bool,
+    scope_machine: bool,
+) -> None:
+    """Activate a virtual skill environment.
+
+    To update your shell prompt, use:
+
+        eval "$(ipman env activate myenv)"
+    """
+    project_path = Path.cwd()
+    scope = _resolve_scope(scope_project, scope_user, scope_machine)
+
+    try:
+        activate_env(
+            name=name,
+            scope=scope,
+            project_path=project_path,
+        )
+        prompt_tag = build_prompt_tag(project_path)
+        shell = _detect_shell()
+        script = generate_activate_script(name, shell, prompt_tag)
+        # If stdout is a terminal, print human-friendly message
+        # If piped (eval), print only the script
+        if os.isatty(1):
+            click.secho(f"Activated '{name}'.", fg="green")
+            click.echo(f"  Prompt tag: {prompt_tag}")
+            click.echo(
+                "\nTo update your shell prompt, run:\n"
+                f'  eval "$(ipman env activate {name})"'
+            )
+        else:
+            click.echo(script, nl=False)
+    except (FileNotFoundError, FileExistsError) as e:
+        click.secho(str(e), fg="red", err=True)
+        raise SystemExit(1) from None
+
+
+@env.command()
+def deactivate() -> None:
+    """Deactivate the current virtual skill environment.
+
+    To update your shell prompt, use:
+
+        eval "$(ipman env deactivate)"
+    """
+    project_path = Path.cwd()
+
+    try:
+        deactivate_env(project_path=project_path)
+        shell = _detect_shell()
+        script = generate_deactivate_script(shell)
+        if os.isatty(1):
+            click.secho("Environment deactivated.", fg="green")
+            click.echo(
+                "\nTo restore your shell prompt, run:\n"
+                '  eval "$(ipman env deactivate)"'
+            )
+        else:
+            click.echo(script, nl=False)
+    except RuntimeError as e:
+        click.secho(str(e), fg="red", err=True)
+        raise SystemExit(1) from None
+
+
+@env.command("delete")
+@click.argument("name")
+@click.option("--project", "scope_project", is_flag=True, default=True)
+@click.option("--user", "scope_user", is_flag=True, default=False)
+@click.option("--machine", "scope_machine", is_flag=True, default=False)
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation.")
+def delete_cmd(
+    name: str,
+    scope_project: bool,
+    scope_user: bool,
+    scope_machine: bool,
+    yes: bool,
+) -> None:
+    """Delete a virtual skill environment."""
+    if not yes:
+        click.confirm(
+            f"Delete environment '{name}'? This cannot be undone.",
+            abort=True,
+        )
+
+    project_path = Path.cwd()
+    scope = _resolve_scope(scope_project, scope_user, scope_machine)
+
+    try:
+        delete_env(name=name, scope=scope, project_path=project_path)
+        click.secho(f"Deleted environment '{name}'.", fg="green")
+    except FileNotFoundError as e:
+        click.secho(str(e), fg="red", err=True)
+        raise SystemExit(1) from None
+
+
+@env.command("list")
+@click.option("--project", "scope_project", is_flag=True, default=True)
+@click.option("--user", "scope_user", is_flag=True, default=False)
+@click.option("--machine", "scope_machine", is_flag=True, default=False)
+def list_cmd(
+    scope_project: bool,
+    scope_user: bool,
+    scope_machine: bool,
+) -> None:
+    """List all virtual skill environments."""
+    project_path = Path.cwd()
+    scope = _resolve_scope(scope_project, scope_user, scope_machine)
+
+    envs = list_envs(scope=scope, project_path=project_path)
+
+    if not envs:
+        click.echo(f"No environments found ({scope.value} scope).")
+        return
+
+    for e in envs:
+        marker = click.style(" *", fg="cyan") if e.get("active") else ""
+        name = e.get("name", "unknown")
+        agent = e.get("agent", "unknown")
+        created = e.get("created", "")
+        click.echo(
+            f"  {name}{marker}  (agent: {agent}, created: {created})"
+        )
+
+    active_count = sum(1 for e in envs if e.get("active"))
+    if active_count:
+        click.echo("\n  * = currently active")
+
+
+@env.command("status")
+def status_cmd() -> None:
+    """Show detailed active environment status across all scopes."""
+    project_path = Path.cwd()
+    prompt_tag = build_prompt_tag(project_path)
+    status = get_env_status(project_path)
+
+    if not status:
+        click.echo("No active environments.")
+        return
+
+    click.echo(f"Prompt: {prompt_tag}\n")
+
+    scope_labels = {
+        "machine": ("*", "Machine"),
+        "user": ("-", "User"),
+        "project": ("", "Project"),
+    }
+
+    for entry in status:
+        scope = entry["scope"]
+        symbol, label = scope_labels.get(scope, ("", scope))
+        prefix = f"  {symbol} " if symbol else "  "
+        click.secho(f"{prefix}{label}", fg="cyan", nl=False)
+        click.echo(
+            f": {entry['name']}  "
+            f"(agent: {entry['agent']}, path: {entry['path']})"
+        )