Add files using upload-large-folder tool

scripts/ci_classifier.py

@@ -32,6 +32,7 @@ DOCS_PATTERNS = (
 GRAPH_ARTIFACT_PATTERNS = (
     "graph/communities.json",
     "graph/skills-sh-catalog.json.gz",
+    "graph/wiki-graph-runtime.tar.gz",
     "graph/wiki-graph.tar.gz",
     "graph/*.html",
 )

scripts/sync_huggingface.py

@@ -3,13 +3,14 @@
 
 from __future__ import annotations
 
-import argparse
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
 
 DEFAULT_REPO_ID = "Stevesolun/ctx"
 DEFAULT_REPO_TYPE = "dataset"
@@ -34,6 +35,7 @@ tags:
 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/wiki-graph-runtime.tar.gz"): 10_000_000,
     Path("graph/skills-sh-catalog.json.gz"): 1_000_000,
 }
 
@@ -73,11 +75,11 @@ def _iter_tracked_files(repo: Path) -> list[Path]:
     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(
+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
@@ -88,26 +90,26 @@ def _assert_hydrated_artifacts(repo: Path) -> None:
             )
         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"
-            )
-    _validate_graph_artifact_integrity(repo)
-
-
-def _validate_graph_artifact_integrity(repo: Path) -> None:
-    src_dir = repo / "src"
-    if str(src_dir) not in sys.path:
-        sys.path.insert(0, str(src_dir))
-    try:
-        from validate_graph_artifacts import validate_graph_artifacts
-
-        validate_graph_artifacts(repo / "graph")
-    except Exception as exc:  # noqa: BLE001
-        raise RuntimeError(
-            "graph artifact integrity validation failed before Hugging Face sync: "
-            f"{exc}"
-        ) from exc
+        if prefix == LFS_POINTER_PREFIX:
+            raise RuntimeError(
+                f"{rel.as_posix()} is a Git LFS pointer, not the hydrated artifact"
+            )
+    _validate_graph_artifact_integrity(repo)
+
+
+def _validate_graph_artifact_integrity(repo: Path) -> None:
+    src_dir = repo / "src"
+    if str(src_dir) not in sys.path:
+        sys.path.insert(0, str(src_dir))
+    try:
+        from validate_graph_artifacts import validate_graph_artifacts
+
+        validate_graph_artifacts(repo / "graph")
+    except Exception as exc:  # noqa: BLE001
+        raise RuntimeError(
+            "graph artifact integrity validation failed before Hugging Face sync: "
+            f"{exc}"
+        ) from exc
 
 
 def _export_tracked_tree(repo: Path, export_dir: Path) -> None:
