mcpsmith 0.2.2__tar.gz → 0.3.0__tar.gz

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mcpsmith",
   "displayName": "mcpsmith",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Turn an OpenAPI file or a recorded website session into a curated, tested MCP server. Skills and an MCP server for your coding agent.",
   "author": {
     "name": "Sepehr Radmard",
@@ -23,7 +23,23 @@
     "mcpsmith": {
       "command": "uvx",
       "args": [
-        "mcpsmith@0.2.2",
+        "mcpsmith@0.3.0",
+        "mcp"
+      ]
+    },
+    "mcpsmith-chrome": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "chrome-devtools-mcp@1.11.0",
+        "--browser-url=http://127.0.0.1:9222"
+      ]
+    },
+    "rea": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "rea-agents@6.7.0",
         "mcp"
       ]
     }

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/AGENTS.md

@@ -4,6 +4,8 @@ Python framework that turns an OpenAPI/Swagger file or a recorded website sessio
 
 ## Workflow
 
+Install for your agents with `uvx mcpsmith setup` (`--dry-run` first).
+
 Ask the user which tasks the server should support, then:
 
 1. Website only: `mcpsmith capture <url> -o site.har --host <host>` (user browses, closes the browser), or use a DevTools HAR export.

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcpsmith
-Version: 0.2.2
+Version: 0.3.0
 Summary: Turn an OpenAPI file or a recorded website session into a curated, tested MCP server, with an LLM designing the tools.
 Project-URL: Homepage, https://github.com/sepehr071/mcpsmith
 Project-URL: Issues, https://github.com/sepehr071/mcpsmith/issues
@@ -22,6 +22,7 @@ Requires-Dist: httpx>=0.27
 Requires-Dist: keyring>=25
 Requires-Dist: mcp<3,>=2.2
 Requires-Dist: pyyaml>=6
+Requires-Dist: tomlkit>=0.12
 Requires-Dist: truststore>=0.9
 Requires-Dist: tzdata>=2024.1; sys_platform == 'win32'
 Requires-Dist: websockets>=12
@@ -40,6 +41,23 @@ Turn an OpenAPI/Swagger file, or a website session you recorded in the browser,
 
 Most generators mirror every endpoint as a tool and hand the model raw JSON, or stop at an OpenAPI spec or API client. mcpsmith designs a few workflow-level tools with plain argument names, descriptions that say when to call what next, and compact output. The input is an OpenAPI file or a HAR recording, so sites with no public API work too. The output is a server project with tests, CI, a PyPI + MCP Registry publish workflow and a Claude Code plugin.
 
+## Install
+
+```bash
+uvx mcpsmith setup
+```
+
+Registers the `mcpsmith` and `mcpsmith-chrome` (Chrome DevTools) MCP servers and copies the skills into each coding agent it finds (Claude Code, Codex, Cursor, Gemini CLI), and installs REA (`rea-agents`) for them. Options:
+
+- `--dry-run` prints the plan and writes nothing.
+- `--agents claude,codex` limits it to those agents (default: the ones found).
+- `--no-rea` skips REA; `--no-skills` skips the skills; `--yes` skips the confirmation.
+- `--remove` undoes what setup did. Entries and skill folders you made yourself are left alone. REA stays installed (you may have had it before); the command prints the line that removes it.
+
+Before setup first changes a config file, it copies the file to `*.mcpsmith.bak`. The backup is made once and not refreshed by later runs. Restart your agents afterwards. Run `mcpsmith browser` before using Chrome DevTools: it starts the shared Chrome the server connects to.
+
+Claude Code plugin users already get all three servers from the plugin and do not need `setup`.
+
 ## Quickstart: OpenAPI
 
 ```bash

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/README.md

@@ -6,6 +6,23 @@ Turn an OpenAPI/Swagger file, or a website session you recorded in the browser,
 
 Most generators mirror every endpoint as a tool and hand the model raw JSON, or stop at an OpenAPI spec or API client. mcpsmith designs a few workflow-level tools with plain argument names, descriptions that say when to call what next, and compact output. The input is an OpenAPI file or a HAR recording, so sites with no public API work too. The output is a server project with tests, CI, a PyPI + MCP Registry publish workflow and a Claude Code plugin.
 
+## Install
+
+```bash
+uvx mcpsmith setup
+```
+
+Registers the `mcpsmith` and `mcpsmith-chrome` (Chrome DevTools) MCP servers and copies the skills into each coding agent it finds (Claude Code, Codex, Cursor, Gemini CLI), and installs REA (`rea-agents`) for them. Options:
+
+- `--dry-run` prints the plan and writes nothing.
+- `--agents claude,codex` limits it to those agents (default: the ones found).
+- `--no-rea` skips REA; `--no-skills` skips the skills; `--yes` skips the confirmation.
+- `--remove` undoes what setup did. Entries and skill folders you made yourself are left alone. REA stays installed (you may have had it before); the command prints the line that removes it.
+
+Before setup first changes a config file, it copies the file to `*.mcpsmith.bak`. The backup is made once and not refreshed by later runs. Restart your agents afterwards. Run `mcpsmith browser` before using Chrome DevTools: it starts the shared Chrome the server connects to.
+
+Claude Code plugin users already get all three servers from the plugin and do not need `setup`.
+
 ## Quickstart: OpenAPI
 
 ```bash

