pactkit-opencode 3.0.5__tar.gz → 4.0.0__tar.gz

{pactkit_opencode-3.0.5 → pactkit_opencode-4.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pactkit-opencode
-Version: 3.0.5
+Version: 4.0.0
 Summary: PactKit adapter for OpenCode IDE
 License-Expression: MIT
 Requires-Python: >=3.10
-Requires-Dist: pactkit<3.1.0,>=3.0.1
+Requires-Dist: pactkit<4.1.0,>=4.0.0

{pactkit_opencode-3.0.5 → pactkit_opencode-4.0.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pactkit-opencode"
-version = "3.0.5"
+version = "4.0.0"
 description = "PactKit adapter for OpenCode IDE"
 requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
-    "pactkit>=3.0.1,<3.1.0",
+    "pactkit>=4.0.0,<4.1.0",
 ]
 
 [project.entry-points."pactkit.deployers"]

{pactkit_opencode-3.0.5 → pactkit_opencode-4.0.0}/src/pactkit_opencode/deployer.py

@@ -28,6 +28,7 @@ from pactkit.generators.deployer import (
     _deploy_rules,
     _deploy_skills,
 )
+from pactkit.generators.spi import generate_config_if_missing
 from pactkit_opencode import declarations
 from pactkit.utils import atomic_write
 
@@ -264,6 +265,7 @@ class OpenCodeDeployer(DeployerBase):
 
         if target is None:
             self._generate_project_agents_md()
+            self._generate_project_config()
 
     # --- OpenCode-specific helpers ---
 
@@ -288,6 +290,27 @@ class OpenCodeDeployer(DeployerBase):
         record_deployed_file(opencode_root, plugin_path.relative_to(opencode_root).as_posix())
         return 1
 
+    @staticmethod
+    def _generate_project_config():
+        """Write this host's pactkit.yaml when the project has none (Step 8 R-③-1).
+
+        Before this existed, `.opencode/pactkit.yaml` was **declared** in
+        `profile.pactkit_yaml_path` and **searched** by every reader, but no
+        code path produced it — the three facts R-③-1 requires to agree did
+        not. It could still appear anyway: `init --format classic` in a project
+        carrying a `.opencode/` directory wrote CLASSIC's config there, because
+        the path fell to `resolve_pactkit_yaml_dir`'s directory-existence
+        fallback (measured 2026-09-26: `mkdir .opencode && pactkit init
+        --format classic` → `.opencode/pactkit.yaml` containing classic's).
+
+        `format="opencode"` closes both halves: this host produces its own
+        copy, and no other host can produce this one's.
+        """
+        project_root = Path.cwd()
+        if project_root.resolve() == Path.home().resolve():
+            return
+        generate_config_if_missing(format="opencode", project_root=project_root)
+
     @staticmethod
     def _generate_project_agents_md():
         """Generate project-level AGENTS.md if it does not exist (STORY-slim-008 R4)."""

{pactkit_opencode-3.0.5 → pactkit_opencode-4.0.0}/src/pactkit_opencode.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pactkit-opencode
-Version: 3.0.5
+Version: 4.0.0
 Summary: PactKit adapter for OpenCode IDE
 License-Expression: MIT
 Requires-Python: >=3.10
-Requires-Dist: pactkit<3.1.0,>=3.0.1
+Requires-Dist: pactkit<4.1.0,>=4.0.0

{pactkit_opencode-3.0.5 → pactkit_opencode-4.0.0}/src/pactkit_opencode.egg-info/SOURCES.txt

@@ -13,13 +13,17 @@ src/pactkit_opencode.egg-info/top_level.txt
 tests/test_a1_config_recovery.py
 tests/test_a2_mcp_retired.py
 tests/test_bug035_opencode_dual_layer.py
+tests/test_capability_contract.py
 tests/test_deploy_opencode_parity.py
 tests/test_gate_plugin_deploy.py
 tests/test_host_body_snapshot.py
 tests/test_opencode_enforcement_channel.py
+tests/test_profile_contract.py
 tests/test_step6_self_sufficiency.py
+tests/test_step8_declaration_search_producer.py
 tests/test_story069_opencode_format.py
 tests/test_story070_opencode_compliance.py
 tests/test_story071_opencode_config_parity.py
 tests/test_story073_command_model_routing.py
-tests/test_story_work_units.py
+tests/test_story_work_units.py
+tests/test_wire_format_contract.py

pactkit_opencode-4.0.0/src/pactkit_opencode.egg-info/requires.txt

@@ -0,0 +1 @@
+pactkit<4.1.0,>=4.0.0

pactkit_opencode-4.0.0/tests/test_capability_contract.py

@@ -0,0 +1,112 @@
+"""SPEC-4.0-22 Step 7 — 本宿主的 capability / deployment claim / pretool 契约。
+
+**为什么这份测试在本仓。** 这三张表（能力声明、部署声明、pre-tool 机制名）
+自 Step 6/7 起由本 adapter 自带并经 entry-point 注册。core 侧只保留它随包发布
+的 `classic`。所以「本宿主能做什么、怎么执行、pre-tool 机制叫什么」的断言属于
+**本仓**——生产里的事实归谁，断言就归谁。
+
+core 侧对应断言（`test_spec40_22_capability_registry.py` 的宿主值行）已随之删除。
+**是搬迁，不是复制**：两处各留一份就是给同一个事实造两个真相源。
+"""
+
+from __future__ import annotations
+
+from pactkit.capability import resolve_capabilities
+from pactkit.generators.deploy_base import _ensure_entry_point_deployers
+from pactkit.profiles import registered_adapters
+
+HOST = "opencode"
+PRETOOL = 'tool.execute.before (plugin; veto by throwing)'
+CLAIM = ('portable', 'adapter_native_command_facade')
+ENV_CAPABLE = {'opencode.json'}
+PROTECTED = set()
+CONDITIONAL = set()
+PRESENT = ['git_hook', 'native_command', 'native_skill', 'pre_tool_hook', 'project_instruction', 'shell_execution']
+
+
+def _registration():
+    _ensure_entry_point_deployers()
+    return registered_adapters()[HOST]
+
+
+class TestTheDeclarationReachesTheRegistry:
+    def test_the_registry_carries_this_hosts_claim(self):
+        claim = _registration().deployment_claim
+        assert (claim.execution_mode, claim.verification_source) == CLAIM
+
+    def test_the_registry_carries_this_hosts_pretool_mechanism(self):
+        assert _registration().pretool_surface == PRETOOL
+
+
+class TestTheCapabilityDeclaration:
+    def test_the_present_set_is_exactly_this(self):
+        """**逐项**钉住，不是只钉个数——多一项少一项都要红。
+
+        迁移前基线是 6 项；这条断言的是同一批名字，所以它既防漏声明，
+        也防「为了让表看起来完整」而虚报一项。
+        """
+        resolved = resolve_capabilities(HOST)
+        assert resolved.known
+        present = sorted(n for n, e in resolved.entries.items() if e.present)
+        assert present == PRESENT
+
+    def test_every_declared_entry_carries_evidence(self):
+        for name, entry in resolve_capabilities(HOST).entries.items():
+            assert entry.evidence, f"{name} 没有证据来源——那就是一个断言，不是声明"
+
+    def test_the_declaration_is_not_empty(self):
+        assert _registration().capabilities, (
+            "本宿主没有声明任何能力——registry 会把每一项都填成 Degraded"
+        )
+
+
+class TestTheContractHasTeeth:
+    """反证：改坏本仓的声明，上面必须有测试变红。"""
+
+    def test_mutating_the_claim_moves_the_answer(self):
+        import dataclasses
+
+        from pactkit.profiles import register_adapter
+        import pactkit_opencode.declarations as decl
+
+        entry = _registration()
+        broken = dataclasses.replace(
+            entry.deployment_claim, verification_source="mutated"
+        )
+        register_adapter(HOST, deployer=entry.deployer, profile=entry.profile,
+                         deployment_claim=broken)
+        try:
+            assert _registration().deployment_claim.verification_source == "mutated", (
+                "改掉本仓的声明后 registry 没变——core 侧还有第二份真相源"
+            )
+        finally:
+            register_adapter(HOST, deployer=entry.deployer, profile=entry.profile,
+                             deployment_claim=decl.DEPLOYMENT_CLAIM)
+
+
+# ---------------------------------------------------------------------------
+# 安全事实（SPEC-4.0-22 R8 / Step 7）
+# ---------------------------------------------------------------------------
+
+
+class TestTheSecurityFacts:
+    """这三类的定义域是 **PactKit gate-relative**：`env` 能到达 gate 进程的文件、
+    gate 不许任何人编辑的文件、移除 gate 条目算篡改的文件。
+
+    所以它们是**本宿主的声明**——core 侧那张跨宿主表已随 Step 7 删除，这里的
+    断言跟事实走。
+    """
+
+    def test_the_declared_files_are_exactly_these(self):
+        s = _registration().security
+        assert set(s.env_capable.files) == ENV_CAPABLE
+        assert set(s.protected.files) == PROTECTED
+        assert set(s.conditional.files) == CONDITIONAL
+
+    def test_the_declaration_is_complete(self):
+        """`missing`（宿主没说话）与 `empty`（宿主说了它没有）是两件事。
+
+        声明不完整时，需要 tamper_guard 授权的写操作会 fail closed——那是
+        R8 的设计，不是缺陷。所以「完整」本身是要被钉住的事实。
+        """
+        assert _registration().security.complete

{pactkit_opencode-3.0.5 → pactkit_opencode-4.0.0}/tests/test_deploy_opencode_parity.py

@@ -271,18 +271,23 @@ class TestGenerateConfigIfMissing:
         yaml_path = tmp_path / ".claude" / "pactkit.yaml"
         assert yaml_path.exists()
 
-    def test_no_format_autodetects(self, tmp_path):
-        """Without format param, uses auto-detect (existing behavior preserved)."""
-        from pactkit.generators.deployer import _generate_config_if_missing
-
-        (tmp_path / ".opencode").mkdir()
-
-        with patch.object(Path, "cwd", return_value=tmp_path):
-            _generate_config_if_missing()
-
-        # Auto-detect should prefer .opencode
-        yaml_path = tmp_path / ".opencode" / "pactkit.yaml"
-        assert yaml_path.exists()
+    # `test_no_format_autodetects` stood here. It asserted that with no `format`
+    # argument, Core's generator followed whichever candidate directory existed
+    # — "existing behavior preserved", its docstring said. SPEC-4.0-22 Step 8
+    # deleted that behaviour (owner 2026-09-26: *reading may discover existing
+    # layers; writing must know which format it is writing for*).
+    #
+    # The contract it holds now — `format=None` resolves to classic's path and
+    # consults no directory — is **Core's**, so it is asserted in Core
+    # (`tests/unit/test_profiles.py::test_no_format_is_classic_regardless_of_which_dirs_exist`,
+    # `test_spec40_22_step8_config_generation.py`). A copy here would buy no
+    # coverage and would couple this adapter's CI to Core's release schedule:
+    # this repo installs Core from PyPI, so such a copy could only go green once
+    # the Step 8 Core was published — a red that says nothing about this repo.
+    #
+    # What this adapter owns is that IT never relies on that default. See
+    # `test_step8_declaration_search_producer.py`: it drives the real `deploy()`
+    # and asserts the config lands at this host's own declared path.
 
     def test_no_write_when_yaml_exists(self, tmp_path):
         from pactkit.generators.deployer import _generate_config_if_missing

pactkit_opencode-4.0.0/tests/test_host_body_snapshot.py

@@ -0,0 +1,262 @@
+"""This host's deployed prompt bodies, pinned against a golden (R7/AC10).
+
+2026-09-12 review (83/100, gap 2): the zero-credential acceptance split
+left adapter-host body comparison out of CI — the core workflow compares
+classic only. This suite pins the OPENCODE deployment's prompt bodies:
+
+- digest drift (a rule edited or deleted inside a prompt body) fails,
+  naming the file;
+- a core version mismatch fails with an explicit action — regenerate the
+  golden against the new core, or publish the matching core release
+  (PENDING-COMPATIBLE-CORE, see the spec R8 release-window semantics);
+- a probe test deploys, edits one body in place, and proves the SAME
+  comparison logic flags it (删改必被检出, not vacuous).
+
+**Two kinds of artifact, two kinds of assertion** (SPEC-4.0-22 Step 7).
+A prompt body is stable content, so a snapshot is the right instrument. A
+*deployed manifest* and the *gate plugin* are a function of **which adapters
+are installed**, so snapshotting them would freeze "whatever happened to be
+installed on the machine that regenerated the golden" — the golden would then
+be reproducible only there, and CI (which installs core + this adapter alone)
+would go red on a change that is not a regression.
+
+Measured 2026-09-26: a `core+opencode` deploy and an all-four-adapters deploy
+differ in **exactly two files** — `.pactkit-deployed.json` and
+`plugins/pactkit-gate.js` — and in nothing else. Those two are excluded from
+the golden and covered by `TestEnvironmentDerivedArtifactsAreConsistent`
+instead: their bytes may differ between environments, but each environment
+must be internally consistent.
+
+Before Step 7 the distinction was invisible. The transitional seed made
+`PACTKIT_YAML_CANDIDATES` a constant, so the plugin — and therefore the
+manifest that records its hash — was identical everywhere. The golden was
+reproducible for the wrong reason, and removing the seed is what made the
+instrument's real boundary visible.
+
+Regenerate with: tests/scripts/refresh_host_body_golden.py
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent / "scripts"))
+
+from refresh_host_body_golden import (  # noqa: E402
+    DEPLOY_SUFFIXES,
+    ENVIRONMENT_DERIVED,
+)
+
+HOST = "opencode"
+GOLDEN = Path(__file__).parent / "fixtures" / "host_body_golden.json"
+
+#: The plugin's marker list, as emitted by
+#: `pactkit.generators.opencode_plugin.render_plugin_source`.
+_MARKERS_RE = re.compile(r"const PROJECT_MARKERS = (\[.*?\])\n", re.S)
+
+
+def _core_version() -> str:
+    import importlib.metadata as m
+
+    return m.version("pactkit")
+
+
+def _normalize(content: str, deploy_root: str) -> str:
+    """Strip only the deterministic environment difference: the deploy root
+    path baked into rendered prompts. Rule text stays — normalizing it would
+    swallow the drift this suite exists to catch."""
+    return content.replace(deploy_root, "<DEPLOY_ROOT>")
+
+
+def _deploy(tmp_path: Path) -> tuple[Path, subprocess.CompletedProcess]:
+    """Deploy this host into `tmp_path`; returns (deploy root, process)."""
+    home = tmp_path / "home"
+    target = tmp_path / "deploy"
+    home.mkdir(exist_ok=True)
+    proc = subprocess.run(
+        [sys.executable, "-m", "pactkit", "init", "--format", HOST, "--target", str(target)],
+        capture_output=True, text=True, timeout=180,
+        env={"PATH": "/usr/bin:/bin", "HOME": str(home), "COLUMNS": "200"},
+    )
+    return target, proc
+
+
+def _deployed_digests(tmp_path: Path) -> tuple[dict[str, str] | None, subprocess.CompletedProcess]:
+    target, proc = _deploy(tmp_path)
+    if proc.returncode != 0:
+        return None, proc
+    digests: dict[str, str] = {}
+    for path in sorted(target.rglob("*")):
+        rel = path.relative_to(target).as_posix()
+        if not path.is_file() or path.suffix not in DEPLOY_SUFFIXES:
+            continue
+        if rel in ENVIRONMENT_DERIVED:
+            continue
+        body = _normalize(path.read_text(encoding="utf-8"), str(target))
+        digests[rel] = hashlib.sha256(body.encode("utf-8")).hexdigest()
+    return digests, proc
+
+
+def _assert_no_drift(golden_digests: dict[str, str], live: dict[str, str]) -> None:
+    """The one comparison both the golden test and the tamper probe use."""
+    changed = sorted(
+        k for k in set(golden_digests) & set(live) if golden_digests[k] != live[k]
+    )
+    removed = sorted(set(golden_digests) - set(live))
+    added = sorted(set(live) - set(golden_digests))
+    assert not (changed or removed or added), (
+        f"prompt body drift: changed={changed} removed={removed} added={added} "
+        f"— if the core prompts changed, regenerate the golden "
+        f"(tests/scripts/refresh_host_body_golden.py) or publish the matching "
+        f"core release first (PENDING-COMPATIBLE-CORE)"
+    )
+
+
+def _markers_from(source: str) -> list[str]:
+    m = _MARKERS_RE.search(source)
+    assert m, "the deployed plugin has no `const PROJECT_MARKERS = [...]` block"
+    return json.loads(m.group(1))
+
+
+class TestHostBodySnapshot:
+    def test_bodies_match_the_golden(self, tmp_path):
+        golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
+        core_v = _core_version()
+        if golden["core_version"] != core_v:
+            pytest.fail(
+                f"PENDING-COMPATIBLE-CORE: the {HOST} golden was generated "
+                f"against core {golden['core_version']}, this environment has "
+                f"{core_v}. Either regenerate it after the core change "
+                f"(tests/scripts/refresh_host_body_golden.py) or publish the "
+                f"matching core release first (spec R8 release-window semantics)."
+            )
+        live, proc = _deployed_digests(tmp_path)
+        assert live is not None, (
+            f"{HOST} deploy failed: {proc.stdout[-300:]}{proc.stderr[-300:]}"
+        )
+        _assert_no_drift(golden["body_digests"], live)
+
+    def test_the_golden_pins_no_environment_derived_artifact(self):
+        """**边界断言**：golden 里不许出现环境相关产物。
+
+        没有这条，下一个再生的人在装了四个 adapter 的机器上跑一次脚本，就会把
+        本机环境冻回 golden 里，而 CI（core+self）再次变红——正是这次修的形态。
+        """
+        golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
+        leaked = sorted(set(golden["body_digests"]) & set(ENVIRONMENT_DERIVED))
+        assert not leaked, (
+            f"the golden pins environment-derived artifacts: {leaked}. Their "
+            f"bytes are a function of which adapters are installed; pinning "
+            f"them makes the golden reproducible only on the machine that "
+            f"generated it. See TestEnvironmentDerivedArtifactsAreConsistent."
+        )
+
+    def test_a_body_edit_is_caught_by_the_same_comparison(self, tmp_path):
+        """Non-vacuity, end to end: deploy, edit one prompt body in place,
+        and the SAME comparison that guards the golden must flag it."""
+        golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
+        live, proc = _deployed_digests(tmp_path)
+        assert live is not None, f"{HOST} deploy failed: {proc.stderr[-300:]}"
+        target = tmp_path / "deploy"
+        # Pick a real deployed prompt body and delete one rule line from it.
+        victims = sorted(
+            p for p in target.rglob("*.md") if p.relative_to(target).as_posix() in golden["body_digests"]
+        )
+        assert victims, "no deployed .md body found to tamper with"
+        victim = victims[0]
+        rel = victim.relative_to(target).as_posix()
+        body = victim.read_text(encoding="utf-8")
+        victim.write_text(body + "\n- deleted in a review\n", encoding="utf-8")
+
+        tampered = {
+            p.relative_to(target).as_posix(): hashlib.sha256(
+                _normalize(p.read_text(encoding="utf-8"), str(target)).encode("utf-8")
+            ).hexdigest()
+            for p in sorted(target.rglob("*"))
+            if p.is_file()
+            and p.suffix in DEPLOY_SUFFIXES
+            and p.relative_to(target).as_posix() not in ENVIRONMENT_DERIVED
+        }
+        with pytest.raises(AssertionError, match=rel):
+            _assert_no_drift(golden["body_digests"], tampered)
+
+
+class TestEnvironmentDerivedArtifactsAreConsistent:
+    """环境相关产物：字节**可以**随已安装 adapter 集合变化，但必须自洽。
+
+    SPEC-4.0-22 Step 7 之后 `PACTKIT_YAML_CANDIDATES` 是 registry 的活视图，
+    于是插件的 `PROJECT_MARKERS`（以及 manifest 里记的插件摘要）都随环境变化。
+    这类产物的正确仪器是 **invariant**，不是 snapshot——snapshot 会把"本机装了
+    什么"冻成期望值。
+
+    这三条在 `core+opencode` 与"四个 adapter 全装"两个环境下**都**成立，且各自
+    断言各自环境的值。
+    """
+
+    def test_the_plugin_carries_the_current_candidate_list(self, tmp_path):
+        """插件的 `PROJECT_MARKERS` 必须等于**当前**的候选清单。
+
+        这是独立于生成器的那一半：它读**部署出来的 JS** 与**活的 registry**，
+        不问 `render_plugin_source()`。生成器若改了 marker 的来源，这条会红。
+
+        `_ensure_entry_point_deployers()` 必须先跑：`PACTKIT_YAML_CANDIDATES` 是
+        registry 的**活视图**，但本测试进程只 import 了本宿主（conftest），别的
+        adapter 要靠 entry-point discovery 才注册；而子进程里的 CLI 会触发它。
+        不先跑，两边比的就是**两个不同的 registry**。
+        """
+        from pactkit.generators.deploy_base import _ensure_entry_point_deployers
+        from pactkit.profiles import PACTKIT_YAML_CANDIDATES, SHARED_PACTKIT_YAML
+
+        _ensure_entry_point_deployers()
+        target, proc = _deploy(tmp_path)
+        assert proc.returncode == 0, proc.stderr[-300:]
+        source = (target / "plugins" / "pactkit-gate.js").read_text(encoding="utf-8")
+
+        expected = [*PACTKIT_YAML_CANDIDATES, SHARED_PACTKIT_YAML]
+        markers = _markers_from(source)
+        assert markers == expected, (
+            f"the plugin's marker list is not the current candidate list: "
+            f"{markers} != {expected}"
+        )
+        assert markers, "anti-vacuity: the marker list is empty"
+
+    def test_the_manifest_records_the_plugin_it_wrote(self, tmp_path):
+        """manifest 记的插件 sha256 必须等于**实际写出的**插件字节。"""
+        target, proc = _deploy(tmp_path)
+        assert proc.returncode == 0, proc.stderr[-300:]
+        manifest = json.loads(
+            (target / ".pactkit-deployed.json").read_text(encoding="utf-8")
+        )
+        rel = "plugins/pactkit-gate.js"
+        assert rel in manifest["files"], (
+            f"the plugin is not recorded in the manifest: {sorted(manifest['files'])}"
+        )
+        actual = hashlib.sha256((target / rel).read_bytes()).hexdigest()
+        assert manifest["files"][rel] == actual, (
+            "the manifest's plugin digest is not the plugin on disk — a stale "
+            "hash would make the deploy look verified while the file changed"
+        )
+
+    def test_every_recorded_file_is_on_disk_with_that_digest(self, tmp_path):
+        """`files` map 自洽：每一条都在盘上，且摘要相符。"""
+        target, proc = _deploy(tmp_path)
+        assert proc.returncode == 0, proc.stderr[-300:]
+        manifest = json.loads(
+            (target / ".pactkit-deployed.json").read_text(encoding="utf-8")
+        )
+        files = manifest["files"]
+        assert files, "anti-vacuity: the manifest records no files"
+        wrong = sorted(
+            rel
+            for rel, digest in files.items()
+            if not (target / rel).is_file()
+            or hashlib.sha256((target / rel).read_bytes()).hexdigest() != digest
+        )
+        assert not wrong, f"the manifest disagrees with the disk for: {wrong}"