wafer-cli 0.2.9__tar.gz → 0.2.10__tar.gz

{wafer_cli-0.2.9 → wafer_cli-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.9
+Version: 0.2.10
 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.9 → wafer_cli-0.2.10}/README.md

@@ -43,10 +43,16 @@ wafer remote-run --upload-dir ./my_code -- python3 train.py
 
 Create and manage persistent GPU environments.
 
+**Available GPUs:**
+
+- `MI300X` - AMD Instinct MI300X (192GB HBM3, ROCm)
+- `B200` - NVIDIA Blackwell B200 (180GB HBM3e, CUDA) - default
+
 ```bash
 wafer workspaces list
-wafer workspaces create my-workspace
-wafer workspaces attach <workspace-id>    # Get SSH credentials
+wafer workspaces create my-workspace --gpu B200 --wait   # NVIDIA B200
+wafer workspaces create amd-dev --gpu MI300X             # AMD MI300X
+wafer workspaces ssh <workspace-id>
 wafer workspaces delete <workspace-id>
 ```
 
@@ -197,6 +203,39 @@ Now you can tab-complete:
 
 ---
 
+## AI Assistant Skills
+
+Install the Wafer CLI skill to make wafer commands discoverable by your AI coding assistant:
+
+```bash
+# Install for all supported tools (Claude Code, Codex CLI, Cursor)
+wafer skill install
+
+# Install for a specific tool
+wafer skill install -t cursor    # Cursor
+wafer skill install -t claude    # Claude Code
+wafer skill install -t codex     # Codex CLI
+
+# Check installation status
+wafer skill status
+
+# Uninstall
+wafer skill uninstall
+```
+
+### Installing from GitHub (Cursor)
+
+You can also install the skill directly from GitHub in Cursor:
+
+1. Open Cursor Settings (Cmd+Shift+J / Ctrl+Shift+J)
+2. Navigate to **Rules** → **Add Rule** → **Remote Rule (Github)**
+3. Enter: `https://github.com/wafer-ai/skills`
+4. Cursor will automatically discover skills in `.cursor/skills/`
+
+The skill provides comprehensive guidance for GPU kernel development, including documentation lookup, trace analysis, kernel evaluation, and optimization workflows.
+
+---
+
 ## Requirements
 
 - Python 3.10+

