xrefkit 0.7.5__tar.gz → 0.7.6__tar.gz

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

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

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

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

xrefkit-0.7.6/tests/test_package_skill_run.py

@@ -0,0 +1,101 @@
+import pytest
+
+
+@pytest.mark.parametrize(
+    ("module", "reference", "xid"),
+    [
+        ("xrefkit_skills_csharp", "xrefkit.skills.csharp::csharp.review", "xid-skill-csharp-review"),
+        ("xrefkit_skills_brownfield", "xrefkit.skills.brownfield::brownfield.workflow", "xid-skill-brownfield-workflow"),
+        ("xrefkit_skills_batch_regression", "xrefkit.skills.batch_regression::batch.impact_regression", "xid-skill-batch-impact-regression"),
+    ],
+)
+def test_installed_package_run_binds_over_mcp(tmp_path, module, reference, xid):
+    import json
+    import os
+    import subprocess
+    import sys
+    import tempfile
+    from pathlib import Path
+
+    pytest.importorskip(module)
+    anyio = pytest.importorskip("anyio")
+    pytest.importorskip("mcp")
+    from mcp.client.session import ClientSession
+    from mcp.client.stdio import StdioServerParameters, stdio_client
+
+    repo = Path(__file__).resolve().parents[1]
+    cli = [sys.executable, "-m", "xrefkit"]
+
+    env = {**os.environ, "PYTHONPATH": str(repo)}
+
+    def run_cli(*args):
+        return subprocess.check_output(
+            cli + list(args), cwd=tmp_path, env=env, encoding="utf-8"
+        )
+
+    args = [
+        "skill", "run",
+        "--package-skill", reference,
+        "--task", "Verify package run startup and MCP binding",
+        "--capability", "integration verification", "--tuning", "XRefKit package startup",
+        "--responsibility", "Verify run creation and correlation",
+        "--execution-mode", "subagent_required", "--json",
+    ]
+    run = json.loads(run_cli(*args))
+    assert run["skill_id"] == reference.split("::")[1]
+    log_path = Path(run["run_log"])
+    assert log_path.is_relative_to(tmp_path)
+    assert Path(run["skill_doc"]).is_file()
+    log = log_path.read_text(encoding="utf-8")
+    assert "maturity: `unassessed`" in log
+    assert f"package_skill_xid: `{xid}`" in log
+    assert "package_skill_sha256:" in log
+
+    rejected = subprocess.run(
+        cli + [arg for arg in args if arg not in {"--capability", "integration verification"}],
+        cwd=tmp_path, env=env, capture_output=True, encoding="utf-8",
+    )
+    assert rejected.returncode == 1
+    assert json.loads(rejected.stdout)["run_id"] is None
+
+    async def scenario():
+        server = StdioServerParameters(
+            command=sys.executable,
+            args=[
+                "-m", "xrefkit.mcp.server", "--repo", str(repo),
+                "--audit-log", str(tmp_path / "mcp-audit.jsonl"),
+            ],
+            cwd=str(repo),
+        )
+        with tempfile.TemporaryFile(mode="w+", encoding="utf-8") as stderr:
+            async with stdio_client(server, errlog=stderr) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    startup = await session.call_tool("get_startup_context", {})
+                    assert not startup.isError, startup.content
+                    binding = await session.call_tool(
+                        "bind_skill_run",
+                        {"run_id": run["run_id"], "skill_id": run["skill_id"]},
+                    )
+                    assert not binding.isError, binding.content
+                    bound = binding.structuredContent
+                    assert bound["run_id"] == run["run_id"]
+                    assert bound["skill_id"] == run["skill_id"]
+                    assert "xrefkit skill correlate" in bound["client_record_command"]
+                    run_cli(
+                        "skill", "correlate", "--log", str(log_path),
+                        "--run-id", bound["run_id"],
+                        "--mcp-session-id", bound["mcp_session_id"],
+                        "--repository-fingerprint", bound["repository_fingerprint"],
+                    )
+                    assert bound["mcp_session_id"] in log_path.read_text(encoding="utf-8")
+                    requirements = await session.call_tool(
+                        "get_skill_requirements", {"skill_id": run["skill_id"]}
+                    )
+                    assert not requirements.isError, requirements.content
+                    assert not requirements.structuredContent["missing"]
+                    skill = await session.call_tool("get_skill", {"skill_id": run["skill_id"]})
+                    assert not skill.isError, skill.content
+                    assert skill.structuredContent["skill_id"] == run["skill_id"]
+
+    anyio.run(scenario)

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

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

{xrefkit-0.7.5 → xrefkit-0.7.6}/xrefkit/operations_cli.py

