ipman-cli 0.1.73__py3-none-any.whl

ipman/cli/hub.py

@@ -0,0 +1,237 @@
+"""CLI commands for IpHub (search, info, top, publish)."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import click
+
+from ipman.core.vetter import RiskLevel, assess_risk, vet_skill_content
+from ipman.hub.client import IpHubClient
+from ipman.hub.publisher import IpHubPublisher, PublishError, get_github_username
+
+
+def _submit_report(
+    name: str, body: str,
+) -> subprocess.CompletedProcess[str]:
+    """Submit a report issue to IpHub via gh CLI."""
+    import subprocess as _sp
+    return _sp.run(
+        [
+            "gh", "issue", "create",
+            "--repo", "twisker/iphub",
+            "--title", f"[report] {name}",
+            "--body", body,
+            "--label", "report",
+        ],
+        capture_output=True, text=True, check=False,
+    )
+
+
+def _get_hub_client() -> IpHubClient:
+    """Create an IpHubClient using configured hub URL."""
+    from ipman.core.config import load_config
+    cfg = load_config()
+    return IpHubClient(base_url=cfg.hub_url)
+
+
+@click.group()
+def hub() -> None:
+    """Browse and publish to the IpHub registry."""
+
+
+@hub.command()
+@click.argument("query", default="")
+@click.option("--agent", default=None, help="Filter by agent (e.g. claude-code).")
+def search(query: str, agent: str | None) -> None:
+    """Search IpHub for skills and packages."""
+    client = _get_hub_client()
+    results = client.search(query, agent=agent)
+
+    if not results:
+        click.echo("No results found.")
+        return
+
+    for r in results:
+        rtype = r.get("type", "skill")
+        tag = click.style(f"[{rtype}]", fg="cyan")
+        name = click.style(r["name"], bold=True)
+        desc = r.get("description", "")
+        installs = r.get("installs", 0)
+        click.echo(f"  {tag} {name}  {desc}  ({installs} installs)")
+
+
+@hub.command()
+@click.argument("name")
+def info(name: str) -> None:
+    """Show detailed info for a skill or package."""
+    client = _get_hub_client()
+    entry = client.lookup(name)
+
+    if entry is None:
+        raise click.ClickException(f"'{name}' not found in IpHub.")
+
+    click.secho(entry["name"], bold=True)
+    click.echo(f"  Type:        {entry.get('type', 'skill')}")
+    click.echo(f"  Owner:       {entry.get('owner', 'unknown')}")
+    click.echo(f"  Description: {entry.get('description', '')}")
+
+    if entry.get("latest"):
+        click.echo(f"  Latest:      {entry['latest']}")
+    if entry.get("versions"):
+        click.echo(f"  Versions:    {', '.join(entry['versions'])}")
+    if entry.get("agents"):
+        click.echo(f"  Agents:      {', '.join(entry['agents'])}")
+
+    installs = entry.get("installs", 0)
+    users = entry.get("unique_users", 0)
+    click.echo(f"  Installs:    {installs} ({users} unique users)")
+
+
+@hub.command()
+@click.option("--limit", "-n", default=10, help="Number of entries to show.")
+def top(limit: int) -> None:
+    """Show most installed skills and packages."""
+    client = _get_hub_client()
+    index = client.fetch_index()
+
+    entries: list[dict[str, Any]] = []
+    for section in ("skills", "packages"):
+        items = index.get(section, {})
+        for name, data in items.items():
+            entries.append({"name": name, **data})
+
+    entries.sort(key=lambda e: e.get("installs", 0), reverse=True)
+
+    if not entries:
+        click.echo("No entries in IpHub.")
+        return
+
+    click.secho("IpHub Top:", bold=True)
+    for i, e in enumerate(entries[:limit], 1):
+        rtype = e.get("type", "skill")
+        tag = click.style(f"[{rtype}]", fg="cyan")
+        name = click.style(e["name"], bold=True)
+        installs = e.get("installs", 0)
+        click.echo(f"  {i}. {tag} {name}  ({installs} installs)")
+
+
+@hub.command()
+@click.argument("source")
+@click.option("--description", "-d", default="", help="Skill/package description.")
+@click.option("--license", "license_", default=None, help="License (e.g. MIT).")
+@click.option("--homepage", default=None, help="Project homepage URL.")
+def publish(
+    source: str, description: str,
+    license_: str | None, homepage: str | None,
+) -> None:
+    """Publish a skill or IP package to IpHub.
+
+    SOURCE can be a skill name (e.g. web-scraper) or an .ip.yaml file path.
+    """
+    try:
+        username = get_github_username()
+    except PublishError as e:
+        raise click.ClickException(str(e)) from e
+
+    publisher = IpHubPublisher(username=username)
+
+    if source.endswith(".ip.yaml"):
+        # Publish IP package
+        path = Path(source)
+        if not path.exists():
+            raise click.ClickException(f"File not found: {source}")
+
+        from ipman.core.package import parse_ip_file
+        pkg = parse_ip_file(path)
+
+        # Pre-publish risk assessment
+        content = path.read_text(encoding="utf-8")
+        flags = vet_skill_content(content)
+        report = assess_risk(flags, skill_name=pkg.name)
+        if report.risk_level >= RiskLevel.HIGH:
+            click.secho(
+                f"Publish blocked: '{pkg.name}' rated "
+                f"{report.risk_level.name}",
+                fg="red", err=True,
+            )
+            for f in report.flags:
+                click.secho(f"  {f.description}", fg="red", err=True)
+            raise click.ClickException(
+                "HIGH/EXTREME risk items cannot be published."
+            )
+
+        click.echo(
+            f"Publishing package '{pkg.name}' v{pkg.version} "
+            f"as @{username}...",
+        )
+        try:
+            pr_url = publisher.publish_package(pkg)
+        except PublishError as e:
+            raise click.ClickException(str(e)) from e
+        click.secho(f"PR created: {pr_url}", fg="green")
+    else:
+        # Publish skill
+        if not description:
+            raise click.ClickException(
+                "Description is required for skill publishing. "
+                "Use --description."
+            )
+
+        # Pre-publish risk assessment on description
+        flags = vet_skill_content(description)
+        report = assess_risk(flags, skill_name=source)
+        if report.risk_level >= RiskLevel.HIGH:
+            click.secho(
+                f"Publish blocked: '{source}' rated "
+                f"{report.risk_level.name}",
+                fg="red", err=True,
+            )
+            for f in report.flags:
+                click.secho(f"  {f.description}", fg="red", err=True)
+            raise click.ClickException(
+                "HIGH/EXTREME risk items cannot be published."
+            )
+
+        click.echo(f"Publishing skill '{source}' as @{username}...")
+        try:
+            pr_url = publisher.publish_skill(
+                name=source,
+                description=description,
+                license_=license_,
+                homepage=homepage,
+            )
+        except PublishError as e:
+            raise click.ClickException(str(e)) from e
+        click.secho(f"PR created: {pr_url}", fg="green")
+
+
+@hub.command("report")
+@click.argument("name")
+@click.option("--reason", "-r", required=True,
+              help="Reason for reporting (required).")
+def report_cmd(name: str, reason: str) -> None:
+    """Report a suspicious skill or package."""
+    try:
+        username = get_github_username()
+    except PublishError as e:
+        raise click.ClickException(str(e)) from e
+
+    client = _get_hub_client()
+    entry = client.lookup(name)
+    if entry is None:
+        raise click.ClickException(f"'{name}' not found in IpHub.")
+
+    body = f"Report by @{username}: {reason}"
+    result = _submit_report(name, body)
+    if result.returncode != 0:
+        msg = result.stderr.strip() or "Failed to submit report"
+        raise click.ClickException(msg)
+
+    click.secho(
+        f"Reported '{name}'. Thank you for helping keep "
+        f"IpHub safe.",
+        fg="green",
+    )

ipman/cli/main.py

@@ -0,0 +1,37 @@
+"""IpMan CLI main entry point."""
+
+import click
+
+from ipman import __version__
+from ipman.cli.env import env
+from ipman.cli.hub import hub
+from ipman.cli.pack import pack
+from ipman.cli.skill import install, skill, uninstall
+from ipman.utils.i18n import detect_locale, set_locale
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="ipman")
+def cli() -> None:
+    """IpMan - Intelligence Package Manager.
+
+    Agent skill virtual environment manager.
+    Create, manage, and share isolated skill environments
+    for AI agent tools like Claude Code and OpenClaw.
+    """
+    set_locale(detect_locale())
+
+
+cli.add_command(env)
+cli.add_command(hub)
+cli.add_command(pack)
+cli.add_command(skill)
+cli.add_command(install)
+cli.add_command(uninstall)
+
+
+@cli.command()
+def info() -> None:
+    """Show IpMan installation info."""
+    click.echo(f"IpMan v{__version__}")
+    click.echo("https://github.com/twisker/ipman")

ipman/cli/pack.py

@@ -0,0 +1,67 @@
+"""CLI command for packing the current environment into an .ip.yaml file."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from ipman.cli._common import resolve_agent as _resolve_agent
+from ipman.core.package import IPPackage, SkillRef, dump_ip_file
+
+
+@click.command()
+@click.option("--name", "-n", required=True,
+              help="Package name for the .ip.yaml file.")
+@click.option("--version", "-v", "pkg_version", default="1.0.0",
+              help="Package version (default: 1.0.0).")
+@click.option("--description", "-d", default="",
+              help="Package description.")
+@click.option("--output", "-o", "output_path", default=None,
+              type=click.Path(),
+              help="Output file path (default: <name>.ip.yaml).")
+@click.option("--agent", "agent_name", default=None,
+              help="Agent tool to use (e.g. claude-code, openclaw).")
+@click.option("--force", is_flag=True, default=False,
+              help="Overwrite existing output file.")
+def pack(
+    name: str,
+    pkg_version: str,
+    description: str,
+    output_path: str | None,
+    agent_name: str | None,
+    force: bool,
+) -> None:
+    """Pack current environment skills into an .ip.yaml file.
+
+    Reads installed skills from the active agent and generates
+    a distributable IP package file.
+    """
+    adapter = _resolve_agent(agent_name)
+
+    # Determine output path
+    out = Path(output_path) if output_path else Path(f"{name}.ip.yaml")
+
+    if out.exists() and not force:
+        raise click.ClickException(
+            f"Output file already exists: {out}\n"
+            "Use --force to overwrite."
+        )
+
+    # Read skills from agent
+    skills_info = adapter.list_skills()
+    skill_refs = [SkillRef(name=s.name) for s in skills_info]
+
+    pkg = IPPackage(
+        name=name,
+        version=pkg_version,
+        description=description,
+        skills=skill_refs,
+    )
+
+    dump_ip_file(pkg, out)
+
+    click.secho(
+        f"Packed {len(skill_refs)} skill(s) into {out}",
+        fg="green",
+    )