{wafer_cli-0.2.9 → wafer_cli-0.2.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wafer-cli"
-version = "0.2.9"
+version = "0.2.10"
 description = "CLI tool for running commands on remote GPUs and GPU kernel optimization agent"
 requires-python = ">=3.11"
 dependencies = [
@@ -78,6 +78,7 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "tests/**/*.py" = ["ANN201"]  # Don't require return type annotations in tests
 "wafer/evaluate.py" = ["PLR0915", "PLR1702", "E402"]  # complex deployment flows - TODO: refactor
+"wafer/output.py" = ["ANN401"]  # Output collector uses **kwargs for flexible event data
 
 [tool.ruff.lint.pylint]
 max-args = 7             # Max function arguments (Tiger Style: few parameters)

{wafer_cli-0.2.9 → wafer_cli-0.2.10}/tests/test_cli_coverage.py

@@ -61,7 +61,7 @@ def _cleanup_test_workspaces() -> None:
         return
     for ws in workspaces:
         if ws.get("name", "").startswith("test-"):
-            runner.invoke(app, ["workspaces", "delete", ws["id"]])
+            runner.invoke(app, ["workspaces", "delete", ws["id"], "-y"])
 
 
 @pytest.fixture(scope="session", autouse=True)
@@ -213,7 +213,7 @@ class TestWorkspacesCommands:
         finally:
             # Delete
             if ws_id:
-                result = runner.invoke(app, ["workspaces", "delete", ws_id])
+                result = runner.invoke(app, ["workspaces", "delete", ws_id, "-y"])
 
     def test_workspaces_create_pretty(self) -> None:
         """Create workspace with pretty output."""
@@ -228,53 +228,43 @@ class TestWorkspacesCommands:
                 return
 
             # Extract ID from output
-            # Output format: "Created workspace: <name> (<uuid>)"
+            # Output format: "Creating workspace: <name> (<uuid>)"
             match = re.search(r"\(([a-f0-9-]{36})\)", result.output)
             if match:
                 ws_id = match.group(1)
+            assert "Creating workspace:" in result.output
             assert ws_id is not None, f"Could not extract workspace ID from: {result.output}"
 
         finally:
             if ws_id:
-                runner.invoke(app, ["workspaces", "delete", ws_id])
+                runner.invoke(app, ["workspaces", "delete", ws_id, "-y"])
 
-    def test_workspaces_attach_json(self) -> None:
-        """Attach to workspace with JSON output."""
-        ws_name = f"test-attach-{os.getpid()}"
+    def test_workspaces_create_wait_json(self) -> None:
+        """Create workspace with --wait JSON output."""
+        ws_name = f"test-create-wait-{os.getpid()}"
         ws_id = None
 
         try:
-            # Create workspace first
-            result = runner.invoke(app, ["workspaces", "create", ws_name, "--json"])
+            result = runner.invoke(
+                app,
+                ["workspaces", "create", ws_name, "--wait", "--json"],
+            )
             if result.exit_code != 0:
                 if "auth" in result.output.lower() or "not authenticated" in result.output.lower():
                     pytest.skip("Not authenticated")
+                assert "error" in result.output.lower() or "no gpu" in result.output.lower()
                 return
 
             data = json.loads(result.stdout)
-            ws_id = data.get("id")
+            ws_id = data.get("workspace_id")
             assert ws_id is not None
-
-            # Attach with JSON (avoids file I/O side effects)
-            result = runner.invoke(app, ["workspaces", "attach", ws_id, "--json"])
-            if result.exit_code == 0:
-                attach_data = json.loads(result.stdout)
-                # Should have SSH connection info
-                assert "ssh_host" in attach_data
-                assert "ssh_port" in attach_data
-                assert "ssh_user" in attach_data
-                assert "private_key_pem" in attach_data
-            else:
-                # May fail with 503 if no GPU available - that's ok
-                assert (
-                    "503" in result.output
-                    or "No GPU" in result.output
-                    or "error" in result.output.lower()
-                )
+            assert "ssh_host" in data
+            assert "ssh_port" in data
+            assert "ssh_user" in data
 
         finally:
             if ws_id:
-                runner.invoke(app, ["workspaces", "delete", ws_id])
+                runner.invoke(app, ["workspaces", "delete", ws_id, "-y"])
 
     def test_workspaces_show_not_found(self) -> None:
         """Show workspace with invalid ID returns 404."""
@@ -288,10 +278,10 @@ class TestWorkspacesCommands:
                 or "auth" in result.output.lower()
             )
 
-    def test_workspaces_attach_not_found(self) -> None:
-        """Attach to workspace with invalid ID returns 404."""
+    def test_workspaces_ssh_not_found(self) -> None:
+        """SSH to workspace with invalid ID returns 404."""
         fake_id = "00000000-0000-0000-0000-000000000000"
-        result = runner.invoke(app, ["workspaces", "attach", fake_id])
+        result = runner.invoke(app, ["workspaces", "ssh", fake_id])
         if result.exit_code != 0:
             # Should be 404 or auth error
             assert (
@@ -300,6 +290,15 @@ class TestWorkspacesCommands:
                 or "auth" in result.output.lower()
             )
 
+    def test_workspaces_exec_option_order(self) -> None:
+        """Exec should reject options after workspace name."""
+        result = runner.invoke(
+            app,
+            ["workspaces", "exec", "dev", "--timeout", "10", "--", "echo", "hi"],
+        )
+        assert result.exit_code != 0
+        assert "options must come before the workspace name" in result.output.lower()
+
 
 class TestNsysAnalyzeCommand:
     """Test wafer nvidia nsys analyze command."""
@@ -333,7 +332,24 @@ class TestNsysAnalyzeCommand:
         result = runner.invoke(
             app, ["nvidia", "nsys", "analyze", str(real_nsys_file), "--remote", "--json"]
         )
-        assert result.exit_code == 0
+        if result.exit_code != 0:
+            combined = result.output.lower()
+            if "auth" in combined or "login" in combined or "401" in combined or "403" in combined:
+                pytest.skip("Not authenticated")
+            if (
+                "no gpu" in combined
+                or "no targets" in combined
+                or "unavailable" in combined
+                or "timed out" in combined
+                or "timeout" in combined
+                or "connect" in combined
+                or "service" in combined
+                or "billing" in combined
+                or "spend limit" in combined
+                or "402" in combined
+            ):
+                pytest.skip(f"Remote nsys unavailable: {result.output.strip()}")
+            assert result.exit_code == 0
         data = json.loads(result.stdout)
         assert "kernels" in data or "timeline" in data or "summary" in data
 
@@ -344,7 +360,24 @@ class TestNsysAnalyzeCommand:
             pytest.skip("No real .nsys-rep fixture available")
 
         result = runner.invoke(app, ["nvidia", "nsys", "analyze", str(real_nsys_file), "--remote"])
-        assert result.exit_code == 0
+        if result.exit_code != 0:
+            combined = result.output.lower()
+            if "auth" in combined or "login" in combined or "401" in combined or "403" in combined:
+                pytest.skip("Not authenticated")
+            if (
+                "no gpu" in combined
+                or "no targets" in combined
+                or "unavailable" in combined
+                or "timed out" in combined
+                or "timeout" in combined
+                or "connect" in combined
+                or "service" in combined
+                or "billing" in combined
+                or "spend limit" in combined
+                or "402" in combined
+            ):
+                pytest.skip(f"Remote nsys unavailable: {result.output.strip()}")
+            assert result.exit_code == 0
         assert "NSYS" in result.output or "Kernel" in result.output or "Profile" in result.output
 
     def test_nsys_analyze_local(self, real_nsys_file: Path | None) -> None:
@@ -627,3 +660,62 @@ class TestEvaluateCommand:
             or "error" in combined
             or result.exit_code in (0, 1)
         )