mcpsmith-0.3.0/docs/superpowers/plans/2026-10-21-setup-bundle.md

@@ -0,0 +1,75 @@
+# Setup Bundle Implementation Plan (plan 2 of 3)
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** `mcpsmith setup` registers the mcpsmith hub, Chrome DevTools MCP (attached to the shared Chrome) and REA with Claude Code, Codex, Cursor and Gemini CLI, and installs mcpsmith's skills — one command, previewed, backed up, reversible.
+
+**Architecture:** A per-agent target module edits each agent's user-level MCP config (JSON for Claude Code/Cursor/Gemini, TOML via `tomlkit` for Codex) with read → merge → backup → write → verify, never touching unrelated entries. Skills ship inside the wheel and are copied to `~/.claude/skills` (Claude Code) and `~/.agents/skills` (Codex, Cursor, Gemini). REA is registered by delegating to REA's own non-interactive setup.
+
+**Tech Stack:** Python ≥3.10 stdlib (json, shutil, importlib.resources, subprocess), `tomlkit` (new dependency, comment-preserving TOML). Tests: pytest with a fake HOME.
+
+**Spec:** `docs/superpowers/specs/2026-10-20-mcp-everything-design.md` (G6; decisions 8, 9). Research facts (2026-10-21) are recorded in Global Constraints below.
+
+## Global Constraints
+
+- Config locations (user level): Claude Code `~/.claude.json` (`$CLAUDE_CONFIG_DIR/.claude.json` if set), key `mcpServers.<name>` = `{"type":"stdio","command","args","env"}`; Codex `~/.codex/config.toml` (`$CODEX_HOME` if set), table `[mcp_servers.<name>]` with `command`, `args`, `startup_timeout_sec = 30`, sub-table `env`; Cursor `~/.cursor/mcp.json`, `mcpServers.<name>` = `{"type":"stdio","command","args","env"}`; Gemini `~/.gemini/settings.json` (`$GEMINI_CLI_HOME/.gemini/settings.json` if set), `mcpServers.<name>` = `{"command","args","env","timeout":30000}`.
+- Skills: Claude Code `~/.claude/skills/<name>/`; Codex, Cursor, Gemini `~/.agents/skills/<name>/`. Skill folder name equals its frontmatter `name`.
+- Server entries (names exactly): `mcpsmith` → `uvx mcpsmith@<package version> mcp`; `chrome-devtools` → `npx -y chrome-devtools-mcp@1.11.0 --browser-url=http://127.0.0.1:9222`; REA → delegated: `npx -y rea-agents@6.7.0 setup --client <id> --yes` with ids `claude_code`, `codex`, `cursor`, `gemini_cli`.
+- On Windows, `npx` commands are written as `command: "cmd"`, `args: ["/d","/c","npx",...]`; `uvx` stays as is.
+- `env` written for the `mcpsmith` entry: `HTTPS_PROXY`/`HTTP_PROXY`/`NO_PROXY` from setup's environment when set, with userinfo (`user:pass@`) stripped (reuse `browser.clean_proxy`); never write any other secret.
+- Never modify or remove entries mcpsmith did not create; preserve TOML comments and unrelated tables; JSON written with 2-space indent and UTF-8, original key order kept.
+- Before the first write to a file: copy it to `<file>.mcpsmith.bak` (do not overwrite an existing backup). After writing, re-read and verify the entry; on failure restore the backup and report.
+- Node.js missing (`npx` not on PATH) → skip `chrome-devtools` and REA with one clear line each; still do the rest.
+- Default asks for confirmation after printing the plan; `--yes` skips it; `--dry-run` prints the plan and writes nothing; non-interactive stdin without `--yes` → error, exit 2.
+- New dependency only: `tomlkit>=0.12`. Existing behaviour stays; full suite green; ruff clean; commits on branch `feat/setup` without AI attribution.
+
+## Review Focus
+
+1. Existing user configs with unrelated servers, comments (TOML) and other top-level keys → untouched after setup and after `--remove`. (Task 2 tests.)
+2. Running setup twice → idempotent: no duplicate entries, no second backup overwrite. (Task 3 test.)
+3. A config file that is malformed JSON/TOML → that agent is skipped with a clear message; nothing written to it. (Task 2 test.)
+4. Proxy env with credentials → credentials never written. (Task 2 test.)
+5. Agent not installed → not touched unless named with `--agents`. (Task 3 test.)
+
+---
+
+### Task 1: Ship skills in the package
+
+**Files:** Modify `pyproject.toml`; Create `src/mcpsmith/skills_path.py`; Test `tests/test_setup.py`
+
+**Interfaces:**
+- Produces: `skills_path.skills_dir() -> Path` — the packaged skills directory (`importlib.resources.files("mcpsmith") / "skills"` when present, else the repo's `skills/` for editable installs); contains `build-mcp-server`, `design-mcp-tools`, `extract-api`.
+
+- [ ] **Step 1:** Test `test_skills_dir_has_all_skills`: the three folders exist, each with a `SKILL.md` whose frontmatter `name` equals the folder name. Test `test_wheel_contains_skills`: `uv build --wheel` into `tmp_path`, the wheel's namelist contains `mcpsmith/skills/extract-api/SKILL.md` (mark the test `slow` only if it exceeds 20 s).
+- [ ] **Step 2:** Run → FAIL. **Step 3:** Add `[tool.hatch.build.targets.wheel.force-include] "skills" = "mcpsmith/skills"`; implement `skills_dir`. **Step 4:** Run full suite → PASS. **Step 5:** Commit `build: ship skills inside the package`.
+
+### Task 2: Agent targets
+
+**Files:** Create `src/mcpsmith/setup/__init__.py`, `src/mcpsmith/setup/agents.py`; Modify `pyproject.toml` (`tomlkit`); Test `tests/test_setup.py`
+
+**Interfaces:**
+- Produces:
+  - `SERVERS: dict[str, list[str]]` — base commands per server name (from Global Constraints), and `server_entry(name: str, windows: bool, env: dict[str,str]) -> dict` (command/args, Windows `cmd /d /c` wrapping for npx).
+  - `class Agent` (one per agent: `claude`, `codex`, `cursor`, `gemini`) with `id`, `rea_client`, `config_path(home: Path, environ) -> Path`, `skills_root(home) -> Path`, `detected(home, environ, which) -> bool` (config dir exists or CLI on PATH), `add(doc, name, entry) -> doc`, `remove(doc, name) -> doc`, `has(doc, name) -> bool`, `load(path) -> doc` (raises `ValueError` on malformed), `dump(doc) -> str`.
+  - `AGENTS: dict[str, Agent]`.
+- [ ] **Step 1:** Tests on in-memory docs: each agent adds `mcpsmith` and `chrome-devtools` with exact shapes from Global Constraints; unrelated servers/keys preserved; Codex TOML comment and an unrelated `[mcp_servers.other]` survive add+remove; `remove` deletes only our names; malformed JSON/TOML → `ValueError`; `server_entry("chrome-devtools", windows=True, …)` → `command == "cmd"`, args start `["/d","/c","npx","-y","chrome-devtools-mcp@1.11.0"]`; mcpsmith env from `HTTPS_PROXY=http://u:p@h:1` → `"http://h:1"`; `CLAUDE_CONFIG_DIR`/`CODEX_HOME`/`GEMINI_CLI_HOME` honored.
+- [ ] **Step 2:** Run → FAIL. **Step 3:** Implement. **Step 4:** Full suite → PASS. **Step 5:** Commit `feat(setup): agent config targets`.
+
+### Task 3: `mcpsmith setup` command
+
+**Files:** Create `src/mcpsmith/setup/run.py`; Modify `src/mcpsmith/cli.py`; Test `tests/test_setup.py`
+
+**Interfaces:**
+- Consumes: `AGENTS`, `server_entry`, `skills_dir`.
+- Produces: CLI `mcpsmith setup [--agents claude,codex,cursor,gemini] [--no-rea] [--no-skills] [--dry-run] [--yes] [--remove]`; `plan(home, environ, agents, rea, skills, remove) -> list[Change]` (`Change`: agent, kind `server|skill|rea`, target path or command, action `add|update|remove|skip`, reason); `apply(changes, runner=subprocess.run) -> list[str]` (result lines).
+- Behaviour: detected agents by default (or `--agents`); prints the plan (paths, entries, skill folders, REA command), asks `Apply these changes? [y/N]` unless `--yes`/`--dry-run`; per file backup→write→verify (restore on verify failure); skills copied with `shutil.copytree(dirs_exist_ok=True)` (only mcpsmith's three folders; `--remove` deletes only those); REA via `runner([npx..., "setup", "--client", id, "--yes"])` (Windows-wrapped), `--remove` → `rea-agents@6.7.0 uninstall --client id --yes`; final line tells the user to restart their agents and to run `mcpsmith browser` before using Chrome DevTools.
+- [ ] **Step 1:** Tests with fake HOME and stub `which`/runner: `--dry-run` writes nothing and lists every change; a real run writes entries + skills + backups and calls REA once per agent with the right client id; second run → no changes reported as `add`, backups unchanged; `--remove` restores a config equal to the original except formatting (JSON) / byte-identical comments (TOML), skills gone; undetected agent untouched; malformed config → that agent skipped, others done; no `npx` → chrome-devtools and REA skipped with messages; stdin not a TTY and no `--yes` → exit 2.
+- [ ] **Step 2:** Run → FAIL. **Step 3:** Implement. **Step 4:** Full suite → PASS. **Step 5:** Commit `feat: mcpsmith setup registers the bundle with coding agents`.
+
+### Task 4: Plugin, docs, release 0.3.0
+
+**Files:** Modify `.claude-plugin/plugin.json` (add `chrome-devtools` and `rea` servers, pinned, same args as setup on non-Windows), `README.md` (Install section: `uvx mcpsmith setup`; plugin users don't also run setup), `AGENTS.md`, `skills/build-mcp-server/SKILL.md` (setup line), version 0.3.0 in all version spots; `uv lock`.
+
+- [ ] **Step 1:** `claude plugin validate .` → "Validation passed"; `uv run pytest -q`; ruff.
+- [ ] **Step 2: Acceptance** — run `mcpsmith setup --dry-run` on the real machine and show the plan; run the real setup with `HOME`/`USERPROFILE` pointed at a scratch dir seeded with copies of the four real config files (no real config touched) and check: entries added, comments/unrelated servers preserved, `--remove` reverts. Real-machine install only with the user's yes.
+- [ ] **Step 3:** Commit `chore: release 0.3.0`; PR `feat/setup` → main; CI green; merge; tag `v0.3.0`; publish workflow green.

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcpsmith"
-version = "0.2.2"
+version = "0.3.0"
 description = "Turn an OpenAPI file or a recorded website session into a curated, tested MCP server, with an LLM designing the tools."
 readme = "README.md"
 license = "MIT"
@@ -27,6 +27,7 @@ dependencies = [
     "websockets>=12",
     "keyring>=25",
     "tzdata>=2024.1; sys_platform == 'win32'",
+    "tomlkit>=0.12",
 ]
 
 [project.optional-dependencies]
@@ -49,6 +50,9 @@ dev = ["pytest>=8", "anyio>=4", "ruff>=0.6"]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.build.targets.wheel.force-include]
+"skills" = "mcpsmith/skills"
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-m 'not live'"

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/server.json

@@ -8,13 +8,13 @@
     "source": "github"
   },
   "websiteUrl": "https://github.com/sepehr071/mcpsmith",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "packages": [
     {
       "registryType": "pypi",
       "registryBaseUrl": "https://pypi.org",
       "identifier": "mcpsmith",
-      "version": "0.2.2",
+      "version": "0.3.0",
       "runtimeHint": "uvx",
       "transport": {
         "type": "stdio"

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/skills/build-mcp-server/SKILL.md

@@ -5,6 +5,8 @@ description: Build a curated, tested MCP server (agent tools) with mcpsmith. Use
 
 # Build an MCP server with mcpsmith
 
+Not set up yet? `uvx mcpsmith setup` registers mcpsmith, Chrome DevTools MCP and REA with the user's agents.
+
 mcpsmith turns an OpenAPI file or a recorded website session (HAR) into a Python MCP server project with tests, CI, a publish workflow and a Claude Code plugin. You design the tools; mcpsmith generates and checks the code.
 
 Run commands with `uvx mcpsmith <cmd>` (or `mcpsmith <cmd>` if installed). No shell? Use the mcpsmith MCP tools instead: `smith_guide`, `smith_inspect`, `smith_draft`, `smith_validate`, `smith_generate`, `smith_check`, and the hub tools `smith_record_start`, `smith_record_stop`, `smith_connect`, `smith_disconnect`, `smith_connections`, `smith_tools`, `smith_call` (paths absolute).

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/src/mcpsmith/__init__.py

@@ -1,3 +1,3 @@
 """mcpsmith: turn an OpenAPI file or a recorded website session into a curated, tested MCP server."""
 
-__version__ = "0.2.2"
+__version__ = "0.3.0"

{mcpsmith-0.2.2 → mcpsmith-0.3.0}/src/mcpsmith/cli.py

@@ -223,6 +223,12 @@ def cmd_connections(args) -> int:
     return 0
 
 
+def cmd_setup(args) -> int:
+    from .setup.run import cmd
+
+    return cmd(args)
+
+
 def cmd_mcp(args) -> int:
     from .server import main as serve
 
@@ -290,6 +296,16 @@ def build_parser() -> argparse.ArgumentParser:
     sp.add_argument("--port", type=int, default=9222)
     sp.add_argument("--no-proxy", action="store_true", help="do not pass HTTPS_PROXY on to Chrome")
 
+    sp = command(
+        "setup", cmd_setup, "register mcpsmith, Chrome DevTools MCP and REA with your coding agents", workdir=False
+    )
+    sp.add_argument("--agents", help="comma-separated: claude,codex,cursor,gemini (default: the ones found)")
+    sp.add_argument("--no-rea", action="store_true", help="skip the REA install")
+    sp.add_argument("--no-skills", action="store_true", help="skip copying the skills")
+    sp.add_argument("--dry-run", action="store_true", help="print the plan, write nothing")
+    sp.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    sp.add_argument("--remove", action="store_true", help="undo what setup did")
+
     command("connections", cmd_connections, "list the connections saved for the mcpsmith server", workdir=False)
     command("guide", cmd_guide, "print the tool-design rules for plan.yaml", workdir=False)
     command("mcp", cmd_mcp, "run the mcpsmith MCP server on stdio", workdir=False)

mcpsmith-0.3.0/src/mcpsmith/setup/agents.py

@@ -0,0 +1,158 @@
+"""Where each coding agent keeps its MCP servers and skills, and how to add/remove ours without touching the rest."""
+
+import json
+import shutil
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+import tomlkit
+
+from mcpsmith import __version__
+from mcpsmith.browser import clean_proxy
+
+SERVERS = {
+    "mcpsmith": ["uvx", f"mcpsmith@{__version__}", "mcp"],
+    "mcpsmith-chrome": ["npx", "-y", "chrome-devtools-mcp@1.11.0", "--browser-url=http://127.0.0.1:9222"],
+}
+
+
+def proxy_env(environ) -> dict[str, str]:
+    """Proxy variables worth passing to the mcpsmith server: userinfo stripped, nothing else copied."""
+    env = {}
+    for key in ("HTTPS_PROXY", "HTTP_PROXY"):
+        value = clean_proxy(environ.get(key) or environ.get(key.lower()))
+        if value:
+            env[key] = value
+    if no_proxy := environ.get("NO_PROXY") or environ.get("no_proxy"):
+        env["NO_PROXY"] = no_proxy
+    return env
+
+
+def server_entry(name: str, windows: bool, env: dict[str, str]) -> dict:
+    command, *args = SERVERS[name]
+    if windows and command == "npx":
+        command, args = "cmd", ["/d", "/c", "npx", *args]
+    return {"command": command, "args": args, "env": dict(env) if name == "mcpsmith" else {}}
+
+
+@dataclass(frozen=True)
+class Agent:
+    id: str
+    rea_client: str
+    toml: bool
+    config: Callable[[Path, dict], Path]
+    skills: Callable[[Path, dict], Path]
+    config_dir: Callable[[Path, dict], Path]
+    clis: tuple[str, ...]
+
+    def config_path(self, home: Path, environ) -> Path:
+        return self.config(home, environ)
+
+    def skills_root(self, home: Path, environ) -> Path:
+        return self.skills(home, environ)
+
+    def detected(self, home: Path, environ, which=shutil.which) -> bool:
+        return self.config_dir(home, environ).is_dir() or any(which(cli) for cli in self.clis)
+
+    def load(self, path: Path):
+        text = path.read_text(encoding="utf-8") if path.exists() else ""
+        try:
+            if self.toml:
+                return tomlkit.parse(text)
+            doc = json.loads(text) if text.strip() else {}
+        except Exception as e:  # tomlkit and json raise different parse errors
+            raise ValueError(f"{path}: not valid {'TOML' if self.toml else 'JSON'} ({e})") from e
+        if not isinstance(doc, dict):
+            raise ValueError(f"{path}: expected an object at the top level")
+        return doc
+
+    def dump(self, doc) -> str:
+        if self.toml:
+            return tomlkit.dumps(doc)
+        return json.dumps(doc, indent=2, ensure_ascii=False) + "\n"
+
+    def _key(self) -> str:
+        return "mcp_servers" if self.toml else "mcpServers"
+
+    def has(self, doc, name: str) -> bool:
+        return name in doc.get(self._key(), {})
+
+    def add(self, doc, name: str, entry: dict):
+        if self.toml:
+            table = tomlkit.table()
+            table["command"] = entry["command"]
+            table["args"] = entry["args"]
+            table["startup_timeout_sec"] = 30
+            if entry["env"]:
+                table["env"] = tomlkit.item(entry["env"])
+            if "mcp_servers" not in doc:
+                doc["mcp_servers"] = tomlkit.table(is_super_table=True)
+            doc["mcp_servers"][name] = table
+        else:
+            entry = {**entry, "timeout": 30000} if self.id == "gemini" else {"type": "stdio", **entry}
+            doc.setdefault("mcpServers", {})[name] = entry
+        return doc
+
+    def remove(self, doc, name: str):
+        if self.has(doc, name):
+            del doc[self._key()][name]
+        return doc
+
+
+def _claude_dir(home, environ):
+    return Path(environ.get("CLAUDE_CONFIG_DIR") or home / ".claude")
+
+
+def _codex_home(home, environ):
+    return Path(environ.get("CODEX_HOME") or home / ".codex")
+
+
+def _gemini_dir(home, environ):
+    return Path(environ.get("GEMINI_CLI_HOME") or home) / ".gemini"
+
+
+def _agent_skills(home, environ):
+    return home / ".agents" / "skills"
+
+
+AGENTS = {
+    "claude": Agent(
+        "claude",
+        "claude_code",
+        False,
+        lambda home, env: (
+            Path(env["CLAUDE_CONFIG_DIR"]) / ".claude.json" if env.get("CLAUDE_CONFIG_DIR") else home / ".claude.json"
+        ),
+        lambda home, env: _claude_dir(home, env) / "skills",
+        _claude_dir,
+        ("claude",),
+    ),
+    "codex": Agent(
+        "codex",
+        "codex",
+        True,
+        lambda home, env: _codex_home(home, env) / "config.toml",
+        _agent_skills,
+        _codex_home,
+        ("codex",),
+    ),
+    "cursor": Agent(
+        "cursor",
+        "cursor",
+        False,
+        lambda home, env: home / ".cursor" / "mcp.json",
+        _agent_skills,
+        lambda home, env: home / ".cursor",
+        ("cursor-agent", "cursor"),
+    ),
+    "gemini": Agent(
+        "gemini",
+        "gemini_cli",
+        False,
+        lambda home, env: _gemini_dir(home, env) / "settings.json",
+        _agent_skills,
+        _gemini_dir,
+        ("gemini",),
+    ),
+}