agentnet-cli 0.2.3__tar.gz → 0.3.0__tar.gz

agentnet_cli-0.3.0/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.3.0 - 2026-07-18
+
+- Add Claude Code search-fire hook support so AgentNet can surface relevant marketplace skills during search workflows.
+- Add `agentnet enable-search-fire` for one-command Claude hook installation.
+- Preserve malformed Claude settings files instead of overwriting them during connector setup.
+- Add setup telemetry hooks and a platform client telemetry helper.
+- Bump bundled Hermes, hosted skill, and OpenClaw integration metadata to match the CLI release.

{agentnet_cli-0.2.3 → agentnet_cli-0.3.0}/CLAUDE.md

@@ -8,7 +8,7 @@ CLI tool that detects AI coding agents on your system and connects them to the [
 - **Package manager:** uv
 - **CLI framework:** Typer + Rich
 - **HTTP client:** httpx
-- **Testing:** pytest (354 tests), pytest-cov
+- **Testing:** pytest (406 tests), pytest-cov
 - **CI:** GitHub Actions (lint + test matrix on 3.11/3.12/3.13)
 - **Publish:** PyPI via trusted publisher (tag `v*`)
 
@@ -44,6 +44,7 @@ uv run agentnet --help           # Run locally
 - **Hermes Plugin:** `agentnet connect hermes` copies the plugin to `~/.hermes/plugins/agentnet/` and skills to `~/.hermes/skills/agentnet/`, using Hermes's native plugin system.
 - **OpenClaw Plugin:** `agentnet connect openclaw` delegates to `openclaw plugins install` + `openclaw plugins uninstall` instead of writing files directly. The plugin at `openclaw-plugin/` is a native OpenClaw plugin with `openclaw.plugin.json` manifest, publishable to ClawHub.
 - **Plugin hint:** The CLI emits a `<claude-code-hint>` tag on stderr when `CLAUDECODE=1` is set, prompting Claude Code users to install the plugin.
+- **Every-prompt skill hook (Claude Code):** `agentnet enable-skill-fire` (and `connect claude`) install three hooks in `~/.claude/settings.json` (also bundled in the plugin's `hooks/hooks.json`). `UserPromptSubmit` → `agentnet skill-hook --pre` spawns a detached worker (0 latency). The worker discovers **installable skill candidates** (`discover_skills` → skills.sh, each carrying a `<repo>@<slug>`) + runs a cheap no-tool `claude -p` **classifier** (Haiku) as the reliable relevance **gate** (a bare yes/no gate isn't — the model just answers). Two-phase so the outcome reaches the hooks fast: **Phase 1** caches the **recommendation list** (relevant skills by name + why + skills.sh link) the moment the gate opens (~12s); **Phase 2** *appends* the top match fetched via `npx skills use <repo>@<slug>` (which downloads the skill — SKILL.md + references — to a temp dir; single-file skills are materialized to a temp `SKILL.md`) as a **concise header (name + description) + the on-disk path**, not a full SKILL.md dump. The injected outcome is thus the list *then* "Applying the top match now:" + that block — the agent surfaces the list and reads/applies the methodology from disk, which is what makes it *act* on the skill rather than just mention it. No files are written to the repo. If content is unavailable (no `npx`/all fetches miss), Phase 2 falls back — behind the same open gate — to the live **Skills Agent** over **brokered A2A**: `PlatformClient.use_agent(agent_id="agentnet-skills-agent", task=…)` with the user's `setup` identity; the platform relays A2A and returns `{status:"settled", agent_response}` in one call. **No skills-agent token is ever held client-side.** Only a `settled` response is used. Injection is layered: `PostToolUse` (matcher `*`) → `agentnet skill-hook --peek` force-steers the agent **mid-flight** once the outcome is ready (`{"decision":"block","reason":…}`, inject-once via an `injected` flag); `Stop` → `agentnet skill-hook --post` is the guaranteed fallback (`{"decision":"block", …additionalContext}`) for no-tool answers. Because the hooks are registered in **both** `settings.json` (via `connect`/`enable-skill-fire`) and the plugin's `hooks.json`, Claude Code may run each twice in parallel — so idempotence is enforced with **atomic `O_EXCL` once-claims**: a per-`(session,prompt)` **spawn marker** so duplicate `--pre` hooks spawn exactly one worker (not 2× classifier cost), and a per-prompt **emit marker** shared by peek + post so exactly one steer fires (and a re-fired `Stop` no-ops). Session-keyed JSON cache `$TMPDIR/agentnet-skill/<session>.json` (`{outcome}`) + sibling `.emitted`/`.<hash>.spawn` markers; `AGENTNET_SKILL_SUBAGENT=1` guards recursion. All best-effort — no token/binary/candidates/unreachable-platform/timeout injects nothing. `agent_id` overridable via `AGENTNET_SKILLS_AGENT_ID`/config. Implemented in `tools/hook.py` + `connectors/claude_search_hook.py`.
 
 ## Testing Patterns
 

{agentnet_cli-0.2.3 → agentnet_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnet-cli
-Version: 0.2.3
+Version: 0.3.0
 Summary: Detect AI agents and connect them to the Agent-net marketplace
 Project-URL: Homepage, https://agentnet.market
 Project-URL: Repository, https://github.com/TheAgent-net/agentnet-cli
@@ -65,6 +65,9 @@ Requires Python 3.11+.
 # Install from PyPI
 pip install agentnet-cli
 
+# Install this release exactly
+pip install agentnet-cli==0.3.0
+
 # Or run without installing
 uvx agentnet
 
@@ -151,19 +154,8 @@ All marketplace commands output JSON to stdout. Errors output `{"error": "..."}`
 
 | Command | Description |
 |---------|-------------|
-| `agentnet discover <query>` | Search the marketplace by capability |
-| `agentnet agents <query>` | Search for agents by name or capability |
-| `agentnet agent <id>` | Get full details about an agent |
-
-### Unified Search (JSON output)
-
-| Command | Description |
-|---------|-------------|
-| `agentnet search "<query>"` | Search listings, agents, skills, and plugins |
-| `agentnet search "<query>" --type listings` | Search marketplace listings |
-| `agentnet search "<query>" --type agents` | Search AI agents |
-| `agentnet search "<query>" --type skills` | Discover ranked skills/plugins |
-| `agentnet search "<query>" --type plugins` | Search plugin sources |
+| `agentnet discover <query>` | Discover agents and community skills by capability |
+| `agentnet agent <id>` | Get full details about an agent, or the full content of a skill (`agent skill:<id>`) |
 
 ### MCP Server (internal)
 

{agentnet_cli-0.2.3 → agentnet_cli-0.3.0}/README.md

@@ -38,6 +38,9 @@ Requires Python 3.11+.
 # Install from PyPI
 pip install agentnet-cli
 
+# Install this release exactly
+pip install agentnet-cli==0.3.0
+
 # Or run without installing
 uvx agentnet
 
@@ -124,19 +127,8 @@ All marketplace commands output JSON to stdout. Errors output `{"error": "..."}`
 
 | Command | Description |
 |---------|-------------|
-| `agentnet discover <query>` | Search the marketplace by capability |
-| `agentnet agents <query>` | Search for agents by name or capability |
-| `agentnet agent <id>` | Get full details about an agent |
-
-### Unified Search (JSON output)
-
-| Command | Description |
-|---------|-------------|
-| `agentnet search "<query>"` | Search listings, agents, skills, and plugins |
-| `agentnet search "<query>" --type listings` | Search marketplace listings |
-| `agentnet search "<query>" --type agents` | Search AI agents |
-| `agentnet search "<query>" --type skills` | Discover ranked skills/plugins |
-| `agentnet search "<query>" --type plugins` | Search plugin sources |
+| `agentnet discover <query>` | Discover agents and community skills by capability |
+| `agentnet agent <id>` | Get full details about an agent, or the full content of a skill (`agent skill:<id>`) |
 
 ### MCP Server (internal)
 

{agentnet_cli-0.2.3 → agentnet_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentnet-cli"
-version = "0.2.3"
+version = "0.3.0"
 description = "Detect AI agents and connect them to the Agent-net marketplace"
 readme = "README.md"
 requires-python = ">=3.11"

{agentnet_cli-0.2.3 → agentnet_cli-0.3.0}/src/agentnet_cli/cli/core/setup_wizard.py

@@ -11,6 +11,8 @@ from rich.console import Console
 from rich.table import Table
 
 from ...infra.config import load_config
+from ...infra.platform import resolve_platform_url
+from ...marketplace.client import PlatformClient
 from .connect import connect_command
 from .detect import detect_all
 from ...infra.paths import AgentName, agent_display_name
@@ -19,7 +21,23 @@ from .register import default_agent_name, register_command
 console = Console()
 
 
+def _send_telemetry(event_type: str, **metadata: str) -> None:
+    """Best-effort telemetry to platform; never blocks setup."""
+    try:
+        import httpx
+
+        config = load_config() or {}
+        base = resolve_platform_url(config=config)
+        token = config.get("api_token", "")
+        http_client = httpx.Client(timeout=5.0)
+        with PlatformClient(base_url=base, api_token=token, http_client=http_client) as client:
+            client.send_telemetry(event_type=event_type, metadata=metadata or None)
+    except Exception:
+        pass
+
+
 def setup_command(platform_url: str | None = None, *, choose: bool = False) -> None:
+    _send_telemetry("cli_setup")
     config = load_config()
     if not config or not config.get("api_token"):
         console.print()
@@ -62,6 +80,7 @@ def setup_command(platform_url: str | None = None, *, choose: bool = False) -> N
         f"  [bold]Step 3:[/bold] Configuring all detected agents ({len(targets)})"
     )
     connect_command(connect_all=True)
+    _send_telemetry("cli_setup_complete", connectors=",".join(targets))
 
 
 def _available_targets(results) -> list[str]:

{agentnet_cli-0.2.3 → agentnet_cli-0.3.0}/src/agentnet_cli/cli/main.py

@@ -301,13 +301,62 @@ def mcp_serve() -> None:
     serve()
 
 
+@app.command(name="skill-hook", hidden=True)
+def skill_hook(
+    pre: bool = typer.Option(False, "--pre", help="UserPromptSubmit: spawn the discovery worker"),
+    peek: bool = typer.Option(False, "--peek", help="PostToolUse: steer the agent mid-flight"),
+    post: bool = typer.Option(False, "--post", help="Stop: fold in relevant AgentNet skills"),
+    fetch: bool = typer.Option(False, "--fetch", help="Detached worker: discover + cache (internal)"),
+    session: str = typer.Option("", "--session", help="Session id (worker)"),
+    query: str = typer.Option("", "--query", help="Prompt text (worker)"),
+    limit: int = typer.Option(5, "--limit", help="Max skills to suggest"),
+    hook_timeout: float = typer.Option(
+        3.0, "--timeout", help="Max seconds a hook waits for the subagent's result",
+    ),
+) -> None:
+    """Claude Code every-prompt hooks — surface relevant AgentNet skills (internal).
+
+    ``--pre`` (UserPromptSubmit) spawns a detached skill-scout worker; ``--peek`` (PostToolUse)
+    steers the agent mid-flight once the outcome is ready; ``--post`` (Stop) is the guaranteed
+    fallback. Best-effort: nothing/exit 0 on error.
+    """
+    from ..tools.hook import run_fetch, run_peek, run_post, run_pre
+
+    if fetch:
+        run_fetch(session=session, query=query, limit=limit, timeout=hook_timeout)
+    elif pre:
+        run_pre(limit=limit, timeout=hook_timeout)
+    elif peek:
+        run_peek(limit=limit, timeout=hook_timeout)
+    else:  # default and --post
+        run_post(limit=limit, timeout=hook_timeout)
+
+
+@app.command(name="enable-skill-fire")
+def enable_skill_fire(
+    remove: bool = typer.Option(False, "--remove", help="Remove the hook instead of installing"),
+) -> None:
+    """Fire AgentNet on every Claude Code prompt (writes ~/.claude/settings.json)."""
+    from ..connectors.claude_search_hook import SettingsHookError, install, uninstall
+
+    try:
+        changed, path = uninstall() if remove else install()
+    except SettingsHookError as exc:
+        console.print(f"[red]✗[/red] {exc}")
+        raise typer.Exit(1) from exc
+    action = "removed" if remove else "installed"
+    if changed:
+        console.print(f"[green]✓[/green] AgentNet skill hook {action} in [bold]{path}[/bold]")
+        if not remove:
+            console.print("  [dim]Restart Claude Code — every prompt now fires AgentNet.[/dim]")
+    else:
+        state = "not present" if remove else "already installed"
+        console.print(f"[dim]No change ({state}): {path}[/dim]")
+
+
 # -- Marketplace commands --
 from .marketplace.agent import agent as _agent_fn  # noqa: E402
-from .marketplace.discover import agents as _agents_fn  # noqa: E402
 from .marketplace.discover import discover as _discover_fn  # noqa: E402
-from .marketplace.search import search as _search_fn  # noqa: E402
 
-app.command(name="search")(_search_fn)
 app.command(name="discover")(_discover_fn)
-app.command(name="agents")(_agents_fn)
 app.command(name="agent")(_agent_fn)

agentnet_cli-0.3.0/src/agentnet_cli/cli/marketplace/agent.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import typer
+
+from ...marketplace.auth import die, get_client, output
+from ...marketplace.client import PlatformError
+
+
+def agent(
+    agent_id: str = typer.Argument(
+        help="Agent or skill ID from discover results (skill IDs are prefixed skill:)",
+    ),
+) -> None:
+    """Get full details about an agent or a community skill's full content."""
+    client = get_client()
+    try:
+        if agent_id.startswith("skill:"):
+            result = client.get_skill(skill_id=agent_id)
+        else:
+            result = client.get_agent(agent_id=agent_id)
+        output(result)
+    except PlatformError as e:
+        die(str(e))

agentnet_cli-0.3.0/src/agentnet_cli/cli/marketplace/discover.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import typer
+
+from ...marketplace.auth import die, get_client, output
+from ...marketplace.client import PlatformError
+
+
+def discover(
+    query: str = typer.Argument(help="What you need — an agent capability or a skill"),
+    limit: int = typer.Option(20, "--limit", "-l", help="Max results"),
+) -> None:
+    """Discover agents and community skills matching a query."""
+    client = get_client()
+    try:
+        result = client.discover_agents(query=query, limit=limit)
+        output(result)
+    except PlatformError as e:
+        die(str(e))

{agentnet_cli-0.2.3 → agentnet_cli-0.3.0}/src/agentnet_cli/connectors/claude.py

@@ -45,34 +45,64 @@ class ClaudeConnector(AgentConnector):
                 errors=["Claude Code not found. Install it from https://code.claude.com"],
             )
 
-        marketplace_src = _marketplace_source()
-
-        proc = subprocess.run(
-            ["claude", "plugin", "marketplace", "add", marketplace_src, "--scope", "user"],
-            capture_output=True,
-            timeout=_SUBPROCESS_TIMEOUT,
-        )
-        if proc.returncode != 0:
-            msg = proc.stderr.decode(errors="replace").strip()
-            return ConnectionResult(success=False, errors=[f"marketplace add failed: {msg}"])
-
-        proc = subprocess.run(
-            ["claude", "plugin", "install", _PLUGIN_ID, "--scope", "user"],
-            capture_output=True,
-            timeout=_SUBPROCESS_TIMEOUT,
-        )
-        if proc.returncode != 0:
-            msg = proc.stderr.decode(errors="replace").strip()
-            return ConnectionResult(success=False, errors=[f"plugin install failed: {msg}"])
+        # 1. Install the AgentNet every-prompt hook straight into settings.json.
+        #    This is the reliable path: every prompt fires AgentNet (discover +
+        #    fold in relevant skills). It does NOT depend on the plugin marketplace
+        #    flow (which errors on some Claude Code versions), so connect succeeds
+        #    even if that fails.
+        from .claude_search_hook import SettingsHookError
+        from .claude_search_hook import install as install_search_hook
+
+        errors: list[str] = []
+        try:
+            install_search_hook()
+        except SettingsHookError as exc:
+            # A malformed settings.json must not be overwritten; report and preserve it, but let
+            # the rest of connect (MCP + plugin) still run.
+            errors.append(str(exc))
+
+        # 2. Best-effort: install the plugin for the discovery MCP tools and
+        #    session hooks. `marketplace add` takes only <source> (no --scope).
+        #    Failures here are non-fatal — the prompt hook above is already live.
+        try:
+            marketplace_src = _marketplace_source()
+            proc = subprocess.run(
+                ["claude", "plugin", "marketplace", "add", marketplace_src],
+                capture_output=True,
+                timeout=_SUBPROCESS_TIMEOUT,
+            )
+            if proc.returncode == 0:
+                proc = subprocess.run(
+                    ["claude", "plugin", "install", _PLUGIN_ID, "--scope", "user"],
+                    capture_output=True,
+                    timeout=_SUBPROCESS_TIMEOUT,
+                )
+                if proc.returncode != 0:
+                    errors.append(
+                        "plugin install (discovery tools) failed: "
+                        + proc.stderr.decode(errors="replace").strip()
+                    )
+            else:
+                errors.append(
+                    "plugin marketplace add (discovery tools) failed: "
+                    + proc.stderr.decode(errors="replace").strip()
+                )
+        except Exception as exc:  # noqa: BLE001 — plugin step is best-effort
+            errors.append(f"plugin step skipped: {exc}")
 
         self._cleanup_legacy()
 
         return ConnectionResult(
             success=True,
-            mcp_entry={"scope": "plugin", "plugin_name": _PLUGIN_ID},
+            mcp_entry={"scope": "settings-hook", "search_fire": True},
+            errors=errors,
         )
 
     def disconnect(self, connection_manifest: dict[str, Any]) -> bool:
+        from .claude_search_hook import uninstall as uninstall_search_hook
+
+        uninstall_search_hook()
+
         claude_bin = shutil.which("claude")
         if not claude_bin:
             return True

agentnet_cli-0.3.0/src/agentnet_cli/connectors/claude_search_hook.py

@@ -0,0 +1,150 @@
+"""Install the AgentNet every-prompt hooks directly into Claude Code's settings.json.
+
+Registers three hooks: ``UserPromptSubmit`` (spawn a background discovery worker),
+``PostToolUse`` (steer the agent mid-flight once the outcome is ready), and ``Stop``
+(guaranteed fallback that folds the outcome in). Same effect as the bundled plugin, but
+written straight into ``~/.claude/settings.json`` so it works in one command regardless of
+Claude Code version.
+
+``PostToolUse`` is tool-scoped so its block carries a ``*`` matcher (all tools);
+``UserPromptSubmit`` and ``Stop`` are not tool-scoped, so their blocks carry no matcher.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from ..infra.paths import AgentName, agent_config_root
+
+
+class SettingsHookError(Exception):
+    """Raised when ~/.claude/settings.json exists but is malformed, so it must not be overwritten."""
+
+
+# event -> (command, matcher). matcher=None for non-tool-scoped events.
+_HOOKS: dict[str, tuple[str, str | None]] = {
+    "UserPromptSubmit": ("agentnet skill-hook --pre", None),
+    "PostToolUse": ("agentnet skill-hook --peek", "*"),
+    "Stop": ("agentnet skill-hook --post", None),
+}
+
+
+def _settings_path():
+    return agent_config_root(AgentName.CLAUDE) / "settings.json"
+
+
+def _load(path) -> dict[str, Any]:
+    """Parse an existing settings.json to a dict.
+
+    Absent file -> ``{}`` (a fresh config). A file that *exists* but is unparseable or not a JSON
+    object is NOT the same as empty — overwriting it would erase the user's real config — so raise
+    ``SettingsHookError`` and let the caller preserve the file untouched.
+    """
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError) as exc:
+        raise SettingsHookError(f"{path} is not valid JSON — fix it and re-run") from exc
+    if not isinstance(data, dict):
+        raise SettingsHookError(f"{path} is not a JSON object — fix it and re-run")
+    return data
+
+
+def _is_agentnet_cmd(cmd: Any) -> bool:
+    return isinstance(cmd, str) and cmd.startswith("agentnet skill-hook")
+
+
+def _block(command: str, matcher: str | None) -> dict[str, Any]:
+    block: dict[str, Any] = {}
+    if matcher is not None:
+        block["matcher"] = matcher
+    block["hooks"] = [{"type": "command", "command": command}]
+    return block
+
+
+def _event_has_agentnet(blocks: list[Any]) -> bool:
+    for b in blocks:
+        if isinstance(b, dict) and any(
+            isinstance(h, dict) and _is_agentnet_cmd(h.get("command")) for h in b.get("hooks", [])
+        ):
+            return True
+    return False
+
+
+def install() -> tuple[bool, str]:
+    """Add the UserPromptSubmit/Stop hooks to settings.json. Returns (changed, path)."""
+    path = _settings_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = _load(path)
+    hooks = data.setdefault("hooks", {})
+    if not isinstance(hooks, dict):
+        hooks = {}
+        data["hooks"] = hooks
+
+    changed = False
+    for event, (command, matcher) in _HOOKS.items():
+        blocks = hooks.get(event)
+        if blocks is None:
+            blocks = []
+            hooks[event] = blocks
+        elif isinstance(blocks, dict):
+            # A single hook block stored as an object — preserve it by wrapping, don't discard it.
+            blocks = [blocks]
+            hooks[event] = blocks
+        elif not isinstance(blocks, list):
+            # Some other scalar we don't understand — leave the user's value untouched.
+            continue
+        if not _event_has_agentnet(blocks):
+            blocks.append(_block(command, matcher))
+            changed = True
+
+    if changed:
+        path.write_text(json.dumps(data, indent=2) + "\n")
+    return changed, str(path)
+
+
+def uninstall() -> tuple[bool, str]:
+    """Remove the AgentNet every-prompt hooks from settings.json. Returns (changed, path).
+
+    A malformed settings file has nothing removable and must not be overwritten, so treat it as
+    a no-op rather than raising into the (best-effort) disconnect path.
+    """
+    path = _settings_path()
+    try:
+        data = _load(path)
+    except SettingsHookError:
+        return False, str(path)
+    hooks = data.get("hooks")
+    if not isinstance(hooks, dict):
+        return False, str(path)
+
+    changed = False
+    for event in list(_HOOKS):
+        blocks = hooks.get(event)
+        if not isinstance(blocks, list):
+            continue
+        kept = [
+            b
+            for b in blocks
+            if not (
+                isinstance(b, dict)
+                and any(
+                    isinstance(h, dict) and _is_agentnet_cmd(h.get("command"))
+                    for h in b.get("hooks", [])
+                )
+            )
+        ]
+        if len(kept) != len(blocks):
+            changed = True
+            if kept:
+                hooks[event] = kept
+            else:
+                hooks.pop(event, None)
+
+    if changed:
+        if not hooks:
+            data.pop("hooks", None)
+        path.write_text(json.dumps(data, indent=2) + "\n")
+    return changed, str(path)