wafer-cli 0.2.20__tar.gz → 0.2.22__tar.gz

{wafer_cli-0.2.20 → wafer_cli-0.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.20
+Version: 0.2.22
 Summary: CLI tool for running commands on remote GPUs and GPU kernel optimization agent
 Requires-Python: >=3.11
 Requires-Dist: typer>=0.12.0

{wafer_cli-0.2.20 → wafer_cli-0.2.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wafer-cli"
-version = "0.2.20"
+version = "0.2.22"
 description = "CLI tool for running commands on remote GPUs and GPU kernel optimization agent"
 requires-python = ">=3.11"
 dependencies = [

{wafer_cli-0.2.20 → wafer_cli-0.2.22}/wafer/cli.py

@@ -1,6 +1,8 @@
-# ruff: noqa: PLR0913
+# ruff: noqa: PLR0913, E402
 # PLR0913 (too many arguments) is suppressed because Typer CLI commands
 # naturally have many parameters - each --flag becomes a function argument.
+# E402 (module level import not at top) is suppressed because we intentionally
+# load .env files before importing other modules that may read env vars.
 """Wafer CLI - GPU development toolkit for LLM coding agents.
 
 Core commands:
@@ -27,6 +29,12 @@ from pathlib import Path
 
 import trio
 import typer
+from dotenv import load_dotenv
+
+# Auto-load .env from current directory and ~/.wafer/.env
+# This runs at import time so env vars are available before any config is accessed
+load_dotenv()  # cwd/.env
+load_dotenv(Path.home() / ".wafer" / ".env")  # ~/.wafer/.env
 
 from .config import WaferConfig, WaferEnvironment
 from .inference import infer_upload_files, resolve_environment
@@ -42,6 +50,7 @@ from .problems import (
 app = typer.Typer(
     help="GPU development toolkit for LLM coding agents",
     no_args_is_help=True,
+    pretty_exceptions_show_locals=False,  # Don't dump local vars (makes tracebacks huge)
 )
 
 # =============================================================================
@@ -58,11 +67,11 @@ def _show_version() -> None:
     """Show CLI version and environment, then exit."""
     from .analytics import _get_cli_version
     from .global_config import load_global_config
-    
+
     version = _get_cli_version()
     config = load_global_config()
     environment = config.environment
-    
+
     typer.echo(f"wafer-cli {version} ({environment})")
     raise typer.Exit()
 
@@ -110,7 +119,7 @@ def main_callback(
     if version:
         _show_version()
         return
-    
+
     global _command_start_time, _command_outcome
     _command_start_time = time.time()
     _command_outcome = "success"  # Default to success, mark failure on exceptions
@@ -121,6 +130,7 @@ def main_callback(
     analytics.init_analytics()
 
     # Install exception hook to catch SystemExit and mark failures
+    # Also prints error message FIRST so it's visible even when traceback is truncated
     original_excepthook = sys.excepthook
 
     def custom_excepthook(
@@ -136,7 +146,11 @@ def main_callback(
                 _command_outcome = "failure"
         else:
             _command_outcome = "failure"
-        # Call original excepthook
+            # Print error summary FIRST (before traceback) so it's visible even if truncated
+            print(
+                f"\n\033[1;31m>>> ERROR: {exc_type.__name__}: {exc_value}\033[0m\n", file=sys.stderr
+            )
+        # Call original excepthook (prints the full traceback)
         original_excepthook(exc_type, exc_value, exc_traceback)
 
     sys.excepthook = custom_excepthook
@@ -591,7 +605,7 @@ app.add_typer(provider_auth_app, name="auth")
 def provider_auth_login(
     provider: str = typer.Argument(
         ...,
-        help="Provider name: runpod, digitalocean, or modal",
+        help="Provider name: runpod, digitalocean, modal, anthropic, or openai",
     ),
     api_key: str | None = typer.Option(
         None,
@@ -600,15 +614,16 @@ def provider_auth_login(
         help="API key (if not provided, reads from stdin)",
     ),
 ) -> None:
-    """Save API key for a cloud GPU provider.
+    """Save API key for a provider.
 
     Stores the key in ~/.wafer/auth.json. Environment variables
-    (e.g., WAFER_RUNPOD_API_KEY) take precedence over stored keys.
+    (e.g., ANTHROPIC_API_KEY) take precedence over stored keys.
 
     Examples:
+        wafer auth login anthropic --api-key sk-ant-xxx
         wafer auth login runpod --api-key rp_xxx
-        wafer auth login digitalocean --api-key dop_v1_xxx
-        echo $API_KEY | wafer auth login runpod
+        wafer auth login openai --api-key sk-xxx
+        echo $API_KEY | wafer auth login anthropic
     """
     import sys
 
@@ -642,7 +657,7 @@ def provider_auth_login(
 def provider_auth_logout(
     provider: str = typer.Argument(
         ...,
-        help="Provider name: runpod, digitalocean, or modal",
+        help="Provider name: runpod, digitalocean, modal, anthropic, or openai",
     ),
 ) -> None:
     """Remove stored API key for a cloud GPU provider.
@@ -3473,7 +3488,7 @@ def init_runpod(
     gpu_configs = {
         "MI300X": {
             "gpu_type_id": "AMD Instinct MI300X OAM",
-            "image": "runpod/pytorch:2.4.0-py3.10-rocm6.1.0-ubuntu22.04",
+            "image": "rocm/pytorch:rocm7.0.2_ubuntu24.04_py3.12_pytorch_release_2.7.1",
             "compute_capability": "9.4",
         },
         "H100": {
@@ -3569,7 +3584,7 @@ def init_digitalocean(
         "ssh_key": ssh_key,
         "region": region,
         "size_slug": "gpu-mi300x1-192gb-devcloud",
-        "image": "gpu-amd-base",
+        "image": "amd-pytorchrocm7",  # PyTorch (ROCm7) marketplace image
         "provision_timeout": 600,
         "eval_timeout": 600,
         "keep_alive": keep_alive,
@@ -4071,6 +4086,164 @@ def targets_cleanup(
         raise typer.Exit(1) from None
 
 
+# Known libraries that can be installed on targets
+# TODO: Consider adding HipKittens to the default RunPod/DO Docker images
+# so this install step isn't needed. For now, this command handles it.
+INSTALLABLE_LIBRARIES: dict[str, dict[str, object]] = {
+    "hipkittens": {
+        "description": "HipKittens - AMD port of ThunderKittens for MI300X",
+        "git_url": "https://github.com/HazyResearch/hipkittens.git",
+        "install_path": "/opt/hipkittens",
+        "requires_amd": True,
+    },
+    # CK is already installed with ROCm 7.0, no action needed
+    "repair-headers": {
+        "description": "Repair ROCm thrust headers (fixes hipify corruption)",
+        "custom_script": "apt-get update -qq && apt-get install --reinstall -y rocthrust >/dev/null 2>&1 && echo REPAIRED",
+        "requires_amd": True,
+    },
+}
+
+
+@targets_app.command("install")
+def targets_install(
+    name: str = typer.Argument(..., help="Target name"),
+    library: str = typer.Argument(..., help="Library to install (hipkittens, repair-headers)"),
+) -> None:
+    """Install a library or run maintenance on a target (idempotent).
+
+    Installs header-only libraries like HipKittens on remote targets.
+    Safe to run multiple times - will skip if already installed.
+
+    Available libraries:
+        hipkittens     - HipKittens (AMD ThunderKittens port)
+        repair-headers - Fix ROCm thrust headers (after hipify corruption)
+
+    Examples:
+        wafer config targets install runpod-mi300x hipkittens
+        wafer config targets install runpod-mi300x repair-headers
+        wafer config targets install do-mi300x hipkittens
+    """
+    import subprocess
+
+    from .targets import load_target
+    from .targets_ops import get_target_ssh_info
+
+    if library not in INSTALLABLE_LIBRARIES:
+        available = ", ".join(INSTALLABLE_LIBRARIES.keys())
+        typer.echo(f"Error: Unknown library '{library}'. Available: {available}", err=True)
+        raise typer.Exit(1)
+
+    lib_info = INSTALLABLE_LIBRARIES[library]
+
+    try:
+        target = load_target(name)
+    except FileNotFoundError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1) from None
+
+    # Check if target is AMD (for AMD-only libraries)
+    if lib_info.get("requires_amd"):
+        from wafer_core.utils.kernel_utils.targets.config import (
+            DigitalOceanTarget,
+            RunPodTarget,
+        )
+
+        is_amd = isinstance(target, (RunPodTarget, DigitalOceanTarget))
+        if not is_amd and hasattr(target, "compute_capability"):
+            # Check compute capability for MI300X (gfx942 = 9.4)
+            is_amd = target.compute_capability.startswith("9.")
+        if not is_amd:
+            typer.echo(f"Error: {library} requires an AMD GPU target", err=True)
+            raise typer.Exit(1)
+
+    typer.echo(f"Installing {library} on {name}...")
+    typer.echo(f"  {lib_info['description']}")
+
+    async def _install() -> bool:
+        # get_target_ssh_info uses pure trio async (no asyncio bridging needed)
+        # and we use subprocess for SSH, not AsyncSSHClient
+        ssh_info = await get_target_ssh_info(target)
+
+        ssh_cmd = [
+            "ssh",
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-o",
+            "UserKnownHostsFile=/dev/null",
+            "-o",
+            "ConnectTimeout=30",
+            "-i",
+            str(ssh_info.key_path),
+            "-p",
+            str(ssh_info.port),
+            f"{ssh_info.user}@{ssh_info.host}",
+        ]
+
+        # Handle custom scripts (like repair-headers) vs git installs
+        if "custom_script" in lib_info:
+            install_script = str(lib_info["custom_script"])
+            success_marker = "REPAIRED"
+        else:
+            install_path = lib_info["install_path"]
+            git_url = lib_info["git_url"]
+
+            # Idempotent install script
+            install_script = f"""
+if [ -d "{install_path}" ]; then
+    echo "ALREADY_INSTALLED: {install_path} exists"
+    cd {install_path} && git pull --quiet 2>/dev/null || true
+else
+    echo "INSTALLING: cloning to {install_path}"
+    git clone --quiet {git_url} {install_path}
+fi
+echo "DONE"
+"""
+            success_marker = "DONE"
+
+        def run_ssh() -> subprocess.CompletedProcess[str]:
+            return subprocess.run(
+                ssh_cmd + [install_script],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+
+        result = await trio.to_thread.run_sync(run_ssh)
+
+        if result.returncode != 0:
+            typer.echo(f"Error: {result.stderr}", err=True)
+            return False
+
+        output = result.stdout.strip()
+        if "ALREADY_INSTALLED" in output:
+            typer.echo(f"  Already installed at {lib_info.get('install_path', 'N/A')}")
+        elif "INSTALLING" in output:
+            typer.echo(f"  Installed to {lib_info.get('install_path', 'N/A')}")
+        elif "REPAIRED" in output:
+            typer.echo("  ROCm headers repaired")
+
+        return success_marker in output
+
+    try:
+        success = trio.run(_install)
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1) from None
+
+    if success:
+        typer.echo(f"✓ {library} ready on {name}")
+
+        # Print usage hint
+        if library == "hipkittens":
+            typer.echo("")
+            typer.echo("Usage in load_inline:")
+            typer.echo('  extra_include_paths=["/opt/hipkittens/include", "/opt/rocm/include/hip"]')
+    else:
+        typer.echo(f"Failed to install {library}", err=True)
+        raise typer.Exit(1)
+
+
 @targets_app.command("pods")
 def targets_pods() -> None:
     """List all running RunPod pods.
@@ -4406,9 +4579,13 @@ def workspaces_list(
 @workspaces_app.command("create")
 def workspaces_create(
     name: str = typer.Argument(..., help="Workspace name"),
-    gpu_type: str = typer.Option("B200", "--gpu", "-g", help="GPU type: MI300X (AMD) or B200 (NVIDIA, default)"),
+    gpu_type: str = typer.Option(
+        "B200", "--gpu", "-g", help="GPU type: MI300X (AMD) or B200 (NVIDIA, default)"
+    ),
     image: str | None = typer.Option(None, "--image", "-i", help="Docker image (optional)"),
-    wait: bool = typer.Option(False, "--wait", "-w", help="Wait for provisioning and show SSH credentials"),
+    wait: bool = typer.Option(
+        False, "--wait", "-w", help="Wait for provisioning and show SSH credentials"
+    ),
     json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
 ) -> None:
     """Create a new workspace.
@@ -4717,19 +4894,25 @@ def workspaces_ssh(
     ssh_host = ws.get("ssh_host")
     ssh_port = ws.get("ssh_port")
     ssh_user = ws.get("ssh_user")
-    
+
     if not ssh_host or not ssh_port or not ssh_user:
         typer.echo("Error: Workspace not ready. Wait a few seconds and retry.", err=True)
         raise typer.Exit(1)
 
     # Connect via SSH
-    os.execvp("ssh", [
+    os.execvp(
         "ssh",
-        "-p", str(ssh_port),
-        "-o", "StrictHostKeyChecking=no",
-        "-o", "UserKnownHostsFile=/dev/null",
-        f"{ssh_user}@{ssh_host}",
-    ])
+        [
+            "ssh",
+            "-p",
+            str(ssh_port),
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-o",
+            "UserKnownHostsFile=/dev/null",
+            f"{ssh_user}@{ssh_host}",
+        ],
+    )
 
 
 @workspaces_app.command("sync")

{wafer_cli-0.2.20 → wafer_cli-0.2.22}/wafer/corpus.py

@@ -3,10 +3,12 @@
 Download and manage documentation corpora for agent filesystem access.
 """
 
+import re
 import shutil
 import tarfile
 import tempfile
 from dataclasses import dataclass
+from html.parser import HTMLParser
 from pathlib import Path
 from typing import Literal
 from urllib.parse import urlparse
@@ -33,7 +35,7 @@ class CorpusConfig:
 
     name: CorpusName
     description: str
-    source_type: Literal["nvidia_md", "github_repo", "github_multi_repo"]
+    source_type: Literal["nvidia_md", "github_repo", "github_multi_repo", "mixed"]
     urls: list[str] | None = None
     repo: str | None = None
     repo_paths: list[str] | None = None
@@ -67,10 +69,43 @@ CORPORA: dict[CorpusName, CorpusConfig] = {
     ),
     "cutlass": CorpusConfig(
         name="cutlass",
-        description="CUTLASS and CuTe DSL documentation",
-        source_type="github_repo",
-        repo="NVIDIA/cutlass",
-        repo_paths=["media/docs", "python/cutlass/docs"],
+        description="CUTLASS C++ documentation, examples, and tutorials",
+        source_type="mixed",
+        # Official NVIDIA CUTLASS documentation (scraped as markdown)
+        urls=[
+            "https://docs.nvidia.com/cutlass/latest/overview.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/functionality.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/terminology.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/fundamental_types.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/programming_guidelines.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/heuristics.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/efficient_gemm.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/pipeline.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/profiler.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/dependent_kernel_launch.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/blackwell_functionality.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/blackwell_cluster_launch_control.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/00_quickstart.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/01_layout.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/02_layout_algebra.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/03_tensor.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/04_algorithms.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/0t_mma_atom.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/0x_gemm_tutorial.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/0y_predication.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/0z_tma_tensors.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cutlass_3x_design.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cutlass_3x_backwards_compatibility.html",
+            "https://docs.nvidia.com/cutlass/latest/media/docs/cpp/gemm_api_3x.html",
+        ],
+        # NVIDIA/cutlass GitHub examples (excluding python/)
+        repos=[
+            RepoSource(
+                repo="NVIDIA/cutlass",
+                paths=["examples"],
+                branch="main",
+            ),
+        ],
     ),
     "hip": CorpusConfig(
         name="hip",
@@ -169,19 +204,195 @@ def _url_to_filepath(url: str, base_dir: Path) -> Path:
     return base_dir / "/".join(path_parts)
 
 
+class _HTMLToMarkdown(HTMLParser):
+    """HTML to Markdown converter for NVIDIA documentation pages.
+
+    Uses stdlib HTMLParser - requires subclassing due to callback-based API.
+    The public interface is the functional `_html_to_markdown()` below.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.output: list[str] = []
+        self.current_tag: str = ""
+        self.in_code_block = False
+        self.in_pre = False
+        self.list_depth = 0
+        self.ordered_list_counters: list[int] = []
+        self.skip_content = False
+        self.link_href: str | None = None
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self.current_tag = tag
+        attrs_dict = dict(attrs)
+
+        # Skip script, style, nav, footer, header
+        if tag in ("script", "style", "nav", "footer", "header", "aside"):
+            self.skip_content = True
+            return
+
+        if tag == "h1":
+            self.output.append("\n# ")
+        elif tag == "h2":
+            self.output.append("\n## ")
+        elif tag == "h3":
+            self.output.append("\n### ")
+        elif tag == "h4":
+            self.output.append("\n#### ")
+        elif tag == "h5":
+            self.output.append("\n##### ")
+        elif tag == "h6":
+            self.output.append("\n###### ")
+        elif tag == "p":
+            self.output.append("\n\n")
+        elif tag == "br":
+            self.output.append("\n")
+        elif tag == "strong" or tag == "b":
+            self.output.append("**")
+        elif tag == "em" or tag == "i":
+            self.output.append("*")
+        elif tag == "code" and not self.in_pre:
+            self.output.append("`")
+            self.in_code_block = True
+        elif tag == "pre":
+            self.in_pre = True
+            # Check for language hint in class
+            lang = ""
+            if class_attr := attrs_dict.get("class"):
+                if "python" in class_attr.lower():
+                    lang = "python"
+                elif "cpp" in class_attr.lower() or "c++" in class_attr.lower():
+                    lang = "cpp"
+                elif "cuda" in class_attr.lower():
+                    lang = "cuda"
+            self.output.append(f"\n```{lang}\n")
+        elif tag == "ul":
+            self.list_depth += 1
+            self.output.append("\n")
+        elif tag == "ol":
+            self.list_depth += 1
+            self.ordered_list_counters.append(1)
+            self.output.append("\n")
+        elif tag == "li":
+            indent = "  " * (self.list_depth - 1)
+            if self.ordered_list_counters:
+                num = self.ordered_list_counters[-1]
+                self.output.append(f"{indent}{num}. ")
+                self.ordered_list_counters[-1] += 1
+            else:
+                self.output.append(f"{indent}- ")
+        elif tag == "a":
+            self.link_href = attrs_dict.get("href")
+            self.output.append("[")
+        elif tag == "img":
+            alt = attrs_dict.get("alt", "image")
+            src = attrs_dict.get("src", "")
+            self.output.append(f"![{alt}]({src})")
+        elif tag == "blockquote":
+            self.output.append("\n> ")
+        elif tag == "hr":
+            self.output.append("\n---\n")
+        elif tag == "table":
+            self.output.append("\n")
+        elif tag == "th":
+            self.output.append("| ")
+        elif tag == "td":
+            self.output.append("| ")
+        elif tag == "tr":
+            pass  # Handled in endtag
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in ("script", "style", "nav", "footer", "header", "aside"):
+            self.skip_content = False
+            return
+
+        if tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
+            self.output.append("\n")
+        elif tag == "strong" or tag == "b":
+            self.output.append("**")
+        elif tag == "em" or tag == "i":
+            self.output.append("*")
+        elif tag == "code" and not self.in_pre:
+            self.output.append("`")
+            self.in_code_block = False
+        elif tag == "pre":
+            self.in_pre = False
+            self.output.append("\n```\n")
+        elif tag == "ul":
+            self.list_depth = max(0, self.list_depth - 1)
+        elif tag == "ol":
+            self.list_depth = max(0, self.list_depth - 1)
+            if self.ordered_list_counters:
+                self.ordered_list_counters.pop()
+        elif tag == "li":
+            self.output.append("\n")
+        elif tag == "a":
+            if self.link_href:
+                self.output.append(f"]({self.link_href})")
+            else:
+                self.output.append("]")
+            self.link_href = None
+        elif tag == "p":
+            self.output.append("\n")
+        elif tag == "blockquote":
+            self.output.append("\n")
+        elif tag == "tr":
+            self.output.append("|\n")
+        elif tag == "thead":
+            # Add markdown table separator after header row
+            self.output.append("|---" * 10 + "|\n")
+
+    def handle_data(self, data: str) -> None:
+        if self.skip_content:
+            return
+        # Preserve whitespace in code blocks
+        if self.in_pre:
+            self.output.append(data)
+        else:
+            # Collapse whitespace outside code
+            text = re.sub(r"\s+", " ", data)
+            if text.strip():
+                self.output.append(text)
+
+    def get_markdown(self) -> str:
+        """Get the converted markdown, cleaned up."""
+        md = "".join(self.output)
+        # Clean up excessive newlines
+        md = re.sub(r"\n{3,}", "\n\n", md)
+        # Clean up empty table separators
+        md = re.sub(r"\|---\|---.*\|\n(?!\|)", "", md)
+        return md.strip()
+
+
+def _html_to_markdown(html: str) -> str:
+    """Convert HTML to Markdown."""
+    parser = _HTMLToMarkdown()
+    parser.feed(html)
+    return parser.get_markdown()
+
+
 def _download_nvidia_md(config: CorpusConfig, dest: Path, verbose: bool = True) -> int:
-    """Download NVIDIA docs using .md endpoint."""
+    """Download NVIDIA docs and convert HTML to Markdown.
+
+    NVIDIA's .md endpoint no longer works, so we scrape HTML and convert to markdown.
+    """
     assert config.urls is not None
     downloaded = 0
     with httpx.Client(timeout=30.0, follow_redirects=True) as client:
         for url in config.urls:
-            md_url = f"{url}.md"
             filepath = _url_to_filepath(url, dest)
             filepath.parent.mkdir(parents=True, exist_ok=True)
             try:
-                resp = client.get(md_url)
+                # Fetch HTML page directly
+                resp = client.get(url)
                 resp.raise_for_status()
-                filepath.write_text(resp.text)
+
+                # Convert HTML to Markdown
+                markdown = _html_to_markdown(resp.text)
+
+                # Add source URL as header
+                content = f"<!-- Source: {url} -->\n\n{markdown}"
+                filepath.write_text(content)
                 downloaded += 1
                 if verbose:
                     print(f"  ✓ {filepath.relative_to(dest)}")
@@ -275,6 +486,25 @@ def _download_github_multi_repo(config: CorpusConfig, dest: Path, verbose: bool
     return downloaded
 
 
+def _download_mixed(config: CorpusConfig, dest: Path, verbose: bool = True) -> int:
+    """Download from mixed sources (NVIDIA docs + GitHub repos)."""
+    total = 0
+
+    # Download NVIDIA markdown docs (urls)
+    if config.urls:
+        if verbose:
+            print("  [NVIDIA docs]")
+        total += _download_nvidia_md(config, dest, verbose)
+
+    # Download GitHub repos
+    if config.repos:
+        if verbose:
+            print("  [GitHub repos]")
+        total += _download_github_multi_repo(config, dest, verbose)
+
+    return total
+
+
 def download_corpus(name: CorpusName, force: bool = False, verbose: bool = True) -> Path:
     """Download a corpus to local cache.
 
@@ -311,6 +541,8 @@ def download_corpus(name: CorpusName, force: bool = False, verbose: bool = True)
         count = _download_github_repo(config, dest, verbose)
     elif config.source_type == "github_multi_repo":
         count = _download_github_multi_repo(config, dest, verbose)
+    elif config.source_type == "mixed":
+        count = _download_mixed(config, dest, verbose)
     else:
         raise ValueError(f"Unknown source type: {config.source_type}")
     if verbose: