agent-context-mcp 0.3.0__tar.gz

agent_context_mcp-0.3.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+.coverage
+htmlcov/
+*.swp
+.DS_Store
+agent/runtime/

agent_context_mcp-0.3.0/CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+
+All notable changes to acp-mcp will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.3.0] - 2026-05-14
+
+### Changed
+
+- **Breaking**: Templates are no longer bundled with the wheel. `acp init` and `acp version update` now fetch templates from `agent-context-protocol` (GitHub) at runtime via `git clone --depth=1`. Templates evolve independently of acp-mcp releases.
+- **Breaking**: `acp version update` now refreshes the project's ACP artifacts from agent-context-protocol mainline (matching bash semantics). Previously it ran `uv tool upgrade acp-mcp`. To upgrade the tool itself, use `uv tool upgrade acp-mcp` directly.
+- **Breaking**: `acp version check` now compares the project's ACP version (from `AGENT.md`) against agent-context-protocol mainline. Previously it checked PyPI for a new acp-mcp release.
+- `acp init` now performs a shallow git clone instead of copying bundled resources. Requires `git` on PATH.
+
+### Added
+
+- `acp.core.fetch.fetch_acp_templates()` — runtime git-clone primitive (context manager; yields clone root, cleans up on exit).
+- `acp version show` — print the project's ACP version from `AGENT.md` (separate from `acp --version` which shows the tool version).
+- `acp_version` MCP tool: `show` (project ACP version), `check` (compare project vs upstream), `update` (refresh project artifacts).
+- `acp_enumerate` MCP tool: discover ACP artifacts (commands, patterns, designs, specs) in `./agent/` and `~/.acp/agent/`. Extracts `@scry.entry` marker metadata via `scry-parse` when installed; falls back to plain file listing.
+- `acp_package` MCP tool: full implementation — `list`, `install`, `update`, `remove`, `info` backed by `acp.core.package_manager`. `search` returns `status: "not_available"` pending registry launch.
+- `acp package install/list/update/remove/info` CLI commands backed by `acp.core.package_manager`.
+- `acp.core.package_manager` module: package management logic (install from git URL, list, info, remove, update — reads/writes `agent/manifest.yaml`).
+- `scry-parse>=1.0.2` as a runtime dependency.
+- 62+ tests covering fetch, init, version, MCP server, and package manager flows. All tests mock the network; one integration test (real clone, opt-in via `pytest -m integration`) is included.
+
+### Removed
+
+- Bundled template tree under `src/acp/templates/` (73 markdown files). Templates now come from `git clone` at runtime.
+- `uv tool upgrade acp-mcp` wrapper in `acp version update`. Users should run `uv tool upgrade acp-mcp` directly.
+- PyPI version-check logic from `acp version check`. Project ACP version is now the thing being checked.
+
+### Requirements
+
+- `git` must be installed and on PATH for `acp init` and `acp version update`.
+
+## [0.2.0] - 2026-05-14
+
+### Added
+
+- `acp init .` — bootstrap a new ACP project in any directory.
+  - Copies 64+ bundled template files (commands, design templates, patterns, schemas, AGENT.md) into the target directory.
+  - Generates `agent/progress.yaml` with project metadata (name, version, started date).
+  - `--force` flag to overwrite an existing `agent/` directory.
+  - Rich colored output with next-step suggestions.
+- Bundled ACP template library under `src/acp/templates/` (72 files total):
+  - 48+ command files from `agent/commands/`
+  - Design, pattern, milestone, task, spec, artifact, clarification templates
+  - Schema files (`package.schema.yaml`, `progress.schema.yaml`, etc.)
+  - `AGENT.md` methodology documentation
+- Templates are accessible at runtime via `importlib.resources.files("acp.templates")`.
+
+## [0.1.0] - 2026-05-14
+
+### Added
+
+- Project bootstrap.