+
+
+class TestWorkspacesExecFlagPassthrough:
+    """Test that flags after -- are passed through to the command, not intercepted."""
+
+    def test_exec_passes_dash_i_flag(self) -> None:
+        """The -i flag should pass through, not be intercepted as --image."""
+        result = runner.invoke(app, [
+            "workspaces", "exec", "test-ws", "--", "echo", "-i", "test"
+        ])
+        # Should NOT fail with "no such option" or similar parse error
+        assert "no such option" not in result.output.lower()
+        assert "unrecognized" not in result.output.lower()
+        # May fail with workspace not found - that's fine, parsing succeeded
+
+    def test_exec_passes_dash_v_flag(self) -> None:
+        """The -v flag should pass through, not be intercepted as --verbose."""
+        result = runner.invoke(app, [
+            "workspaces", "exec", "test-ws", "--", "python", "-v", "-c", "print(1)"
+        ])
+        assert "no such option" not in result.output.lower()
+
+    def test_exec_passes_double_dash_help(self) -> None:
+        """--help after -- should pass to command, not show exec help."""
+        result = runner.invoke(app, [
+            "workspaces", "exec", "test-ws", "--", "python", "--help"
+        ])
+        # Should NOT show the exec command's help text
+        assert "Execute a command in workspace" not in result.output
+
+    def test_exec_passes_multiple_flags(self) -> None:
+        """Multiple flags like -i -v -n should all pass through."""
+        result = runner.invoke(app, [
+            "workspaces", "exec", "test-ws", "--", "grep", "-i", "-v", "-n", "pattern"
+        ])
+        assert "no such option" not in result.output.lower()
+
+    def test_exec_no_command_shows_error(self) -> None:
+        """Missing command after -- should show helpful error."""
+        result = runner.invoke(app, [
+            "workspaces", "exec", "test-ws", "--"
+        ])
+        assert result.exit_code != 0
+        assert "no command" in result.output.lower() or "error" in result.output.lower()
+
+    def test_exec_preserves_flag_order(self) -> None:
+        """Flags should be preserved in order they were given."""
+        # This tests the shlex.join behavior
+        result = runner.invoke(app, [
+            "workspaces", "exec", "test-ws", "--", "cmd", "-a", "1", "-b", "2"
+        ])
+        assert "no such option" not in result.output.lower()
+
+    def test_exec_with_equals_syntax(self) -> None:
+        """Flags with --flag=value syntax should pass through."""
+        result = runner.invoke(app, [
+            "workspaces", "exec", "test-ws", "--", "cmd", "--output=/tmp/out"
+        ])
+        assert "no such option" not in result.output.lower()