@@ -162,7 +164,7 @@ def _repo_commit_url(*, repo_id: str, repo_type: str, sha: str) -> str:
 
 def _remote_has_no_stale_paths(
     *,
-    api: object,
+    api: Any,
     export_dir: Path,
     repo_id: str,
     repo_type: str,
@@ -176,7 +178,7 @@ def _remote_has_no_stale_paths(
 
 def _upload_export(
     *,
-    api: object,
+    api: Any,
     export_dir: Path,
     repo_id: str,
     repo_type: str,

src/ctx_init.py

@@ -212,9 +212,14 @@ def _resolve_ctx_src_dir() -> Path:
 
 
 _GRAPH_ARCHIVE_NAME = "wiki-graph.tar.gz"
+_GRAPH_RUNTIME_ARCHIVE_NAME = "wiki-graph-runtime.tar.gz"
+_GRAPH_ARCHIVE_NAMES = {
+    "runtime": _GRAPH_RUNTIME_ARCHIVE_NAME,
+    "full": _GRAPH_ARCHIVE_NAME,
+}
 _GRAPH_RELEASE_URL = (
     "https://github.com/stevesolun/ctx/releases/download/"
-    "v{version}/wiki-graph.tar.gz"
+    "v{version}/{archive_name}"
 )
 _GRAPH_REQUIRED_FILES = frozenset({
     "index.md",
@@ -232,7 +237,24 @@ _GRAPH_MANAGED_PATHS = (
     "concepts",
     "external-catalogs",
     "index.md",
+    "catalog.md",
+    "converted-index.md",
+    "log.md",
+    "SCHEMA.md",
+    "versions-catalog.md",
+    ".obsidian",
 )
+_GRAPH_JSON_OUTLINE_BYTES = 1024 * 1024
+_GRAPH_INSTALL_MODES = ("runtime", "full")
+_GRAPH_RUNTIME_PREFIXES = ("graphify-out/", "external-catalogs/", "entities/harnesses/")
+_GRAPH_RUNTIME_ROOT_FILES = frozenset({
+    "catalog.md",
+    "converted-index.md",
+    "index.md",
+    "log.md",
+    "SCHEMA.md",
+    "versions-catalog.md",
+})
 
 
 def build_graph(
@@ -240,27 +262,35 @@ def build_graph(
     *,
     force: bool = False,
     graph_url: str | None = None,
+    install_mode: str = "runtime",
 ) -> int:
     """Install the pre-built knowledge graph into ``~/.claude/skill-wiki``."""
+    if install_mode not in _GRAPH_INSTALL_MODES:
+        raise ValueError(f"unknown graph install mode: {install_mode}")
     claude_dir = claude or _claude_dir()
     wiki_dir = claude_dir / "skill-wiki"
     graph_json = wiki_dir / "graphify-out" / "graph.json"
-    if not force and _graph_install_complete(wiki_dir):
+    install_complete = (
+        _graph_full_install_complete(wiki_dir)
+        if install_mode == "full"
+        else _graph_install_complete(wiki_dir)
+    )
+    if not force and install_complete:
         print(f"Graph already installed at {graph_json}; use --force to refresh.")
         return 0
 
     temp_dir: tempfile.TemporaryDirectory[str] | None = None
-    archive = _find_local_graph_archive()
+    archive = _find_local_graph_archive(install_mode)
     try:
         if archive is None:
             temp_dir = tempfile.TemporaryDirectory(prefix="ctx-graph-download-")
-            archive = Path(temp_dir.name) / _GRAPH_ARCHIVE_NAME
-            url = graph_url or _release_graph_url()
+            archive = Path(temp_dir.name) / _graph_archive_name(install_mode)
+            url = graph_url or _release_graph_url(install_mode)
             print(f"Downloading pre-built graph from {url}")
             _download_graph_archive(archive, url=url)
         else:
             print(f"Installing pre-built graph from {archive}")
-        _extract_graph_archive(archive, wiki_dir)
+        _extract_graph_archive(archive, wiki_dir, install_mode=install_mode)
     except Exception as exc:
         print(
             f"  [error] graph install failed: {type(exc).__name__}: {exc}",
@@ -279,20 +309,32 @@ def build_graph(
     return 0
 
 
-def _find_local_graph_archive() -> Path | None:
+def _find_local_graph_archive(install_mode: str = "runtime") -> Path | None:
     module_path = Path(__file__).resolve()
-    candidates = (
-        module_path.parent.parent / "graph" / _GRAPH_ARCHIVE_NAME,
-        Path.cwd() / "graph" / _GRAPH_ARCHIVE_NAME,
-    )
+    archive_names = [_graph_archive_name(install_mode)]
+    if install_mode == "runtime":
+        archive_names.append(_GRAPH_ARCHIVE_NAME)
+    graph_dirs = (module_path.parent.parent / "graph", Path.cwd() / "graph")
+    candidates = [
+        graph_dir / archive_name
+        for archive_name in archive_names
+        for graph_dir in graph_dirs
+    ]
     for candidate in candidates:
         if candidate.is_file():
             return candidate
     return None
 
 
-def _release_graph_url() -> str:
-    return _GRAPH_RELEASE_URL.format(version=_package_version())
+def _release_graph_url(install_mode: str = "runtime") -> str:
+    return _GRAPH_RELEASE_URL.format(
+        version=_package_version(),
+        archive_name=_graph_archive_name(install_mode),
+    )
+
+
+def _graph_archive_name(install_mode: str) -> str:
+    return _GRAPH_ARCHIVE_NAMES.get(install_mode, _GRAPH_RUNTIME_ARCHIVE_NAME)
 
 
 def _package_version() -> str:
@@ -313,25 +355,46 @@ def _download_graph_archive(destination: Path, *, url: str) -> None:
             shutil.copyfileobj(response, fh)
 
 
-def _extract_graph_archive(archive: Path, target_dir: Path) -> None:
+def _extract_graph_archive(
+    archive: Path,
+    target_dir: Path,
+    *,
+    install_mode: str,
+) -> None:
     target_dir.parent.mkdir(parents=True, exist_ok=True)
     with tempfile.TemporaryDirectory(
         prefix=f".{target_dir.name}-stage-",
         dir=target_dir.parent,
     ) as staging_name:
         staging_dir = Path(staging_name)
-        _extract_graph_archive_to_dir(archive, staging_dir)
+        _extract_graph_archive_to_dir(
+            archive,
+            staging_dir,
+            install_mode=install_mode,
+        )
         _validate_graph_install_tree(staging_dir)
         _promote_graph_tree(staging_dir, target_dir)
 
 
-def _extract_graph_archive_to_dir(archive: Path, target_dir: Path) -> None:
+def _extract_graph_archive_to_dir(
+    archive: Path,
+    target_dir: Path,
+    *,
+    install_mode: str,
+) -> None:
     target_dir.mkdir(parents=True, exist_ok=True)
     target_root = target_dir.resolve()
+    extracted_required: set[str] = set()
     with tarfile.open(archive, "r:gz") as tf:
-        members = tf.getmembers()
-        for member in members:
+        for member in tf:
             _validate_graph_tar_member(member)
+            safe_name = _safe_graph_member_name(member.name)
+            if not _should_extract_graph_member(
+                safe_name,
+                member,
+                install_mode=install_mode,
+            ):
+                continue
             destination = _graph_member_destination(target_dir, target_root, member)
             if member.isdir():
                 destination.mkdir(parents=True, exist_ok=True)
@@ -343,6 +406,13 @@ def _extract_graph_archive_to_dir(archive: Path, target_dir: Path) -> None:
             _ensure_path_under_root(destination.parent, target_root)
             with source, destination.open("wb") as fh:
                 shutil.copyfileobj(source, fh)
+            if safe_name in _GRAPH_REQUIRED_FILES:
+                extracted_required.add(safe_name)
+                if (
+                    install_mode == "runtime"
+                    and _GRAPH_REQUIRED_FILES <= extracted_required
+                ):
+                    break
 
 
 def _graph_install_complete(wiki_dir: Path) -> bool:
@@ -353,6 +423,13 @@ def _graph_install_complete(wiki_dir: Path) -> bool:
     return True
 
 
+def _graph_full_install_complete(wiki_dir: Path) -> bool:
+    if not _graph_install_complete(wiki_dir):
+        return False
+    entities = wiki_dir / "entities"
+    return entities.is_dir() and any(entities.iterdir())
+
+
 def _validate_graph_install_tree(wiki_dir: Path) -> None:
     missing = [
         name
@@ -362,13 +439,7 @@ def _validate_graph_install_tree(wiki_dir: Path) -> None:
     if missing:
         raise ValueError(f"graph archive is missing required files: {missing}")
 
-    graph = _read_json_file(wiki_dir / "graphify-out" / "graph.json")
-    if not isinstance(graph, dict):
-        raise ValueError("graphify-out/graph.json must contain a JSON object")
-    if not isinstance(graph.get("nodes"), list):
-        raise ValueError("graphify-out/graph.json is missing a nodes list")
-    if not isinstance(graph.get("edges", graph.get("links")), list):
-        raise ValueError("graphify-out/graph.json is missing an edges/links list")
+    _validate_graph_json_outline(wiki_dir / "graphify-out" / "graph.json")
 
     manifest = _read_json_file(wiki_dir / "graphify-out" / "graph-export-manifest.json")
     if not isinstance(manifest, dict):
@@ -389,6 +460,29 @@ def _validate_graph_install_tree(wiki_dir: Path) -> None:
         raise ValueError("graph export manifest artifacts map is incomplete")
 
 
+def _validate_graph_json_outline(path: Path) -> None:
+    size = path.stat().st_size
+    read_size = min(size, _GRAPH_JSON_OUTLINE_BYTES)
+    with path.open("rb") as f:
+        head = f.read(read_size)
+        if size > read_size:
+            f.seek(max(0, size - read_size))
+            tail = f.read(read_size)
+        else:
+            tail = b""
+    head_text = head.decode("utf-8", errors="ignore")
+    tail_text = tail.decode("utf-8", errors="ignore")
+    if not head_text.lstrip().startswith("{"):
+        raise ValueError("graphify-out/graph.json must contain a JSON object")
+    if tail_text and not tail_text.rstrip().endswith("}"):
+        raise ValueError("graphify-out/graph.json appears truncated")
+    outline = f"{head_text}\n{tail_text}"
+    if '"nodes"' not in outline:
+        raise ValueError("graphify-out/graph.json is missing a nodes list")
+    if '"edges"' not in outline and '"links"' not in outline:
+        raise ValueError("graphify-out/graph.json is missing an edges/links list")
+
+
 def _read_json_file(path: Path) -> Any:
     with path.open("r", encoding="utf-8") as f:
         return json.load(f)
@@ -425,6 +519,28 @@ def _graph_member_destination(
     return destination
 
 
+def _safe_graph_member_name(name: str) -> str:
+    path = PurePosixPath(name.replace("\\", "/"))
+    return path.as_posix()
+
+
+def _should_extract_graph_member(
+    safe_name: str,
+    member: tarfile.TarInfo,
+    *,
+    install_mode: str,
+) -> bool:
+    if install_mode == "full":
+        return True
+    if member.isdir():
+        return False
+    return (
+        safe_name in _GRAPH_RUNTIME_ROOT_FILES
+        or safe_name in _GRAPH_REQUIRED_FILES
+        or any(safe_name.startswith(prefix) for prefix in _GRAPH_RUNTIME_PREFIXES)
+    )
+
+
 def _ensure_path_under_root(path: Path, root: Path) -> None:
     resolved = path.resolve(strict=False)
     if resolved != root and root not in resolved.parents:
@@ -1423,6 +1539,15 @@ def main(argv: list[str] | None = None) -> int:
         "--graph-url",
         help="Override the pre-built wiki-graph.tar.gz download URL",
     )
+    parser.add_argument(
+        "--graph-install-mode",
+        choices=_GRAPH_INSTALL_MODES,
+        default="runtime",
+        help=(
+            "Graph install shape: runtime extracts graph/catalog artifacts "
+            "needed for recommendations; full expands every wiki markdown file."
+        ),
+    )
     parser.add_argument(
         "--knowledge-mode",
         choices=("shipped", "local", "enriched", "skip"),
@@ -1552,9 +1677,19 @@ def main(argv: list[str] | None = None) -> int:
         print("  [skip] hook injection (pass --hooks to enable)")
 
     if args.graph:
-        rc = build_graph(claude, force=args.force, graph_url=args.graph_url)
+        rc = build_graph(
+            claude,
+            force=args.force,
+            graph_url=args.graph_url,
+            install_mode=args.graph_install_mode,
+        )
         if rc == 0:
             print("  [ok] knowledge graph installed")
+            if args.graph_install_mode == "runtime":
+                print(
+                    "  [info] runtime graph install only; pass "
+                    "--graph-install-mode full to expand the full wiki"
+                )
         else:
             print(f"  [warn] graph install returned {rc}", file=sys.stderr)
             if final_rc == 0:

src/ctx_monitor.py

@@ -582,6 +582,7 @@ def _artifact_status() -> dict[str, Any]:
             repo_graph_dir / "wiki-graph.tar.gz",
         ),
         "skills_sh_catalog": _first_existing_file_status(
+            wiki / "external-catalogs" / "skills-sh" / "catalog.json",
             claude_graph_dir / "skills-sh-catalog.json.gz",
             repo_graph_dir / "skills-sh-catalog.json.gz",
         ),