wafer-cli 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

wafer/analytics.py

@@ -0,0 +1,307 @@
+"""PostHog analytics for Wafer CLI.
+
+Tracks CLI command usage and user activity for product analytics.
+Mirrors the analytics implementation in apps/wevin-extension/src/services/analytics.ts.
+
+Usage:
+    from .analytics import track_command, identify_user, shutdown_analytics
+
+    # Track a command execution
+    track_command("evaluate", {"subcommand": "kernelbench", "outcome": "success"})
+
+    # Identify user after login
+    identify_user("user-id", "user@example.com")
+"""
+
+import atexit
+import platform
+import sys
+import uuid
+from pathlib import Path
+from typing import Any
+
+# PostHog configuration - same as wevin-extension
+POSTHOG_API_KEY = "phc_9eDjkY72ud9o4l1mA1Gr1dnRT1yx71rP3XY9z66teFh"
+POSTHOG_HOST = "https://us.i.posthog.com"
+
+# Anonymous ID storage
+ANONYMOUS_ID_FILE = Path.home() / ".wafer" / ".analytics_id"
+
+# Global state
+_posthog_client: Any = None
+_distinct_id: str | None = None
+_initialized: bool = False
+
+
+def _get_anonymous_id() -> str:
+    """Get or create anonymous ID for users who aren't logged in."""
+    if ANONYMOUS_ID_FILE.exists():
+        return ANONYMOUS_ID_FILE.read_text().strip()
+
+    # Generate new anonymous ID
+    anonymous_id = f"anon_{uuid.uuid4().hex}"
+    ANONYMOUS_ID_FILE.parent.mkdir(parents=True, exist_ok=True)
+    ANONYMOUS_ID_FILE.write_text(anonymous_id)
+    return anonymous_id
+
+
+def _get_user_id_from_credentials() -> tuple[str | None, str | None]:
+    """Get user ID and email from stored credentials.
+
+    Returns:
+        Tuple of (user_id, email), both may be None if not logged in.
+    """
+    # Import here to avoid circular imports
+    from .auth import load_credentials, verify_token
+
+    creds = load_credentials()
+    if not creds:
+        return None, None
+
+    # Try to get user info from token
+    try:
+        user_info = verify_token(creds.access_token)
+        return user_info.user_id, user_info.email or creds.email
+    except Exception:
+        # Token verification failed, use email from credentials if available
+        return None, creds.email
+
+
+def _is_analytics_enabled() -> bool:
+    """Check if analytics is enabled via preferences.
+
+    Returns True by default, respects user preference in config.
+    """
+    from .global_config import get_preferences
+
+    try:
+        prefs = get_preferences()
+        return getattr(prefs, "analytics_enabled", True)
+    except Exception:
+        # Default to enabled if we can't read preferences
+        return True
+
+
+def init_analytics() -> bool:
+    """Initialize PostHog client.
+
+    Returns:
+        True if initialization succeeded, False otherwise.
+    """
+    global _posthog_client, _distinct_id, _initialized
+
+    if _initialized:
+        return _posthog_client is not None
+
+    _initialized = True
+
+    # Check if analytics is enabled
+    if not _is_analytics_enabled():
+        return False
+
+    try:
+        from posthog import Posthog
+
+        _posthog_client = Posthog(
+            api_key=POSTHOG_API_KEY,
+            host=POSTHOG_HOST,
+            # Flush immediately for CLI - commands are short-lived
+            flush_at=1,
+            flush_interval=1,
+            # Disable debug logging
+            debug=False,
+        )
+
+        # Set up distinct ID - prefer authenticated user, fall back to anonymous
+        user_id, email = _get_user_id_from_credentials()
+        if user_id:
+            _distinct_id = user_id
+            # Identify the user with their email
+            if email:
+                _posthog_client.identify(
+                    distinct_id=user_id,
+                    properties={
+                        "email": email,
+                        "auth_provider": "github",
+                    },
+                )
+        else:
+            _distinct_id = _get_anonymous_id()
+
+        # Register shutdown handler to flush events
+        atexit.register(shutdown_analytics)
+
+        return True
+
+    except ImportError:
+        # PostHog not installed - analytics disabled
+        return False
+    except Exception:
+        # Any other error - fail silently, don't break CLI
+        return False
+
+
+def shutdown_analytics() -> None:
+    """Shutdown PostHog client and flush pending events."""
+    global _posthog_client
+
+    if _posthog_client is not None:
+        try:
+            _posthog_client.flush()
+            _posthog_client.shutdown()
+        except Exception:
+            pass  # Fail silently on shutdown
+        _posthog_client = None
+
+
+def identify_user(user_id: str, email: str | None = None) -> None:
+    """Identify a user after login.
+
+    Args:
+        user_id: Supabase user ID
+        email: User's email address
+    """
+    global _distinct_id
+
+    if not init_analytics():
+        return
+
+    if _posthog_client is None:
+        return
+
+    _distinct_id = user_id
+
+    try:
+        properties: dict[str, Any] = {"auth_provider": "github"}
+        if email:
+            properties["email"] = email
+
+        _posthog_client.identify(
+            distinct_id=user_id,
+            properties=properties,
+        )
+        _posthog_client.flush()
+    except Exception:
+        pass  # Fail silently
+
+
+def reset_user_identity() -> None:
+    """Reset user identity after logout."""
+    global _distinct_id
+
+    _distinct_id = _get_anonymous_id()
+
+
+def get_distinct_id() -> str:
+    """Get current distinct ID for tracking."""
+    global _distinct_id
+
+    if _distinct_id is None:
+        user_id, _ = _get_user_id_from_credentials()
+        _distinct_id = user_id or _get_anonymous_id()
+
+    return _distinct_id
+
+
+def _get_cli_version() -> str:
+    """Get CLI version from package metadata."""
+    try:
+        from importlib.metadata import version
+
+        return version("wafer-cli")
+    except Exception:
+        return "unknown"
+
+
+def _get_base_properties() -> dict[str, Any]:
+    """Get base properties included with all events."""
+    return {
+        "platform": "cli",
+        "tool_id": "cli",
+        "cli_version": _get_cli_version(),
+        "os": platform.system().lower(),
+        "os_version": platform.release(),
+        "python_version": platform.python_version(),
+    }
+
+
+def track_event(event_name: str, properties: dict[str, Any] | None = None) -> None:
+    """Track a generic event.
+
+    Args:
+        event_name: Name of the event to track
+        properties: Additional properties to include
+    """
+    if not init_analytics():
+        return
+
+    if _posthog_client is None:
+        return
+
+    try:
+        event_properties = _get_base_properties()
+        if properties:
+            event_properties.update(properties)
+
+        _posthog_client.capture(
+            distinct_id=get_distinct_id(),
+            event=event_name,
+            properties=event_properties,
+        )
+    except Exception:
+        pass  # Fail silently
+
+
+def track_command(
+    command: str,
+    subcommand: str | None = None,
+    outcome: str = "success",
+    duration_ms: int | None = None,
+    properties: dict[str, Any] | None = None,
+) -> None:
+    """Track a CLI command execution.
+
+    This event counts towards DAU in the internal dashboard.
+
+    Args:
+        command: The main command name (e.g., "evaluate", "agent")
+        subcommand: Optional subcommand (e.g., "kernelbench")
+        outcome: "success" or "error"
+        duration_ms: Command execution time in milliseconds
+        properties: Additional properties to include
+    """
+    event_properties: dict[str, Any] = {
+        "command": command,
+        "outcome": outcome,
+    }
+
+    if subcommand:
+        event_properties["subcommand"] = subcommand
+
+    if duration_ms is not None:
+        event_properties["duration_ms"] = duration_ms
+
+    if properties:
+        event_properties.update(properties)
+
+    track_event("cli_command_executed", event_properties)
+
+
+def track_login(user_id: str, email: str | None = None) -> None:
+    """Track user login event.
+
+    Args:
+        user_id: Supabase user ID
+        email: User's email address
+    """
+    # First identify the user
+    identify_user(user_id, email)
+
+    # Then track the login event
+    track_event("cli_user_signed_in", {"user_id": user_id})
+
+
+def track_logout() -> None:
+    """Track user logout event."""
+    track_event("cli_user_signed_out")
+    reset_user_identity()