{wafer_cli-0.2.9 → wafer_cli-0.2.10}/tests/test_cli_parity_integration.py

@@ -77,7 +77,7 @@ class TestWorkspacesWorkflow:
         finally:
             # Cleanup
             if ws_id:
-                run_cli("workspaces", "delete", ws_id, check=False)
+                run_cli("workspaces", "delete", ws_id, "-y", check=False)
 
 
 @requires_api

{wafer_cli-0.2.9 → wafer_cli-0.2.10}/tests/test_kernel_scope_cli.py

@@ -217,15 +217,15 @@ class TestTargetsCommandFunction:
 
 
 # ============================================================================
-# CLI Integration Tests
+# CLI Integration Tests (using unified wafer amd isa command)
 # ============================================================================
 
-class TestKernelScopeCliCommands:
-    """Tests for wafer amd kernel-scope CLI commands."""
+class TestISAAnalyzerCliCommands:
+    """Tests for wafer amd isa CLI commands (unified ISA Analyzer)."""
 
     def test_analyze_command_help(self) -> None:
         """Should display help for analyze command."""
-        result = runner.invoke(app, ["amd", "kernel-scope", "analyze", "--help"])
+        result = runner.invoke(app, ["amd", "isa", "analyze", "--help"])
 
         assert result.exit_code == 0
         output = strip_ansi(result.stdout)
@@ -237,7 +237,7 @@ class TestKernelScopeCliCommands:
         isa_file.write_text(SAMPLE_ISA)
 
         result = runner.invoke(app, [
-            "amd", "kernel-scope", "analyze", str(isa_file)
+            "amd", "isa", "analyze", str(isa_file)
         ])
 
         assert result.exit_code == 0, f"Failed: {result.output}"
@@ -249,7 +249,7 @@ class TestKernelScopeCliCommands:
         isa_file.write_text(SAMPLE_ISA)
 
         result = runner.invoke(app, [
-            "amd", "kernel-scope", "analyze", str(isa_file), "--json"
+            "amd", "isa", "analyze", str(isa_file), "--json"
         ])
 
         assert result.exit_code == 0, f"Failed: {result.output}"
@@ -262,7 +262,7 @@ class TestKernelScopeCliCommands:
         isa_file.write_text(SAMPLE_ISA)
 
         result = runner.invoke(app, [
-            "amd", "kernel-scope", "analyze", str(isa_file), "--csv"
+            "amd", "isa", "analyze", str(isa_file), "--csv"
         ])
 
         assert result.exit_code == 0, f"Failed: {result.output}"
@@ -271,32 +271,32 @@ class TestKernelScopeCliCommands:
     def test_analyze_missing_file_via_cli(self, tmp_path: Path) -> None:
         """Should fail for missing file."""
         result = runner.invoke(app, [
-            "amd", "kernel-scope", "analyze", str(tmp_path / "missing.s")
+            "amd", "isa", "analyze", str(tmp_path / "missing.s")
         ])
 
         assert result.exit_code != 0
 
     def test_metrics_via_cli(self) -> None:
         """Should list metrics via CLI."""
-        result = runner.invoke(app, ["amd", "kernel-scope", "metrics"])
+        result = runner.invoke(app, ["amd", "isa", "metrics"])
 
         assert result.exit_code == 0
         assert "vgpr_count" in result.stdout
 
     def test_targets_via_cli(self) -> None:
         """Should list targets via CLI."""
-        result = runner.invoke(app, ["amd", "kernel-scope", "targets"])
+        result = runner.invoke(app, ["amd", "isa", "targets"])
 
         assert result.exit_code == 0
         assert "gfx90a" in result.stdout or "gfx942" in result.stdout
 
 
