xrefkit 0.4.5__tar.gz → 0.4.7__tar.gz

{xrefkit-0.4.5 → xrefkit-0.4.7}/PKG-INFO

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

{xrefkit-0.4.5 → xrefkit-0.4.7}/pyproject.toml

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

xrefkit-0.4.7/tests/test_skills_sync.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import io
+import json
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from xrefkit.skills_sync import sync_bundle
+
+
+def _zip_bytes() -> bytes:
+    payload = io.BytesIO()
+    with zipfile.ZipFile(payload, "w") as archive:
+        archive.writestr("xrefkit-skills-demo/skills/demo/meta.md", "<!-- xid: skill-demo -->\n# Demo\n")
+        archive.writestr("xrefkit-skills-demo/skills/demo/SKILL.md", "<!-- xid: skill-demo-body -->\n# Demo\n")
+        archive.writestr("xrefkit-skills-demo/knowledge/demo.md", "<!-- xid: knowledge-demo -->\n# Knowledge\n")
+    return payload.getvalue()
+
+
+def test_sync_bundle_extracts_skill_and_knowledge(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    release = {
+        "tag_name": "skills-2026.07.30",
+        "assets": [{"name": "xrefkit-skills-demo-1.0.0.zip", "browser_download_url": "https://example.test/demo.zip"}],
+    }
+
+    def fake_json(_url: str) -> dict:
+        return release
+
+    def fake_download(_asset: dict) -> tuple[str, bytes]:
+        return "xrefkit-skills-demo-1.0.0.zip", _zip_bytes()
+
+    monkeypatch.setattr("xrefkit.skills_sync._github_json", fake_json)
+    monkeypatch.setattr("xrefkit.skills_sync._download_asset", fake_download)
+
+    result = sync_bundle(repo=tmp_path, source_repository="owner/repo", bundle="demo")
+
+    assert result.release == "skills-2026.07.30"
+    assert (tmp_path / "skills/demo/SKILL.md").is_file()
+    assert (tmp_path / "knowledge/demo.md").is_file()
+    state = json.loads((tmp_path / ".xrefkit/skill-sync/demo.json").read_text(encoding="utf-8"))
+    assert state["files"] == ["knowledge/demo.md", "skills/demo/SKILL.md", "skills/demo/meta.md"]
+
+
+def test_sync_bundle_refuses_unmanaged_collision(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    release = {"tag_name": "v1", "assets": [{"name": "xrefkit-skills-demo-1.0.0.zip", "browser_download_url": "https://example.test/demo.zip"}]}
+    monkeypatch.setattr("xrefkit.skills_sync._github_json", lambda _url: release)
+    monkeypatch.setattr("xrefkit.skills_sync._download_asset", lambda _asset: ("demo.zip", _zip_bytes()))
+    target = tmp_path / "skills/demo/SKILL.md"
+    target.parent.mkdir(parents=True)
+    target.write_text("local", encoding="utf-8")
+
+    with pytest.raises(RuntimeError, match="not owned by sync state"):
+        sync_bundle(repo=tmp_path, source_repository="owner/repo", bundle="demo")

{xrefkit-0.4.5 → xrefkit-0.4.7}/xrefkit/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.4.5"
+__version__ = "0.4.7"

{xrefkit-0.4.5 → xrefkit-0.4.7}/xrefkit/cli.py

@@ -27,6 +27,7 @@ def _print_help() -> None:
         "  dashboard  inspect runtime state\n"
         "  analysis   generate proposal-only observation reports\n"
         "  mcp        start the integrated MCP server\n"
+        "  skills     synchronize released Skill and Knowledge bundles\n"
         "  package    inspect installed Skill packages\n"
         "  show       show effective Skill bundles"
     )
@@ -67,6 +68,10 @@ def main(argv: Sequence[str] | None = None) -> int:
         from .mcp import main as mcp_main
 
         return mcp_main(args[1:])
+    if command == "skills":
+        from .skills_sync import main as skills_main
+
+        return skills_main(args[1:])
 
     print(f"xrefkit: unknown command: {command}", file=sys.stderr)
     _print_help()

{xrefkit-0.4.5 → xrefkit-0.4.7}/xrefkit/skillrun.py

@@ -434,6 +434,10 @@ def _render_log(
     worklist_lines = "\n".join(
         f"- [ ] {name}: {description}" for name, description in WORKLIST_ROWS
     )
+    worklist_report_lines = "\n".join(
+        f"| [{name}](#{_safe_slug(name.lower())}) | {description} | Phase checklist | not_checked | [{name}](#{_safe_slug(name.lower())}) |"
+        for name, description in WORKLIST_ROWS
+    )
     handoff_source_lines = "\n".join(
         f"- source_log: `{source['source_log']}` skill_id=`{source['skill_id']}` closure=`{source['closure']}` handoff=`{source['handoff']}`"
         for source in handoff_sources
@@ -494,6 +498,8 @@ def _render_log(
 - meta: `{meta_path.as_posix()}`
 - skill_doc: `{skill_doc.as_posix()}`
 - task: {task}
+- report_language: `user_language`
+- language_rule: `human-facing report prose follows the user's language; runtime keys, status enums, IDs, paths, and commands remain stable`
 
 ## Skill Load Gate
 
@@ -602,6 +608,36 @@ def _render_log(
 
 ## Worklist
 
+### Report
+
+### Status
+pending
+
+### Reason
+The workflow protocol has not started; phase results are not yet available.
+
+### Result
+The workflow protocol worklist has not started.
+
+### Checks Performed
+
+| Check ID | What was checked | Target / Scope | Result | Evidence / Details |
+| --- | --- | --- | --- | --- |
+{worklist_report_lines}
+
+### Evidence
+- Phase checklist and phase sections in this Run Log
+- Phase events recorded below
+
+### Open Items
+- All workflow phases are not_checked.
+
+### Handoff
+- Next owner: executor
+- Next action: complete Startup and Planning.
+
+### Phase Checklist
+
 {worklist_lines}
 
 ## Concrete Work Items
@@ -631,6 +667,33 @@ def _render_log(
 - policy: `{quality_policy}`
 - rule: declare acceptance check items as `check`-kind artifacts at planning; an independent quality reviewer sets each to `done` (pass) or `blocked` (fail) with `xrefkit skill artifact`; domain reviews run as separate review Skills orchestrated by the main session and linked here. Required when model_tier is `standard` or `heavy`; optional otherwise
 
+### Report
+
+### Status
+pending
+
+### Reason
+Quality acceptance checks have not yet been recorded.
+
+### Result
+No quality checklist items have been recorded yet.
+
+### Checks Performed
+
+| Check ID | What was checked | Target / Scope | Result | Evidence / Details |
+| --- | --- | --- | --- | --- |
+| none | No check artifact recorded | Quality Gate | not_checked | [Runtime Artifacts](#runtime-artifacts) |
+
+### Evidence
+- Check-kind artifacts in Runtime Artifacts
+
+### Open Items
+- Quality acceptance checks are pending.
+
+### Handoff
+- Next owner: quality_reviewer
+- Next action: record each acceptance check as a check-kind artifact.
+
 ## Unknowns And Risks
 
 - status: `pending`
@@ -675,12 +738,14 @@ def _append_phase_event(text: str, *, phase: str, status: str, role: str | None,
 
 
 def _section_status(text: str, section: str) -> str | None:
-    marker = f"## {section}\n"
-    start = text.find(marker)
-    if start == -1:
+    heading = re.compile(rf"^## {re.escape(section)}\s*$", re.MULTILINE)
+    match = heading.search(text)
+    if match is None:
         return None
+    start = match.start()
 
-    next_section = text.find("\n## ", start + len(marker))
+    next_heading = re.compile(r"^## (?!#).*$", re.MULTILINE).search(text, match.end())
+    next_section = next_heading.start() if next_heading else -1
     body = text[start:] if next_section == -1 else text[start:next_section]
     prefix = "- status: `"
     status_start = body.find(prefix)
@@ -694,12 +759,13 @@ def _section_status(text: str, section: str) -> str | None:
 
 
 def _section_body(text: str, section: str) -> tuple[str | None, int, int]:
-    marker = f"## {section}\n"
-    start = text.find(marker)
-    if start == -1:
+    heading = re.compile(rf"^## {re.escape(section)}\s*$", re.MULTILINE)
+    match = heading.search(text)
+    if match is None:
         return None, -1, -1
-    next_section = text.find("\n## ", start + len(marker))
-    end = len(text) if next_section == -1 else next_section
+    start = match.start()
+    next_heading = re.compile(r"^## (?!#).*$", re.MULTILINE).search(text, match.end())
+    end = len(text) if next_heading is None else next_heading.start()
     return text[start:end], start, end
 
 
@@ -801,7 +867,128 @@ def _set_phase_status(text: str, *, phase: str, status: str) -> str:
             text, changed = _replace_line(text, old_status, new_status)
             if changed:
                 break
-    return text
+    return _refresh_quality_report(_refresh_worklist_report(text))
+
+
+def _refresh_worklist_report(text: str) -> str:
+    """Keep the human-facing worklist report aligned with phase checkboxes."""
+    body, _, _ = _section_body(text, "Worklist")
+    if body is None or "### Phase Checklist\n" not in body:
+        return text
+
+    rows: list[tuple[str, str, str]] = []
+    for name, _description in WORKLIST_ROWS:
+        match = re.search(
+            rf"^- \[(?P<checkbox>[ x!])\] {re.escape(name)}: (?P<description>.+)$",
+            body,
+            flags=re.MULTILINE,
+        )
+        if match:
+            checkbox = match.group("checkbox")
+            result = "pass" if checkbox == "x" else "fail" if checkbox == "!" else "not_checked"
+            rows.append((name, match.group("description"), result))
+
+    if not rows:
+        return text
+    completed = sum(result == "pass" for _, _, result in rows)
+    if completed == len(rows):
+        status = "done"
+    elif any(result == "fail" for _, _, result in rows):
+        status = "blocked"
+    elif completed:
+        status = "partial"
+    else:
+        status = "pending"
+    open_items = [name for name, _, result in rows if result != "pass"] or ["なし"]
+    next_phase = next((name for name, _, result in rows if result != "pass"), "なし")
+    table = "\n".join(
+        f"| {name} | {description} | {result} | Phase checklist |"
+        for name, description, result in rows
+    )
+    report = (
+        "### Report\n\n"
+        f"### Status\n{status}\n\n"
+        + "### Reason\n"
+        + (
+            "All workflow phases are complete."
+            if status == "done"
+            else f"The workflow remains {status}; incomplete phases: {', '.join(open_items)}."
+        )
+        + "\n\n"
+        f"### Result\n{completed} of {len(rows)} workflow protocol phases are complete.\n\n"
+        "### Checks Performed\n\n"
+        "| Check ID | What was checked | Target / Scope | Result | Evidence / Details |\n"
+        "| --- | --- | --- | --- | --- |\n"
+        + "\n".join(
+            f"| [{name}](#{_safe_slug(name.lower())}) | {description} | Phase checklist | {result} | [{name}](#{_safe_slug(name.lower())}) |"
+            for name, description, result in rows
+        )
+        + "\n\n"
+        "### Evidence\n"
+        "- Phase checklist and phase sections in this Run Log\n"
+        "- Phase events recorded below\n\n"
+        "### Open Items\n"
+        + "\n".join(f"- {item}" for item in open_items)
+        + "\n\n### Handoff\n"
+        f"- Next owner: executor\n- Next action: advance {next_phase}.\n"
+    )
+    updated = re.sub(
+        r"(?ms)### Report\n\n.*?(?=\n### Phase Checklist\n)",
+        report.rstrip(),
+        body,
+        count=1,
+    )
+    start = text.find(body)
+    return text if start == -1 else text[:start] + updated + text[start + len(body):]
+
+
+def _refresh_quality_report(text: str) -> str:
+    """Render quality check artifacts as the common checklist report."""
+    body, start, end = _section_body(text, "Quality Gate")
+    if body is None or "### Report\n" not in body:
+        return text
+    checks = [artifact for artifact in _parse_artifacts(text) if artifact["kind"] == "check"]
+    status = _section_status(text, "Quality Gate") or "pending"
+    if checks:
+        rows = []
+        for check in checks:
+            result = {
+                "done": "pass",
+                "blocked": "fail",
+                "na": "not_applicable",
+                "pending": "not_checked",
+            }.get(check["status"], check["status"])
+            rows.append(
+                f"| {check['artifact_id']} | {check['note']} | {check['target']} | {result} | [{check['artifact_id']}](#runtime-artifacts) |"
+            )
+        result_text = f"{len(checks)} quality checklist item(s) are recorded."
+        open_items = [check["artifact_id"] for check in checks if check["status"] not in {"done", "na"}] or ["なし"]
+    else:
+        rows = ["| none | No check artifact recorded | Quality Gate | not_checked | [Runtime Artifacts](#runtime-artifacts) |"]
+        result_text = "No quality checklist items have been recorded yet."
+        open_items = ["Quality acceptance checks are pending."]
+    report = (
+        "### Report\n\n"
+        f"### Status\n{status}\n\n"
+        + "### Reason\n"
+        + (
+            "All quality checks are complete."
+            if status == "done"
+            else f"The quality gate remains {status}; open checks: {', '.join(open_items)}."
+        )
+        + "\n\n"
+        f"### Result\n{result_text}\n\n"
+        "### Checks Performed\n\n"
+        "| Check ID | What was checked | Target / Scope | Result | Evidence / Details |\n"
+        "| --- | --- | --- | --- | --- |\n"
+        + "\n".join(rows)
+        + "\n\n### Evidence\n- Check-kind artifacts in Runtime Artifacts\n\n"
+        "### Open Items\n"
+        + "\n".join(f"- {item}" for item in open_items)
+        + "\n\n### Handoff\n- Next owner: quality_reviewer\n- Next action: resolve open checklist items.\n"
+    )
+    updated = re.sub(r"(?ms)### Report\n\n.*?(?=\n## Unknowns And Risks\n)", report.rstrip(), body, count=1)
+    return text[:start] + updated + text[end:]
 
 
 def _workitem_checkbox(status: str) -> str:
@@ -1116,6 +1303,7 @@ def update_artifact(args) -> SkillRunResult:
         )
 
     text = _replace_runtime_artifacts_section(text, artifacts)
+    text = _refresh_quality_report(text)
     text = _append_phase_event(text, phase=f"artifact:{artifact_id}", status=status, role=role, note=note or target)
     _atomic_write_text(log_path, text)
     return SkillRunResult(ok=True, skill_id=None, skill_doc=None, run_log=str(log_path), errors=[], artifacts=artifacts)

xrefkit-0.4.7/xrefkit/skills_sync.py

@@ -0,0 +1,278 @@
+"""Synchronize released Skill/Knowledge bundles into an XRefKit repository."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import tempfile
+import urllib.error
+import urllib.parse
+import urllib.request
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+
+
+DEFAULT_SOURCE_REPOSITORY = "synthaicode/XRefKit"
+DEFAULT_GITHUB_API = "https://api.github.com"
+ASSET_PREFIX = "xrefkit-skills-"
+VERSION_SUFFIX_RE = re.compile(r"^(?P<bundle>.+)-(?P<version>\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?)$")
+ALLOWED_ROOTS = {"skills", "knowledge", "review_axes", "schemas"}
+
+
+@dataclass(frozen=True)
+class SyncResult:
+    bundle: str
+    release: str
+    asset: str
+    sha256: str
+    files: tuple[str, ...]
+    changed: bool
+    dry_run: bool = False
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "bundle": self.bundle,
+            "release": self.release,
+            "asset": self.asset,
+            "sha256": self.sha256,
+            "files": list(self.files),
+            "changed": self.changed,
+            "dry_run": self.dry_run,
+        }
+
+
+def _github_json(url: str) -> dict[str, object]:
+    request = urllib.request.Request(
+        url,
+        headers={
+            "Accept": "application/vnd.github+json",
+            "User-Agent": "xrefkit-skill-sync",
+        },
+    )
+    try:
+        with urllib.request.urlopen(request) as response:  # nosec B310 - URL is GitHub API HTTPS
+            payload = json.loads(response.read().decode("utf-8"))
+    except (urllib.error.URLError, urllib.error.HTTPError) as exc:
+        raise RuntimeError(f"could not read GitHub release metadata: {url}") from exc
+    if not isinstance(payload, dict):
+        raise RuntimeError(f"GitHub release metadata was not an object: {url}")
+    return payload
+
+
+def _release(source_repository: str, release: str) -> dict[str, object]:
+    encoded_repo = urllib.parse.quote(source_repository, safe="/")
+    if release == "latest":
+        url = f"{DEFAULT_GITHUB_API}/repos/{encoded_repo}/releases/latest"
+    else:
+        encoded_release = urllib.parse.quote(release, safe="")
+        url = f"{DEFAULT_GITHUB_API}/repos/{encoded_repo}/releases/tags/{encoded_release}"
+    return _github_json(url)
+
+
+def _assets(release: dict[str, object]) -> list[dict[str, object]]:
+    assets = release.get("assets")
+    if not isinstance(assets, list):
+        raise RuntimeError("GitHub release has no assets list")
+    return [item for item in assets if isinstance(item, dict)]
+
+
+def _asset_for_bundle(release: dict[str, object], bundle: str) -> dict[str, object]:
+    expected_prefix = f"{ASSET_PREFIX}{bundle}-"
+    candidates = [
+        asset
+        for asset in _assets(release)
+        if isinstance(asset.get("name"), str)
+        and asset["name"].startswith(expected_prefix)
+        and asset["name"].endswith(".zip")
+    ]
+    if len(candidates) != 1:
+        names = ", ".join(str(item.get("name")) for item in candidates) or "none"
+        raise RuntimeError(f"expected one release asset for bundle {bundle}; found: {names}")
+    return candidates[0]
+
+
+def _download_asset(asset: dict[str, object]) -> tuple[str, bytes]:
+    name = asset.get("name")
+    url = asset.get("browser_download_url")
+    if not isinstance(name, str) or not isinstance(url, str):
+        raise RuntimeError("GitHub release asset has no usable name or download URL")
+    request = urllib.request.Request(url, headers={"User-Agent": "xrefkit-skill-sync"})
+    try:
+        with urllib.request.urlopen(request) as response:  # nosec B310 - URL comes from GitHub release metadata
+            return name, response.read()
+    except (urllib.error.URLError, urllib.error.HTTPError) as exc:
+        raise RuntimeError(f"could not download release asset: {name}") from exc
+
+
+def _safe_zip_extract(data: bytes, destination: Path) -> None:
+    with zipfile.ZipFile(__import__("io").BytesIO(data)) as archive:
+        for member in archive.infolist():
+            relative = PurePosixPath(member.filename)
+            if relative.is_absolute() or ".." in relative.parts:
+                raise RuntimeError(f"unsafe path in Skill bundle: {member.filename}")
+            target = (destination / Path(*relative.parts)).resolve()
+            target.relative_to(destination.resolve())
+            if member.is_dir():
+                target.mkdir(parents=True, exist_ok=True)
+                continue
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(archive.read(member))
+
+
+def _bundle_root(extracted: Path) -> Path:
+    if any((extracted / name).is_dir() for name in ALLOWED_ROOTS):
+        return extracted
+    children = [path for path in extracted.iterdir() if path.is_dir()]
+    if len(children) == 1 and any((children[0] / name).is_dir() for name in ALLOWED_ROOTS):
+        return children[0]
+    raise RuntimeError("Skill bundle must contain skills/ or knowledge/ at its root")
+
+
+def _bundle_files(root: Path) -> list[tuple[Path, Path]]:
+    files: list[tuple[Path, Path]] = []
+    for dirname in sorted(ALLOWED_ROOTS):
+        base = root / dirname
+        if not base.is_dir():
+            continue
+        for source in sorted(path for path in base.rglob("*") if path.is_file()):
+            files.append((source, Path(dirname) / source.relative_to(base)))
+    manifest = root / "package_manifest.yaml"
+    if manifest.is_file():
+        files.append((manifest, Path("package_manifest.yaml")))
+    if not files:
+        raise RuntimeError("Skill bundle contains no files under skills/ or knowledge/")
+    return files
+
+
+def _state_path(repo: Path, bundle: str) -> Path:
+    return repo / ".xrefkit" / "skill-sync" / f"{bundle}.json"
+
+
+def sync_bundle(
+    *,
+    repo: Path,
+    source_repository: str,
+    bundle: str,
+    release: str = "latest",
+    force: bool = False,
+    dry_run: bool = False,
+) -> SyncResult:
+    repo = repo.resolve()
+    if not repo.is_dir():
+        raise FileNotFoundError(f"XRefKit repository not found: {repo}")
+    release_payload = _release(source_repository, release)
+    asset = _asset_for_bundle(release_payload, bundle)
+    asset_name, data = _download_asset(asset)
+    digest = hashlib.sha256(data).hexdigest()
+    release_name = str(release_payload.get("tag_name") or release)
+
+    with tempfile.TemporaryDirectory(prefix="xrefkit-skill-sync-") as temp_dir:
+        extracted = Path(temp_dir) / "bundle"
+        extracted.mkdir()
+        _safe_zip_extract(data, extracted)
+        root = _bundle_root(extracted)
+        files = _bundle_files(root)
+        relative_files = tuple(sorted(destination.as_posix() for _source, destination in files))
+
+        previous: dict[str, object] = {}
+        state = _state_path(repo, bundle)
+        if state.is_file():
+            try:
+                loaded = json.loads(state.read_text(encoding="utf-8"))
+                if isinstance(loaded, dict):
+                    previous = loaded
+            except json.JSONDecodeError:
+                raise RuntimeError(f"invalid sync state: {state}")
+        managed = {str(item) for item in previous.get("files", []) if isinstance(item, str)}
+        conflicts = [
+            str(destination)
+            for _source, destination in files
+            if (repo / destination).exists() and destination.as_posix() not in managed and not force
+        ]
+        if conflicts:
+            raise RuntimeError(
+                "refusing to overwrite existing files not owned by sync state; "
+                f"use --force after review: {', '.join(sorted(conflicts))}"
+            )
+
+        if not dry_run:
+            for source, destination in files:
+                target = repo / destination
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(source.read_bytes())
+            state.parent.mkdir(parents=True, exist_ok=True)
+            state.write_text(
+                json.dumps(
+                    {
+                        "source_repository": source_repository,
+                        "release": release_name,
+                        "asset": asset_name,
+                        "sha256": digest,
+                        "files": list(relative_files),
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+    return SyncResult(bundle, release_name, asset_name, digest, relative_files, True, dry_run)
+
+
+def _print(payload: object, *, as_json: bool) -> None:
+    if as_json:
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return
+    results = payload if isinstance(payload, list) else [payload]
+    for item in results:
+        print(f"synced: {item['bundle']} ({item['release']})")
+        print(f"asset: {item['asset']}")
+        print(f"files: {len(item['files'])}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="xrefkit skills")
+    sub = parser.add_subparsers(dest="command", required=True)
+    sync = sub.add_parser("sync", help="download and register Skill/Knowledge bundles from GitHub Releases")
+    sync.add_argument("--repo", default=".", help="Target XRefKit repository; defaults to the current directory")
+    sync.add_argument("--source-repository", default=DEFAULT_SOURCE_REPOSITORY, help="GitHub owner/repository containing releases")
+    sync.add_argument("--bundle", action="append", help="Bundle name, for example csharp; repeat for multiple bundles")
+    sync.add_argument("--all", action="store_true", help="Synchronize every xrefkit-skills-*.zip asset in the release")
+    sync.add_argument("--release", default="latest", help="Release tag, or latest (default)")
+    sync.add_argument("--force", action="store_true", help="Allow overwriting files not owned by a previous sync")
+    sync.add_argument("--dry-run", action="store_true", help="Download and validate without writing the repository")
+    sync.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    if not args.bundle and not args.all:
+        parser.error("one of --bundle or --all is required")
+    release_payload = _release(args.source_repository, args.release)
+    bundles = list(args.bundle or [])
+    if args.all:
+        for asset in _assets(release_payload):
+            name = asset.get("name")
+            if not isinstance(name, str) or not name.startswith(ASSET_PREFIX) or not name.endswith(".zip"):
+                continue
+            stem = name[:-4][len(ASSET_PREFIX) :]
+            match = VERSION_SUFFIX_RE.match(stem)
+            bundles.append(match.group("bundle") if match else stem)
+    bundles = list(dict.fromkeys(bundles))
+    results = [
+        sync_bundle(
+            repo=Path(args.repo),
+            source_repository=args.source_repository,
+            bundle=bundle,
+            release=args.release,
+            force=args.force,
+            dry_run=args.dry_run,
+        ).to_dict()
+        for bundle in bundles
+    ]
+    _print(results, as_json=args.json)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{xrefkit-0.4.5 → xrefkit-0.4.7}/xrefkit.egg-info/PKG-INFO

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

{xrefkit-0.4.5 → xrefkit-0.4.7}/xrefkit.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ tests/test_runtime_contracts.py
 tests/test_sarif_to_locator.py
 tests/test_skill_runtime_audit.py
 tests/test_skillmeta.py
+tests/test_skills_sync.py
 tests/test_structure_catalog.py
 tests/test_xref.py
 tests/test_xrefkit_instance.py
@@ -62,6 +63,7 @@ xrefkit/resource_provider.py
 xrefkit/runlog.py
 xrefkit/skillmeta.py
 xrefkit/skillrun.py
+xrefkit/skills_sync.py
 xrefkit/structure_catalog.py
 xrefkit/v2_cli.py
 xrefkit/workspace.py