@@ -413,6 +413,7 @@ def _build_parser() -> argparse.ArgumentParser:
     p_skill_run_source = p_skill_run.add_mutually_exclusive_group(required=True)
     p_skill_run_source.add_argument("--meta", help="Relative path to the legacy Skill meta.md to run")
     p_skill_run_source.add_argument("--definition", help="Explicit SkillDefinition document to run without a legacy meta source")
+    p_skill_run_source.add_argument("--package-skill", help="Explicit installed Skill Package reference (package_id::skill_id)")
     p_skill_run.add_argument(
         "--governance",
         default=None,

{xrefkit-0.7.5 → xrefkit-0.7.6}/xrefkit/skillrun.py

@@ -660,7 +660,7 @@ def _render_log(
         ]
     )
     definition_lines = "".join(
-        f"- definition_{key}: `{value}`\n"
+        f"- {key if key.startswith('package_') else 'definition_' + key}: `{value}`\n"
         for key, value in (definition_identity or {}).items()
     )
     runtime_responsibility = role_responsibilities.get("executor") or "not declared"
@@ -2929,15 +2929,50 @@ def update_token_usage(args) -> SkillRunResult:
     return SkillRunResult(ok=True, skill_id=_log_skill_id(text), skill_doc=None, run_log=str(log_path), errors=[])
 
 
+def _resolve_package_run_source(reference: str) -> tuple[Path, str, dict[str, str]]:
+    from xrefkit.discovery import enabled_discovered_packages
+    from xrefkit.hashing import sha256_file
+    from xrefkit.workspace import build_registry
+
+    package_id, separator, skill_id = reference.partition("::")
+    if not separator or not package_id or not skill_id:
+        raise ValueError("--package-skill requires package_id::skill_id")
+    packages = enabled_discovered_packages(enabled_package_ids={package_id})
+    if len(packages) != 1:
+        raise ValueError(f"expected one installed package for {package_id}, found {len(packages)}")
+    package = packages[0]
+    provided = next((item for item in package.manifest.provides.skills if item.id == skill_id), None)
+    if provided is None:
+        raise ValueError(f"package does not provide Skill: {reference}")
+    if not provided.path.endswith(".skill.yaml"):
+        raise ValueError("--package-skill requires a split YAML Skill; use --definition with packaged governance for Markdown")
+
+    registry = build_registry(package_manifests=[package.manifest_path])
+    record = registry.skills.require(skill_id)
+    if record.package_id != package_id or record.xid != provided.xid:
+        raise ValueError(f"package Skill identity mismatch: {reference}")
+    entry = (record.root / record.definition.entry.path).resolve()
+    identity = {
+        "format": "legacy_split_v1",
+        "package_id": package_id,
+        "package_version": package.manifest.version,
+        "package_skill_xid": record.xid,
+        "package_skill_path": record.path.relative_to(record.root).as_posix(),
+        "package_skill_sha256": sha256_file(record.path),
+    }
+    return entry, skill_id, identity
+
+
 def run_skill(args) -> SkillRunResult:
     root = Path(args.root).resolve()
     definition_arg = getattr(args, "definition", None)
     governance_arg = getattr(args, "governance", None)
     meta_arg = getattr(args, "meta", None)
-    if bool(definition_arg) == bool(meta_arg):
-        return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=["exactly one of --meta or --definition is required"])
+    package_arg = getattr(args, "package_skill", None)
+    if sum(bool(source) for source in (definition_arg, meta_arg, package_arg)) != 1:
+        return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=["exactly one of --meta, --definition, or --package-skill is required"])
     try:
-        adoption = load_repository_adoption(root)
+        adoption = None if package_arg else load_repository_adoption(root)
         adapter = repository_skill(root, definition_arg or meta_arg, adoption) if adoption else None
     except (ValueError, OSError) as exc:
         return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=[str(exc)])
@@ -2946,15 +2981,26 @@ def run_skill(args) -> SkillRunResult:
             return SkillRunResult(ok=False, skill_id=adapter["skill_id"], skill_doc=None, run_log=None,
                                   errors=["draft or deprecated repository Skills are not adopted and cannot execute"])
         definition_arg = adapter["definition_path"]