agent_context_mcp-0.3.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: agent-context-mcp
+Version: 0.3.0
+Summary: Python package manager and MCP server for Agent Context Protocol (ACP) projects.
+Project-URL: Homepage, https://github.com/prmichaelsen/acp-mcp
+Project-URL: Repository, https://github.com/prmichaelsen/acp-mcp
+Author-email: Patrick Michaelsen <michaelsenpatrick@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: fastmcp>=0.2.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: scry-parse>=1.0.2
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
+# acp-mcp
+
+Python package manager and MCP server for [Agent Context Protocol (ACP)](https://github.com/prmichaelsen/agent-context-protocol) projects.
+
+## What this provides
+
+**Substrate operations** for ACP projects, available as both CLI commands and MCP tools:
+
+- **Project bootstrap**: `acp init` — scaffold a new ACP project from agent-context-protocol's latest templates
+- **Version management**: check and refresh a project's ACP methodology version against agent-context-protocol mainline
+- **Package management**: list, install, update, remove ACP packages from git repositories
+- **Discovery**: enumerate available commands, patterns, designs, and specs across global (`~/.acp/agent/`) and project (`./agent/`) contexts
+
+## What this does NOT provide
+
+Workflow commands like `@acp.proceed`, `@acp.status`, `@acp.task-create`, etc. remain as **markdown directives** in `agent/commands/`. Agents read those files directly — they are intentionally not exposed as CLI or MCP tools. acp-mcp is the substrate; the workflow is the markdown.
+
+## Installation
+
+```bash
+uv tool install agent-context-mcp
+```
+
+This registers:
+- CLI command: `acp`
+- MCP server: `agent-context-mcp` (auto-discovered by Claude Code and compatible MCP clients)
+
+**Requirements**: `git` must be installed and on PATH (required by `acp init` and `acp version update`).
+
+## Usage
+
+### CLI
+
+```bash
+# Bootstrap a new ACP project in the current directory
+# Fetches latest templates from agent-context-protocol (GitHub)
+acp init .
+
+# Show the project's ACP methodology version
+acp version show
+
+# Check if project is behind agent-context-protocol mainline
+acp version check
+
+# Refresh the project's ACP templates from agent-context-protocol mainline
+# (Only updates templates; your design docs, tasks, milestones are preserved)
+acp version update
+
+# Install an ACP package
+acp package install https://github.com/user/acp-firebase.git
+
+# List installed packages
+acp package list
+```
+
+### MCP
+
+Once installed via `uv tool install`, the MCP server is discoverable by your agent runtime. Tools available:
+
+- `acp_package(action, ...)` — package operations
+- `acp_version(action)` — version management (show/check/update)
+- `acp_enumerate(scope, kind)` — discovery with rich `@scry.entry` marker metadata
+
+> **Note**: The PyPI package name is `agent-context-mcp` (not `acp-mcp`, which is a different unrelated package by IBM Corp). The CLI binary is still `acp`.
+
+## How `acp init` works
+
+`acp init .` performs a shallow git clone of [agent-context-protocol](https://github.com/prmichaelsen/agent-context-protocol) to a temp directory, copies the relevant template files into the target project, then cleans up the clone.
+
+**What gets copied:**
+
+- **`AGENT.md`** — ACP methodology documentation
+- **`agent/commands/`** — all workflow command files (`acp.proceed.md`, `acp.plan.md`, `acp.task-create.md`, etc.)
+- **`agent/design/`** — `*.template.md` files only
+- **`agent/patterns/`**, **`agent/milestones/`**, **`agent/tasks/`**, **`agent/specs/`** — `*.template.md` files only
+- **`agent/schemas/`** — all schema files
+- **`agent/progress.template.yaml`** — progress tracking template
+- **`agent/progress.yaml`** — generated fresh with project name and start date
+- **`.gitignore`** — ACP-recommended gitignore
+
+**What is NOT copied:** bash scripts (`agent/scripts/`), reports, clarifications, feedback, drafts, project-specific files.
+
+Templates live in agent-context-protocol's GitHub repo — not bundled with this wheel. This means template fixes and new commands flow to users via `acp version update`, not via acp-mcp releases.
+
+## Runtime-fetch model
+
+acp-mcp does **not** bundle templates. Instead, `acp init` and `acp version update` clone `agent-context-protocol/mainline` at runtime. This decouples template evolution from acp-mcp release cadence — a typo fix in `acp.proceed.md` doesn't require a new acp-mcp release.
+
+This mirrors the bash install path (`acp.install.sh` also curls from GitHub at runtime).
+
+## Status
+
+See [CHANGELOG.md](./CHANGELOG.md) for shipped features and version history.
+
+## License
+
+MIT

agent_context_mcp-0.3.0/README.md

@@ -0,0 +1,97 @@
+# acp-mcp
+
+Python package manager and MCP server for [Agent Context Protocol (ACP)](https://github.com/prmichaelsen/agent-context-protocol) projects.
+
+## What this provides
+
+**Substrate operations** for ACP projects, available as both CLI commands and MCP tools:
+
+- **Project bootstrap**: `acp init` — scaffold a new ACP project from agent-context-protocol's latest templates
+- **Version management**: check and refresh a project's ACP methodology version against agent-context-protocol mainline
+- **Package management**: list, install, update, remove ACP packages from git repositories
+- **Discovery**: enumerate available commands, patterns, designs, and specs across global (`~/.acp/agent/`) and project (`./agent/`) contexts
+
+## What this does NOT provide
+
+Workflow commands like `@acp.proceed`, `@acp.status`, `@acp.task-create`, etc. remain as **markdown directives** in `agent/commands/`. Agents read those files directly — they are intentionally not exposed as CLI or MCP tools. acp-mcp is the substrate; the workflow is the markdown.
+
+## Installation
+
+```bash
+uv tool install agent-context-mcp
+```
+
+This registers:
+- CLI command: `acp`
+- MCP server: `agent-context-mcp` (auto-discovered by Claude Code and compatible MCP clients)
+
+**Requirements**: `git` must be installed and on PATH (required by `acp init` and `acp version update`).
+
+## Usage
+
+### CLI
+
+```bash
+# Bootstrap a new ACP project in the current directory
+# Fetches latest templates from agent-context-protocol (GitHub)
+acp init .
+
+# Show the project's ACP methodology version
+acp version show
+
+# Check if project is behind agent-context-protocol mainline
+acp version check
+
+# Refresh the project's ACP templates from agent-context-protocol mainline
+# (Only updates templates; your design docs, tasks, milestones are preserved)
+acp version update
+
+# Install an ACP package
+acp package install https://github.com/user/acp-firebase.git
+
+# List installed packages
+acp package list
+```
+
+### MCP
+
+Once installed via `uv tool install`, the MCP server is discoverable by your agent runtime. Tools available:
+
+- `acp_package(action, ...)` — package operations
+- `acp_version(action)` — version management (show/check/update)
+- `acp_enumerate(scope, kind)` — discovery with rich `@scry.entry` marker metadata
+
+> **Note**: The PyPI package name is `agent-context-mcp` (not `acp-mcp`, which is a different unrelated package by IBM Corp). The CLI binary is still `acp`.
+
+## How `acp init` works
+
+`acp init .` performs a shallow git clone of [agent-context-protocol](https://github.com/prmichaelsen/agent-context-protocol) to a temp directory, copies the relevant template files into the target project, then cleans up the clone.
+
+**What gets copied:**
+
+- **`AGENT.md`** — ACP methodology documentation
+- **`agent/commands/`** — all workflow command files (`acp.proceed.md`, `acp.plan.md`, `acp.task-create.md`, etc.)
+- **`agent/design/`** — `*.template.md` files only
+- **`agent/patterns/`**, **`agent/milestones/`**, **`agent/tasks/`**, **`agent/specs/`** — `*.template.md` files only
+- **`agent/schemas/`** — all schema files
+- **`agent/progress.template.yaml`** — progress tracking template
+- **`agent/progress.yaml`** — generated fresh with project name and start date
+- **`.gitignore`** — ACP-recommended gitignore
+
+**What is NOT copied:** bash scripts (`agent/scripts/`), reports, clarifications, feedback, drafts, project-specific files.
+
+Templates live in agent-context-protocol's GitHub repo — not bundled with this wheel. This means template fixes and new commands flow to users via `acp version update`, not via acp-mcp releases.
+
+## Runtime-fetch model
+
+acp-mcp does **not** bundle templates. Instead, `acp init` and `acp version update` clone `agent-context-protocol/mainline` at runtime. This decouples template evolution from acp-mcp release cadence — a typo fix in `acp.proceed.md` doesn't require a new acp-mcp release.
+
+This mirrors the bash install path (`acp.install.sh` also curls from GitHub at runtime).
+
+## Status
+
+See [CHANGELOG.md](./CHANGELOG.md) for shipped features and version history.
+
+## License
+
+MIT

agent_context_mcp-0.3.0/agent/design/migrate-from-bash-acp.md

@@ -0,0 +1,334 @@
+<!-- @scry.entry
+id: design.migrate-from-bash-acp~e9c4f1a2
+kind: design
+summary: >
+  Architectural separation between agent-context-protocol (canonical ACP
+  methodology repo) and acp-mcp (Python tooling that consumes it). Eliminates
+  template duplication via runtime git clone, not wheel bundling. Bash version
+  remains as a legacy install path; acp-mcp becomes the preferred tool surface.
+status: active
+weight: 0.95
+tags: ["scope:acp-mcp", "topic:architecture", "topic:templates", "topic:fetch"]
+rationale: >
+  Two repos, clear separation of concerns. agent-context-protocol owns the
+  methodology (templates, commands, patterns, AGENT.md); acp-mcp consumes it
+  via runtime git clone. Templates evolve at agent-context-protocol's cadence,
+  decoupled from acp-mcp release cycles. Mirrors the scry-spec / scry-parse
+  pattern: spec in one repo, implementations consume it.
+applies: implementing acp init, implementing acp version check/update, deciding where templates live, naming version commands, planning agent-context-protocol's continued role
+seeded_questions:
+  - "Why fetch from github instead of bundling templates with the wheel?"
+  - "What happens to agent-context-protocol the GitHub repo?"
+  - "How do acp init and acp version update differ?"
+  - "What does the bash version do that acp-mcp doesn't?"
+  - "Does this break existing ACP packages (acp-firebase, etc.)?"
+@scry.entry.end -->
+
+# Architecture: acp-mcp consumes agent-context-protocol via runtime fetch
+
+**Concept**: agent-context-protocol stays alive as the canonical source of truth for ACP methodology. acp-mcp is a preferred Python tooling layer that fetches templates from agent-context-protocol at runtime via git clone.
+**Created**: 2026-05-14
+**Status**: Design Specification
+
+---
+
+## Overview
+
+`agent-context-protocol` (ACP) is a project that ships the **ACP methodology**:
+- `AGENT.md` (methodology documentation)
+- 48+ command markdown files (`agent/commands/acp.*.md`)
+- Pattern, design, milestone, task, spec, and clarification templates
+- Schemas (`package.yaml`, `progress.yaml`, etc.)
+- Key file index conventions
+- Bash scripts for install, version-check, and update (legacy install path)
+
+`acp-mcp` is a Python package that provides:
+- A CLI for ACP operations (`acp init`, `acp package`, `acp version`)
+- An MCP server exposing substrate tools to agents (`acp_package`, `acp_version`, `acp_enumerate`)
+- A core library for project detection, marker parsing (via scry-parse), and package management
+
+**The relationship**: acp-mcp is a **preferred consumer tool**, not a fork. It fetches templates and commands from agent-context-protocol at runtime; both projects evolve independently.
+
+---
+
+## Problem Statement
+
+The earlier draft of this design proposed bundling templates inside acp-mcp's wheel as Python package data. That approach has a critical downside: **templates can only evolve at acp-mcp's release cadence**. A typo in `acp.proceed.md` would require a new acp-mcp release, even though no Python code changed.
+
+The bash version solves this differently: `acp.install.sh` and `acp.version-update.sh` both **curl from agent-context-protocol's github** at runtime. Templates evolve in agent-context-protocol on their own cadence; the bash scripts just orchestrate the fetch.
+
+acp-mcp should preserve this property. Otherwise, every template fix requires a Python release.
+
+---
+
+## Solution
+
+### Two repos, clean separation
+
+```
+agent-context-protocol  →  Source of truth for ACP methodology
+                           (templates, commands, patterns, AGENT.md, schemas)
+                           ├─ bash install path (legacy, still works)
+                           └─ git/github (canonical content host)
+
+acp-mcp                 →  Preferred Python tooling
+                           ├─ CLI: acp init, acp version, acp package
+                           ├─ MCP surface: acp_package, acp_version, acp_enumerate
+                           └─ Fetches templates from agent-context-protocol via git clone
+```
+
+This mirrors the scry ecosystem:
+- `scry-spec` (markdown contract) — source of truth
+- `scry-parse-py` / `scry-parse-ts` (implementations) — consume the spec
+- `scry-mcp` (server) — consumes scry-parse
+
+Same pattern. agent-context-protocol is the spec/content; acp-mcp is one consumer.
+
+### Runtime template fetching via git clone
+
+`acp init` and `acp version update` clone agent-context-protocol's `mainline` branch to a temporary directory, copy files into the target project, then clean up.
+
+**Why git clone instead of per-file fetch or tarball**:
+- Single command, well-understood semantics
+- Works with private repos via SSH if ever needed
+- Shallow clone (`--depth=1`) is fast (~1 second for agent-context-protocol)
+- No need to know individual file paths or maintain a manifest
+- Idempotent — clone, copy what's needed, clean up
+
+**Why /tmp instead of persistent cache**:
+- Simpler model: every fetch gets a fresh clone
+- No staleness concerns (cache invalidation is a hard problem)
+- Disk churn is negligible (one shallow clone per operation)
+- A future optimization could add `~/.cache/acp-mcp/` if measurements show /tmp churn is a real cost
+
+### Command surface (clarified)
+
+| Command | What it does |
+|---|---|
+| `acp init [PATH]` | Clone agent-context-protocol/mainline to /tmp, copy AGENT.md + agent/ templates into PATH, generate progress.yaml, clean up. |
+| `acp version show` | Print the project's ACP version (read from progress.yaml or similar). |
+| `acp version check` | Compare the project's ACP version against agent-context-protocol's mainline HEAD. |
+| `acp version update` | Clone agent-context-protocol/mainline to /tmp, refresh template files in `agent/`, preserve user content (milestones, designs, etc.), clean up. |
+| `acp --version` | Print acp-mcp tool version (typer adds this automatically). |
+| `uv tool upgrade acp-mcp` | Upgrade the acp-mcp tool itself (not our command — defer to uv). |
+
+**Key distinction**: `acp version *` operates on the **project's ACP methodology version**, not the **acp-mcp tool version**. The tool version is uv's concern; the project version is ours.
+
+This matches bash semantics — `@acp.version-update` historically refreshed project files, not the bash scripts.
+
+---
+
+## Implementation
+
+### Phase 1: Build the fetch primitive
+
+Add `src/acp/core/fetch.py`:
+
+```python
+import subprocess
+import tempfile
+from pathlib import Path
+from contextlib import contextmanager
+
+ACP_REPO_URL = "https://github.com/prmichaelsen/agent-context-protocol.git"
+ACP_BRANCH = "mainline"
+
+
+@contextmanager
+def fetch_acp_templates(branch: str = ACP_BRANCH):
+    """Shallow-clone agent-context-protocol to a temp dir and yield the path.
+    Cleans up on exit.
+    """
+    tmpdir = Path(tempfile.mkdtemp(prefix="acp-mcp-fetch-"))
+    try:
+        subprocess.run(
+            ["git", "clone", "--depth=1", "--branch", branch, ACP_REPO_URL, str(tmpdir)],
+            check=True, capture_output=True,
+        )
+        yield tmpdir
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+```
+
+### Phase 2: Rework `acp init`
+
+Replace the bundle-reading logic with a fetch-and-copy:
+
+```python
+def init(path: Path = ".", force: bool = False):
+    target = path.resolve()
+    agent_dir = target / "agent"
+    if agent_dir.exists() and not force:
+        # error
+        ...
+
+    with fetch_acp_templates() as src_root:
+        # Copy AGENT.md and agent/ from src_root into target
+        # Skip bash scripts (agent/scripts/), reports, clarifications, drafts
+        ...
+
+    # Generate fresh progress.yaml
+    ...
+```
+
+### Phase 3: Implement `acp version check` and `acp version update`
+
+```python
+def check():
+    """Compare project's ACP version to agent-context-protocol/mainline HEAD."""
+    project_version = read_acp_version_from_project()  # from progress.yaml or similar
+    with fetch_acp_templates() as src_root:
+        upstream_version = read_acp_version_from_repo(src_root)  # from AGENT.md or VERSION file
+    # report whether project is up to date
+    ...
+
+
+def update():
+    """Refresh project's ACP template files from agent-context-protocol/mainline."""
+    project_root = find_project_root()
+    with fetch_acp_templates() as src_root:
+        for tpl in template_files(src_root):
+            dest = project_root / tpl.relative_to(src_root)
+            shutil.copy(tpl, dest)
+    # Preserve user content (don't overwrite milestone/task/design instances)
+    ...
+```
+
+### Phase 4: Drop the bundled templates
+
+Remove the bundled `src/acp/templates/` tree. The package no longer carries 73 markdown files. Wheel shrinks.
+
+Remove the `[tool.hatch.build.targets.wheel.shared-data]` config (or simplify the comment block) so hatchling doesn't include the templates directory.
+
+### Phase 5: agent-context-protocol stays alive
+
+- **bash scripts get deprecated**: `acp.install.sh`, `acp.version-update.sh`, `acp.version-check.sh` are no longer the recommended install path. They keep working for users who still want bash.
+- **Templates and methodology live on**: AGENT.md, agent/commands/, agent/*.template.md, agent/schemas/ — all stay in agent-context-protocol's repo. This is the canonical content.
+- **README updates**: agent-context-protocol's README points users to `uv tool install acp-mcp` as the preferred install path, with bash as the fallback.
+- **Repo lives in its own release cadence**: template/command/pattern changes happen on agent-context-protocol's release schedule. acp-mcp just consumes the latest.
+
+---
+
+## Benefits
+
+- **Templates evolve independently of tool releases** — typo fix in `acp.proceed.md` doesn't require an acp-mcp release.
+- **Single source of truth** — agent-context-protocol is the canonical methodology repo. acp-mcp is one consumer (others can exist).
+- **bash version stays functional** — legacy install path still works for users who want it; no forced migration.
+- **Simpler model** — both `acp init` and `acp version update` do the same thing (clone, copy); only the destination's prior state differs.
+- **Consistent semantics with bash** — `acp version update` refreshes project files, matching what bash users already expect.
+- **Smaller wheel** — no bundled markdown payload (~500 KB saved). Minor but nice.
+- **No staleness surprises** — users always get whatever's on mainline at the moment they ran the command.
+
+---
+
+## Trade-offs
+
+### Network required at `acp init` time
+
+**Impact**: First-time bootstrap requires network access (git clone).
+
+**Mitigation**: Same as bash version's `acp.install.sh` (which curls from github). Standard expectation for install operations in 2026. Airgapped environments use the bash version's offline-friendly path (template files copied manually).
+
+### Git dependency
+
+**Impact**: `git` must be installed and on PATH.
+
+**Mitigation**: Same as bash version's requirements. Virtually all dev environments have git. Document the requirement in README.
+
+### No reproducibility from acp-mcp version alone
+
+**Impact**: `acp init` today and tomorrow can produce different output if agent-context-protocol's mainline moved.
+
+**Mitigation**: This is by design — users want fresh templates. If reproducibility is needed for a specific deployment, pin via `--branch` or `--ref` (future flag) to a specific commit or tag.
+
+### Slower than bundled
+
+**Impact**: Shallow clone takes ~1 second vs file-copy taking ~10ms.
+
+**Mitigation**: `acp init` is a one-time operation per project; the latency is invisible against the user's first-run mental model. `acp version update` is periodic; same.
+
+---
+
+## Migration for already-bundled v0.2.0
+
+The acp-worker shipped v0.2.0 with bundled templates and a fully functional `acp init` reading from `importlib.resources`. That work isn't wasted — the structure and tests carry forward — but the template source changes.
+
+Migration tasks (to be queued to acp-worker):
+
+1. Add `src/acp/core/fetch.py` with the git-clone primitive.
+2. Rework `src/acp/cli/init.py` to fetch + copy instead of reading bundled resources.
+3. Remove `src/acp/templates/` directory (bundle no longer needed).
+4. Update `pyproject.toml` to drop the bundled data config.
+5. Rework `src/acp/cli/version.py`:
+   - `acp version show` — show project's ACP version (from progress.yaml)
+   - `acp version check` — compare project vs agent-context-protocol mainline
+   - `acp version update` — fetch and refresh project artifacts (NOT `uv tool upgrade`)
+6. Rework `src/acp/mcp/server.py`'s `acp_version` MCP tool to mirror the new CLI semantics.
+7. Update README to describe the runtime-fetch model.
+8. Add tests for the fetch primitive (mock subprocess) and the new init/version flows.
+9. Bump to v0.3.0.
+
+---
+
+## Dependencies
+
+- `git` must be installed and on PATH (runtime requirement, not a Python dependency).
+- No new Python dependencies (subprocess + tempfile + pathlib are stdlib).
+- `scry-parse` is still required for `acp_enumerate` (marker extraction) — that path is unchanged.
+
+---
+
+## Testing Strategy
+
+### Fetch tests
+- Unit test: mock subprocess.run, verify the right `git clone` command is issued
+- Integration test: actually clone agent-context-protocol from github, verify expected files appear (gated behind a marker, skipped in CI by default to avoid network requirements)
+
+### `acp init` tests
+- Verify clone happens, files are copied, progress.yaml is generated
+- Verify --force overwrites
+- Verify tempdir is cleaned up on success and on failure
+
+### `acp version update` tests
+- Verify template files get updated
+- Verify user content (specific milestones, designs, etc.) is preserved
+- Verify dry-run mode shows diff without applying
+
+### Reliability tests
+- Network failure during clone: clean error, no partial state
+- Tempdir cleanup happens even on exception
+- Git not installed: clear error message
+
+---
+
+## Key Design Decisions
+
+| Decision | Choice | Rationale |
+|---|---|---|
+| Template source | agent-context-protocol github | Stays canonical; templates evolve independently |
+| Fetch mechanism | `git clone --depth=1` to /tmp | Simple, fast, well-understood |
+| Cache strategy | None — fresh fetch every time | Avoids cache invalidation; cheap enough |
+| Bundle templates in wheel | No | Defeats the purpose of independent evolution |
+| `acp version update` semantics | Project artifact refresh | Matches bash semantics; tool upgrade is uv's job |
+| Tool self-upgrade command | No (defer to `uv tool upgrade acp-mcp`) | Don't reinvent uv |
+| Bash version status | Deprecated but functional | Backward compat for legacy users |
+| agent-context-protocol status | Active, canonical methodology repo | Same model as scry-spec / scry-parse |
+| Project ACP version source | progress.yaml or VERSION file | TBD during implementation; one place to read it |
+
+---
+
+## Future Considerations
+
+- **Cached fetches**: if `/tmp` clones become a measurable cost, add `~/.cache/acp-mcp/templates/` with TTL-based invalidation.
+- **Pinning**: `--branch`, `--ref`, or `--tag` flag on `acp init` for reproducible deployments.
+- **Multi-source templates**: support custom template sources beyond agent-context-protocol (e.g., for orgs with their own ACP fork).
+- **Diff/preview mode**: `acp version update --dry-run` shows what would change without applying.
+- **Offline mode**: detect network failure and prompt to install via bash, or use a manually-supplied template directory.
+
+---
+
+**Status**: Active design specification.
+**Recommendation**: Queue the migration tasks to acp-worker. Drop bundled templates. Implement fetch primitive. Rework version commands. Bump to v0.3.0.
+**Related documents**:
+- `acp-mcp/CHANGELOG.md` — track releases that implement each phase
+- `scry-spec v1.0` — markers used in fetched templates (when `@scry.entry` markers are added to agent-context-protocol's templates)

agent_context_mcp-0.3.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "agent-context-mcp"
+version = "0.3.0"
+description = "Python package manager and MCP server for Agent Context Protocol (ACP) projects."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Patrick Michaelsen", email = "michaelsenpatrick@gmail.com" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "fastmcp>=0.2.0",
+    "typer>=0.12.0",
+    "pyyaml>=6.0.0",
+    "httpx>=0.27.0",
+    "rich>=13.0.0",
+    "scry-parse>=1.0.2",
+]
+
+[project.scripts]
+acp = "acp.cli.main:app"
+
+[project.entry-points."mcp.server"]
+agent-context-mcp = "acp.mcp.server:main"
+
+[project.urls]
+Homepage = "https://github.com/prmichaelsen/acp-mcp"
+Repository = "https://github.com/prmichaelsen/acp-mcp"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/acp"]
+# No bundled templates. Templates are fetched at runtime from agent-context-protocol
+# via shallow git clone. The wheel contains only Python source.
+
+[tool.pytest.ini_options]
+markers = [
+    "integration: marks tests that require network access and git (skipped by default)",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+]

agent_context_mcp-0.3.0/src/acp/__init__.py

@@ -0,0 +1,3 @@
+"""acp — Python package manager and MCP server for Agent Context Protocol projects."""
+
+__version__ = "0.3.0"

agent_context_mcp-0.3.0/src/acp/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI entry points."""