#!/usr/bin/env python3 """Sync the current git tree to Hugging Face with HF-only card metadata.""" from __future__ import annotations import argparse import os import shutil import subprocess import tempfile from pathlib import Path DEFAULT_REPO_ID = "Stevesolun/ctx" DEFAULT_REPO_TYPE = "dataset" HF_CARD_METADATA = """--- license: mit pretty_name: ctx tags: - agents - mcp - skills - knowledge-graph - llm-wiki - recommendation-system - harness - codex - claude-code --- """ LFS_POINTER_PREFIX = b"version https://git-lfs.github.com/spec/v1" HYDRATED_ARTIFACT_MIN_BYTES = { Path("graph/wiki-graph.tar.gz"): 100_000_000, Path("graph/skills-sh-catalog.json.gz"): 1_000_000, } def with_hf_repo_card_metadata(readme_text: str) -> str: """Return README text with Hugging Face repo-card metadata prepended.""" return HF_CARD_METADATA + _strip_leading_yaml_frontmatter(readme_text) def _strip_leading_yaml_frontmatter(text: str) -> str: if not text.startswith("---\n"): return text end = text.find("\n---\n", 4) if end == -1: return text return text[end + len("\n---\n") :].lstrip("\n") def _git(repo: Path, *args: str) -> str: return subprocess.check_output(["git", *args], cwd=repo, text=True).strip() def _git_bytes(repo: Path, *args: str) -> bytes: return subprocess.check_output(["git", *args], cwd=repo) def _iter_tracked_files(repo: Path) -> list[Path]: output = _git_bytes(repo, "ls-files", "-z") files: list[Path] = [] for raw in output.split(b"\0"): if not raw: continue rel = Path(raw.decode("utf-8")) if rel.is_absolute() or ".." in rel.parts: raise ValueError(f"unsafe git path: {rel}") files.append(rel) return files def _assert_hydrated_artifacts(repo: Path) -> None: for rel, min_bytes in HYDRATED_ARTIFACT_MIN_BYTES.items(): artifact = repo / rel if not artifact.is_file(): raise FileNotFoundError( f"{rel.as_posix()} is required before Hugging Face sync" ) size = artifact.stat().st_size if size < min_bytes: raise RuntimeError( f"{rel.as_posix()} is {size:,} bytes; expected at least " f"{min_bytes:,}. Run git lfs pull before publishing." ) with artifact.open("rb") as fh: prefix = fh.read(len(LFS_POINTER_PREFIX)) if prefix == LFS_POINTER_PREFIX: raise RuntimeError( f"{rel.as_posix()} is a Git LFS pointer, not the hydrated artifact" ) def _export_tracked_tree(repo: Path, export_dir: Path) -> None: _assert_hydrated_artifacts(repo) repo_root = repo.resolve() export_root = export_dir.resolve() for rel in _iter_tracked_files(repo): source = (repo_root / rel).resolve() if source != repo_root and not source.is_relative_to(repo_root): raise ValueError(f"unsafe source path: {rel}") if source.is_symlink(): raise ValueError(f"refusing to follow symlink during HF sync: {rel}") if not source.is_file(): continue target = (export_root / rel).resolve() if target != export_root and not target.is_relative_to(export_root): raise ValueError(f"unsafe export path: {rel}") target.parent.mkdir(parents=True, exist_ok=True) shutil.copy2(source, target) def _patch_export_readme(export_dir: Path) -> None: readme = export_dir / "README.md" readme.write_text( with_hf_repo_card_metadata(readme.read_text(encoding="utf-8")), encoding="utf-8", newline="\n", ) def _iter_export_file_names(export_dir: Path) -> set[str]: names: set[str] = set() for path in export_dir.rglob("*"): if not path.is_file(): continue rel = path.relative_to(export_dir).as_posix() if rel == ".cache" or rel.startswith(".cache/"): continue names.add(rel) return names def _repo_url(*, repo_id: str, repo_type: str) -> str: prefix = {"dataset": "datasets", "space": "spaces"}.get(repo_type) repo_path = f"{prefix}/{repo_id}" if prefix else repo_id return f"https://huggingface.co/{repo_path}" def _repo_commit_url(*, repo_id: str, repo_type: str, sha: str) -> str: return f"{_repo_url(repo_id=repo_id, repo_type=repo_type)}/commit/{sha}" def _remote_has_no_stale_paths( *, api: object, export_dir: Path, repo_id: str, repo_type: str, ) -> bool: try: remote_files = set(api.list_repo_files(repo_id=repo_id, repo_type=repo_type)) except Exception: return False return remote_files <= _iter_export_file_names(export_dir) def _upload_export( *, api: object, export_dir: Path, repo_id: str, repo_type: str, head: str, prefer_large_upload: bool, ) -> str: if ( prefer_large_upload and hasattr(api, "upload_large_folder") and _remote_has_no_stale_paths( api=api, export_dir=export_dir, repo_id=repo_id, repo_type=repo_type, ) ): api.upload_large_folder( repo_id=repo_id, repo_type=repo_type, folder_path=str(export_dir), print_report=True, ) info = api.repo_info(repo_id=repo_id, repo_type=repo_type) sha = getattr(info, "sha", None) if sha: return _repo_commit_url(repo_id=repo_id, repo_type=repo_type, sha=str(sha)) return _repo_url(repo_id=repo_id, repo_type=repo_type) info = api.upload_folder( repo_id=repo_id, repo_type=repo_type, folder_path=str(export_dir), commit_message=f"Sync ctx {head[:7]}", commit_description=f"GitHub commit: {head}", delete_patterns="*", ) return str(getattr(info, "commit_url", info)) def sync_to_huggingface( *, repo: Path, repo_id: str, repo_type: str, token: str, ) -> str: """Upload HEAD to Hugging Face and return the commit URL.""" from huggingface_hub import HfApi head = _git(repo, "rev-parse", "HEAD") workspace = Path(tempfile.mkdtemp(prefix="ctx-hf-upload-")) export_dir = workspace / "export" try: export_dir.mkdir() _export_tracked_tree(repo, export_dir) _patch_export_readme(export_dir) api = HfApi(token=token) api.create_repo(repo_id, repo_type=repo_type, exist_ok=True) return _upload_export( api=api, repo_id=repo_id, repo_type=repo_type, export_dir=export_dir, head=head, prefer_large_upload=True, ) finally: shutil.rmtree(workspace, ignore_errors=True) def main() -> None: parser = argparse.ArgumentParser( description="Upload this git checkout to Hugging Face with repo-card metadata" ) parser.add_argument("--repo", default=".", help="Git checkout path") parser.add_argument( "--repo-id", default=os.environ.get("HF_REPO_ID", DEFAULT_REPO_ID), help="Hugging Face repo ID", ) parser.add_argument( "--repo-type", default=os.environ.get("HF_REPO_TYPE", DEFAULT_REPO_TYPE), help="Hugging Face repo type", ) args = parser.parse_args() token = os.environ.get("HF_TOKEN") if not token: raise SystemExit("HF_TOKEN is required") print( sync_to_huggingface( repo=Path(args.repo).resolve(), repo_id=args.repo_id, repo_type=args.repo_type, token=token, ) ) if __name__ == "__main__": main()