wafer-cli 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

wafer/analytics.py

@@ -15,7 +15,6 @@ Usage:
 
 import atexit
 import platform
-import sys
 import uuid
 from pathlib import Path
 from typing import Any

wafer/auth.py

@@ -419,7 +419,7 @@ def device_code_login(timeout: int = 600) -> tuple[str, str | None]:
                     print(f" {CROSS}\n")
                     raise RuntimeError(f"CLI auth flow failed: {response.status_code} {response.text}")
 
-                except httpx.RequestError as e:
+                except httpx.RequestError:
                     # Network error, retry
                     print("!", end="", flush=True)
                     last_poll = time.time()

wafer/autotuner.py

@@ -5,6 +5,7 @@ This module provides the implementation for the `wafer autotuner` commands.
 
 import asyncio
 import json
+from datetime import UTC
 from pathlib import Path
 from typing import Any
 
@@ -32,13 +33,14 @@ def run_sweep_command(
         raise FileNotFoundError(f"Config file not found: {config_file}")
 
     # Import autotuner core
-    from datetime import datetime, timezone
+    from datetime import datetime
     from uuid import uuid4
+
     import trio
     from wafer_core.tools.autotuner import AutotunerConfig, run_sweep
     from wafer_core.tools.autotuner.dtypes import Sweep, Trial
     from wafer_core.tools.autotuner.search import generate_grid_trials
-    from wafer_core.tools.autotuner.storage import create_sweep, add_trial, get_sweep, get_trials
+    from wafer_core.tools.autotuner.storage import add_trial, create_sweep, get_sweep, get_trials
 
     # Load or reconstruct config
     if resume_sweep_id:
@@ -189,8 +191,8 @@ def run_sweep_command(
                     status="running",
                     total_trials=total_trials,
                     completed_trials=0,
-                    created_at=datetime.now(timezone.utc),
-                    updated_at=datetime.now(timezone.utc),
+                    created_at=datetime.now(UTC),
+                    updated_at=datetime.now(UTC),
                 )
 
                 # Create sweep and get the actual ID from the API
@@ -245,7 +247,7 @@ def run_sweep_command(
             # Helper to update sweep status
             async def update_sweep_status(status: str) -> None:
                 import httpx
-                from wafer_core.tools.autotuner.storage import get_api_url, _get_auth_headers
+                from wafer_core.tools.autotuner.storage import _get_auth_headers, get_api_url
 
                 api_url = get_api_url()
                 headers = _get_auth_headers()
@@ -260,7 +262,7 @@ def run_sweep_command(
             # Note: working_dir already set based on is_resume flag
 
             try:
-                trials = await run_sweep(
+                await run_sweep(
                     config=config,
                     sweep_id=actual_sweep_id,
                     working_dir=working_dir,
@@ -273,7 +275,7 @@ def run_sweep_command(
 
                 # Print final summary
                 print()
-                print(f"✅ Sweep completed!")
+                print("✅ Sweep completed!")
                 print(f"   Total: {total_trials} trials")
                 print(f"   Success: {success_count}")
                 print(f"   Failed: {failed_count}")
@@ -297,7 +299,7 @@ def run_sweep_command(
             except KeyboardInterrupt:
                 # User pressed Ctrl+C
                 print()
-                print(f"❌ Sweep interrupted by user (Ctrl+C)")
+                print("❌ Sweep interrupted by user (Ctrl+C)")
                 print(f"   Completed: {completed_count}/{total_trials} trials")
                 await update_sweep_status("failed")
                 raise
@@ -350,8 +352,8 @@ def results_command(
         Formatted string with results
     """
     from wafer_core.tools.autotuner import compute_pareto_frontier
-    from wafer_core.tools.autotuner.storage import get_sweep, get_trials
     from wafer_core.tools.autotuner.aggregation import aggregate_trials_by_config
+    from wafer_core.tools.autotuner.storage import get_sweep, get_trials
 
     try:
         # Get sweep and trials
@@ -501,7 +503,10 @@ def results_command(
                     # Use aggregated config scoring
                     if len(objectives_data) > 1:
                         # Multi-objective: compute Pareto
-                        from wafer_core.tools.autotuner.scoring import compute_pareto_frontier_configs, rank_pareto_configs
+                        from wafer_core.tools.autotuner.scoring import (
+                            compute_pareto_frontier_configs,
+                            rank_pareto_configs,
+                        )
                         objectives = [
                             Objective(
                                 metric=obj["metric"],
@@ -513,7 +518,7 @@ def results_command(
                         pareto_configs = compute_pareto_frontier_configs(aggregated_configs, objectives)
                         ranked_configs = rank_pareto_configs(pareto_configs, objectives)
 
-                        lines.append(f"Pareto Frontier (using config objectives):")
+                        lines.append("Pareto Frontier (using config objectives):")
                         lines.append(f"Found {len(ranked_configs)} non-dominated configurations.")
                         lines.append("")
 
@@ -563,7 +568,7 @@ def results_command(
                         ]
                         pareto_trials = compute_pareto_frontier(completed_trials, objectives)
 
-                        lines.append(f"Pareto Frontier (using config objectives):")
+                        lines.append("Pareto Frontier (using config objectives):")
                         lines.append(f"Found {len(pareto_trials)} non-dominated configurations.")
                         lines.append("")
 
@@ -699,8 +704,8 @@ def best_command(
     Returns:
         Formatted string with best config
     """
-    from wafer_core.tools.autotuner.storage import get_sweep, get_trials
     from wafer_core.tools.autotuner.aggregation import aggregate_trials_by_config
+    from wafer_core.tools.autotuner.storage import get_sweep, get_trials
 
     try:
         # Get sweep and trials
@@ -991,7 +996,7 @@ def delete_command(sweep_id: str) -> str:
         Success message
     """
     import httpx
-    from wafer_core.tools.autotuner.storage import get_api_url, _get_auth_headers
+    from wafer_core.tools.autotuner.storage import _get_auth_headers, get_api_url
 
     try:
         api_url = get_api_url()
@@ -1008,8 +1013,7 @@ def delete_command(sweep_id: str) -> str:
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 404:
             raise ValueError(f"Sweep {sweep_id} not found")
-        else:
-            raise ValueError(f"Failed to delete sweep: {e}")
+        raise ValueError(f"Failed to delete sweep: {e}")
     except Exception as e:
         raise ValueError(f"Failed to delete sweep: {e}") from e
 
@@ -1024,7 +1028,7 @@ def delete_all_command(status_filter: str | None = None) -> str:
         Summary of deletions
     """
     import httpx
-    from wafer_core.tools.autotuner.storage import list_sweeps, get_api_url, _get_auth_headers
+    from wafer_core.tools.autotuner.storage import _get_auth_headers, get_api_url, list_sweeps
 
     try:
         # Get all sweeps

wafer/cli.py

@@ -1805,6 +1805,18 @@ def kernelbench_evaluate(  # noqa: PLR0913, PLR0915
         True, "--sync-artifacts/--no-sync-artifacts", help="Download artifacts"
     ),
     gpu_id: int | None = typer.Option(None, "--gpu-id", help="Override GPU ID"),
+    stages: str = typer.Option(
+        "compile,correctness",
+        "--stages",
+        help="Comma-separated stages to run: compile, correctness, benchmark, defense. "
+        "Use 'all' for compile,correctness,benchmark,defense. Default: compile,correctness",
+    ),
+    prepare_only: bool = typer.Option(
+        False,
+        "--prepare-only",
+        help="Sync files and generate eval script but don't run. "
+        "Prints the command to run manually (useful for wrapping with rocprof, etc.)",
+    ),
     json_output: bool = typer.Option(
         False, "--json", help="Output as single JSON object (machine-readable)"
     ),
@@ -1912,18 +1924,42 @@ def kernelbench_evaluate(  # noqa: PLR0913, PLR0915
 
     collector.target = resolved_target
 
+    # Expand 'all' stages shorthand
+    resolved_stages = stages
+    if stages == "all":
+        resolved_stages = "compile,correctness,benchmark,defense"
+
+    # Handle backward compat: --benchmark and --defensive flags add to stages
+    stage_set = set(resolved_stages.split(","))
+    if benchmark and "benchmark" not in stage_set:
+        stage_set.add("benchmark")
+    if defensive and "defense" not in stage_set:
+        stage_set.add("defense")
+    resolved_stages = ",".join(
+        sorted(
+            stage_set,
+            key=lambda s: (
+                ["compile", "correctness", "benchmark", "defense"].index(s)
+                if s in ["compile", "correctness", "benchmark", "defense"]
+                else 99
+            ),
+        )
+    )
+
     args = KernelBenchEvaluateArgs(
         implementation=implementation,
         reference=reference,
         target_name=resolved_target,
-        benchmark=benchmark,
+        benchmark=benchmark or "benchmark" in stage_set,
         profile=profile,
         inputs=inputs,
         seed=seed,
-        defensive=defensive,
+        defensive=defensive or "defense" in stage_set,
         backend=backend,
         sync_artifacts=sync_artifacts,
         gpu_id=gpu_id,
+        stages=resolved_stages,
+        prepare_only=prepare_only,
     )
 
     collector.emit("started", target=resolved_target)
@@ -1955,7 +1991,9 @@ def kernelbench_evaluate(  # noqa: PLR0913, PLR0915
         collector.output_text_result(result)
         collector.finalize()
 
-        if not result.all_correct:
+        # For prepare-only mode, success means we prepared successfully (don't check correctness)
+        # For compile-only (all_correct is None), also treat as success
+        if not prepare_only and result.all_correct is not None and not result.all_correct:
             raise typer.Exit(1)
     else:
         collector.output_text_error(result.error_message or "Unknown error")

wafer/evaluate.py

@@ -21,7 +21,6 @@ from wafer_core.utils.kernel_utils.targets.config import (
     WorkspaceTarget,
 )
 
-
 # Map AMD compute capability to ROCm architecture
 # Used to set PYTORCH_ROCM_ARCH for faster compilation (compile only for target arch)
 AMD_CC_TO_ARCH = {
@@ -189,6 +188,8 @@ class KernelBenchEvaluateArgs:
     backend: str | None = None  # Kernel backend for static validation
     sync_artifacts: bool = True
     gpu_id: int | None = None
+    stages: str = "compile,correctness"  # Stages to run: compile, correctness, benchmark, defense
+    prepare_only: bool = False  # Sync files and generate script but don't run
 
 
 @dataclass(frozen=True)
@@ -196,7 +197,7 @@ class EvaluateResult:
     """Result from remote evaluation."""
 
     success: bool
-    all_correct: bool
+    all_correct: bool | None  # None when correctness wasn't checked (compile-only, prepare-only)
     correctness_score: float
     geomean_speedup: float
     passed_tests: int
@@ -3066,8 +3067,18 @@ def main():
     parser.add_argument("--num-correct-trials", type=int, default=3)
     parser.add_argument("--num-perf-trials", type=int, default=10)
     parser.add_argument("--output", required=True)
+    parser.add_argument("--stages", default="compile,correctness",
+                        help="Comma-separated stages: compile, correctness, benchmark, defense")
     args = parser.parse_args()
 
+    # Parse stages
+    stages = set(args.stages.split(","))
+    run_compile = "compile" in stages
+    run_correctness = "correctness" in stages
+    run_benchmark = "benchmark" in stages or args.benchmark
+    run_defense = "defense" in stages or args.defensive
+    print(f"[KernelBench] Stages: {args.stages}")
+
     # Load defense module if defensive mode is enabled
     defense_module = None
     if args.defensive and args.defense_module:
@@ -3156,64 +3167,69 @@ def main():
             new_model = ModelNew(*init_inputs).cuda().eval()
         print(f"[KernelBench] Models instantiated (seed={seed})")
 
-        # Run correctness trials
+        # Run correctness trials (if stage enabled)
         all_correct = True
-        for trial in range(args.num_correct_trials):
-            inputs = get_inputs()
-            inputs = [x.cuda() if isinstance(x, torch.Tensor) else x for x in inputs]
-
-            with torch.no_grad():
-                ref_output = ref_model(*inputs)
-                new_output = new_model(*inputs)
-
-            # Compare outputs
-            if isinstance(ref_output, torch.Tensor):
-                if not torch.allclose(ref_output, new_output, rtol=1e-3, atol=1e-3):
-                    all_correct = False
-                    analysis = analyze_diff(ref_output, new_output)
-                    results["error"] = f"Correctness failed on trial {trial+1}: max diff = {analysis['max_diff']}"
-                    results["diff_analysis"] = analysis
-                    print_diff_analysis(analysis)
-
-                    # Save tensors for debugging
-                    debug_dir = output_dir / "debug"
-                    debug_dir.mkdir(exist_ok=True)
-                    torch.save(ref_output.cpu(), debug_dir / "ref_output.pt")
-                    torch.save(new_output.cpu(), debug_dir / "impl_output.pt")
-                    torch.save(inputs[0].cpu() if inputs else None, debug_dir / "input.pt")
-                    print(f"[KernelBench] Debug tensors saved to: {debug_dir}/")
-                    break
-            else:
-                # Handle tuple/list outputs
-                for i, (r, n) in enumerate(zip(ref_output, new_output)):
-                    if isinstance(r, torch.Tensor):
-                        if not torch.allclose(r, n, rtol=1e-3, atol=1e-3):
-                            all_correct = False
-                            analysis = analyze_diff(r, n)
-                            results["error"] = f"Correctness failed on trial {trial+1}, output {i}: max diff = {analysis['max_diff']}"
-                            results["diff_analysis"] = analysis
-                            print_diff_analysis(analysis)
-
-                            # Save tensors for debugging
-                            debug_dir = output_dir / "debug"
-                            debug_dir.mkdir(exist_ok=True)
-                            torch.save(r.cpu(), debug_dir / f"ref_output_{i}.pt")
-                            torch.save(n.cpu(), debug_dir / f"impl_output_{i}.pt")
-                            print(f"[KernelBench] Debug tensors saved to: {debug_dir}/")
-                            break
-                if not all_correct:
-                    break
+        if not run_correctness:
+            print("[KernelBench] Skipping correctness (not in stages)")
+            results["correct"] = None  # Unknown - not checked
+        else:
+            for trial in range(args.num_correct_trials):
+                inputs = get_inputs()
+                inputs = [x.cuda() if isinstance(x, torch.Tensor) else x for x in inputs]
+
+                with torch.no_grad():
+                    ref_output = ref_model(*inputs)
+                    new_output = new_model(*inputs)
+
+                # Compare outputs
+                if isinstance(ref_output, torch.Tensor):
+                    if not torch.allclose(ref_output, new_output, rtol=1e-3, atol=1e-3):
+                        all_correct = False
+                        analysis = analyze_diff(ref_output, new_output)
+                        results["error"] = f"Correctness failed on trial {trial+1}: max diff = {analysis['max_diff']}"
+                        results["diff_analysis"] = analysis
+                        print_diff_analysis(analysis)
+
+                        # Save tensors for debugging
+                        debug_dir = output_dir / "debug"
+                        debug_dir.mkdir(exist_ok=True)
+                        torch.save(ref_output.cpu(), debug_dir / "ref_output.pt")
+                        torch.save(new_output.cpu(), debug_dir / "impl_output.pt")
+                        torch.save(inputs[0].cpu() if inputs else None, debug_dir / "input.pt")
+                        print(f"[KernelBench] Debug tensors saved to: {debug_dir}/")
+                        break
+                else:
+                    # Handle tuple/list outputs
+                    for i, (r, n) in enumerate(zip(ref_output, new_output)):
+                        if isinstance(r, torch.Tensor):
+                            if not torch.allclose(r, n, rtol=1e-3, atol=1e-3):
+                                all_correct = False
+                                analysis = analyze_diff(r, n)
+                                results["error"] = f"Correctness failed on trial {trial+1}, output {i}: max diff = {analysis['max_diff']}"
+                                results["diff_analysis"] = analysis
+                                print_diff_analysis(analysis)
+
+                                # Save tensors for debugging
+                                debug_dir = output_dir / "debug"
+                                debug_dir.mkdir(exist_ok=True)
+                                torch.save(r.cpu(), debug_dir / f"ref_output_{i}.pt")
+                                torch.save(n.cpu(), debug_dir / f"impl_output_{i}.pt")
+                                print(f"[KernelBench] Debug tensors saved to: {debug_dir}/")
+                                break
+                    if not all_correct:
+                        break
 
-        results["correct"] = all_correct
-        print(f"[KernelBench] Correctness: {all_correct}")
+            results["correct"] = all_correct
+            print(f"[KernelBench] Correctness: {all_correct}")
 
-        # Run benchmark if requested and correctness passed
-        if args.benchmark and all_correct:
+        # Run benchmark if stage enabled (and correctness passed or skipped)
+        should_benchmark = run_benchmark and (all_correct or not run_correctness)
+        if should_benchmark:
             print("[KernelBench] Running benchmarks...")
             inputs = get_inputs()
             inputs = [x.cuda() if isinstance(x, torch.Tensor) else x for x in inputs]
 
-            if args.defensive and defense_module is not None:
+            if run_defense and defense_module is not None:
                 # Use full defense suite
                 print("[KernelBench] Running defense checks on implementation...")
                 run_all_defenses = defense_module.run_all_defenses
@@ -3598,6 +3614,7 @@ async def run_evaluate_kernelbench_docker(
             python_cmd_parts.append("--defensive")
             python_cmd_parts.append(f"--defense-module {container_defense_path}")
         python_cmd_parts.append(f"--seed {args.seed}")
+        python_cmd_parts.append(f"--stages {args.stages}")
 
         eval_cmd = " ".join(python_cmd_parts)
 
@@ -3869,6 +3886,7 @@ async def run_evaluate_kernelbench_digitalocean(
                     python_cmd_parts.append("--defensive")
                     python_cmd_parts.append(f"--defense-module {container_defense_path}")
                 python_cmd_parts.append(f"--seed {args.seed}")
+                python_cmd_parts.append(f"--stages {args.stages}")
 
                 eval_cmd = " ".join(python_cmd_parts)
 
@@ -4124,6 +4142,7 @@ async def run_evaluate_kernelbench_runpod(
                     python_cmd_parts.append("--defensive")
                     python_cmd_parts.append(f"--defense-module {defense_module_path}")
                 python_cmd_parts.append(f"--seed {args.seed}")
+                python_cmd_parts.append(f"--stages {args.stages}")
 
                 eval_cmd = " ".join(python_cmd_parts)
 
@@ -4134,6 +4153,26 @@ async def run_evaluate_kernelbench_runpod(
                 env_vars = f"HIP_VISIBLE_DEVICES={gpu_id} ROCM_PATH=/opt/rocm PYTHONUNBUFFERED=1 {arch_env}"
                 full_cmd = f"cd {run_path} && {env_vars} {eval_cmd}"
 
+                # Handle prepare-only mode
+                if args.prepare_only:
+                    print(f"\n[wafer] Prepared evaluation at: {run_path}")
+                    print(f"[wafer] Target: {target.name} ({client.host}:{client.port})")
+                    print("[wafer] To run manually:")
+                    print(f"  ssh -p {client.port} root@{client.host} '{full_cmd}'")
+                    print("\n[wafer] Or wrap with rocprof:")
+                    print(
+                        f"  ssh -p {client.port} root@{client.host} 'cd {run_path} && {env_vars} rocprof -i counters.txt {eval_cmd}'"
+                    )
+                    return EvaluateResult(
+                        success=True,
+                        all_correct=None,  # Not checked in prepare-only mode
+                        correctness_score=0.0,
+                        geomean_speedup=0.0,
+                        passed_tests=0,
+                        total_tests=0,
+                        error_message=None,
+                    )
+
                 # Run and stream output
                 log_lines = []
                 async for line in client.exec_stream(full_cmd):
@@ -4361,6 +4400,7 @@ async def run_evaluate_kernelbench_baremetal_amd(
             python_cmd_parts.append("--defensive")
             python_cmd_parts.append(f"--defense-module {defense_module_path}")
         python_cmd_parts.append(f"--seed {args.seed}")
+        python_cmd_parts.append(f"--stages {args.stages}")
 
         eval_cmd = " ".join(python_cmd_parts)
 
@@ -4371,6 +4411,26 @@ async def run_evaluate_kernelbench_baremetal_amd(
         env_vars = f"HIP_VISIBLE_DEVICES={gpu_id} ROCM_PATH=/opt/rocm PYTHONUNBUFFERED=1 {arch_env}"
         full_cmd = f"cd {run_path} && {env_vars} {eval_cmd}"
 
+        # Handle prepare-only mode
+        if args.prepare_only:
+            print(f"\n[wafer] Prepared evaluation at: {run_path}")
+            print(f"[wafer] Target: {target.name} ({client.host}:{client.port})")
+            print("[wafer] To run manually:")
+            print(f"  ssh -p {client.port} root@{client.host} '{full_cmd}'")
+            print("\n[wafer] Or wrap with rocprof:")
+            print(
+                f"  ssh -p {client.port} root@{client.host} 'cd {run_path} && {env_vars} rocprof -i counters.txt {eval_cmd}'"
+            )
+            return EvaluateResult(
+                success=True,
+                all_correct=None,  # Not checked in prepare-only mode
+                correctness_score=0.0,
+                geomean_speedup=0.0,
+                passed_tests=0,
+                total_tests=0,
+                error_message=None,
+            )
+
         # Run and stream output
         log_lines = []
         async for line in client.exec_stream(full_cmd):

wafer/kernel_scope.py

@@ -10,10 +10,8 @@ It supports analysis of:
 Design: Wafer-436 - AMD Kernel Scope / ISA Analyzer
 """
 
-import json
 import sys
 from pathlib import Path
-from typing import Optional
 
 
 def print_usage() -> None:
@@ -54,11 +52,11 @@ def analyze_command(
     json_output: bool = False,
     csv_output: bool = False,
     recursive: bool = True,
-    filter_expr: Optional[str] = None,
-    output_file: Optional[str] = None,
+    filter_expr: str | None = None,
+    output_file: str | None = None,
     kernel_index: int = 0,
-    api_url: Optional[str] = None,
-    auth_headers: Optional[dict[str, str]] = None,
+    api_url: str | None = None,
+    auth_headers: dict[str, str] | None = None,
 ) -> str:
     """Analyze ISA/LLVM-IR/TTGIR/.co file or directory.
 
@@ -77,10 +75,10 @@ def analyze_command(
         Analysis output string
     """
     from wafer_core.lib.kernel_scope import (
-        analyze_isa_file,
         analyze_code_object,
         analyze_directory,
         analyze_file,
+        analyze_isa_file,
     )
 
     target_path = Path(path).expanduser()
@@ -249,7 +247,7 @@ def _result_to_text(result) -> str:
         lines.extend([
             f"Kernel: {a.kernel_name}",
             f"Architecture: {a.architecture}",
-            f"Source: Code Object (.co)",
+            "Source: Code Object (.co)",
             "",
             "=== Registers ===",
             f"  VGPRs: {a.vgpr_count}",
@@ -289,7 +287,7 @@ def _result_to_text(result) -> str:
         lines.extend([
             f"Kernel: {a.kernel_name}",
             f"Architecture: {a.architecture}",
-            f"Source: ISA Assembly (.s)",
+            "Source: ISA Assembly (.s)",
             "",
             "=== Registers ===",
             f"  VGPRs: {a.vgpr_count}",

wafer/nsys_profile.py

@@ -18,7 +18,6 @@ from .nsys_analyze import (
     NSYSAnalysisResult,
     _find_nsys,
     _get_install_command,
-    _get_platform,
     _parse_target,
     is_macos,
 )
@@ -316,11 +315,11 @@ def profile_remote_ssh(
     Returns:
         NSYSProfileResult with success status and output path
     """
+    import trio
+
     from .targets import load_target
     from .targets_ops import TargetExecError, exec_on_target_sync, get_target_ssh_info
 
-    import trio
-
     # Load target
     try:
         target_config = load_target(target)

wafer/output.py

@@ -127,10 +127,17 @@ class OutputCollector:
 
         typer.echo("")
         typer.echo("=" * 60)
-        status = "PASS" if result.all_correct else "FAIL"
+        # Handle None (correctness not run), True (pass), False (fail)
+        if result.all_correct is None:
+            status = "OK"  # Correctness wasn't checked (e.g., compile-only or prepare-only)
+        elif result.all_correct:
+            status = "PASS"
+        else:
+            status = "FAIL"
         typer.echo(f"Result: {status}")
-        score_pct = f"{result.correctness_score:.1%}"
-        typer.echo(f"Correctness: {result.passed_tests}/{result.total_tests} ({score_pct})")
+        if result.total_tests > 0:
+            score_pct = f"{result.correctness_score:.1%}"
+            typer.echo(f"Correctness: {result.passed_tests}/{result.total_tests} ({score_pct})")
         if result.geomean_speedup > 0:
             typer.echo(f"Speedup: {result.geomean_speedup:.2f}x")
         typer.echo("=" * 60)

wafer/rocprof_compute.py

@@ -15,8 +15,8 @@ Architecture follows similar patterns from the codebase.
 import json
 import subprocess
 import sys
-from pathlib import Path
 from dataclasses import asdict
+from pathlib import Path
 
 
 def print_usage() -> None:
@@ -67,9 +67,12 @@ def check_command(json_output: bool = False) -> str:
     Returns:
         Status message or JSON string
     """
-    from wafer_core.lib.rocprofiler.compute import check_installation as core_check  # pragma: no cover
     from dataclasses import asdict
 
+    from wafer_core.lib.rocprofiler.compute import (
+        check_installation as core_check,  # pragma: no cover
+    )
+
     result = core_check()
 
     if json_output:
@@ -77,27 +80,27 @@ def check_command(json_output: bool = False) -> str:
         return json.dumps(result_dict, indent=2)
     else:
         if result.installed:
-            print(f"✓ rocprof-compute is installed", file=sys.stderr)
+            print("✓ rocprof-compute is installed", file=sys.stderr)
             if result.path:
                 print(f"  Path: {result.path}", file=sys.stderr)
             if result.version:
                 print(f"  Version: {result.version}", file=sys.stderr)
             return "rocprof-compute is installed"
         else:
-            print(f"✗ rocprof-compute is not installed", file=sys.stderr)
-            print(f"", file=sys.stderr)
-            print(f"rocprof-compute is required to use this feature.", file=sys.stderr)
-            print(f"", file=sys.stderr)
-            print(f"Installation options:", file=sys.stderr)
-            print(f"  1. Install ROCm toolkit (includes rocprof-compute):", file=sys.stderr)
-            print(f"     sudo apt-get install rocm-dev", file=sys.stderr)
-            print(f"", file=sys.stderr)
-            print(f"  2. Install rocprofiler-compute package:", file=sys.stderr)
-            print(f"     sudo apt-get install rocprofiler-compute", file=sys.stderr)
-            print(f"", file=sys.stderr)
-            print(f"  3. Add ROCm to PATH if already installed:", file=sys.stderr)
-            print(f"     export PATH=/opt/rocm/bin:$PATH", file=sys.stderr)
-            print(f"", file=sys.stderr)
+            print("✗ rocprof-compute is not installed", file=sys.stderr)
+            print("", file=sys.stderr)
+            print("rocprof-compute is required to use this feature.", file=sys.stderr)
+            print("", file=sys.stderr)
+            print("Installation options:", file=sys.stderr)
+            print("  1. Install ROCm toolkit (includes rocprof-compute):", file=sys.stderr)
+            print("     sudo apt-get install rocm-dev", file=sys.stderr)
+            print("", file=sys.stderr)
+            print("  2. Install rocprofiler-compute package:", file=sys.stderr)
+            print("     sudo apt-get install rocprofiler-compute", file=sys.stderr)
+            print("", file=sys.stderr)
+            print("  3. Add ROCm to PATH if already installed:", file=sys.stderr)
+            print("     export PATH=/opt/rocm/bin:$PATH", file=sys.stderr)
+            print("", file=sys.stderr)
             if result.install_command:
                 print(f"Suggested command: {result.install_command}", file=sys.stderr)
             return "rocprof-compute is not installed"
@@ -105,9 +108,12 @@ def check_command(json_output: bool = False) -> str:
 
 def check_installation() -> dict:
     """Legacy function for backward compatibility."""
-    from wafer_core.lib.rocprofiler.compute import check_installation as core_check  # pragma: no cover
     from dataclasses import asdict
 
+    from wafer_core.lib.rocprofiler.compute import (
+        check_installation as core_check,  # pragma: no cover
+    )
+
     result = core_check()
     if hasattr(result, "__dataclass_fields__"):
         return asdict(result)
@@ -160,13 +166,13 @@ def gui_command(
         if json_output:
             return json.dumps(result_dict, indent=2)
         else:
-            print(f"Launching bundled rocprof-compute GUI viewer...", file=sys.stderr)
+            print("Launching bundled rocprof-compute GUI viewer...", file=sys.stderr)
             print(f"Folder: {launch_result.folder}", file=sys.stderr)
             print(f"Port: {launch_result.port}", file=sys.stderr)
             print(f"URL: {launch_result.url}", file=sys.stderr)
-            print(f"", file=sys.stderr)
+            print("", file=sys.stderr)
             print(f"Open {launch_result.url} in your browser", file=sys.stderr)
-            print(f"Press Ctrl+C to stop the server", file=sys.stderr)
+            print("Press Ctrl+C to stop the server", file=sys.stderr)
 
             # The launch_gui_server with background=False is blocking, so we never reach here
             # unless there's an error
@@ -186,7 +192,7 @@ def gui_command(
         if json_output:
             return json.dumps(result_dict, indent=2)
         else:
-            print(f"Launching external rocprof-compute GUI...", file=sys.stderr)
+            print("Launching external rocprof-compute GUI...", file=sys.stderr)
             print(f"Folder: {launch_result.folder}", file=sys.stderr)
             print(f"Port: {launch_result.port}", file=sys.stderr)
             print(f"URL: {launch_result.url}", file=sys.stderr)
@@ -247,9 +253,10 @@ def profile_command(
     Raises:
         RuntimeError: If profiling fails
     """
-    from wafer_core.lib.rocprofiler.compute import run_profile  # pragma: no cover
     import shlex
 
+    from wafer_core.lib.rocprofiler.compute import run_profile  # pragma: no cover
+
     # Parse command string
     cmd_list = shlex.split(command)
 
@@ -276,30 +283,30 @@ def profile_command(
         return json.dumps(result_dict, indent=2)
     else:
         if result.success:
-            print(f"✓ Profiling completed", file=sys.stderr)
+            print("✓ Profiling completed", file=sys.stderr)
             if result.workload_path:
                 print(f"  Workload: {result.workload_path}", file=sys.stderr)
             if result.output_files:
                 print(f"  Generated {len(result.output_files)} files", file=sys.stderr)
             return f"Results in: {result.workload_path}"
         else:
-            print(f"✗ Profiling failed", file=sys.stderr)
-            print(f"", file=sys.stderr)
+            print("✗ Profiling failed", file=sys.stderr)
+            print("", file=sys.stderr)
 
             # Show stderr output (contains actual error details)
             # Note: rocprof-compute may write errors to stdout instead of stderr
             error_output = result.stderr or result.stdout
             if error_output and error_output.strip():
-                print(f"rocprof-compute output:", file=sys.stderr)
-                print(f"─" * 60, file=sys.stderr)
+                print("rocprof-compute output:", file=sys.stderr)
+                print("─" * 60, file=sys.stderr)
                 print(error_output.strip(), file=sys.stderr)
-                print(f"─" * 60, file=sys.stderr)
-                print(f"", file=sys.stderr)
+                print("─" * 60, file=sys.stderr)
+                print("", file=sys.stderr)
 
             # Show command that was run
             if result.command:
                 print(f"Command: {' '.join(result.command)}", file=sys.stderr)
-                print(f"", file=sys.stderr)
+                print("", file=sys.stderr)
 
             # Show high-level error
             if result.error:
@@ -359,7 +366,7 @@ def analyze_command(
     Raises:
         RuntimeError: If analysis fails
     """
-    from wafer_core.lib.rocprofiler.compute import run_analysis, parse_workload  # pragma: no cover
+    from wafer_core.lib.rocprofiler.compute import parse_workload, run_analysis  # pragma: no cover
 
     # If GUI mode, delegate to GUI launch
     if gui:
@@ -396,23 +403,23 @@ def analyze_command(
         # Just return success message
         return "Analysis completed"
     else:
-        print(f"✗ Analysis failed", file=sys.stderr)
-        print(f"", file=sys.stderr)
+        print("✗ Analysis failed", file=sys.stderr)
+        print("", file=sys.stderr)
 
         # Show stderr output (contains actual error details)
         # Note: rocprof-compute may write errors to stdout instead of stderr
         error_output = result.stderr or result.stdout
         if error_output and error_output.strip():
-            print(f"rocprof-compute output:", file=sys.stderr)
-            print(f"─" * 60, file=sys.stderr)
+            print("rocprof-compute output:", file=sys.stderr)
+            print("─" * 60, file=sys.stderr)
             print(error_output.strip(), file=sys.stderr)
-            print(f"─" * 60, file=sys.stderr)
-            print(f"", file=sys.stderr)
+            print("─" * 60, file=sys.stderr)
+            print("", file=sys.stderr)
 
         # Show command that was run
         if result.command:
             print(f"Command: {' '.join(result.command)}", file=sys.stderr)
-            print(f"", file=sys.stderr)
+            print("", file=sys.stderr)
 
         # Show high-level error
         if result.error:
@@ -443,10 +450,11 @@ def list_metrics_command(arch: str) -> str:
     Returns:
         Metrics list output
     """
-    from wafer_core.lib.rocprofiler.compute import find_rocprof_compute  # pragma: no cover
-    import subprocess
     import os
     import shutil
+    import subprocess
+
+    from wafer_core.lib.rocprofiler.compute import find_rocprof_compute  # pragma: no cover
 
     rocprof_path = find_rocprof_compute()
     if not rocprof_path:
@@ -475,7 +483,7 @@ def list_metrics_command(arch: str) -> str:
     else:
         print(f"✗ Failed to list metrics for {arch}", file=sys.stderr)
         if result.stderr:
-            print(f"Error output:", file=sys.stderr)
+            print("Error output:", file=sys.stderr)
             print(result.stderr, file=sys.stderr)
         if result.stdout:
             print(result.stdout, file=sys.stderr)

wafer/rocprof_sdk.py

@@ -109,7 +109,7 @@ def list_counters_command() -> str:
         print(output)
         return output
     else:
-        print(f"✗ Failed to list counters", file=sys.stderr)
+        print("✗ Failed to list counters", file=sys.stderr)
         print(f"  {error}", file=sys.stderr)
         raise RuntimeError(error)
 

wafer/targets_ops.py

@@ -12,7 +12,6 @@ getting SSH credentials, and syncing files. It handles:
 from __future__ import annotations
 
 import logging
-import shlex
 import subprocess
 from collections.abc import Callable
 from dataclasses import dataclass, replace

wafer/templates/optimize_kernelbench.py

@@ -0,0 +1,137 @@
+"""Template for KernelBench optimization - matches eval system prompt.
+
+Usage:
+    # Run on a specific problem
+    wafer agent -t optimize-kernelbench \
+        --args reference=/path/to/problem.py \
+        --args pool=kernelbench-pool \
+        --args backend=hip \
+        --json \
+        "Optimize the Softmax kernel"
+
+    # Watch in real-time with JSON streaming
+    wafer agent -t optimize-kernelbench \
+        --args reference=./23_Softmax.py \
+        --json
+
+Variables:
+    - reference: Path to the KernelBench problem file (required)
+    - pool: Target pool name (default: kernelbench-pool)
+    - target: Single target name (alternative to pool)
+    - backend: Backend type - hip or cuda (default: hip)
+"""
+
+try:
+    from wafer_core.rollouts.templates import TemplateConfig
+except ImportError:
+    from rollouts.templates import TemplateConfig
+
+# System prompt matches optimize_kernelbench_eval/base_config.py SYSTEM_PROMPT
+SYSTEM_PROMPT = """\
+You are a GPU kernel optimization expert. Your task is to write optimized GPU kernels that are correct and faster than the PyTorch baseline.
+
+IMPORTANT: You do NOT have a local GPU. You MUST use `wafer evaluate kernelbench` to test kernels on remote GPU hardware.
+
+## Kernel Format (KernelBench)
+
+The reference file contains a PyTorch `Model` class. You must write a `ModelNew` class that:
+1. Has the same `__init__` signature as `Model`
+2. Has a `forward()` method with the same input/output signature
+3. Uses custom $backend_upper kernels for the computation (NOT PyTorch ops like F.scaled_dot_product_attention or torch.matmul)
+
+The reference file also provides:
+- `get_inputs()` - generates test inputs for forward()
+- `get_init_inputs()` - generates constructor arguments
+
+## Available Tools
+
+- read(file_path): Read source files
+- write(file_path, content): Write your optimized kernel
+- glob(pattern): Find files by pattern
+- grep(pattern): Search code
+- bash(command): Run shell commands including wafer CLI
+
+## Workflow
+
+1. Read the reference problem file to understand what `Model` does
+2. Analyze the computation and identify optimization opportunities
+3. Write an optimized `ModelNew` class with custom $backend_upper kernels using `__global__` kernel definitions and `torch.utils.cpp_extension.load_inline`
+4. Test with: `wafer evaluate kernelbench $target_flag --backend $backend --impl <your_file.py> --reference <problem.py> --benchmark`
+5. Iterate based on feedback until correct and fast
+
+## Example Command
+
+```bash
+wafer evaluate kernelbench \\
+    $target_flag \\
+    --backend $backend \\
+    --impl optimized_kernel.py \\
+    --reference $reference \\
+    --benchmark
+```
+
+## Profiling Tools (USE THESE!)
+
+When your kernel is slower than expected, use profiling to understand WHY:
+
+- `wafer rocprof profile --impl <file> --reference <ref>` - AMD GPU profiling
+- `wafer nvidia ncu --impl <file> --reference <ref>` - NVIDIA NCU profiling
+
+## CRITICAL: Reactive Debugging
+
+After EVERY `wafer evaluate` call:
+1. Check the speedup result
+2. If speedup < 1.0x (slowdown), STOP and analyze:
+   - Run profiling to identify the bottleneck
+   - Ask: "Why is this slow?" before trying another approach
+3. Don't just try random optimizations - understand the root cause
+
+Your kernel MUST:
+- Pass correctness tests (outputs match reference within tolerance)
+- Achieve speedup > 1.0x over PyTorch baseline
+- Use actual $backend_upper kernels (with `__global__` definitions), NOT PyTorch ops
+
+You MUST run `wafer evaluate kernelbench` to verify your kernel. Your score depends on actual measured results."""
+
+template = TemplateConfig(
+    # Identity
+    name="optimize-kernelbench",
+    description="Optimize KernelBench problems (matches eval system prompt)",
+    # System prompt
+    system_prompt=SYSTEM_PROMPT,
+    # Tools
+    tools=["read", "write", "edit", "glob", "grep", "bash"],
+    bash_allowlist=[
+        "wafer evaluate",
+        "wafer nvidia ncu",
+        "wafer nvidia nsys",
+        "wafer rocprof",
+        "wafer compiler-analyze",
+        "python",
+        "python3",
+        "timeout",
+        "ls",
+        "cat",
+        "head",
+        "tail",
+        "wc",
+        "pwd",
+        "which",
+    ],
+    # Model config - match eval settings
+    model="anthropic/claude-opus-4-5-20251101",
+    max_tokens=8192,
+    # No thinking by default (match eval), can override with --thinking
+    thinking=False,
+    # Multi-turn for iterative optimization
+    single_turn=False,
+    # Template variables
+    defaults={
+        "reference": "./problem.py",
+        "pool": "kernelbench-pool",
+        "target": "",  # If set, overrides pool
+        "backend": "hip",
+        "backend_upper": "HIP",  # Auto-computed from backend
+        "target_flag": "--pool kernelbench-pool",  # Auto-computed
+    },
+)

wafer/wevin_cli.py

@@ -364,9 +364,9 @@ def main(  # noqa: PLR0913, PLR0915
     json_output: bool = False,
 ) -> None:
     """Run wevin agent in-process via rollouts."""
-    import trio
     from dataclasses import asdict
 
+    import trio
     from wafer_core.rollouts import FileSessionStore
 
     session_store = FileSessionStore()

wafer/workspaces.py

@@ -404,8 +404,6 @@ def delete_workspace(workspace_id: str, json_output: bool = False) -> str:
     return f"Deleted workspace: {workspace_id}"
 
 
-
-
 def sync_files(
     workspace_id: str,
     local_path: Path,

{wafer_cli-0.2.13.dist-info → wafer_cli-0.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.13
+Version: 0.2.15
 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.13.dist-info → wafer_cli-0.2.15.dist-info}/RECORD

@@ -1,40 +1,41 @@
 wafer/GUIDE.md,sha256=G6P4aFZslEXiHmVjtTB3_OIpGK5d1tSiqxtawASVUZg,3588
 wafer/__init__.py,sha256=kBM_ONCpU6UUMBOH8Tmg4A88sNFnbaD59o61cJs-uYM,90
-wafer/analytics.py,sha256=Xxw3bbY3XLgedSJPwzIOBJIjyycIiornWCpjoWbTKYU,8190
+wafer/analytics.py,sha256=qLY6Z16usVHFD8TCv7XBuz7l47vXVdXk-qhOzA-hW_8,8179
 wafer/api_client.py,sha256=i_Az2b2llC3DSW8yOL-BKqa7LSKuxOr8hSN40s-oQXY,6313
-wafer/auth.py,sha256=acBVOz-3la6avztDGjtLRopdjNRIqbrV4tRMM1FAmHI,13682
-wafer/autotuner.py,sha256=6gH0Ho7T58EFerMQcHQxshWe3DF4qU7fb5xthAh5SPM,44364
+wafer/auth.py,sha256=nneKUjGwb5ggJEHRdF_GlFkT1ZozHP4kGyuXjhZjtgM,13677
+wafer/autotuner.py,sha256=41WYP41pTDvMijv2h42vm89bcHtDMJXObDlWmn6xpFU,44416
 wafer/billing.py,sha256=jbLB2lI4_9f2KD8uEFDi_ixLlowe5hasC0TIZJyIXRg,7163
-wafer/cli.py,sha256=PaWvp7h130Pct5U6Kx_9_zyy20GDPaIQzri2VIDtv5Q,252625
+wafer/cli.py,sha256=lBBTQCcmKREqZDOQh27qSq8i6NedjHW5oh1JiuT9aho,254241
 wafer/config.py,sha256=h5Eo9_yfWqWGoPNdVQikI9GoZVUeysunSYiixf1mKcw,3411
 wafer/corpus.py,sha256=x5aFhCsTSAtgzFG9AMFpqq92Ej63mXofL-vvvpjj1sM,12913
-wafer/evaluate.py,sha256=Lf_H6Afrdo4k9JOnI27wchFwEteqy73gKt5gLQgaXSE,172671
+wafer/evaluate.py,sha256=bLTfL7jAGQlfqLL39hSGSB7bnBp5THTCY7nl6giVMkQ,176005
 wafer/global_config.py,sha256=fhaR_RU3ufMksDmOohH1OLeQ0JT0SDW1hEip_zaP75k,11345
 wafer/gpu_run.py,sha256=TwqXy72T7f2I7e6n5WWod3xgxCPnDhU0BgLsB4CUoQY,9716
 wafer/inference.py,sha256=tZCO5i05FKY27ewis3CSBHFBeFbXY3xwj0DSjdoMY9s,4314
-wafer/kernel_scope.py,sha256=lQDSTx_IBIhjUOkBCOohB13MV7HjkH_dLcvJRs02DHE,20850
+wafer/kernel_scope.py,sha256=YtnxknAChkJoeU_vIdxiqWsAITGBeabp9OGIK-X32i0,20796
 wafer/ncu_analyze.py,sha256=rAWzKQRZEY6E_CL3gAWUaW3uZ4kvQVZskVCPDpsFJuE,24633
 wafer/nsys_analyze.py,sha256=AhNcjPaapB0QCbqiHRXvyy-ccjevvVwEyxes84D28JU,36124
-wafer/nsys_profile.py,sha256=JNB6EgMlKbLnF0vw0av97BSfZRvT8Zrj2QbwbaUKtdw,15497
-wafer/output.py,sha256=SL8f6AccacGY486bHHxc_zHkFNiqPFWJPycSFGUGWHc,8002
+wafer/nsys_profile.py,sha256=QFBl8pkr8r4uRNdNUO9gY-obj9slqpOgVYFZ_sXu6Nw,15478
+wafer/output.py,sha256=8jw5ifvIMK8ldyBMGW4NhrKvJPl66TV2Y2fJ5Tlhh1I,8293
 wafer/problems.py,sha256=ce2sy10A1nnNUG3VGsseTS8jL7LZsku4dE8zVf9JHQ4,11296
-wafer/rocprof_compute.py,sha256=Tu16Vb05b2grvheFWi1XLGlAr6m48NEDeZoDyw_4Uzw,19885
-wafer/rocprof_sdk.py,sha256=fAYCxpfJa5BZTTkIMBOXg4KsYK4i_wNOKrJJn1ZfypM,10086
+wafer/rocprof_compute.py,sha256=n_yOGZaFbOXna_ghhmYWXeyUoSabgH4KkjlYq38DlHo,19888
+wafer/rocprof_sdk.py,sha256=0Q7Ye6dUfa1anFZbqKc21rItgqva8V8VIZoSB7wqbmA,10085
 wafer/rocprof_systems.py,sha256=4IWbMcbYk1x_8iS7P3FC_u5sgH6EXADCtR2lV9id80M,18629
 wafer/ssh_keys.py,sha256=9kSdhV_dg9T6pQu2JmNQptarkkwGtN9rLyRkI1bW4i4,8094
 wafer/target_lock.py,sha256=SDKhNzv2N7gsphGflcNni9FE5YYuAMuEthngAJEo4Gs,7809
 wafer/targets.py,sha256=9r-iRWoKSH5cQl1LcamaX-T7cNVOg99ngIm_hlRk-qU,26922
-wafer/targets_ops.py,sha256=FJQhlQ4MfOMN5ZNaVfqUvrkRwGjOXI22cNTIEVSKeSE,21488
+wafer/targets_ops.py,sha256=jN1oIBx0mutxRNE9xpIc7SaBxPkVmOyus2eqn0kEKNI,21475
 wafer/tracelens.py,sha256=g9ZIeFyNojZn4uTd3skPqIrRiL7aMJOz_-GOd3aiyy4,7998
-wafer/wevin_cli.py,sha256=4cZ05GFCGBq11ekVQH_AgaqnITVq6IUfwwHo6CeHFN4,22179
-wafer/workspaces.py,sha256=w6VHhCV189BdVZNLZ6obL71qlB5N4iLWX5fvyqFB87c,30085
+wafer/wevin_cli.py,sha256=vF3GNH-qWXO4hAlXaDg98VZpS4uFexVUp94BHsJjjMU,22179
+wafer/workspaces.py,sha256=XZvN-13oq40fkpoJTB2UWTG9KkD-eO47ptXK0FY6360,30083
 wafer/skills/wafer-guide/SKILL.md,sha256=KWetJw2TVTbz11_nzqazqOJWWRlbHRFShs4sOoreiWo,3255
 wafer/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wafer/templates/ask_docs.py,sha256=Lxs-faz9v5m4Qa4NjF2X_lE8KwM9ES9MNJkxo7ep56o,2256
 wafer/templates/optimize_kernel.py,sha256=u6AL7Q3uttqlnBLzcoFdsiPq5lV2TV3bgqwCYYlK9gk,2357
+wafer/templates/optimize_kernelbench.py,sha256=aoOA13zWEl89r6QW03xF9NKxQ7j4mWe9rwua6-mlr4Y,4780
 wafer/templates/trace_analyze.py,sha256=XE1VqzVkIUsZbXF8EzQdDYgg-AZEYAOFpr6B_vnRELc,2880
-wafer_cli-0.2.13.dist-info/METADATA,sha256=wRWRnySLYOqvUTJT6NPPVBY5KBLL0CGquHK98fQ_Y_g,560
-wafer_cli-0.2.13.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-wafer_cli-0.2.13.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
-wafer_cli-0.2.13.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
-wafer_cli-0.2.13.dist-info/RECORD,,
+wafer_cli-0.2.15.dist-info/METADATA,sha256=z1TLYbZzeOJpMMaG3TqJd_M5WbeLRVEtSmoTO0qhPc4,560
+wafer_cli-0.2.15.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+wafer_cli-0.2.15.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
+wafer_cli-0.2.15.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
+wafer_cli-0.2.15.dist-info/RECORD,,