aicp-cli 0.3.1__tar.gz → 0.4.0__tar.gz

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.4.0] - 2026-09-14
+
+### 🚜 Refactor
+
+- **agents:** Centralize agent definitions
 ## [0.3.1] - 2026-09-14
 
 ### 🐛 Bug Fixes
@@ -9,6 +14,7 @@
 - **readme:** Document releasing and the wheel version check
 - Remove CI section from README.md
 - Add uv requirement note to README.md
+- **changelog:** Release v0.3.1
 ## [0.3.0] - 2026-09-14
 
 ### 🐛 Bug Fixes

aicp_cli-0.4.0/CLAUDE.md

@@ -0,0 +1,7 @@
+# CLAUDE.md
+
+## Cross-platform compatibility
+
+Keep tools platform-agnostic. OS-specific behavior (clipboard, package installation, ANSI) belongs in a shared helper, funneled through one function, so individual tool modules stay clean.
+
+Support macOS, Windows, and Linux for user-facing platform behavior.

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aicp-cli
-Version: 0.3.1
+Version: 0.4.0
 Summary: AI commit + push, with a git-verified result summary
 Project-URL: Repository, https://github.com/weskao/aicp
 Project-URL: Issues, https://github.com/weskao/aicp/issues
@@ -49,7 +49,8 @@ uv tool install aicp-cli             # latest release
 uv tool install aicp-cli==X.Y.Z      # pin to a specific version
 ```
 
-The distribution is `aicp-cli`; the command it installs is `aicp`. (The plain
+The distribution is [`aicp-cli`](https://pypi.org/project/aicp-cli/); the command
+it installs is `aicp`. (The plain
 `aicp` name on PyPI belongs to an unrelated 2021 project — don't install it.)
 Replace `X.Y.Z` with the release version you want; re-running either command
 switches an existing install to that version.
@@ -197,6 +198,44 @@ in that tree. Bump the version and tag again.
 
 ## Configuration
 
+Agent definitions live in [`src/aicp/agents.json`](src/aicp/agents.json),
+bundled with the installed package. Both `aicp` and `aicp --config` use this
+registry for executable lookup, invocation arguments, config directories,
+and skill installation/status. To maintain an agent, edit its entry here.
+Registry order supplies the default fallback order; `aicp_cli_order` still
+controls the user's preferred order.
+
+Use `~/` paths and bare executable names for entries shared across macOS,
+Linux, and Windows. Python resolves `~` to the native home directory
+(`USERPROFILE` on Windows); forward slashes work on all three systems.
+Absolute paths are specific to the host OS; in JSON, a Windows path can use
+`C:/Users/name/.codex` or escaped backslashes (`C:\\Users\\name\\.codex`).
+Executable lookup uses `PATH` and, on Windows, `PATHEXT`; the runner handles
+both native executables and `.cmd`/`.bat` launchers. CI runs the registry
+integration tests and installed-wheel checks on all three operating systems.
+
+| Agent field | Meaning |
+| --- | --- |
+| `executable` | Binary name resolved on `PATH`, or an absolute executable path. Separate from the stable agent ID used in fallback order and history. |
+| `config_dir` | Absolute path or `~/`-relative directory; home is resolved when used. |
+| `config_dir_env` | Optional environment variable overriding that directory (currently `GROK_HOME`). |
+| `skills_dir` | Relative directory inside `config_dir` where skills are installed. |
+| `skills` | Vendored skills to install: `commit` and/or `safe-git-push`. Claude keeps its existing `/commit`. |
+| `memory_file` | Instruction filename used when adapting vendored skill text. Project directory references use the basename of `config_dir`. |
+| `args` | Argument array containing exactly one standalone `{prompt}`, replaced with the complete prompt as one argument. No shell evaluation. |
+
+The JSON envelope has `version: 1` and an `agents` object keyed by stable
+agent IDs. Future supported settings can be added to each entry and the
+loader; adding a JSON field alone does not implement new behavior.
+Invocation defaults preserve agy's `--new-project` (use the current working
+directory), vibe's `--trust` (avoid an interactive trust prompt), and the
+existing MCP startup suppression flags.
+
+This is packaged application data, not a per-user override file. Package
+upgrades replace it; neither repository-local files nor
+`~/.aicp/config.json` can override agent execution settings. Ordinary user
+preferences continue to use the config file below.
+
 The config file lives at `~/.aicp/config.json` (override the path itself
 with `AICP_CONFIG`, which — being the thing that names the file — can only be
 set as a real environment variable). Precedence everywhere is

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/README.md

@@ -37,7 +37,8 @@ uv tool install aicp-cli             # latest release
 uv tool install aicp-cli==X.Y.Z      # pin to a specific version
 ```
 
