xrefkit 0.7.4__tar.gz → 0.7.5__tar.gz

{xrefkit-0.7.4/xrefkit.egg-info → xrefkit-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xrefkit
-Version: 0.7.4
+Version: 0.7.5
 Summary: Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit
 Author: synthaicode
 License: MIT License

{xrefkit-0.7.4 → xrefkit-0.7.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xrefkit"
-version = "0.7.4"
+version = "0.7.5"
 description = "Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit"
 readme = "README.md"
 requires-python = ">=3.11"

xrefkit-0.7.5/tests/test_packaged_native_governance.py

@@ -0,0 +1,54 @@
+import json
+import hashlib
+from pathlib import Path
+
+import pytest
+import yaml
+
+from xrefkit.discovery import DiscoveredSkillPackage
+from xrefkit.loaders import load_package_manifest
+from xrefkit.mcp.catalog import _build_package_skills
+from xrefkit.models.package_manifest import ProvidedSkill
+
+
+def fixture(tmp_path):
+    root=Path(__file__).resolve().parents[1]
+    source=root/'skills/packs/project-management/progress_rules_setup/SKILL.v1.md'
+    (tmp_path/'skill.md').write_bytes(source.read_bytes())
+    gov=json.loads((root/'governance/skills/progress_rules_setup.json').read_text())
+    gov['definition_content_hash']=hashlib.sha256(source.read_bytes()).hexdigest()
+    (tmp_path/'governance.json').write_text(json.dumps(gov))
+    manifest={'package_id':'test.native','package_type':'skill_package','version':'0.1.0',
+              'requires':{'xrefkit_core':'>=2.0.0 <3.0.0'},'contract':{},
+              'provides':{'skills':[{'id':'progress_rules_setup','xid':'91F7D3B6A204','path':'skill.md','governance_path':'governance.json'}]}}
+    (tmp_path/'package_manifest.yaml').write_text(yaml.safe_dump(manifest))
+    return DiscoveredSkillPackage('test',tmp_path,tmp_path/'package_manifest.yaml',load_package_manifest(tmp_path/'package_manifest.yaml'))
+
+
+def test_bound_native_draft_and_live_hash_check(tmp_path):
+    package=fixture(tmp_path)
+    assert _build_package_skills(package)[0].maturity=='draft'
+    (tmp_path/'skill.md').write_bytes((tmp_path/'skill.md').read_bytes()+b'\nchanged\n')
+    with pytest.raises(ValueError,match='content_hash'):
+        _build_package_skills(package)
+
+
+def test_omitted_governance_preserves_existing_unassessed_behavior(tmp_path):
+    package=fixture(tmp_path)
+    package.manifest.provides.skills[0].governance_path=None
+    assert _build_package_skills(package)[0].maturity=='unassessed'
+
+
+def test_legacy_governance_field_is_rejected():
+    with pytest.raises(ValueError,match='native Markdown'):
+        ProvidedSkill(id='legacy',xid='legacy.xid',path='legacy.yaml',governance_path='gov.json')
+
+def test_packaged_draft_ranking_is_not_runnable(tmp_path):
+    from xrefkit.mcp.catalog import XRefCatalog
+    package=fixture(tmp_path)
+    catalog=XRefCatalog(tmp_path,'test','test',[],discovered_packages=(package,))
+    ranked=catalog.rank_skills_for_purpose('confirm progress rules and destinations')
+    row=next(r for r in ranked if r['skill_id']=='progress_rules_setup')
+    assert row['maturity']=='draft'
+    assert row['execution_readiness']['runnable'] is False
+    assert 'draft' in row['execution_readiness']['governance_block_reason']

xrefkit-0.7.5/tests/test_project_management_materialization.py

@@ -0,0 +1,39 @@
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from tools.materialize_project_management_package import generate, main, PACKAGE
+
+
+def test_approved_bytes_cannot_be_rebound_after_link_transform(tmp_path):
+    root=Path(__file__).resolve().parents[1]
+    for rel in ['skills','governance','docs']:
+        # Source links resolve against the actual tree; copy only governed inputs,
+        # then use the real remaining targets through a full temporary fixture.
+        shutil.copytree(root/rel,tmp_path/rel)
+    gp=tmp_path/'governance/skills/requirements_discovery_coordination.json'
+    record=json.loads(gp.read_text())
+    record['maturity']='trial'
+    record['promotion']['decision']='approved'
+    gp.write_text(json.dumps(record))
+    with pytest.raises(ValueError,match='separate package governance'):
+        generate(tmp_path)
+
+
+def test_stale_extra_managed_asset_is_rejected(tmp_path,monkeypatch):
+    target=tmp_path/PACKAGE/'skills'
+    target.mkdir(parents=True)
+    (target/'retired.md').write_text('stale')
+    monkeypatch.setattr('tools.materialize_project_management_package.generate',lambda root:{})
+    monkeypatch.setattr('sys.argv',['materialize','--root',str(tmp_path),'--check'])
+    with pytest.raises(SystemExit,match='unexpected managed asset'):
+        main()
+
+
+def test_embedded_migration_adoption_matches_raw_bytes():
+    from xrefkit.repository_skills import load_repository_adoption
+    import xrefkit
+    root=Path(xrefkit.__file__).parent/'resources/migration'
+    assert load_repository_adoption(root)['entries']

{xrefkit-0.7.4 → xrefkit-0.7.5}/tests/test_skill_release_compatibility.py

@@ -91,6 +91,31 @@ def test_real_resolver_probe_passes_representative_fixture(tmp_path, monkeypatch
     assert installed.verify_installed("demo", "official.demo", "0.6.1")["skills"] == ["demo.skill"]
 
 
+def test_native_probe_uses_bound_catalog_and_rejects_changed_governance(tmp_path, monkeypatch):
+    from test_packaged_native_governance import fixture
+    from xrefkit import discovery
+    candidate = fixture(tmp_path)
+    monkeypatch.setattr(discovery, "discover_skill_packages", lambda: [candidate])
+    monkeypatch.setattr(installed.metadata, "version", lambda name: "0.7.5")
+    monkeypatch.setattr(installed.metadata, "distribution", lambda name: SimpleNamespace(
+        version="0.1.0", entry_points=[SimpleNamespace(group="xrefkit.skill_packages", name="test")]))
+    # This minimal fixture method uses repository links, so first replace it with
+    # an equivalent native method with no external file dependency and rebind draft.
+    path = tmp_path / "skill.md"
+    text = path.read_text().split("## Method", 1)[0] + "## Method\nInspect requested target.\n"
+    path.write_text(text)
+    import hashlib
+    gp = tmp_path / "governance.json"
+    record = json.loads(gp.read_text())
+    record["definition_content_hash"] = hashlib.sha256(path.read_bytes()).hexdigest()
+    gp.write_text(json.dumps(record))
+    assert installed.verify_installed("demo", "test.native", "0.7.5")["skills"] == ["progress_rules_setup"]
+    record["definition_content_hash"] = "0" * 64
+    gp.write_text(json.dumps(record))
+    with pytest.raises(ValueError, match="content_hash"):
+        installed.verify_installed("demo", "test.native", "0.7.5")
+
+
 def test_real_protocol_rejection_stops_installed_probe(tmp_path, monkeypatch):
     root, manifest, _ = contract_fixture(tmp_path, monkeypatch)
     manifest["requires"]["xrefkit_core"] = ">=3.0.0"

{xrefkit-0.7.4 → xrefkit-0.7.5}/xrefkit/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.7.4"
+__version__ = "0.7.5"

{xrefkit-0.7.4 → xrefkit-0.7.5}/xrefkit/mcp/catalog.py

@@ -1055,8 +1055,8 @@ class XRefCatalog:
             ]
             # Declared preconditions travel with the ranking so the client can
             # filter to Skills runnable in the current state (084 M4). Empty
-            # until metas adopt preconditions; tool-availability stays the only
-            # server-known readiness signal.
+            # until metas adopt preconditions; known adoption and packaged
+            # governance restrictions also constrain readiness below.
             readiness = {
                 "runnable": not missing_tools,
                 "missing_tool_contracts": missing_tools,
@@ -1071,6 +1071,11 @@ class XRefCatalog:
                     "repository_adopted": skill.repository_adoption["effective_adopted"],
                     "historical_repository_adopted": skill.repository_adoption["adopted"],
                 })
+            if skill.package_id and skill.maturity_governance and skill.maturity in {"draft", "deprecated"}:
+                readiness.update({
+                    "runnable": False,
+                    "governance_block_reason": f"Packaged Skill maturity {skill.maturity} prohibits execution",
+                })
             if score <= 0:
                 continue
             results.append(
@@ -2343,12 +2348,24 @@ def _build_package_skills(package: DiscoveredSkillPackage) -> list[SkillCatalogE
                 worklist_policy="required",
             )
             knowledge_needs = [dict(item) for item in meta["knowledge_needs"]]
+            maturity_governance = None
+            if provided.governance_path is not None:
+                from ..skill_definition_governance import (
+                    governance_projection, load_governance_record, match_definition,
+                )
+                governance_path = (package_root / provided.governance_path).resolve()
+                if not governance_path.is_relative_to(package_root):
+                    raise ValueError("package Skill governance path escapes package root")
+                record = load_governance_record(governance_path)
+                match_definition(record, definition)
+                maturity_governance = governance_projection(record)
+                maturity_governance["record_ref"]["path"] = governance_path.relative_to(package_root).as_posix()
             entries.append(
                 SkillCatalogEntry(
                     skill_id=meta["skill_id"],
                     title=first_heading(method, meta["skill_id"]),
                     summary=meta["summary"],
-                    maturity="unassessed",
+                    maturity=maturity_governance["maturity"] if maturity_governance else "unassessed",
                     intent=list(meta["applies_when"]),
                     target_artifacts=list(meta["outputs"]),
                     applies_when=list(meta["applies_when"]),
@@ -2378,6 +2395,7 @@ def _build_package_skills(package: DiscoveredSkillPackage) -> list[SkillCatalogE
                     definition_format="skill_definition_v1",
                     definition_xid=meta["xid"],
                     definition_content_hash=definition["content_hash"],
+                    maturity_governance=maturity_governance,
                 )
             )
             continue

{xrefkit-0.7.4 → xrefkit-0.7.5}/xrefkit/models/package_manifest.py

@@ -35,12 +35,21 @@ class ProvidedAsset(StrictModel):
 
 
 class ProvidedSkill(ProvidedAsset):
+    governance_path: str | None = None
     contract_role: str | None = None
     required_outputs: list[str] = Field(default_factory=list)
     required_knowledge: list[str] = Field(default_factory=list)
     required_review_axes: list[str] = Field(default_factory=list)
     must_not: list[str] = Field(default_factory=list)
 
+    @model_validator(mode="after")
+    def _validate_governance_path(self) -> "ProvidedSkill":
+        if self.governance_path is not None:
+            validate_non_empty(self.governance_path, "governance_path")
+            if not self.path.lower().endswith(".md"):
+                raise ValueError("governance_path requires a native Markdown SkillDefinition")
+        return self
+
     @field_validator("required_outputs", "required_knowledge", "required_review_axes", "must_not")
     @classmethod
     def _validate_string_list(cls, values: list[str]) -> list[str]:

{xrefkit-0.7.4 → xrefkit-0.7.5/xrefkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xrefkit
-Version: 0.7.4
+Version: 0.7.5
 Summary: Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit
 Author: synthaicode
 License: MIT License

{xrefkit-0.7.4 → xrefkit-0.7.5}/xrefkit.egg-info/SOURCES.txt

@@ -78,9 +78,11 @@ tests/test_os_family_definition.py
 tests/test_os_knowledge_family_definition.py
 tests/test_os_selected_family.py
 tests/test_ownership.py
+tests/test_packaged_native_governance.py
 tests/test_packmeta.py
 tests/test_plan_markdown.py
 tests/test_plan_observation.py
+tests/test_project_management_materialization.py
 tests/test_project_quality_baseline.py
 tests/test_qa_report_definition.py
 tests/test_reporting_profiles.py