-class TestKernelScopeCliHelp:
-    """Tests for kernel-scope command help text."""
+class TestISAAnalyzerCliHelp:
+    """Tests for ISA Analyzer command help text."""
 
-    def test_kernel_scope_help(self) -> None:
-        """Should display help for kernel-scope command group."""
-        result = runner.invoke(app, ["amd", "kernel-scope", "--help"])
+    def test_isa_help(self) -> None:
+        """Should display help for isa command group."""
+        result = runner.invoke(app, ["amd", "isa", "--help"])
 
         assert result.exit_code == 0
         output = strip_ansi(result.stdout)
@@ -304,12 +304,12 @@ class TestKernelScopeCliHelp:
         assert "metrics" in output.lower()
         assert "targets" in output.lower()
 
-    def test_amd_help_includes_kernel_scope(self) -> None:
-        """AMD help should mention kernel-scope."""
+    def test_amd_help_includes_isa(self) -> None:
+        """AMD help should mention ISA analyzer."""
         result = runner.invoke(app, ["amd", "--help"])
 
         assert result.exit_code == 0
-        assert "kernel-scope" in result.stdout
+        assert "isa" in result.stdout.lower()
 
 
 # ============================================================================
@@ -465,3 +465,156 @@ class TestEdgeCases:
         output = analyze_command(str(tmp_path), recursive=True)
 
         assert "1 files" in output or "test_kernel" in output