ipman/cli/skill.py

@@ -0,0 +1,299 @@
+"""CLI commands for skill management (delegated to agent CLI)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import click
+
+from ipman.agents.base import AgentAdapter
+from ipman.cli._common import resolve_agent as _resolve_agent
+from ipman.core.config import SecurityMode, load_config
+from ipman.core.security import Action, decide_action, log_security_event
+from ipman.core.vetter import RiskLevel, VetReport, assess_risk, vet_skill_content
+
+if TYPE_CHECKING:
+    from ipman.hub.client import IpHubClient
+
+
+def _is_ip_file(source: str) -> bool:
+    """Check if the source argument looks like an .ip.yaml file path."""
+    return source.endswith(".ip.yaml")
+
+
+def _run_vet(content: str, skill_name: str) -> VetReport:
+    """Run risk assessment on skill content."""
+    flags = vet_skill_content(content)
+    return assess_risk(flags, skill_name=skill_name)
+
+
+def _enforce_security(
+    report: VetReport,
+    mode: SecurityMode,
+    source: str,
+) -> bool:
+    """Enforce security policy. Returns True if install should proceed."""
+    action = decide_action(report.risk_level, mode)
+    cfg = load_config()
+
+    if action == Action.BLOCK:
+        click.secho(
+            f"BLOCKED: '{report.skill_name}' — "
+            f"risk {report.risk_level.name}",
+            fg="red", err=True,
+        )
+        for f in report.flags:
+            click.secho(f"  {f.description}", fg="red", err=True)
+        if cfg.log_enabled:
+            log_security_event(
+                log_path=cfg.log_path,
+                skill_name=report.skill_name,
+                source=source,
+                risk_level=report.risk_level,
+                action=action,
+            )
+        return False
+
+    if action in (Action.WARN_INSTALL, Action.WARN_CONFIRM):
+        click.secho(
+            f"WARNING: '{report.skill_name}' — "
+            f"risk {report.risk_level.name}",
+            fg="yellow", err=True,
+        )
+        for f in report.flags:
+            click.secho(f"  {f.description}", fg="yellow", err=True)
+        if cfg.log_enabled:
+            log_security_event(
+                log_path=cfg.log_path,
+                skill_name=report.skill_name,
+                source=source,
+                risk_level=report.risk_level,
+                action=action,
+            )
+
+    return True
+
+
+def _get_hub_client() -> IpHubClient:
+    """Create an IpHubClient using configured hub URL."""
+    from ipman.hub.client import IpHubClient
+    cfg = load_config()
+    return IpHubClient(base_url=cfg.hub_url)
+
+
+def _install_from_hub(
+    name: str, adapter: AgentAdapter, *, dry_run: bool = False,
+) -> None:
+    """Install a skill or IP package by short name via IpHub."""
+    hub = _get_hub_client()
+    info = hub.lookup(name)
+    if info is None:
+        raise click.ClickException(
+            f"'{name}' not found in IpHub. "
+            "Check the name or use a file path for local .ip.yaml files."
+        )
+
+    entry_type = info.get("type", "skill")
+
+    if entry_type == "skill":
+        if dry_run:
+            click.echo(f"Would install skill: {name} (from IpHub)")
+            return
+        result = adapter.install_skill(name)
+        if result.returncode == 0:
+            click.secho(f"Installed '{name}' via {adapter.display_name}.", fg="green")
+        else:
+            msg = result.stderr.strip() or result.stdout.strip() or "Unknown error"
+            click.secho(f"Install failed: {msg}", fg="red", err=True)
+            raise SystemExit(1)
+    else:
+        # IP package — fetch version file and install all skills
+        registry = hub.fetch_registry(name)
+        if registry is None:
+            raise click.ClickException(f"Failed to fetch registry for '{name}'.")
+
+        skills = registry.get("skills", [])
+        if not skills:
+            click.secho(f"No skills in package '{name}'.", fg="yellow")
+            return
+
+        if dry_run:
+            click.echo(f"Would install {len(skills)} skill(s) from package '{name}':")
+            for s in skills:
+                click.echo(f"  {s['name']}")
+            return
+
+        ok, failed = 0, 0
+        for s in skills:
+            r = adapter.install_skill(s["name"])
+            if r.returncode == 0:
+                click.secho(f"  Installed '{s['name']}'", fg="green")
+                ok += 1
+            else:
+                msg = r.stderr.strip() or r.stdout.strip() or "Unknown error"
+                click.secho(f"  Failed '{s['name']}': {msg}", fg="red", err=True)
+                failed += 1
+
+        click.echo(f"\n{ok} installed, {failed} failed (from package '{name}')")
+        if failed:
+            raise SystemExit(1)
+
+
+def _install_from_ip_file(
+    path: Path, adapter: AgentAdapter, *, dry_run: bool = False,
+) -> None:
+    """Install all skills from an .ip.yaml file."""
+    from ipman.core.package import parse_ip_file
+
+    if not path.exists():
+        raise click.ClickException(f"IP file not found: {path}")
+
+    pkg = parse_ip_file(path)
+
+    if not pkg.skills:
+        click.secho(
+            f"No skills defined in {path.name} — nothing to install.",
+            fg="yellow",
+        )
+        return
+
+    if dry_run:
+        click.echo(f"Would install {len(pkg.skills)} skill(s) from {path.name}:")
+        for s in pkg.skills:
+            click.echo(f"  {s.name}")
+        return
+
+    ok, failed = 0, 0
+    for s in pkg.skills:
+        result = adapter.install_skill(s.name)
+        if result.returncode == 0:
+            click.secho(f"  Installed '{s.name}'", fg="green")
+            ok += 1
+        else:
+            msg = result.stderr.strip() or result.stdout.strip() or "Unknown error"
+            click.secho(f"  Failed '{s.name}': {msg}", fg="red", err=True)
+            failed += 1
+
+    click.echo(f"\n{ok} installed, {failed} failed (from {path.name})")
+    if failed:
+        raise SystemExit(1)
+
+
+@click.command()
+@click.argument("source")
+@click.option("--agent", "agent_name", default=None,
+              help="Agent tool to use (e.g. claude-code, openclaw).")
+@click.option("--dry-run", is_flag=True, default=False,
+              help="Show what would be installed without executing.")
+@click.option("--security", "security_mode", default=None,
+              type=click.Choice(
+                  ["permissive", "default", "cautious", "strict"],
+                  case_sensitive=False,
+              ),
+              help="Security mode override.")
+@click.option("--vet", "force_vet", is_flag=True, default=False,
+              help="Force local risk assessment (even for IpHub).")
+@click.option("--no-vet", "skip_vet", is_flag=True, default=False,
+              help="Skip local risk assessment.")
+@click.option("--yes", "auto_yes", is_flag=True, default=False,
+              help="Auto-confirm security warnings.")
+def install(
+    source: str,
+    agent_name: str | None,
+    dry_run: bool,
+    security_mode: str | None,
+    force_vet: bool,
+    skip_vet: bool,
+    auto_yes: bool,
+) -> None:
+    """Install a skill or an IP package.
+
+    SOURCE can be a skill name (e.g. web-scraper) or an .ip.yaml file path.
+    """
+    adapter = _resolve_agent(agent_name)
+
+    # Resolve security mode
+    cfg = load_config()
+    mode = SecurityMode(security_mode) if security_mode else cfg.security_mode
+
+    is_local = _is_ip_file(source)
+
+    # Determine whether to run local vet
+    should_vet = False
+    if skip_vet:
+        should_vet = False
+    elif force_vet:
+        should_vet = True
+    elif is_local:
+        # Local/URL sources: always vet by default
+        should_vet = True
+    elif mode == SecurityMode.STRICT:
+        # STRICT mode: vet everything
+        should_vet = True
+    # else: IpHub source in non-STRICT mode → trust existing label
+
+    # Run vet if needed
+    if should_vet and not dry_run:
+        if is_local:
+            path = Path(source)
+            if not path.exists():
+                raise click.ClickException(
+                    f"IP file not found: {path}",
+                )
+            content = path.read_text(encoding="utf-8")
+            report = _run_vet(content, skill_name=source)
+        else:
+            # For hub skills, vet the registry content
+            report = _run_vet("", skill_name=source)
+
+        if not _enforce_security(report, mode, source):
+            raise SystemExit(1)
+
+    if is_local:
+        _install_from_ip_file(
+            Path(source), adapter, dry_run=dry_run,
+        )
+    else:
+        _install_from_hub(source, adapter, dry_run=dry_run)
+
+
+@click.command()
+@click.argument("name")
+@click.option("--agent", "agent_name", default=None,
+              help="Agent tool to use (e.g. claude-code, openclaw).")
+def uninstall(name: str, agent_name: str | None) -> None:
+    """Uninstall a skill via the agent's native CLI."""
+    adapter = _resolve_agent(agent_name)
+    result = adapter.uninstall_skill(name)
+    if result.returncode == 0:
+        click.secho(
+            f"Uninstalled '{name}' via {adapter.display_name}.",
+            fg="green",
+        )
+    else:
+        msg = result.stderr.strip() or result.stdout.strip() or "Unknown error"
+        click.secho(f"Uninstall failed: {msg}", fg="red", err=True)
+        raise SystemExit(1)
+
+
+@click.group()
+def skill() -> None:
+    """Manage skills in the current environment."""
+
+
+@skill.command("list")
+@click.option("--agent", "agent_name", default=None,
+              help="Agent tool to use (e.g. claude-code, openclaw).")
+def list_cmd(agent_name: str | None) -> None:
+    """List installed skills via the agent's native CLI."""
+    adapter = _resolve_agent(agent_name)
+    skills = adapter.list_skills()
+    if not skills:
+        click.echo(f"No skills installed ({adapter.display_name}).")
+        return
+    for s in skills:
+        status = "" if s.enabled else click.style(" (disabled)", fg="yellow")
+        version = f" v{s.version}" if s.version else ""
+        click.echo(f"  {s.name}{version}{status}")
+    click.echo(f"\n{len(skills)} skill(s) installed.")