-    if not definition_arg and (governance_arg or any(
+    if package_arg and governance_arg:
+        return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None,
+                              errors=["--governance requires a Markdown SkillDefinition"])
+    if not (definition_arg or package_arg) and (governance_arg or any(
         getattr(args, key, None)
         for key in ("capability", "tuning", "responsibility", "execution_mode")
     )):
         return SkillRunResult(
             ok=False, skill_id=None, skill_doc=None, run_log=None,
-            errors=["--governance, --capability, --tuning, --responsibility, and --execution-mode are definition-only runtime inputs"],
+            errors=["--governance, --capability, --tuning, --responsibility, and --execution-mode require --definition or --package-skill"],
         )
-    meta_path = (root / (definition_arg or meta_arg)).resolve()
+    definition_identity = None
+    if package_arg:
+        try:
+            meta_path, package_skill_id, definition_identity = _resolve_package_run_source(package_arg)
+        except (ImportError, KeyError, OSError, ValueError) as exc:
+            return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=[str(exc)])
+    else:
+        meta_path = (root / (definition_arg or meta_arg)).resolve()
+    instruction_bound = bool(definition_arg or package_arg)
     task, task_errors = _read_task(args)
     if task_errors:
         return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=task_errors)
@@ -2964,7 +3010,6 @@ def run_skill(args) -> SkillRunResult:
         source_name = "definition" if definition_arg else "meta"
         return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=[f"{source_name} not found: {meta_path}"])
 
-    definition_identity = None
     if definition_arg:
         try:
             definition = load_skill_definition(meta_path)
@@ -3018,6 +3063,12 @@ def run_skill(args) -> SkillRunResult:
                 "governance_sha256": str(governance["_content_hash"]),
                 "promotion_decision": str(governance["promotion"]["decision"]),
             })
+    elif package_arg:
+        parsed = {"skill_id": package_skill_id}
+        skill_id = package_skill_id
+        definition_maturity = "unassessed"
+
+    if instruction_bound:
         runtime = {key: str(getattr(args, key, "") or
                    (adapter["runtime"][key]["value"] if adapter else "") or "").strip()
                    for key in RUNTIME_FIELDS}
@@ -3058,7 +3109,7 @@ def run_skill(args) -> SkillRunResult:
             domain_knowledge=domain_knowledge,
         )
     maturity, _ = _resolve_maturity(parsed)
-    maturity = (str(parsed.get("maturity") or "unassessed") if definition_arg else (maturity or "stable"))
+    maturity = (str(parsed.get("maturity") or "unassessed") if instruction_bound else (maturity or "stable"))
 
     if maturity == "draft":
         return SkillRunResult(
@@ -3080,8 +3131,8 @@ def run_skill(args) -> SkillRunResult:
         )
 
     validation_level = "trial" if maturity == "trial" else "stable"
-    validation = validate_skill_meta(meta_path, check_level=validation_level) if not definition_arg else None
-    if definition_arg:
+    validation = validate_skill_meta(meta_path, check_level=validation_level) if not instruction_bound else None
+    if instruction_bound:
         blocking_errors = []
     elif maturity == "trial":
         allowed_trial_errors = {"trial-or-higher skills must include at least one observation_refs entry"}
@@ -3147,7 +3198,7 @@ def run_skill(args) -> SkillRunResult:
             errors=[f"skill_doc not found: {skill_doc_path}"],
         )
     os_contract = resolve_os_contract(parsed.get("os_contract"))
-    if definition_arg:
+    if instruction_bound:
         os_contract = dict(REQUIRED_OS_CONTRACT)
     if maturity == "trial":
         merged_os_contract = dict(REQUIRED_OS_CONTRACT)
@@ -3226,8 +3277,8 @@ def run_skill(args) -> SkillRunResult:
         node_id=getattr(args, "node_id", None),
         skill_id=skill_id,
         maturity=maturity,
-        meta_path=Path("-") if definition_arg else meta_path.relative_to(root),
-        skill_doc=skill_doc_path.relative_to(root),
+        meta_path=Path("-") if instruction_bound else meta_path.relative_to(root),
+        skill_doc=skill_doc_path if package_arg else skill_doc_path.relative_to(root),
         execution_mode=execution_mode,
         guard_policy=guard_policy,
         capability_layering=capability_layering,
@@ -3244,7 +3295,7 @@ def run_skill(args) -> SkillRunResult:
         domain_knowledge=domain_knowledge,
         decision_trace_checkpoint=checkpoint,
         definition_identity=definition_identity,
-        runtime_binding_source="instruction_derived" if definition_arg else "legacy_meta_compatibility",
+        runtime_binding_source="instruction_derived" if instruction_bound else "legacy_meta_compatibility",
         compact=True,
     )
     kickoff = None

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

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

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

@@ -78,6 +78,7 @@ 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_package_skill_run.py
 tests/test_packaged_native_governance.py
 tests/test_packmeta.py
 tests/test_plan_markdown.py