+
+
+# ============================================================================
+# Unified ISA Analyzer CLI Tests (supports .co, .s, .ll, .ttgir)
+# ============================================================================
+
+
+class TestUnifiedISAAnalyzerCLI:
+    """Tests for unified ISA analyzer CLI command."""
+
+    def test_cli_wafer_amd_isa_analyze_help(self) -> None:
+        """wafer amd isa analyze --help should show help."""
+        result = runner.invoke(app, ["amd", "isa", "analyze", "--help"])
+
+        assert result.exit_code == 0
+        assert "AMD GPU ISA" in result.output or "analyze" in result.output.lower()
+
+    def test_cli_wafer_amd_isa_metrics(self) -> None:
+        """wafer amd isa metrics should list available metrics."""
+        result = runner.invoke(app, ["amd", "isa", "metrics"])
+
+        assert result.exit_code == 0
+        output = strip_ansi(result.output)
+        assert "vgpr_count" in output
+        assert "spill_count" in output
+        assert "mfma_count" in output
+
+    def test_cli_wafer_amd_isa_targets(self) -> None:
+        """wafer amd isa targets should list supported GPU targets."""
+        result = runner.invoke(app, ["amd", "isa", "targets"])
+
+        assert result.exit_code == 0
+        output = strip_ansi(result.output)
+        assert "gfx90a" in output
+        assert "gfx942" in output
+
+    def test_cli_wafer_amd_isa_analyze_isa_file(self, tmp_path: Path) -> None:
+        """wafer amd isa analyze should analyze .s files."""
+        isa_file = tmp_path / "kernel.s"
+        isa_file.write_text(SAMPLE_ISA)
+
+        result = runner.invoke(app, ["amd", "isa", "analyze", str(isa_file)])
+
+        assert result.exit_code == 0
+        output = strip_ansi(result.output)
+        assert "test_kernel" in output
+        assert "gfx90a" in output
+
+    def test_cli_wafer_amd_isa_analyze_json_output(self, tmp_path: Path) -> None:
+        """wafer amd isa analyze --json should output JSON."""
+        isa_file = tmp_path / "kernel.s"
+        isa_file.write_text(SAMPLE_ISA)
+
+        result = runner.invoke(app, ["amd", "isa", "analyze", str(isa_file), "--json"])
+
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["success"] is True
+        assert data["file_type"] == "isa"
+        assert data["isa_analysis"]["kernel_name"] == "test_kernel"
+
+    def test_cli_wafer_amd_isa_analyze_csv_output(self, tmp_path: Path) -> None:
+        """wafer amd isa analyze --csv should output CSV."""
+        isa_file = tmp_path / "kernel.s"
+        isa_file.write_text(SAMPLE_ISA)
+
+        result = runner.invoke(app, ["amd", "isa", "analyze", str(isa_file), "--csv"])
+
+        assert result.exit_code == 0
+        lines = result.output.strip().split("\n")
+        assert len(lines) >= 2  # Header + data
+        assert "kernel_name" in lines[0]
+        assert "test_kernel" in lines[1]
+
+    def test_cli_wafer_amd_isa_analyze_co_uses_api(self, tmp_path: Path) -> None:
+        """wafer amd isa analyze on .co should attempt API call."""
+        co_file = tmp_path / "kernel.co"
+        co_file.write_bytes(b"fake code object")
+
+        result = runner.invoke(app, ["amd", "isa", "analyze", str(co_file)])
+
+        # Should exit with error (API call will fail in test environment)
+        # The error could be auth-related or API unavailable
+        assert result.exit_code != 0
+        output = result.output.lower()
+        assert "error" in output or "api" in output or "failed" in output
+
+    def test_cli_wafer_amd_isa_analyze_nonexistent_file(self) -> None:
+        """wafer amd isa analyze should error on nonexistent file."""
+        result = runner.invoke(app, ["amd", "isa", "analyze", "/nonexistent/path.s"])
+
+        assert result.exit_code != 0
+        assert "not found" in result.output.lower() or "error" in result.output.lower()
+
+    def test_cli_wafer_amd_isa_analyze_directory(self, tmp_path: Path) -> None:
+        """wafer amd isa analyze should analyze directories."""
+        (tmp_path / "kernel1.s").write_text(SAMPLE_ISA)
+        (tmp_path / "kernel2.s").write_text(SAMPLE_ISA_WITH_SPILLS)
+
+        result = runner.invoke(app, ["amd", "isa", "analyze", str(tmp_path)])
+
+        assert result.exit_code == 0
+        output = strip_ansi(result.output)
+        assert "2 files" in output
+        assert "Successful" in output or "successful" in output
+
+    def test_cli_wafer_amd_isa_analyze_with_filter(self, tmp_path: Path) -> None:
+        """wafer amd isa analyze --filter should filter results."""
+        (tmp_path / "no_spills.s").write_text(SAMPLE_ISA)
+        (tmp_path / "has_spills.s").write_text(SAMPLE_ISA_WITH_SPILLS)
+
+        result = runner.invoke(
+            app, 
+            ["amd", "isa", "analyze", str(tmp_path), "--filter", "spills > 0"]
+        )
+
+        assert result.exit_code == 0
+        output = strip_ansi(result.output)
+        # Should only show the file with spills
+        assert "1 files" in output or "spilling_kernel" in output
+
+    def test_cli_wafer_amd_isa_analyze_output_to_file(self, tmp_path: Path) -> None:
+        """wafer amd isa analyze --output should write to file."""
+        isa_file = tmp_path / "kernel.s"
+        isa_file.write_text(SAMPLE_ISA)
+        output_file = tmp_path / "output.json"
+
+        result = runner.invoke(
+            app, 
+            ["amd", "isa", "analyze", str(isa_file), "--json", "-o", str(output_file)]
+        )
+
+        assert result.exit_code == 0
+        assert output_file.exists()
+        data = json.loads(output_file.read_text())
+        assert data["success"] is True
+
+    def test_analyze_command_with_api_params(self, tmp_path: Path) -> None:
+        """analyze_command should accept API params for .co files."""
+        co_file = tmp_path / "kernel.co"
+        co_file.write_bytes(b"fake code object")
+
+        # Even with fake API params, should attempt to call API
+        # (will fail because .co file doesn't exist at API, but params are passed)
+        with pytest.raises(RuntimeError) as exc_info:
+            analyze_command(
+                str(co_file),
+                api_url="https://fake.api.wafer.dev",
+                auth_headers={"Authorization": "Bearer fake"}
+            )
+        
+        # Should have tried to make API call (not just reject due to missing params)
+        assert "API error" in str(exc_info.value) or "Request failed" in str(exc_info.value)