agentbundle 0.2.0__py3-none-any.whl

agentbundle/build/tests/test_direct_directory_cleanup.py

@@ -0,0 +1,65 @@
+"""Tests for `sweep_orphans` — the shared post-pass for
+`direct-directory` skill projections."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentbundle.build.projections.direct_directory import sweep_orphans
+
+
+def test_removes_orphan_directory(tmp_path: Path) -> None:
+    for name in ("a", "b", "c"):
+        (tmp_path / name).mkdir()
+
+    sweep_orphans(tmp_path, {"a", "c"})
+
+    assert (tmp_path / "a").is_dir()
+    assert (tmp_path / "c").is_dir()
+    assert not (tmp_path / "b").exists()
+
+
+def test_noop_on_full_match(tmp_path: Path) -> None:
+    for name in ("a", "b"):
+        (tmp_path / name).mkdir()
+
+    sweep_orphans(tmp_path, {"a", "b"})
+
+    assert (tmp_path / "a").is_dir()
+    assert (tmp_path / "b").is_dir()
+
+
+def test_noop_on_missing_target(tmp_path: Path) -> None:
+    sweep_orphans(tmp_path / "does-not-exist", {"a"})
+
+
+def test_ignores_root_files(tmp_path: Path) -> None:
+    (tmp_path / "a").mkdir()
+    readme = tmp_path / "README.md"
+    readme.write_text("hello\n", encoding="utf-8")
+
+    sweep_orphans(tmp_path, set())
+
+    assert not (tmp_path / "a").exists()
+    assert readme.is_file()
+    assert readme.read_text(encoding="utf-8") == "hello\n"
+
+
+def test_symlink_safe_sweep(tmp_path: Path) -> None:
+    external = tmp_path / "outside"
+    external.mkdir()
+    (external / "anchor").write_text("keep me\n", encoding="utf-8")
+
+    target = tmp_path / "skills"
+    target.mkdir()
+    (target / "a").mkdir()
+    link = target / "b"
+    link.symlink_to(external, target_is_directory=True)
+
+    sweep_orphans(target, {"a"})
+
+    assert (target / "a").is_dir()
+    assert not link.exists()
+    assert not link.is_symlink()
+    assert external.is_dir()
+    assert (external / "anchor").read_text(encoding="utf-8") == "keep me\n"

agentbundle/build/tests/test_end_to_end_build.py

@@ -0,0 +1,227 @@
+"""End-to-end pipeline test (T8).
+
+Drives `make build` (via `python -m agentbundle.build build`) against
+the four reference fixture packs at
+`packages/agentbundle/agentbundle/build/tests/fixtures/packs/` on a
+clean checkout and asserts the dist/ shape AC #7 + AC #13 require.
+Production-pack migration into a top-level `packs/` directory is out
+of scope per the spec's amended AC #7 (RFC-0001 F-dist follow-on
+owns it).
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+FIXTURES_PACKS = (
+    Path(__file__).resolve().parent / "fixtures" / "packs"
+)
+REFERENCE_PACKS = ("core", "governance-extras", "user-guide-diataxis", "monorepo-extras")
+
+
+def _run_build(args: list[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, "-m", "agentbundle.build", *args],
+        capture_output=True,
+        text=True,
+        cwd=REPO_ROOT,
+    )
+
+
+class EndToEndBuildTests(unittest.TestCase):
+    def test_default_build_produces_expected_shape(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            result = _run_build(
+                [
+                    "build",
+                    "--packs-dir",
+                    str(FIXTURES_PACKS),
+                    "--output-dir",
+                    tmp,
+                ]
+            )
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+            tmp_path = Path(tmp)
+            marketplace = tmp_path / "claude-plugins" / "marketplace.json"
+            self.assertTrue(marketplace.exists())
+            entries = json.loads(marketplace.read_text(encoding="utf-8"))
+            self.assertEqual(
+                {entry["name"] for entry in entries["plugins"]},
+                set(REFERENCE_PACKS),
+            )
+            for pack in REFERENCE_PACKS:
+                self.assertTrue((tmp_path / "claude-plugins" / pack).exists())
+                self.assertTrue((tmp_path / "apm" / pack).exists())
+
+            # AC #7 + integrated-journey coverage: assert each of the five
+            # primitives lands at its declared output under the `core` pack
+            # — the only fixture that exercises every primitive type.
+            core_plugin = tmp_path / "claude-plugins" / "core"
+            self.assertTrue((core_plugin / ".claude" / "skills" / "example").exists())
+            self.assertTrue((core_plugin / ".claude" / "agents" / "bar.md").exists())
+            self.assertTrue((core_plugin / "tools" / "hooks" / "baz.sh").exists())
+            self.assertTrue((core_plugin / "tools" / "hooks" / "baz.py").exists())
+            self.assertTrue(
+                (core_plugin / ".claude" / "settings.local.json").exists()
+            )
+            self.assertTrue((core_plugin / ".claude" / "commands" / "qux.md").exists())
+
+    def test_plain_build_does_not_invoke_self_host_recipes(self) -> None:
+        """AC: plain `make build` produces only dist/apm, dist/claude-plugins,
+        and dist/claude-plugins/marketplace.json — never the three self-host
+        recipes' artefacts (overlay output in the working tree, composite
+        AGENTS.md, composite marketplace). Verifies AC #14: working tree is
+        unchanged after the run (git status --porcelain returns byte-
+        identical output before and after)."""
+        before = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=REPO_ROOT,
+            capture_output=True,
+            text=True,
+            check=False,
+        ).stdout
+        with tempfile.TemporaryDirectory() as tmp:
+            result = _run_build(
+                [
+                    "build",
+                    "--packs-dir",
+                    str(FIXTURES_PACKS),
+                    "--output-dir",
+                    tmp,
+                ]
+            )
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+            tmp_path = Path(tmp)
+            self.assertFalse((tmp_path / "AGENTS.md").exists())
+            self.assertFalse((tmp_path / ".claude-plugin" / "marketplace.json").exists())
+        after = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=REPO_ROOT,
+            capture_output=True,
+            text=True,
+            check=False,
+        ).stdout
+        self.assertEqual(before, after, "plain `make build` modified the working tree")
+
+
+class CheckCommandTests(unittest.TestCase):
+    def test_make_build_check_on_a_clean_pre_projected_tree_exits_zero(self) -> None:
+        """Render once into a temp working tree, then `check` it. The check
+        should exit 0 because the tree matches the rendered output."""
+        with tempfile.TemporaryDirectory() as tmp:
+            working = Path(tmp) / "tree"
+            working.mkdir()
+            # Use git init to make it dirty-tree-detection-ready.
+            import os
+            env = os.environ.copy()
+            env["GIT_AUTHOR_NAME"] = "test"
+            env["GIT_AUTHOR_EMAIL"] = "test@example.com"
+            env["GIT_COMMITTER_NAME"] = "test"
+            env["GIT_COMMITTER_EMAIL"] = "test@example.com"
+            subprocess.run(["git", "init", "-q", str(working)], check=True, env=env)
+
+            # Seed `.adapt-discovery.toml` so `make build-check`'s
+            # fail-fast (spec AC14) doesn't reject the call. Canonical
+            # v0.1 shape per adapt-to-project AC9.
+            (working / ".adapt-discovery.toml").write_text(
+                'discovery-schema-version = "0.1"\n', encoding="utf-8"
+            )
+
+            from agentbundle.build.adapters import ADAPTERS
+            from agentbundle.build.contract import load as load_contract
+            from agentbundle.build.main import discover_packs
+            from agentbundle.build.self_host import run_self_host
+
+            contract = load_contract(
+                REPO_ROOT / "docs" / "contracts" / "adapter.toml"
+            )
+            # Pre-seed using the self-host runner so the working
+            # tree exactly matches what `make build-check` will render
+            # (including new seed/marketplace/symlink outputs).
+            run_self_host(
+                working_tree=working,
+                packs_dir=FIXTURES_PACKS,
+                dry_run=False,
+                force=True,
+                contract=contract,
+            )
+            subprocess.run(["git", "-C", str(working), "add", "-A"], check=True, env=env)
+            subprocess.run(
+                ["git", "-C", str(working), "commit", "-q", "-m", "seed"],
+                check=True,
+                env=env,
+            )
+
+            # `make build-check` depends on `make build` (Makefile:63) so the
+            # writer-template / APM drift gates introduced in commits
+            # 25590fe + 89c0db3 always see a populated dist/ tree. Mirror
+            # that dependency here: run `build` into <working>/dist/ before
+            # invoking `check --output-dir <working>` so `<working>/dist/
+            # claude-plugins/` and `<working>/dist/apm/` exist.
+            build_result = _run_build(
+                [
+                    "build",
+                    "--packs-dir",
+                    str(FIXTURES_PACKS),
+                    "--output-dir",
+                    str(working / "dist"),
+                ]
+            )
+            self.assertEqual(
+                build_result.returncode, 0, msg=build_result.stderr
+            )
+
+            result = _run_build(
+                [
+                    "check",
+                    "--packs-dir",
+                    str(FIXTURES_PACKS),
+                    "--output-dir",
+                    str(working),
+                ]
+            )
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+
+
+class ScaffoldCommandTests(unittest.TestCase):
+    def test_scaffold_copies_seeds_into_output(self) -> None:
+        """Scaffold copies a pack's seeds/ to the named output directory.
+
+        Uses a tempfile-based packs dir so the source fixture tree stays
+        untouched even if the test is interrupted mid-run.
+        """
+        import shutil
+
+        with tempfile.TemporaryDirectory() as workspace:
+            workspace_path = Path(workspace)
+            packs_clone = workspace_path / "packs"
+            shutil.copytree(FIXTURES_PACKS, packs_clone)
+            (packs_clone / "core" / "seeds").mkdir()
+            (packs_clone / "core" / "seeds" / "AGENTS.md").write_text(
+                "# seeded\n", encoding="utf-8"
+            )
+            output_dir = workspace_path / "out"
+
+            result = _run_build(
+                [
+                    "scaffold",
+                    "--packs-dir",
+                    str(packs_clone),
+                    "--pack",
+                    "core",
+                    "--output",
+                    str(output_dir),
+                ]
+            )
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+            self.assertTrue((output_dir / "AGENTS.md").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

agentbundle/build/tests/test_lint_agents_md_legacy_block.py

@@ -0,0 +1,135 @@
+"""T9 / AC31 — `tools/lint-agents-md.py` warns when a projected
+`AGENTS.md` still carries the legacy `<!-- agent-skills:start -->`
+literal *and* the contract declares Codex `skill` as `direct-directory`.
+
+The check fires through the linter's existing `warn(...)` closure
+(prefix `⚠` on stderr), not `note(...)` — so the exit code remains 0.
+
+Test shape: CLI subprocess invocation in a `tmp_path` scratch tree
+that mirrors the repo's layout (root `AGENTS.md`, `CLAUDE.md` symlink,
+synthetic `docs/contracts/adapter.toml`). The linter is run with
+`cwd=tmp_path`; the test asserts the return code and stderr.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+LINTER = REPO_ROOT / "tools" / "lint-agents-md.py"
+
+
+_CONTRACT_DIRECT_DIRECTORY = """\
+[primitive.skill]
+source-path = ".apm/skills/"
+
+[[adapter.codex.projection]]
+primitive = "skill"
+mode = "direct-directory"
+target-path = ".agents/skills/"
+on-conflict = "prompt-then-preserve"
+"""
+
+_CONTRACT_LEGACY = """\
+[primitive.skill]
+source-path = ".apm/skills/"
+
+[[adapter.codex.projection]]
+primitive = "skill"
+mode = "managed-block-inline"
+target-path = "AGENTS.md"
+managed-block-delimiter-start = "<!-- agent-skills:start -->"
+managed-block-delimiter-end = "<!-- agent-skills:end -->"
+on-conflict = "preserve-outside-block"
+"""
+
+
+def _seed_tree(
+    root: Path,
+    contract_body: str,
+    agents_md_body: str,
+) -> None:
+    contracts = root / "docs" / "contracts"
+    contracts.mkdir(parents=True)
+    (contracts / "adapter.toml").write_text(contract_body, encoding="utf-8")
+
+    (root / "AGENTS.md").write_text(agents_md_body, encoding="utf-8")
+    (root / "CLAUDE.md").symlink_to("AGENTS.md")
+
+
+def _run_linter(cwd: Path) -> subprocess.CompletedProcess[str]:
+    env = dict(os.environ)
+    return subprocess.run(
+        [sys.executable, str(LINTER)],
+        cwd=cwd,
+        env=env,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+class LegacyBlockWarningTests(unittest.TestCase):
+    def test_warns_when_legacy_marker_present_with_direct_directory_contract(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            _seed_tree(
+                tmp_path,
+                contract_body=_CONTRACT_DIRECT_DIRECTORY,
+                agents_md_body=(
+                    "# AGENTS.md\n\n"
+                    "Outside content.\n\n"
+                    "<!-- agent-skills:start -->\n"
+                    "- **work-loop** — desc\n"
+                    "<!-- agent-skills:end -->\n"
+                ),
+            )
+
+            result = _run_linter(tmp_path)
+            # The warning must fire and must name the offending file
+            # path. It must NOT change the exit code — other checks
+            # (e.g. CLAUDE.md symlink, AGENTS.md size) determine the
+            # return value.
+            self.assertIn("legacy-codex-skill-block", result.stderr)
+            self.assertIn("AGENTS.md", result.stderr)
+            self.assertIn("⚠", result.stderr)
+
+    def test_no_warn_when_legacy_marker_absent(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            _seed_tree(
+                tmp_path,
+                contract_body=_CONTRACT_DIRECT_DIRECTORY,
+                agents_md_body="# AGENTS.md\n\nNo legacy block here.\n",
+            )
+
+            result = _run_linter(tmp_path)
+            self.assertNotIn("legacy-codex-skill-block", result.stderr)
+
+    def test_no_warn_when_contract_still_managed_block(self) -> None:
+        # If the contract hasn't flipped (some adopter mid-upgrade
+        # against an older bundle), the marker is expected — the linter
+        # does not warn.
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            _seed_tree(
+                tmp_path,
+                contract_body=_CONTRACT_LEGACY,
+                agents_md_body=(
+                    "# AGENTS.md\n\n"
+                    "<!-- agent-skills:start -->\n"
+                    "<!-- agent-skills:end -->\n"
+                ),
+            )
+
+            result = _run_linter(tmp_path)
+            self.assertNotIn("legacy-codex-skill-block", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

agentbundle/build/tests/test_lint_agents_md_risk_block.py

@@ -0,0 +1,116 @@
+"""Local regression check for `tools/lint-agents-md.py` check 10g, which
+fails when the `risk-triggers:start`..`:end` block diverges between the
+four docs that carry it (work-loop-light-mode spec AC2).
+
+The standing CI guard is the lint itself (run in `.github/workflows/docs.yml`);
+this test — like its sibling `test_lint_agents_md_legacy_block.py` — runs
+only under a local `pytest` invocation, not in CI, and exists to pin the
+check's behaviour against regressions.
+
+Test shape mirrors test_lint_agents_md_legacy_block.py: CLI subprocess
+invocation in a `tmp_path` scratch tree, asserting on stderr (the linter
+fails on other missing-repo-structure checks regardless, so the exit code
+is not a clean signal — the `risk-trigger-block drift` substring is).
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+LINTER = REPO_ROOT / "tools" / "lint-agents-md.py"
+
+_DRIFT_MARKER = "risk-trigger-block drift"
+
+
+def _block(third_bullet: str) -> str:
+    return (
+        "<!-- risk-triggers:start — canonical wording lives here. -->\n"
+        "**Risk triggers — any one routes the work to full mode:**\n\n"
+        "- **Unfamiliar** — territory you don't know well.\n"
+        "- **Multi-person** — more than one person builds or reviews it.\n"
+        f"- {third_bullet}\n"
+        "<!-- risk-triggers:end -->\n"
+    )
+
+
+def _seed(root: Path, canonical_block: str, agents_block: str) -> None:
+    skill = root / ".claude" / "skills" / "work-loop"
+    skill.mkdir(parents=True)
+    (skill / "SKILL.md").write_text(
+        "# Skill: work-loop\n\n" + canonical_block, encoding="utf-8"
+    )
+    (root / "AGENTS.md").write_text(
+        "# AGENTS.md\n\n" + agents_block, encoding="utf-8"
+    )
+    (root / "CLAUDE.md").symlink_to("AGENTS.md")
+
+
+def _run_linter(cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(LINTER)],
+        cwd=cwd,
+        env=dict(os.environ),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+class RiskBlockEqualityTests(unittest.TestCase):
+    def test_fires_when_blocks_diverge(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            _seed(
+                tmp_path,
+                canonical_block=_block("**New dependency** — it adds a dependency."),
+                agents_block=_block("**New dependency** — it adds a DIFFERENT thing."),
+            )
+            result = _run_linter(tmp_path)
+            self.assertIn(_DRIFT_MARKER, result.stderr)
+            self.assertIn("AGENTS.md", result.stderr)
+
+    def test_silent_when_blocks_identical(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            same = _block("**New dependency** — it adds a dependency.")
+            _seed(tmp_path, canonical_block=same, agents_block=same)
+            result = _run_linter(tmp_path)
+            self.assertNotIn(_DRIFT_MARKER, result.stderr)
+
+    def test_fires_on_truncated_block(self) -> None:
+        # A `:start` with no matching `:end` is itself drift — fail closed.
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            same = _block("**New dependency** — it adds a dependency.")
+            _seed(tmp_path, canonical_block=same, agents_block=same)
+            # Truncate the AGENTS.md copy: drop its closing marker.
+            agents = tmp_path / "AGENTS.md"
+            agents.write_text(
+                agents.read_text(encoding="utf-8").replace(
+                    "<!-- risk-triggers:end -->\n", ""
+                ),
+                encoding="utf-8",
+            )
+            result = _run_linter(tmp_path)
+            self.assertIn(_DRIFT_MARKER, result.stderr)
+            self.assertIn("truncated", result.stderr)
+
+    def test_silent_when_no_marker(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            (tmp_path / "AGENTS.md").write_text(
+                "# AGENTS.md\n\nNo risk-trigger block here.\n", encoding="utf-8"
+            )
+            (tmp_path / "CLAUDE.md").symlink_to("AGENTS.md")
+            result = _run_linter(tmp_path)
+            self.assertNotIn(_DRIFT_MARKER, result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()