wafer/auth.py

@@ -287,7 +287,7 @@ if (accessToken) {
             self.end_headers()
 
 
-def browser_login(timeout: int = 120) -> tuple[str, str | None]:
+def browser_login(timeout: int = 120, port: int | None = None) -> tuple[str, str | None]:
     """Open browser for GitHub OAuth and return tokens.
 
     Starts a local HTTP server, opens browser to Supabase OAuth,
@@ -295,6 +295,7 @@ def browser_login(timeout: int = 120) -> tuple[str, str | None]:
 
     Args:
         timeout: Seconds to wait for callback (default 120)
+        port: Port for callback server. If None, finds a free port (default None)
 
     Returns:
         Tuple of (access_token, refresh_token). refresh_token may be None.
@@ -303,7 +304,8 @@ def browser_login(timeout: int = 120) -> tuple[str, str | None]:
         TimeoutError: If no callback received within timeout
         RuntimeError: If OAuth flow failed
     """
-    port = _find_free_port()
+    if port is None:
+        port = _find_free_port()
     redirect_uri = f"http://localhost:{port}/callback"
     supabase_url = get_supabase_url()
 

wafer/cli.py

@@ -18,9 +18,11 @@ Setup:
   config                CLI configuration and local GPU targets
 """
 
+import atexit
 import json
 import os
 import sys
+import time
 from pathlib import Path
 
 import trio
@@ -34,6 +36,98 @@ app = typer.Typer(
     no_args_is_help=True,
 )
 
+# =============================================================================
+# Analytics tracking
+# =============================================================================
+
+# Track command start time for duration calculation
+_command_start_time: float | None = None
+# Track command outcome (defaults to failure, set to success on clean exit)
+_command_outcome: str = "failure"
+
+
+def _get_command_path(ctx: typer.Context) -> tuple[str, str | None]:
+    """Extract command and subcommand from Typer context.
+
+    Returns:
+        Tuple of (command, subcommand). subcommand may be None.
+    """
+    # Build command path from invoked subcommand chain
+    invoked = ctx.invoked_subcommand
+    info_name = ctx.info_name or ""
+
+    # Get parent command if exists
+    parent_cmd = None
+    if ctx.parent and ctx.parent.info_name and ctx.parent.info_name != "wafer":
+        parent_cmd = ctx.parent.info_name
+
+    if parent_cmd:
+        return parent_cmd, info_name
+    return info_name or "unknown", invoked
+
+
+def _mark_command_success() -> None:
+    """Mark the current command as successful.
+
+    Call this at the end of successful command execution.
+    Commands that raise typer.Exit(1) or exceptions will remain marked as failures.
+    """
+    global _command_outcome
+    _command_outcome = "success"
+
+
+@app.callback()
+def main_callback(ctx: typer.Context) -> None:
+    """Initialize analytics and track command execution."""
+    global _command_start_time, _command_outcome
+    _command_start_time = time.time()
+    _command_outcome = "success"  # Default to success, mark failure on exceptions
+
+    # Initialize analytics (lazy import to avoid slowing down --help)
+    from . import analytics
+
+    analytics.init_analytics()
+
+    # Install exception hook to catch SystemExit and mark failures
+    original_excepthook = sys.excepthook
+
+    def custom_excepthook(exc_type, exc_value, exc_traceback):
+        global _command_outcome
+        # Mark as failure if SystemExit with non-zero code, or any other exception
+        if exc_type is SystemExit:
+            exit_code = exc_value.code if hasattr(exc_value, 'code') else 1
+            if exit_code != 0 and exit_code is not None:
+                _command_outcome = "failure"
+        else:
+            _command_outcome = "failure"
+        # Call original excepthook
+        original_excepthook(exc_type, exc_value, exc_traceback)
+
+    sys.excepthook = custom_excepthook
+
+    # Register tracking at exit to capture command outcome
+    def track_on_exit() -> None:
+        command, subcommand = _get_command_path(ctx)
+
+        # Skip tracking for --help and --version
+        if ctx.resilient_parsing:
+            return
+
+        # Calculate duration
+        duration_ms = None
+        if _command_start_time is not None:
+            duration_ms = int((time.time() - _command_start_time) * 1000)
+
+        # Track the command execution with the recorded outcome
+        analytics.track_command(
+            command=command,
+            subcommand=subcommand,
+            outcome=_command_outcome,
+            duration_ms=duration_ms,
+        )
+
+    atexit.register(track_on_exit)
+
 
 # =============================================================================
 # Autocompletion helpers
@@ -1945,17 +2039,31 @@ def login(
     token: str | None = typer.Option(
         None, "--token", "-t", help="Access token (skip browser OAuth)"
     ),
+    port: int | None = typer.Option(
+        None, "--port", "-p", help="Port for OAuth callback server (default: 8765 for SSH, random for local)"
+    ),
 ) -> None:
     """Authenticate CLI with wafer-api via GitHub OAuth.
 
     Opens browser for GitHub authentication. Use --token to skip browser.
     Uses the API environment from config (see 'wafer config show').
 
+    SSH Users:
+    - Automatically uses port 8765 (just set up port forwarding once)
+    - On local machine: ssh -L 8765:localhost:8765 user@host
+    - On remote machine: wafer login
+    - Browser opens locally, redirect works through tunnel
+
+    Manual token option:
+    - Visit auth.wafer.ai, authenticate, copy token from URL
+    - Run: wafer login --token <paste-token>
+
     Examples:
-        wafer login              # opens browser for GitHub OAuth
-        wafer login --token xyz  # use existing token
+        wafer login                    # auto-detects SSH, uses appropriate port
+        wafer login --port 9000        # override port
+        wafer login --token xyz        # manual token (no browser)
 
-        # To login to a different environment:
+        # Change environment:
         wafer config set api.environment staging
         wafer login
     """
@@ -1971,11 +2079,21 @@ def login(
     typer.echo(f"Auth: {get_supabase_url()}")
     typer.echo("")
 
+    # Auto-detect SSH and use fixed port
+    if port is None:
+        is_ssh = bool(os.environ.get("SSH_CONNECTION") or os.environ.get("SSH_CLIENT"))
+        if is_ssh:
+            port = 8765
+            typer.echo("🔒 SSH session detected - using port 8765 for OAuth callback")
+            typer.echo("   Make sure you have port forwarding set up:")
+            typer.echo("   ssh -L 8765:localhost:8765 user@host")
+            typer.echo("")
+
     # Browser OAuth if no token provided
     refresh_token = None
     if token is None:
         try:
-            token, refresh_token = browser_login()
+            token, refresh_token = browser_login(port=port)
         except TimeoutError as e:
             typer.echo(f"Error: {e}", err=True)
             raise typer.Exit(1) from None
@@ -2009,6 +2127,11 @@ def login(
     # Save credentials (with refresh token if available)
     save_credentials(token, refresh_token, user_info.email)
 
+    # Track login event with analytics
+    from . import analytics
+
+    analytics.track_login(user_info.user_id, user_info.email)
+
     if user_info.email:
         typer.echo(f"Logged in as {user_info.email}")
     else:
@@ -2021,6 +2144,13 @@ def logout() -> None:
     """Remove stored credentials."""
     from .auth import clear_credentials
 
+    from . import analytics
+
+    # Track logout event first (while credentials still exist for user identification)
+    # Note: track_logout() handles the case where user is not logged in
+    analytics.track_logout()
+
+    # Clear credentials and report result
     if clear_credentials():
         typer.echo("Logged out. Credentials removed.")
     else:
@@ -4298,6 +4428,29 @@ autotuner_app = typer.Typer(help="Hyperparameter sweep for performance engineeri
 app.add_typer(autotuner_app, name="autotuner", hidden=True)
 
 
+def _setup_wafer_core_env() -> None:
+    """Set environment variables for wafer-core to use.
+
+    Call this before using any wafer-core functions that need API access.
+
+    Respects explicit environment variable overrides:
+    - WAFER_API_URL: If already set, uses that instead of config
+    - WAFER_AUTH_TOKEN: If already set, uses that instead of cached token
+    """
+    from .global_config import get_api_url
+    from .auth import get_valid_token
+
+    # Set API URL (get_api_url already respects WAFER_API_URL env var)
+    os.environ["WAFER_API_URL"] = get_api_url()
+
+    # Only set auth token if not explicitly provided in environment
+    # This allows CI/service accounts to override with their own tokens
+    if "WAFER_AUTH_TOKEN" not in os.environ:
+        token = get_valid_token()
+        if token:
+            os.environ["WAFER_AUTH_TOKEN"] = token
+
+
 @autotuner_app.command("list")
 def autotuner_list(
     show_all: bool = typer.Option(
@@ -4313,6 +4466,7 @@ def autotuner_list(
         wafer autotuner list
         wafer autotuner list --all
     """
+    _setup_wafer_core_env()
     from .autotuner import list_command
 
     try:
@@ -4353,6 +4507,7 @@ def autotuner_delete(
         wafer autotuner delete --all --status pending
         wafer autotuner delete --all --status failed --yes
     """
+    _setup_wafer_core_env()
     from .autotuner import delete_all_command, delete_command
 
     # Validate arguments
@@ -4419,6 +4574,7 @@ def autotuner_run(
         wafer autotuner run --resume <sweep-id>
         wafer autotuner run --resume <sweep-id> --parallel 8
     """
+    _setup_wafer_core_env()
     from .autotuner import run_sweep_command
 
     # Validate arguments
@@ -4583,8 +4739,23 @@ def capture_command(  # noqa: PLR0915
         wafer capture grid-search "python train.py --lr {LR} --bs {BS}" --sweep "LR=0.001,0.01,0.1" --sweep "BS=16,32"
     """
     import itertools
+    import os
     import tomllib
 
+    from .global_config import get_api_url
+    from .auth import get_valid_token
+
+    # Set environment variables for wafer-core BEFORE importing it
+    # wafer-core backend.py reads WAFER_API_URL and WAFER_AUTH_TOKEN from env
+    os.environ["WAFER_API_URL"] = get_api_url()
+
+    # Only set auth token if not explicitly provided in environment
+    # This allows CI/service accounts to override with their own tokens
+    if "WAFER_AUTH_TOKEN" not in os.environ:
+        token = get_valid_token()
+        if token:
+            os.environ["WAFER_AUTH_TOKEN"] = token
+
     import trio
     from wafer_core.tools.capture_tool import (  # pragma: no cover
         CaptureConfig,
@@ -4774,6 +4945,20 @@ def capture_list_command(
         # Pagination
         wafer capture-list --limit 20 --offset 20
     """
+    import os
+
+    from .global_config import get_api_url
+    from .auth import get_valid_token
+
+    # Set environment variables for wafer-core BEFORE importing it
+    os.environ["WAFER_API_URL"] = get_api_url()
+
+    # Only set auth token if not explicitly provided in environment
+    # This allows CI/service accounts to override with their own tokens
+    if "WAFER_AUTH_TOKEN" not in os.environ:
+        token = get_valid_token()
+        if token:
+            os.environ["WAFER_AUTH_TOKEN"] = token
 
     import trio
     from wafer_core.utils.backend import list_captures  # pragma: no cover

wafer/global_config.py

@@ -67,9 +67,12 @@ class Preferences:
 
     mode: "implicit" (default) = quiet output, use -v for status messages
           "explicit" = verbose output, shows [wafer] status messages
+    analytics_enabled: True (default) = send anonymous usage analytics to PostHog
+                       False = disable all analytics tracking
     """
 
     mode: Literal["explicit", "implicit"] = "implicit"
+    analytics_enabled: bool = True
 
 
 @dataclass(frozen=True)
@@ -148,7 +151,9 @@ def _parse_config_file(path: Path) -> GlobalConfig:
     pref_data = data.get("preferences", {})
     mode = pref_data.get("mode", "explicit")
     assert mode in ("explicit", "implicit"), f"mode must be 'explicit' or 'implicit', got '{mode}'"
-    preferences = Preferences(mode=mode)
+    analytics_enabled = pref_data.get("analytics_enabled", True)
+    assert isinstance(analytics_enabled, bool), f"analytics_enabled must be true or false, got '{analytics_enabled}'"
+    preferences = Preferences(mode=mode, analytics_enabled=analytics_enabled)
 
     # Parse defaults
     defaults_data = data.get("defaults", {})
@@ -301,10 +306,16 @@ def save_global_config(config: GlobalConfig) -> None:
                         lines.append(f"{key} = {value}")
                 lines.append("")
 
-    # Preferences section (only if non-default)
+    # Preferences section (only if non-default values)
+    pref_lines = []
     if config.preferences.mode != "implicit":
+        pref_lines.append(f'mode = "{config.preferences.mode}"')
+    if not config.preferences.analytics_enabled:
+        pref_lines.append("analytics_enabled = false")
+
+    if pref_lines:
         lines.append("[preferences]")
-        lines.append(f'mode = "{config.preferences.mode}"')
+        lines.extend(pref_lines)
         lines.append("")
 
     # Defaults section (only if non-default values)

{wafer_cli-0.2.2.dist-info → wafer_cli-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: CLI tool for running commands on remote GPUs and GPU kernel optimization agent
 Requires-Python: >=3.11
 Requires-Dist: typer>=0.12.0
@@ -8,6 +8,7 @@ Requires-Dist: trio>=0.24.0
 Requires-Dist: trio-asyncio>=0.15.0
 Requires-Dist: wafer-core>=0.1.0
 Requires-Dist: perfetto>=0.16.0
+Requires-Dist: posthog>=3.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"

{wafer_cli-0.2.2.dist-info → wafer_cli-0.2.3.dist-info}/RECORD

@@ -1,14 +1,15 @@
 wafer/GUIDE.md,sha256=Z_jsSgHAS6bFa83VKhG9jxjUK1XpLjR1fEIKapDa_6g,3195
 wafer/__init__.py,sha256=kBM_ONCpU6UUMBOH8Tmg4A88sNFnbaD59o61cJs-uYM,90
+wafer/analytics.py,sha256=Xxw3bbY3XLgedSJPwzIOBJIjyycIiornWCpjoWbTKYU,8190
 wafer/api_client.py,sha256=cPULiTxqOAYYSfDTNJgd-6Pqrt3IM4Gm9903U7yGIwY,6163
-wafer/auth.py,sha256=3ExbDx5amwX4JiW3Ee9Vg0f0ohsS-8bqeqMIFPPE4dw,10571
+wafer/auth.py,sha256=ZLsXZ73GDLD8GL7Rij1ELtuLqyJ5EU_uPBUMPVKwExA,10703
 wafer/autotuner.py,sha256=6gH0Ho7T58EFerMQcHQxshWe3DF4qU7fb5xthAh5SPM,44364
 wafer/billing.py,sha256=jbLB2lI4_9f2KD8uEFDi_ixLlowe5hasC0TIZJyIXRg,7163
-wafer/cli.py,sha256=TEHxiG9e3T_eCFlwfh2FOetzGwdc1YkI6_5QWh8m5OY,178115
+wafer/cli.py,sha256=kscK-JBiAu0H7roMdcaZ_lT7xlgR6mUJ1nBruidUdsE,184745
 wafer/config.py,sha256=h5Eo9_yfWqWGoPNdVQikI9GoZVUeysunSYiixf1mKcw,3411
 wafer/corpus.py,sha256=yTF3UA5bOa8BII2fmcXf-3WsIsM5DX4etysv0AzVknE,8912
 wafer/evaluate.py,sha256=7E1BqVl0um7kfU2_4FkXZrNc-PQJIHe09G1-L07PXmg,114971
-wafer/global_config.py,sha256=nQOCNjLPeXdFb0WPRpKXukXAisBNjTBw2Va6bTQGNro,10757
+wafer/global_config.py,sha256=fhaR_RU3ufMksDmOohH1OLeQ0JT0SDW1hEip_zaP75k,11345
 wafer/gpu_run.py,sha256=gUbzMsMPsw3UHcn00bI-zTSHrU8c2FEpDvbcsczlDPo,9557
 wafer/inference.py,sha256=tZCO5i05FKY27ewis3CSBHFBeFbXY3xwj0DSjdoMY9s,4314
 wafer/ncu_analyze.py,sha256=rAWzKQRZEY6E_CL3gAWUaW3uZ4kvQVZskVCPDpsFJuE,24633
@@ -25,8 +26,8 @@ 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/trace_analyze.py,sha256=XE1VqzVkIUsZbXF8EzQdDYgg-AZEYAOFpr6B_vnRELc,2880
-wafer_cli-0.2.2.dist-info/METADATA,sha256=HKyOvF4UTxmC2_F2PoRLDHg27q-4qeQzFn9fk2-qblc,529
-wafer_cli-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wafer_cli-0.2.2.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
-wafer_cli-0.2.2.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
-wafer_cli-0.2.2.dist-info/RECORD,,
+wafer_cli-0.2.3.dist-info/METADATA,sha256=MKzRmMwc1zhKUVeu_NE4h5_17EFnX1bjLE4Jcox0AAk,559
+wafer_cli-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wafer_cli-0.2.3.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
+wafer_cli-0.2.3.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
+wafer_cli-0.2.3.dist-info/RECORD,,