-The distribution is `aicp-cli`; the command it installs is `aicp`. (The plain
+The distribution is [`aicp-cli`](https://pypi.org/project/aicp-cli/); the command
+it installs is `aicp`. (The plain
 `aicp` name on PyPI belongs to an unrelated 2021 project — don't install it.)
 Replace `X.Y.Z` with the release version you want; re-running either command
 switches an existing install to that version.
@@ -185,6 +186,44 @@ in that tree. Bump the version and tag again.
 
 ## Configuration
 
+Agent definitions live in [`src/aicp/agents.json`](src/aicp/agents.json),
+bundled with the installed package. Both `aicp` and `aicp --config` use this
+registry for executable lookup, invocation arguments, config directories,
+and skill installation/status. To maintain an agent, edit its entry here.
+Registry order supplies the default fallback order; `aicp_cli_order` still
+controls the user's preferred order.
+
+Use `~/` paths and bare executable names for entries shared across macOS,
+Linux, and Windows. Python resolves `~` to the native home directory
+(`USERPROFILE` on Windows); forward slashes work on all three systems.
+Absolute paths are specific to the host OS; in JSON, a Windows path can use
+`C:/Users/name/.codex` or escaped backslashes (`C:\\Users\\name\\.codex`).
+Executable lookup uses `PATH` and, on Windows, `PATHEXT`; the runner handles
+both native executables and `.cmd`/`.bat` launchers. CI runs the registry
+integration tests and installed-wheel checks on all three operating systems.
+
+| Agent field | Meaning |
+| --- | --- |
+| `executable` | Binary name resolved on `PATH`, or an absolute executable path. Separate from the stable agent ID used in fallback order and history. |
+| `config_dir` | Absolute path or `~/`-relative directory; home is resolved when used. |
+| `config_dir_env` | Optional environment variable overriding that directory (currently `GROK_HOME`). |
+| `skills_dir` | Relative directory inside `config_dir` where skills are installed. |
+| `skills` | Vendored skills to install: `commit` and/or `safe-git-push`. Claude keeps its existing `/commit`. |
+| `memory_file` | Instruction filename used when adapting vendored skill text. Project directory references use the basename of `config_dir`. |
+| `args` | Argument array containing exactly one standalone `{prompt}`, replaced with the complete prompt as one argument. No shell evaluation. |
+
+The JSON envelope has `version: 1` and an `agents` object keyed by stable
+agent IDs. Future supported settings can be added to each entry and the
+loader; adding a JSON field alone does not implement new behavior.
+Invocation defaults preserve agy's `--new-project` (use the current working
+directory), vibe's `--trust` (avoid an interactive trust prompt), and the
+existing MCP startup suppression flags.
+
+This is packaged application data, not a per-user override file. Package
+upgrades replace it; neither repository-local files nor
+`~/.aicp/config.json` can override agent execution settings. Ordinary user
+preferences continue to use the config file below.
+
 The config file lives at `~/.aicp/config.json` (override the path itself
 with `AICP_CONFIG`, which — being the thing that names the file — can only be
 set as a real environment variable). Precedence everywhere is

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/pyproject.toml

@@ -2,7 +2,7 @@
 # PyPI distribution name only — the `aicp` name was taken in 2021 by an
 # unrelated project. The command, import path and repo stay `aicp`.
 name = "aicp-cli"
-version = "0.3.1"
+version = "0.4.0"
 description = "AI commit + push, with a git-verified result summary"
 readme = "README.md"
 requires-python = ">=3.10"

aicp_cli-0.4.0/src/aicp/agents.json

@@ -0,0 +1,54 @@
+{
+  "version": 1,
+  "agents": {
+    "copilot": {
+      "executable": "copilot",
+      "config_dir": "~/.copilot",
+      "memory_file": "AGENTS.md",
+      "skills_dir": "skills",
+      "skills": ["commit", "safe-git-push"],
+      "args": ["-p", "{prompt}", "--allow-all", "--disable-builtin-mcps", "--no-auto-update"]
+    },
+    "agy": {
+      "executable": "agy",
+      "config_dir": "~/.gemini",
+      "memory_file": "GEMINI.md",
+      "skills_dir": "skills",
+      "skills": ["commit", "safe-git-push"],
+      "args": ["-p", "{prompt}", "--dangerously-skip-permissions", "--new-project"]
+    },
+    "codex": {
+      "executable": "codex",
+      "config_dir": "~/.codex",
+      "memory_file": "AGENTS.md",
+      "skills_dir": "skills",
+      "skills": ["commit", "safe-git-push"],
+      "args": ["exec", "--dangerously-bypass-approvals-and-sandbox", "{prompt}"]
+    },
+    "claude": {
+      "executable": "claude",
+      "config_dir": "~/.claude",
+      "memory_file": "CLAUDE.md",
+      "skills_dir": "skills",
+      "skills": ["safe-git-push"],
+      "args": ["-p", "{prompt}", "--dangerously-skip-permissions", "--strict-mcp-config"]
+    },
+    "vibe": {
+      "executable": "vibe",
+      "config_dir": "~/.vibe",
+      "memory_file": "AGENTS.md",
+      "skills_dir": "skills",
+      "skills": ["commit", "safe-git-push"],
+      "args": ["-p", "{prompt}", "--auto-approve", "--trust"]
+    },
+    "grok": {
+      "executable": "grok",
+      "config_dir": "~/.grok",
+      "config_dir_env": "GROK_HOME",
+      "memory_file": "AGENTS.md",
+      "skills_dir": "skills",
+      "skills": ["commit", "safe-git-push"],
+      "args": ["-p", "{prompt}", "--always-approve", "--no-subagents"]
+    }
+  }
+}

aicp_cli-0.4.0/src/aicp/agents.py

@@ -0,0 +1,83 @@
+"""Bundled agent definitions shared by execution and skill management.
+
+Only the package's agents.json is read; working-directory and user config
+files cannot supply executable paths or arguments through this registry.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Agent:
+    executable: str
+    config_dir: str
+    memory_file: str
+    skills_dir: str
+    skills: tuple[str, ...]
+    args: tuple[str, ...]
+    config_dir_env: str = ""
+
+    def config_root(self, home: Path | None = None) -> Path:
+        if home is None and (override := os.environ.get(self.config_dir_env)):
+            return Path(override).expanduser()
+        if self.config_dir.startswith("~/"):
+            return (Path.home() if home is None else home) / self.config_dir[2:]
+        return Path(self.config_dir)
+
+
+def load_agents(path: Path) -> dict[str, Agent]:
+    """Validate packaged data and preserve its default fallback order."""
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict) or data.get("version") != 1:
+        raise ValueError(f"{path}: unsupported agent registry version")
+    entries = data.get("agents")
+    if not isinstance(entries, dict) or not entries:
+        raise ValueError(f"{path}: expected a nonempty agents object")
+    agents = {}
+    for name, entry in entries.items():
+        if not isinstance(entry, dict):
+            raise TypeError(f"{path}: {name}: expected an agent object")
+        for key in ["executable", "config_dir", "memory_file", "skills_dir"]:
+            value = entry.get(key)
+            if not isinstance(value, str) or not value.strip() or "\0" in value:
+                raise ValueError(f"{path}: {name}: invalid {key}")
+        for key in ("args", "skills"):
+            value = entry.get(key)
+            if not isinstance(value, list) or not all(
+                isinstance(item, str) and "\0" not in item for item in value
+            ):
+                raise ValueError(f"{path}: {name}: invalid {key}")
+        if entry["args"].count("{prompt}") != 1:
+            raise ValueError(f"{path}: {name}: args must contain one {{prompt}} argument")
+        if not entry["config_dir"].startswith("~/") and not Path(entry["config_dir"]).is_absolute():
+            raise ValueError(f"{path}: {name}: config_dir must be absolute or start with ~/")
+        skills_dir = Path(entry["skills_dir"])
+        if skills_dir.anchor or ".." in skills_dir.parts or skills_dir == Path("."):
+            raise ValueError(f"{path}: {name}: skills_dir must stay inside config_dir")
+        env = entry.get("config_dir_env", "")
+        if not isinstance(env, str) or (env and not env.isidentifier()):
+            raise ValueError(f"{path}: {name}: invalid config_dir_env")
+        agents[name] = Agent(
+            executable=entry["executable"],
+            config_dir=entry["config_dir"],
+            memory_file=entry["memory_file"],
+            skills_dir=entry["skills_dir"],
+            skills=tuple(entry["skills"]),
+            args=tuple(entry["args"]),
+            config_dir_env=env,
+        )
+    return agents
+
+
+AGENTS = load_agents(Path(__file__).with_name("agents.json"))
+
+
+def executable(name: str) -> str:
+    """Resolve a roster ID to its binary; leave non-agent commands alone."""
+    agent = AGENTS.get(name)
+    return agent.executable if agent else name

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/src/aicp/cli.py

@@ -38,6 +38,7 @@ from typing import NoReturn
 
 from . import __version__, config, gitflow, i18n, menu, notify, present, runner, skills
 from ._utils import BLUE, BOLD, CYAN, DIM, GREEN, MAGENTA, RED, RESET, YELLOW, have
+from .agents import executable
 from .contracts import ROSTER
 from .i18n import t
 
@@ -152,7 +153,7 @@ def _nudge(chain: Sequence[str]) -> None:
     target, no reads, no sidecar parsing).
     """
     for name in chain:
-        if not have(name):
+        if not have(executable(name)):
             continue
         entry = _BY_NAME.get(name)
         if entry is None:

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/src/aicp/contracts.py

@@ -17,6 +17,8 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 
+from .agents import AGENTS
+
 __all__ = [
     "CLI",
     "ROSTER",
@@ -35,7 +37,7 @@ class CLI:
     equivalents) both key off ``name``; T2 additionally needs ``config_dir``
     to detect whether a CLI is configured at all before trying to run it.
 
-    ``name`` is the literal binary invoked on PATH (``shutil.which(name)``).
+    ``name`` is the stable agent ID; agents.json supplies its executable.
     ``config_dir`` is where that CLI keeps its own config/session state — and
     is deliberately a SEPARATE field, not derived from ``name``, because it
     does not always match: the ``agy`` binary (this project's wrapper name
@@ -53,13 +55,10 @@ class CLI:
 # saved-chain compatibility. T3 is the consumer that reorders/persists a
 # chain derived from this; T2 and T4 must never hardcode this tuple themselves
 # — import it.
-ROSTER: tuple[CLI, ...] = (
-    CLI(name="copilot", config_dir=Path.home() / ".copilot"),
-    CLI(name="agy", config_dir=Path.home() / ".gemini"),  # the trap — see CLI's docstring
-    CLI(name="codex", config_dir=Path.home() / ".codex"),
-    CLI(name="claude", config_dir=Path.home() / ".claude"),
-    CLI(name="vibe", config_dir=Path.home() / ".vibe"),
-    CLI(name="grok", config_dir=Path.home() / ".grok"),
+# Resolve defaults here; environment overrides stay live in config_root.
+ROSTER: tuple[CLI, ...] = tuple(
+    CLI(name=name, config_dir=agent.config_root(Path.home()))
+    for name, agent in AGENTS.items()
 )
 
 # The resolved fallback chain — whatever order a run will actually try its

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/src/aicp/gitflow.py

@@ -30,6 +30,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from ._utils import BOLD, DIM, GREEN, RED, RESET, YELLOW, have, run_interruptible
+from .agents import executable
 from .i18n import t
 from .secrets import report_lines, scan
 
@@ -188,7 +189,7 @@ def preflight(chain: Sequence[str]) -> tuple[bool, list[str]]:
     alone and succeeds with no AI CLI installed. A blanket pre-flight would
     turn that into a failure — a regression wearing a check's clothing.
     """
-    if any(have(cli) for cli in chain):
+    if any(have(executable(cli)) for cli in chain):
         return True, []
     return False, [
         f"{RED}" + t("no_cli_found", "✗ no AI CLI found on PATH") + RESET,

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/src/aicp/runner.py

@@ -60,6 +60,7 @@ from aicp._utils import (
     have,
     run_interruptible,
 )
+from aicp.agents import AGENTS
 from aicp.contracts import NotifyFn
 from aicp.i18n import t
 from aicp.present import Spinner
@@ -103,27 +104,6 @@ class StepResult:
 # budget.py's stated invariant true: a bad config value never bricks aicp.
 _MAX_DEADLINE = 365 * 24 * 3600
 
-# Per-CLI flags, ported flag-for-flag from _aicp_invoke. Each branch skips MCP
-# server startup where the CLI exposes a way to — /commit and /safe-git-push
-# are plain git prompts, no MCP tool use — which measurably shortens cold start;
-# codex and agy showed no consistent gain, so they keep their existing flags.
-_FLAGS: dict[str, tuple[str, ...]] = {
-    # agy resumes its last session/workspace by default, ignoring $PWD entirely
-    # unless --new-project pins it to the caller's cwd.
-    "agy": ("--dangerously-skip-permissions", "--new-project"),
-    "claude": ("--dangerously-skip-permissions", "--strict-mcp-config"),
-    "copilot": ("--allow-all", "--disable-builtin-mcps", "--no-auto-update"),
-    "grok": ("--always-approve", "--no-subagents"),
-    # --trust is not the approval flag (--auto-approve is) and is not optional:
-    # vibe asks once, interactively, before it will touch an untrusted
-    # directory, and its own --help names --trust as the answer for
-    # non-interactive automation. Without it the very first aicp run in a new
-    # repo blocks on a prompt nobody can see behind the spinner until the budget
-    # kills it — a hang presented as a timeout. Per-invocation, never written to
-    # vibe's trusted_folders.toml, so aicp leaves no persistent trust behind.
-    "vibe": ("--auto-approve", "--trust"),
-}
-
 # Literal signals confirmed by T1. Copilot and agy are intentionally absent:
 # neither had a supported quota signature, and broad guesses would turn an
 # ordinary failure into a run-scoped exclusion.
@@ -153,10 +133,10 @@ def invoke_argv(cli: str, prompt: str) -> list[str] | None:
     silently returned 0 for a name it did not know, which would be read here as
     "that CLI succeeded" without anything having run.
     """
-    if cli == "codex":  # the only one that takes the prompt positionally
-        return ["codex", "exec", "--dangerously-bypass-approvals-and-sandbox", prompt]
-    flags = _FLAGS.get(cli)
-    return None if flags is None else [cli, "-p", prompt, *flags]
+    agent = AGENTS.get(cli)
+    if agent is None:
+        return None
+    return [agent.executable, *(prompt if arg == "{prompt}" else arg for arg in agent.args)]
 
 
 # ── Windows: launching an npm shim ───────────────────────────────────────────
@@ -187,7 +167,7 @@ _BATCH_SUFFIXES = frozenset({".cmd", ".bat"})
 # is expanded inside quotes too. There is no sound, portable escape for either
 # one on a cmd command line, so a launch carrying them is refused rather than
 # half-escaped. aicp never builds one — prompts are slash-command names and the
-# flags are fixed literals in _FLAGS — so this is a tripwire, not a limit
+# flags are literals in the bundled agents.json — so this is a tripwire, not a limit
 # anyone meets.
 # ponytail: fail closed; write a real cmd quoter only if aicp ever has to pass
 # arbitrary free text as a prompt on Windows.
@@ -447,7 +427,7 @@ def run_step(
     with _capture_file() as (capture, capture_path):
         for cli in chain:
             argv = invoke_argv(cli, prompt)
-            if argv is None or not have(cli):
+            if argv is None or not have(argv[0]):
                 continue
 
             # An earlier run already found this one out of quota. Skipping is

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/src/aicp/skills.py

@@ -8,9 +8,8 @@ vendored copies under ``skills/`` into each configured CLI.
 
 Three rules make it safe:
 
-* **Targets are keyed on** :attr:`aicp.contracts.CLI.config_dir`, never on the
-  binary name — ``agy`` reads ``~/.gemini``, and ``~/.agy`` does not exist.
-  :data:`PLATFORMS` is that table, keyed by the config dir's own name.
+* **Targets come from agents.json**, never from the binary name — ``agy``
+  reads ``~/.gemini``, and ``~/.agy`` does not exist.
 * **Anything aicp did not write, byte for byte, is the user's**
   (:data:`FOREIGN`). It is never overwritten without an explicit
   ``force=True``; a ``--yes``-style non-interactive run installs only what's
@@ -24,11 +23,9 @@ Three rules make it safe:
   config dir is the skill itself. Pre-0.2 in-place ``.aicp-version`` sidecars
   are folded into that file and deleted on the next install.
 
-All public functions take ``home=`` and otherwise resolve :func:`Path.home`
-at call time (i.e. ``$HOME`` as it is *now*), so a test with a fake ``$HOME``
-can never reach the developer's real config dirs. The per-CLI directory name
-still comes from ``config_dir.name`` — from the contract, not from the binary
-name.
+All public functions take ``home=`` to rebase home-relative registry paths
+and otherwise resolve :func:`Path.home` at call time. Absolute registry paths
+remain absolute; environment overrides apply only when home is omitted.
 """
 
 from __future__ import annotations
@@ -42,6 +39,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from . import __version__
+from .agents import AGENTS
 from .contracts import (
     CLI,
     ROSTER,
@@ -166,15 +164,10 @@ class Platform:
     skills: tuple[str, ...]
 
 
-_BOTH = ("commit", "safe-git-push")
-
 PLATFORMS: dict[str, Platform] = {
-    ".claude": Platform(".claude", "CLAUDE.md", ("safe-git-push",)),
-    ".codex": Platform(".codex", "AGENTS.md", _BOTH),
-    ".copilot": Platform(".copilot", "AGENTS.md", _BOTH),
-    ".gemini": Platform(".gemini", "GEMINI.md", _BOTH),  # the agy binary
-    ".vibe": Platform(".vibe", "AGENTS.md", _BOTH),
-    ".grok": Platform(".grok", "AGENTS.md", _BOTH),
+    name: Platform(name, agent.memory_file, agent.skills)
+    for agent in AGENTS.values()
+    for name in (Path(agent.config_dir).name,)
 }
 
 
@@ -204,20 +197,21 @@ class InstallResult:
 
 
 def _platform(cli: CLI) -> Platform:
-    return PLATFORMS[cli.config_dir.name]
+    agent = AGENTS[cli.name]
+    return Platform(Path(agent.config_dir).name, agent.memory_file, agent.skills)
 
 
 def config_root(cli: CLI, home: Path | None = None) -> Path:
     """This CLI's config dir, re-based on *home* or the live environment."""
-    if home is not None:
-        return Path(home) / cli.config_dir.name
-    if cli.name == "grok" and (grok_home := os.environ.get("GROK_HOME")):
-        return Path(grok_home)
-    return Path.home() / cli.config_dir.name
+    return AGENTS[cli.name].config_root(home)
 
 
 def target_path(cli: CLI, skill: str, home: Path | None = None) -> Path:
-    return config_root(cli, home) / SKILLS[skill].rel_target
+    return (
+        config_root(cli, home)
+        / AGENTS[cli.name].skills_dir
+        / SKILLS[skill].rel_target.relative_to("skills")
+    )
 
 
 # ── the state file ───────────────────────────────────────────────────────────
@@ -455,7 +449,7 @@ def _inspect(cli: CLI, skill: str, home: Path | None) -> tuple[str, str | None]:
     if not root.is_dir():
         return NOT_INSTALLED, None
     spec = SKILLS[skill]
-    target = root / spec.rel_target
+    target = target_path(cli, skill, home)
     if not target.exists():
         return MISSING, None
 
@@ -500,7 +494,7 @@ def missing_skills(cli: CLI, home: Path | None = None) -> tuple[str, ...]:
     return tuple(
         name
         for name in _platform(cli).skills
-        if not (root / SKILLS[name].rel_target).exists()
+        if not target_path(cli, name, home).exists()
     )
 
 

aicp_cli-0.4.0/tests/test_agents.py

@@ -0,0 +1,112 @@
+"""Exercise registry edits through the real command and skill consumers."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+import aicp
+from aicp.agents import load_agents
+
+
+@pytest.mark.parametrize("location", ["home", "absolute", "environment"])
+def test_registry_edit_reaches_commands_and_skills(tmp_path, location):
+    package = Path(aicp.__file__).parent
+    registry = package / "agents.json"
+    assert registry.is_file(), "agent definitions must ship with the package"
+    shutil.copytree(package, tmp_path / "aicp")
+    from aicp.skills import VENDOR_DIR
+
+    shutil.copytree(VENDOR_DIR, tmp_path / "aicp/_skills_data", dirs_exist_ok=True)
+    data = json.loads(registry.read_text())
+    root = Path.home() / "custom agent 測試" / "config"
+    data["agents"]["codex"].update(
+        executable=sys.executable,
+        config_dir="~/custom agent 測試/config" if location == "home" else str(root),
+        skills_dir="custom-skills",
+        args=["-c", "import sys; print(sys.argv[1])", "{prompt}"],
+    )
+    if location == "environment":
+        data["agents"]["codex"].update(
+            config_dir="~/unused", config_dir_env="AICP_TEST_AGENT_HOME"
+        )
+    (tmp_path / "aicp/agents.json").write_text(json.dumps(data))
+    result = subprocess.run(
+        [sys.executable, "-c", """
+from pathlib import Path
+import os
+from aicp import cli, gitflow, runner, skills
+from aicp.contracts import ROSTER
+agent = next(c for c in ROSTER if c.name == 'codex')
+root = Path(os.environ['AICP_TEST_AGENT_HOME'])
+root.mkdir(parents=True)
+assert skills.config_root(agent) == root
+assert gitflow.preflight(['codex'])[0]
+cli._nudge(['codex'])
+assert skills.missing_skills(agent) == ('commit', 'safe-git-push')
+skills.install([agent])
+target = root / 'custom-skills/commit/SKILL.md'
+assert target.is_file()
+assert skills.detect(agent, 'commit') == skills.CURRENT
+assert skills.missing_skills(agent) == ()
+assert skills.full_status([agent])[0].target == target
+prompt = 'literal $HOME; {prompt} with spaces'
+assert runner.invoke_argv('codex', prompt)[-1] == prompt
+assert runner.run_step(prompt, ['codex']).rc == 0
+"""],
+        cwd=tmp_path,
+        env={
+            **os.environ,
+            "PYTHONPATH": str(tmp_path),
+            "PATH": "",
+            "PYTHONUTF8": "1",
+            "AICP_TEST_AGENT_HOME": str(root),
+        },
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        check=False,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert "missing the commit, safe-git-push skill" in result.stdout
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    [
+        ("args", ["-p"]),
+        ("args", ["{prompt}", "{prompt}"]),
+        ("args", "-p {prompt}"),
+        ("args", ["{prompt}", 1]),
+        ("executable", ""),
+        ("config_dir", "relative/to/cwd"),
+        ("skills_dir", "../outside"),
+        ("skills_dir", "/outside"),
+        ("skills_dir", "."),
+        ("config_dir_env", ["INVALID"]),
+    ],
+)
+def test_rejects_invalid_registry_fields(tmp_path, field, value):
+    data = json.loads(Path(aicp.__file__).with_name("agents.json").read_text())
+    data["agents"]["codex"][field] = value
+    path = tmp_path / "agents.json"
+    path.write_text(json.dumps(data))
+    with pytest.raises(ValueError, match=field):
+        load_agents(path)
+
+
+def test_config_root_preserves_absolute_paths_and_live_env(tmp_path, monkeypatch):
+    from dataclasses import replace
+
+    from aicp.agents import AGENTS
+
+    agent = replace(AGENTS["grok"], config_dir=str(tmp_path / "absolute"))
+    monkeypatch.setenv("GROK_HOME", str(tmp_path / "override"))
+    assert agent.config_root() == tmp_path / "override"
+    assert agent.config_root(tmp_path / "home") == tmp_path / "absolute"
+    monkeypatch.delenv("GROK_HOME")
+    assert agent.config_root() == tmp_path / "absolute"

{aicp_cli-0.3.1 → aicp_cli-0.4.0}/uv.lock

@@ -4,7 +4,7 @@ requires-python = ">=3.10"
 
 [[package]]
 name = "aicp-cli"
-version = "0.3.1"
+version = "0.4.0"
 source = { editable = "." }
 
 [package.dev-dependencies]