chp-adapter-ci 0.8.0__tar.gz

chp_adapter_ci-0.8.0/.gitignore

@@ -0,0 +1,23 @@
+node_modules/
+dist/
+.yalc/
+yalc.lock
+*.tgz
+.env
+.env.*
+coverage/
+dashboard/
+components/
+.tech-hub-cache/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.chp/
+.DS_Store
+.coverage
+.forge/
+.hypothesis/
+.claude/
+
+# chp-agent evidence store
+.chp-agent/sessions.sqlite

chp_adapter_ci-0.8.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: chp-adapter-ci
+Version: 0.8.0
+Summary: CHP adapter for running package test suites as governed evidence-producing invocations
+Keywords: capability-host-protocol,chp,ci,pytest,testing
+Requires-Python: >=3.11
+Requires-Dist: chp-core

chp_adapter_ci-0.8.0/chp_adapter_ci/__init__.py

@@ -0,0 +1,3 @@
+from .adapter import CIAdapter, CIConfig
+
+__all__ = ["CIAdapter", "CIConfig"]

chp_adapter_ci-0.8.0/chp_adapter_ci/adapter.py

@@ -0,0 +1,227 @@
+"""CIAdapter — run package test suites as governed CHP capability invocations.
+
+Each package's pytest run becomes a ctx.ainvoke("chp.adapters.ci.run_suite")
+call so it appears as a first-class record in the correlation chain. The
+run_all capability orchestrates the full suite via the lego-block pattern:
+  run_all → ctx.ainvoke(run_suite) × N packages → evidence per package
+
+Evidence policy:
+  Emitted: package name, path, pass/fail counts, duration, exit code, summary.
+  NOT emitted: test output, failure messages (may contain paths or secrets).
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from chp_core import BaseAdapter, capability
+
+_EMITS = [
+    "ci_run_started",
+    "ci_run_completed",
+    "ci_suite_started",
+    "ci_suite_completed",
+    "ci_suite_failed",
+]
+
+_PASSED_RE = re.compile(r"(\d+) passed")
+_FAILED_RE = re.compile(r"(\d+) failed")
+_ERROR_RE  = re.compile(r"(\d+) error")
+
+
+@dataclass
+class CIConfig:
+    """Config for CIAdapter.
+
+    ``repo_root`` — root of the chp-dev repo; defaults to cwd() at call time.
+    ``python`` — Python executable to use for subprocess pytest invocations.
+    """
+
+    repo_root: str = ""
+    python: str = ""
+
+    def resolved_root(self) -> Path:
+        return Path(self.repo_root).expanduser().resolve() if self.repo_root else Path.cwd()
+
+    def resolved_python(self) -> str:
+        return self.python or sys.executable
+
+
+class CIAdapter(BaseAdapter):
+    """Run package test suites as governed CHP invocations with per-suite evidence."""
+
+    adapter_id = "chp.adapters.ci"
+    adapter_name = "CI"
+    adapter_description = "Run pytest across CHP packages as governed capability calls. Each suite is a separate evidence-producing invocation."
+    adapter_category = "developer_tooling"
+    adapter_tags = ["ci", "testing", "pytest", "quality", "evidence"]
+
+    def __init__(self, config: CIConfig | None = None) -> None:
+        self._config = config or CIConfig()
+
+    def _discover_packages(self) -> list[dict[str, str]]:
+        """Find all packages under repo_root/packages/ that have a pyproject.toml."""
+        packages_dir = self._config.resolved_root() / "packages"
+        if not packages_dir.is_dir():
+            return []
+        return sorted(
+            [
+                {"name": p.name, "path": str(p)}
+                for p in packages_dir.iterdir()
+                if p.is_dir() and (p / "pyproject.toml").exists()
+            ],
+            key=lambda x: x["name"],
+        )
+
+    # ------------------------------------------------------------------
+    # run_suite
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.ci.run_suite",
+        version="1.0.0",
+        description="Run pytest for a single package and emit pass/fail evidence. Output is not recorded — only counts and duration.",
+        category="developer_tooling",
+        risk="low",
+        emits=_EMITS,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "package_name": {"type": "string", "description": "Human-readable package name (e.g. chp-adapter-messages)"},
+                "package_path": {"type": "string", "description": "Absolute path to the package directory"},
+            },
+            "required": ["package_name", "package_path"],
+            "additionalProperties": False,
+        },
+    )
+    async def run_suite(self, ctx: Any, payload: dict) -> dict:
+        package_name: str = payload["package_name"]
+        package_path: str = payload["package_path"]
+
+        ctx.emit("ci_suite_started", {
+            "package": package_name,
+            "path": package_path,
+        }, redacted=False)
+
+        t0 = time.monotonic()
+        result = subprocess.run(
+            [self._config.resolved_python(), "-m", "pytest", "-q", "-o", "addopts="],
+            cwd=package_path,
+            capture_output=True,
+            text=True,
+        )
+        duration_ms = round((time.monotonic() - t0) * 1000)
+
+        output = (result.stdout + result.stderr).strip()
+        summary_line = next(
+            (ln for ln in reversed(output.splitlines()) if ln.strip()),
+            "",
+        )
+
+        passed = int(m.group(1)) if (m := _PASSED_RE.search(summary_line)) else 0
+        failed = int(m.group(1)) if (m := _FAILED_RE.search(summary_line)) else 0
+        errors = int(m.group(1)) if (m := _ERROR_RE.search(summary_line)) else 0
+        ok = result.returncode == 0
+
+        evidence = {
+            "package": package_name,
+            "passed": passed,
+            "failed": failed,
+            "errors": errors,
+            "duration_ms": duration_ms,
+            "exit_code": result.returncode,
+            "summary": summary_line[:200],
+        }
+
+        if ok:
+            ctx.emit("ci_suite_completed", evidence, redacted=False)
+        else:
+            ctx.emit("ci_suite_failed", evidence, redacted=False)
+
+        return {"ok": ok, **evidence}
+
+    # ------------------------------------------------------------------
+    # run_all
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.ci.run_all",
+        version="1.0.0",
+        description="Run pytest across all packages in the repo. Each suite is a separate ctx.ainvoke(run_suite) call — every package gets its own evidence record.",
+        category="developer_tooling",
+        risk="low",
+        emits=_EMITS,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "packages": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Package names to run (default: all discovered packages)",
+                },
+            },
+            "additionalProperties": False,
+        },
+    )
+    async def run_all(self, ctx: Any, payload: dict) -> dict:
+        all_packages = self._discover_packages()
+        filter_names: list[str] | None = payload.get("packages") or None
+
+        packages = (
+            [p for p in all_packages if p["name"] in filter_names]
+            if filter_names
+            else all_packages
+        )
+
+        ctx.emit("ci_run_started", {
+            "package_count": len(packages),
+            "packages": [p["name"] for p in packages],
+        }, redacted=False)
+
+        suite_results: list[dict] = []
+        for pkg in packages:
+            result = await ctx.ainvoke(
+                "chp.adapters.ci.run_suite",
+                {"package_name": pkg["name"], "package_path": pkg["path"]},
+            )
+            if result.success:
+                suite_results.append(result.data)
+            else:
+                suite_results.append({
+                    "package": pkg["name"],
+                    "ok": False,
+                    "passed": 0,
+                    "failed": 0,
+                    "errors": 1,
+                    "duration_ms": 0,
+                    "exit_code": -1,
+                    "summary": str(result.error),
+                })
+
+        total_passed = sum(r.get("passed", 0) for r in suite_results)
+        total_failed = sum(r.get("failed", 0) + r.get("errors", 0) for r in suite_results)
+        failed_suites = [r["package"] for r in suite_results if not r.get("ok")]
+        ok = len(failed_suites) == 0
+
+        ctx.emit("ci_run_completed", {
+            "ok": ok,
+            "total_packages": len(packages),
+            "total_passed": total_passed,
+            "total_failed": total_failed,
+            "failed_suites": failed_suites,
+        }, redacted=False)
+
+        return {
+            "ok": ok,
+            "total_packages": len(packages),
+            "total_passed": total_passed,
+            "total_failed": total_failed,
+            "failed_suites": failed_suites,
+            "suites": suite_results,
+        }

chp_adapter_ci-0.8.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "chp-adapter-ci"
+version = "0.8.0"
+description = "CHP adapter for running package test suites as governed evidence-producing invocations"
+requires-python = ">=3.11"
+dependencies = ["chp-core"]
+keywords = ["chp", "capability-host-protocol", "ci", "testing", "pytest"]
+
+[project.entry-points."chp.adapters"]
+ci = "chp_adapter_ci:CIAdapter"
+
+[tool.hatch.build.targets.wheel]
+packages = ["chp_adapter_ci"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"

chp_adapter_ci-0.8.0/tests/test_ci_adapter.py

@@ -0,0 +1,263 @@
+"""Tests for chp-adapter-ci."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import textwrap
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from chp_adapter_ci import CIAdapter, CIConfig
+from chp_core import LocalCapabilityHost, register_adapter
+from chp_core.store import SQLiteEvidenceStore
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_host(repo_root: str = "") -> LocalCapabilityHost:
+    store = SQLiteEvidenceStore(":memory:")
+    host = LocalCapabilityHost(store=store)
+    config = CIConfig(repo_root=repo_root)
+    register_adapter(host, CIAdapter(config))
+    return host
+
+
+def _invoke(host: LocalCapabilityHost, cap_id: str, payload: dict | None = None):
+    return asyncio.get_event_loop().run_until_complete(
+        host.ainvoke(cap_id, payload or {})
+    )
+
+
+def _fake_run(returncode: int = 0, stdout: str = "1 passed in 0.1s", stderr: str = ""):
+    result = MagicMock()
+    result.returncode = returncode
+    result.stdout = stdout
+    result.stderr = stderr
+    return result
+
+
+# ---------------------------------------------------------------------------
+# CIConfig
+# ---------------------------------------------------------------------------
+
+class TestCIConfig:
+    def test_resolved_root_defaults_to_cwd(self):
+        config = CIConfig()
+        assert config.resolved_root() == Path.cwd()
+
+    def test_resolved_root_expands_path(self, tmp_path):
+        config = CIConfig(repo_root=str(tmp_path))
+        assert config.resolved_root() == tmp_path
+
+    def test_resolved_python_defaults_to_sys(self):
+        import sys
+        config = CIConfig()
+        assert config.resolved_python() == sys.executable
+
+    def test_resolved_python_uses_override(self):
+        config = CIConfig(python="/custom/python3")
+        assert config.resolved_python() == "/custom/python3"
+
+
+# ---------------------------------------------------------------------------
+# CIAdapter._discover_packages
+# ---------------------------------------------------------------------------
+
+class TestDiscoverPackages:
+    def test_finds_packages_with_pyproject(self, tmp_path):
+        pkg_a = tmp_path / "packages" / "pkg-a"
+        pkg_a.mkdir(parents=True)
+        (pkg_a / "pyproject.toml").write_text("[project]\nname = 'pkg-a'\n")
+
+        pkg_b = tmp_path / "packages" / "pkg-b"
+        pkg_b.mkdir(parents=True)
+        (pkg_b / "pyproject.toml").write_text("[project]\nname = 'pkg-b'\n")
+
+        no_toml = tmp_path / "packages" / "not-a-package"
+        no_toml.mkdir(parents=True)
+
+        adapter = CIAdapter(CIConfig(repo_root=str(tmp_path)))
+        packages = adapter._discover_packages()
+
+        names = [p["name"] for p in packages]
+        assert "pkg-a" in names
+        assert "pkg-b" in names
+        assert "not-a-package" not in names
+
+    def test_returns_empty_when_no_packages_dir(self, tmp_path):
+        adapter = CIAdapter(CIConfig(repo_root=str(tmp_path)))
+        assert adapter._discover_packages() == []
+
+    def test_sorted_alphabetically(self, tmp_path):
+        for name in ["pkg-z", "pkg-a", "pkg-m"]:
+            d = tmp_path / "packages" / name
+            d.mkdir(parents=True)
+            (d / "pyproject.toml").write_text("")
+
+        adapter = CIAdapter(CIConfig(repo_root=str(tmp_path)))
+        names = [p["name"] for p in adapter._discover_packages()]
+        assert names == sorted(names)
+
+
+# ---------------------------------------------------------------------------
+# run_suite capability
+# ---------------------------------------------------------------------------
+
+class TestRunSuite:
+    def test_passing_suite(self, tmp_path):
+        host = _make_host()
+        with patch("chp_adapter_ci.adapter.subprocess.run") as mock_run:
+            mock_run.return_value = _fake_run(0, "3 passed in 0.42s")
+            result = _invoke(host, "chp.adapters.ci.run_suite", {
+                "package_name": "my-pkg",
+                "package_path": str(tmp_path),
+            })
+
+        assert result.success
+        assert result.data["ok"] is True
+        assert result.data["passed"] == 3
+        assert result.data["failed"] == 0
+        assert result.data["exit_code"] == 0
+        assert result.data["package"] == "my-pkg"
+
+    def test_failing_suite(self, tmp_path):
+        host = _make_host()
+        with patch("chp_adapter_ci.adapter.subprocess.run") as mock_run:
+            mock_run.return_value = _fake_run(1, "2 passed, 1 failed in 0.5s")
+            result = _invoke(host, "chp.adapters.ci.run_suite", {
+                "package_name": "bad-pkg",
+                "package_path": str(tmp_path),
+            })
+
+        assert result.success
+        assert result.data["ok"] is False
+        assert result.data["passed"] == 2
+        assert result.data["failed"] == 1
+        assert result.data["exit_code"] == 1
+
+    def test_summary_truncated_at_200(self, tmp_path):
+        host = _make_host()
+        long_line = "x" * 300
+        with patch("chp_adapter_ci.adapter.subprocess.run") as mock_run:
+            mock_run.return_value = _fake_run(0, long_line)
+            result = _invoke(host, "chp.adapters.ci.run_suite", {
+                "package_name": "pkg",
+                "package_path": str(tmp_path),
+            })
+
+        assert len(result.data["summary"]) <= 200
+
+    def test_duration_ms_positive(self, tmp_path):
+        host = _make_host()
+        with patch("chp_adapter_ci.adapter.subprocess.run") as mock_run:
+            mock_run.return_value = _fake_run()
+            result = _invoke(host, "chp.adapters.ci.run_suite", {
+                "package_name": "pkg",
+                "package_path": str(tmp_path),
+            })
+        assert result.data["duration_ms"] >= 0
+
+    def test_subprocess_called_with_correct_args(self, tmp_path):
+        host = _make_host()
+        with patch("chp_adapter_ci.adapter.subprocess.run") as mock_run:
+            mock_run.return_value = _fake_run()
+            _invoke(host, "chp.adapters.ci.run_suite", {
+                "package_name": "pkg",
+                "package_path": str(tmp_path),
+            })
+
+        call_args = mock_run.call_args
+        cmd = call_args[0][0]
+        assert "-m" in cmd
+        assert "pytest" in cmd
+        assert call_args[1]["cwd"] == str(tmp_path)
+        assert call_args[1]["capture_output"] is True
+
+
+# ---------------------------------------------------------------------------
+# run_all capability
+# ---------------------------------------------------------------------------
+
+class TestRunAll:
+    def test_all_pass(self, tmp_path):
+        for name in ["pkg-a", "pkg-b"]:
+            d = tmp_path / "packages" / name
+            d.mkdir(parents=True)
+            (d / "pyproject.toml").write_text("")
+
+        host = _make_host(repo_root=str(tmp_path))
+        with patch("chp_adapter_ci.adapter.subprocess.run") as mock_run:
+            mock_run.return_value = _fake_run(0, "5 passed in 0.1s")
+            result = _invoke(host, "chp.adapters.ci.run_all", {})
+
+        assert result.success
+        assert result.data["ok"] is True
+        assert result.data["total_packages"] == 2
+        assert result.data["total_passed"] == 10  # 5 per package
+        assert result.data["failed_suites"] == []
+
+    def test_one_fails(self, tmp_path):
+        for name in ["pkg-ok", "pkg-broken"]:
+            d = tmp_path / "packages" / name
+            d.mkdir(parents=True)
+            (d / "pyproject.toml").write_text("")
+
+        host = _make_host(repo_root=str(tmp_path))
+
+        def side_effect(cmd, cwd=None, **kwargs):
+            if "pkg-broken" in str(cwd):
+                return _fake_run(1, "1 failed in 0.1s")
+            return _fake_run(0, "3 passed in 0.1s")
+
+        with patch("chp_adapter_ci.adapter.subprocess.run", side_effect=side_effect):
+            result = _invoke(host, "chp.adapters.ci.run_all", {})
+
+        assert result.success
+        assert result.data["ok"] is False
+        assert "pkg-broken" in result.data["failed_suites"]
+        assert "pkg-ok" not in result.data["failed_suites"]
+
+    def test_package_filter(self, tmp_path):
+        for name in ["pkg-a", "pkg-b", "pkg-c"]:
+            d = tmp_path / "packages" / name
+            d.mkdir(parents=True)
+            (d / "pyproject.toml").write_text("")
+
+        host = _make_host(repo_root=str(tmp_path))
+        with patch("chp_adapter_ci.adapter.subprocess.run") as mock_run:
+            mock_run.return_value = _fake_run()
+            result = _invoke(host, "chp.adapters.ci.run_all", {
+                "packages": ["pkg-a", "pkg-c"],
+            })
+
+        assert result.data["total_packages"] == 2
+        ran = {r["package"] for r in result.data["suites"]}
+        assert ran == {"pkg-a", "pkg-c"}
+
+    def test_empty_repo_no_packages(self, tmp_path):
+        host = _make_host(repo_root=str(tmp_path))
+        result = _invoke(host, "chp.adapters.ci.run_all", {})
+
+        assert result.success
+        assert result.data["total_packages"] == 0
+        assert result.data["ok"] is True
+
+
+# ---------------------------------------------------------------------------
+# Conformance: adapter.py has no violations
+# ---------------------------------------------------------------------------
+
+class TestCIAdapterConformance:
+    def test_no_conformance_violations(self):
+        from chp_adapter_conformance import check_source_file
+        import chp_adapter_ci.adapter as mod
+        import inspect
+
+        src_path = inspect.getfile(mod)
+        violations = check_source_file(src_path)
+        assert not violations, f"CIAdapter has conformance violations: {violations}"