weco 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

weco/__init__.py

@@ -1,4 +1,14 @@
+import os
+
 # DO NOT EDIT
-__pkg_version__ = "0.2.12"
+__pkg_version__ = "0.2.14"
 __api_version__ = "v1"
-__base_url__ = f"https://api.aide.weco.ai/{__api_version__}"
+
+__base_url__ = f"https://api.weco.ai/{__api_version__}"
+# If user specifies a custom base URL, use that instead
+if os.environ.get("WECO_BASE_URL"):
+    __base_url__ = os.environ.get("WECO_BASE_URL")
+
+__dashboard_url__ = "https://dashboard.weco.ai"
+if os.environ.get("WECO_DASHBOARD_URL"):
+    __dashboard_url__ = os.environ.get("WECO_DASHBOARD_URL")

weco/api.py

@@ -7,8 +7,7 @@ import sys
 
 def handle_api_error(e: requests.exceptions.HTTPError, console: rich.console.Console) -> None:
     """Extract and display error messages from API responses in a structured format."""
-    error_message = str(e)  # Default message
-    console.print(f"[bold red]Error:[/] {error_message}")
+    console.print(f"[bold red]{e.response.json()['detail']}[/]")
     sys.exit(1)
 
 
@@ -24,13 +23,15 @@ def start_optimization_session(
     search_policy_config: Dict[str, Any],
     additional_instructions: str = None,
     api_keys: Dict[str, Any] = {},
+    auth_headers: dict = {},  # Add auth_headers
     timeout: int = 800,
 ) -> Dict[str, Any]:
     """Start the optimization session."""
     with console.status("[bold green]Starting Optimization..."):
         try:
+            # __base_url__ already contains /v1
             response = requests.post(
-                f"{__base_url__}/sessions",
+                f"{__base_url__}/sessions",  # Path is relative to base_url
                 json={
                     "source_code": source_code,
                     "additional_instructions": additional_instructions,
@@ -43,6 +44,7 @@ def start_optimization_session(
                     },
                     "metadata": {"client_name": "cli", "client_version": __pkg_version__, **api_keys},
                 },
+                headers=auth_headers,  # Add headers
                 timeout=timeout,
             )
             response.raise_for_status()
@@ -57,17 +59,20 @@ def evaluate_feedback_then_suggest_next_solution(
     execution_output: str,
     additional_instructions: str = None,
     api_keys: Dict[str, Any] = {},
+    auth_headers: dict = {},  # Add auth_headers
     timeout: int = 800,
 ) -> Dict[str, Any]:
     """Evaluate the feedback and suggest the next solution."""
     try:
+        # __base_url__ already contains /v1
         response = requests.post(
-            f"{__base_url__}/sessions/{session_id}/suggest",
+            f"{__base_url__}/sessions/{session_id}/suggest",  # Path is relative to base_url
             json={
                 "execution_output": execution_output,
                 "additional_instructions": additional_instructions,
                 "metadata": {**api_keys},
             },
+            headers=auth_headers,  # Add headers
             timeout=timeout,
         )
         response.raise_for_status()
@@ -77,12 +82,20 @@ def evaluate_feedback_then_suggest_next_solution(
 
 
 def get_optimization_session_status(
-    console: rich.console.Console, session_id: str, include_history: bool = False, timeout: int = 800
+    console: rich.console.Console,
+    session_id: str,
+    include_history: bool = False,
+    auth_headers: dict = {},
+    timeout: int = 800,  # Add auth_headers
 ) -> Dict[str, Any]:
     """Get the current status of the optimization session."""
     try:
+        # __base_url__ already contains /v1
         response = requests.get(
-            f"{__base_url__}/sessions/{session_id}", params={"include_history": include_history}, timeout=timeout
+            f"{__base_url__}/sessions/{session_id}",  # Path is relative to base_url
+            params={"include_history": include_history},
+            headers=auth_headers,  # Add headers
+            timeout=timeout,
         )
         response.raise_for_status()
         return response.json()

weco/auth.py

@@ -0,0 +1,64 @@
+# weco/auth.py
+import os
+import pathlib
+import json
+import stat
+
+CONFIG_DIR = pathlib.Path.home() / ".config" / "weco"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials.json"
+
+
+def ensure_config_dir():
+    """Ensures the configuration directory exists."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    # Ensure directory permissions are secure (optional but good practice)
+    try:
+        os.chmod(CONFIG_DIR, stat.S_IRWXU)  # Read/Write/Execute for owner only
+    except OSError as e:
+        print(f"Warning: Could not set permissions on {CONFIG_DIR}: {e}")
+
+
+def save_api_key(api_key: str):
+    """Saves the Weco API key securely."""
+    ensure_config_dir()
+    credentials = {"api_key": api_key}
+    try:
+        with open(CREDENTIALS_FILE, "w") as f:
+            json.dump(credentials, f)
+        # Set file permissions to read/write for owner only (600)
+        os.chmod(CREDENTIALS_FILE, stat.S_IRUSR | stat.S_IWUSR)
+    except IOError as e:
+        print(f"Error: Could not write credentials file at {CREDENTIALS_FILE}: {e}")
+    except OSError as e:
+        print(f"Warning: Could not set permissions on {CREDENTIALS_FILE}: {e}")
+
+
+def load_weco_api_key() -> str | None:
+    """Loads the Weco API key."""
+    if not CREDENTIALS_FILE.exists():
+        return None
+    try:
+        # Check permissions before reading (optional but safer)
+        file_stat = os.stat(CREDENTIALS_FILE)
+        if file_stat.st_mode & (stat.S_IRWXG | stat.S_IRWXO):  # Check if group/other have permissions
+            print(f"Warning: Credentials file {CREDENTIALS_FILE} has insecure permissions. Please set to 600.")
+            # Optionally, refuse to load or try to fix permissions
+
+        with open(CREDENTIALS_FILE, "r") as f:
+            credentials = json.load(f)
+            return credentials.get("api_key")
+    except (IOError, json.JSONDecodeError, OSError) as e:
+        print(f"Warning: Could not read or parse credentials file at {CREDENTIALS_FILE}: {e}")
+        return None
+
+
+def clear_api_key():
+    """Removes the stored API key."""
+    if CREDENTIALS_FILE.exists():
+        try:
+            os.remove(CREDENTIALS_FILE)
+            print("Logged out successfully.")
+        except OSError as e:
+            print(f"Error: Could not remove credentials file at {CREDENTIALS_FILE}: {e}")
+    else:
+        print("Already logged out.")

weco/cli.py

@@ -2,11 +2,23 @@ import argparse
 import sys
 import pathlib
 import math
+import time
+import requests
+import webbrowser
 from rich.console import Console
 from rich.live import Live
 from rich.panel import Panel
 from rich.traceback import install
-from .api import start_optimization_session, evaluate_feedback_then_suggest_next_solution, get_optimization_session_status
+from rich.prompt import Prompt
+from .api import (
+    start_optimization_session,
+    evaluate_feedback_then_suggest_next_solution,
+    get_optimization_session_status,
+    handle_api_error,
+)
+
+from . import __base_url__
+from .auth import load_weco_api_key, save_api_key, clear_api_key
 from .panels import (
     SummaryPanel,
     PlanPanel,
@@ -31,348 +43,541 @@ install(show_locals=True)
 console = Console()
 
 
+def perform_login(console: Console):
+    """Handles the device login flow."""
+    try:
+        # 1. Initiate device login
+        console.print("Initiating login...")
+        init_response = requests.post(f"{__base_url__}/auth/device/initiate")
+        init_response.raise_for_status()
+        init_data = init_response.json()
+
+        device_code = init_data["device_code"]
+        verification_uri = init_data["verification_uri"]
+        expires_in = init_data["expires_in"]
+        interval = init_data["interval"]
+
+        # 2. Display instructions
+        console.print("\n[bold yellow]Action Required:[/]")
+        console.print("Please open the following URL in your browser to authenticate:")
+        console.print(f"[link={verification_uri}]{verification_uri}[/link]")
+        console.print(f"This request will expire in {expires_in // 60} minutes.")
+        console.print("Attempting to open the authentication page in your default browser...")  # Notify user
+
+        # Automatically open the browser
+        try:
+            if not webbrowser.open(verification_uri):
+                console.print("[yellow]Could not automatically open the browser. Please open the link manually.[/]")
+        except Exception as browser_err:
+            console.print(
+                f"[yellow]Could not automatically open the browser ({browser_err}). Please open the link manually.[/]"
+            )
+
+        console.print("Waiting for authentication...", end="")
+
+        # 3. Poll for token
+        start_time = time.time()
+        # Use a simple text update instead of Spinner within Live for potentially better compatibility
+        polling_status = "Waiting..."
+        with Live(polling_status, refresh_per_second=1, transient=True, console=console) as live_status:
+            while True:
+                # Check for timeout
+                if time.time() - start_time > expires_in:
+                    console.print("\n[bold red]Error:[/] Login request timed out.")
+                    return False
+
+                time.sleep(interval)
+                live_status.update("Waiting... (checking status)")
+
+                try:
+                    token_response = requests.post(
+                        f"{__base_url__}/auth/device/token",  # REMOVED /v1 prefix
+                        json={"grant_type": "urn:ietf:params:oauth:grant-type:device_code", "device_code": device_code},
+                    )
+
+                    # Check for 202 Accepted - Authorization Pending
+                    if token_response.status_code == 202:
+                        token_data = token_response.json()
+                        if token_data.get("error") == "authorization_pending":
+                            live_status.update("Waiting... (authorization pending)")
+                            continue  # Continue polling
+                        else:
+                            # Unexpected 202 response format
+                            console.print(f"\n[bold red]Error:[/] Received unexpected 202 response: {token_data}")
+                            return False
+
+                    # Check for standard OAuth2 errors (often 400 Bad Request)
+                    elif token_response.status_code == 400:
+                        token_data = token_response.json()
+                        error_code = token_data.get("error", "unknown_error")
+                        # NOTE: Removed "authorization_pending" check from here
+                        if error_code == "slow_down":
+                            interval += 5  # Increase polling interval if instructed
+                            live_status.update(f"Waiting... (slowing down polling to {interval}s)")
+                            continue
+                        elif error_code == "expired_token":
+                            console.print("\n[bold red]Error:[/] Login request expired.")
+                            return False
+                        elif error_code == "access_denied":
+                            console.print("\n[bold red]Error:[/] Authorization denied by user.")
+                            return False
+                        else:  # invalid_grant, etc.
+                            error_desc = token_data.get("error_description", "Unknown error during polling.")
+                            console.print(f"\n[bold red]Error:[/] {error_desc} ({error_code})")
+                            return False
+
+                    # Check for other non-200/non-202/non-400 HTTP errors
+                    token_response.raise_for_status()
+
+                    # If successful (200 OK and no 'error' field)
+                    token_data = token_response.json()
+                    if "access_token" in token_data:
+                        api_key = token_data["access_token"]
+                        save_api_key(api_key)
+                        console.print("\n[bold green]Login successful![/]")
+                        return True
+                    else:
+                        # Unexpected successful response format
+                        console.print("\n[bold red]Error:[/] Received unexpected response from server during polling.")
+                        print(token_data)  # Log for debugging
+                        return False
+
+                except requests.exceptions.RequestException as e:
+                    # Handle network errors during polling gracefully
+                    live_status.update("Waiting... (network error, retrying)")
+                    console.print(f"\n[bold yellow]Warning:[/] Network error during polling: {e}. Retrying...")
+                    # Optional: implement backoff strategy
+                    time.sleep(interval * 2)  # Simple backoff
+
+    except requests.exceptions.HTTPError as e:  # Catch HTTPError specifically for handle_api_error
+        handle_api_error(e, console)
+    except requests.exceptions.RequestException as e:  # Catch other request errors
+        console.print(f"\n[bold red]Network Error:[/] {e}")
+        return False
+    except Exception as e:
+        console.print(f"\n[bold red]An unexpected error occurred during login:[/] {e}")
+        return False
+
+
 def main() -> None:
     """Main function for the Weco CLI."""
+    # --- Argument Parsing ---
     parser = argparse.ArgumentParser(
         description="[bold cyan]Weco CLI[/]", formatter_class=argparse.RawDescriptionHelpFormatter
     )
-    parser.add_argument("--source", type=str, required=True, help="Path to the source code (e.g. optimize.py)")
-    parser.add_argument(
+    # Add subparsers for commands like 'run' and 'logout'
+    subparsers = parser.add_subparsers(dest="command", help="Available commands", required=True)  # Make command required
+
+    # --- Run Command ---
+    run_parser = subparsers.add_parser(
+        "run", help="Run code optimization", formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    # Add arguments specific to the 'run' command to the run_parser
+    run_parser.add_argument("--source", type=str, required=True, help="Path to the source code file (e.g. optimize.py)")
+    run_parser.add_argument(
         "--eval-command", type=str, required=True, help="Command to run for evaluation (e.g. 'python eval.py --arg1=val1')"
     )
-    parser.add_argument("--metric", type=str, required=True, help="Metric to optimize")
-    parser.add_argument(
+    run_parser.add_argument("--metric", type=str, required=True, help="Metric to optimize")
+    run_parser.add_argument(
         "--maximize",
         type=str,
         choices=["true", "false"],
         required=True,
         help="Specify 'true' to maximize the metric or 'false' to minimize.",
     )
-    parser.add_argument("--steps", type=int, required=True, help="Number of steps to run")
-    parser.add_argument("--model", type=str, required=True, help="Model to use for optimization")
-    parser.add_argument("--log-dir", type=str, default=".runs", help="Directory to store logs and results")
-    parser.add_argument(
+    run_parser.add_argument("--steps", type=int, required=True, help="Number of steps to run")
+    run_parser.add_argument("--model", type=str, required=True, help="Model to use for optimization")
+    run_parser.add_argument("--log-dir", type=str, default=".runs", help="Directory to store logs and results")
+    run_parser.add_argument(
         "--additional-instructions",
         default=None,
         type=str,
         help="Description of additional instruction or path to a file containing additional instructions",
     )
-    parser.add_argument(
+    run_parser.add_argument(
         "--preserve-source",
         action="store_true",
         help="If set, do not overwrite the original source file; only save modified versions in the runs directory",
     )
+
+    # --- Logout Command ---
+    _ = subparsers.add_parser("logout", help="Log out from Weco and clear saved API key.")
+
     args = parser.parse_args()
 
-    try:
-        with console.status("[bold green]Loading Modules..."):
-            # Define optimization session config
+    # --- Handle Logout Command ---
+    if args.command == "logout":
+        clear_api_key()
+        sys.exit(0)
+
+    # --- Handle Run Command ---
+    elif args.command == "run":
+        # --- Check Authentication ---
+        weco_api_key = load_weco_api_key()
+        llm_api_keys = read_api_keys_from_env()  # Read keys from client environment
+
+        if not weco_api_key:
+            login_choice = Prompt.ask(
+                "Log in to Weco to save run history or use anonymously? ([bold]L[/]ogin / [bold]S[/]kip)",
+                choices=["l", "s"],
+                default="s",
+            ).lower()
+
+            if login_choice == "l":
+                console.print("[cyan]Starting login process...[/]")
+                if not perform_login(console):
+                    console.print("[bold red]Login process failed or was cancelled.[/]")
+                    sys.exit(1)
+                weco_api_key = load_weco_api_key()
+                if not weco_api_key:
+                    console.print("[bold red]Error: Login completed but failed to retrieve API key.[/]")
+                    sys.exit(1)
+
+            elif login_choice == "s":
+                console.print("[yellow]Proceeding anonymously. LLM API keys must be provided via environment variables.[/]")
+                if not llm_api_keys:
+                    console.print(
+                        "[bold red]Error:[/] No LLM API keys found in environment (e.g., OPENAI_API_KEY). Cannot proceed anonymously."
+                    )
+                    sys.exit(1)
+
+        # --- Prepare API Call Arguments ---
+        auth_headers = {}
+
+        if weco_api_key:
+            auth_headers["Authorization"] = f"Bearer {weco_api_key}"
+            # Backend will decide whether to use client keys based on auth status
+
+        # --- Main Run Logic ---
+        try:
+            # --- Configuration Loading ---
             evaluation_command = args.eval_command
             metric_name = args.metric
             maximize = args.maximize == "true"
             steps = args.steps
             code_generator_config = {"model": args.model}
-            evaluator_config = {"model": args.model}
+            evaluator_config = {
+                "model": args.model,
+                "include_analysis": False,  # NOTE: False for now
+            }
             search_policy_config = {
-                "num_drafts": max(1, math.ceil(0.15 * steps)),  # 15% of steps
+                "num_drafts": max(1, math.ceil(0.15 * steps)),
                 "debug_prob": 0.5,
-                "max_debug_depth": max(1, math.ceil(0.1 * steps)),  # 10% of steps
+                "max_debug_depth": max(1, math.ceil(0.1 * steps)),
             }
-            # Read API keys
-            api_keys = read_api_keys_from_env()
-            # API request timeout
-            timeout = 800
-
             # Read additional instructions
             additional_instructions = read_additional_instructions(additional_instructions=args.additional_instructions)
-            # Read source code
+            # Read source code path
             source_fp = pathlib.Path(args.source)
+            # Read source code content
             source_code = read_from_path(fp=source_fp, is_json=False)
+            # API request timeout
+            timeout = 800
 
-        # Initialize panels
-        summary_panel = SummaryPanel(
-            maximize=maximize, metric_name=metric_name, total_steps=steps, model=args.model, runs_dir=args.log_dir
-        )
-        plan_panel = PlanPanel()
-        solution_panels = SolutionPanels(metric_name=metric_name, source_fp=source_fp)
-        eval_output_panel = EvaluationOutputPanel()
-        tree_panel = MetricTreePanel(maximize=maximize)
-        layout = create_optimization_layout()
-        end_optimization_layout = create_end_optimization_layout()
-
-        # Start optimization session
-        session_response = start_optimization_session(
-            console=console,
-            source_code=source_code,
-            evaluation_command=evaluation_command,
-            metric_name=metric_name,
-            maximize=maximize,
-            steps=steps,
-            code_generator_config=code_generator_config,
-            evaluator_config=evaluator_config,
-            search_policy_config=search_policy_config,
-            additional_instructions=additional_instructions,
-            api_keys=api_keys,
-            timeout=timeout,
-        )
-
-        # Define the refresh rate
-        refresh_rate = 4
-        with Live(layout, refresh_per_second=refresh_rate, screen=True) as live:
-            # Define the runs directory (.runs/<session-id>)
-            session_id = session_response["session_id"]
-            runs_dir = pathlib.Path(args.log_dir) / session_id
-            runs_dir.mkdir(parents=True, exist_ok=True)
-
-            # Save the original code (.runs/<session-id>/original.<extension>)
-            runs_copy_source_fp = runs_dir / f"original{source_fp.suffix}"
-            write_to_path(fp=runs_copy_source_fp, content=source_code)
-
-            # Write the code string to the source file path
-            # Do this after the original code is saved
-            if not args.preserve_source:
-                write_to_path(fp=source_fp, content=session_response["code"])
-
-            # Update the panels with the initial solution
-            # Add session id now that we have it
-            summary_panel.session_id = session_id
-            # Set the step of the progress bar
-            summary_panel.set_step(step=0)
-            # Update the token counts
-            summary_panel.update_token_counts(usage=session_response["usage"])
-            # Update the plan
-            plan_panel.update(plan=session_response["plan"])
-            # Build the metric tree
-            tree_panel.build_metric_tree(
-                nodes=[
-                    {
-                        "solution_id": session_response["solution_id"],
-                        "parent_id": None,
-                        "code": session_response["code"],
-                        "step": 0,
-                        "metric_value": None,
-                        "is_buggy": False,
-                    }
-                ]
-            )
-            # Set the current solution as unevaluated since we haven't run the evaluation function and fed it back to the model yet
-            tree_panel.set_unevaluated_node(node_id=session_response["solution_id"])
-            # Update the solution panels with the initial solution and get the panel displays
-            solution_panels.update(
-                current_node=Node(
-                    id=session_response["solution_id"],
-                    parent_id=None,
-                    code=session_response["code"],
-                    metric=None,
-                    is_buggy=False,
-                ),
-                best_node=None,
+            # --- Panel Initialization ---
+            summary_panel = SummaryPanel(
+                maximize=maximize, metric_name=metric_name, total_steps=steps, model=args.model, runs_dir=args.log_dir
             )
-            current_solution_panel, best_solution_panel = solution_panels.get_display(current_step=0)
-
-            # Update the entire layout
-            smooth_update(
-                live=live,
-                layout=layout,
-                sections_to_update=[
-                    ("summary", summary_panel.get_display()),
-                    ("plan", plan_panel.get_display()),
-                    ("tree", tree_panel.get_display()),
-                    ("current_solution", current_solution_panel),
-                    ("best_solution", best_solution_panel),
-                    ("eval_output", eval_output_panel.get_display()),
-                ],
-                transition_delay=0.1,  # Slightly longer delay for initial display
+            plan_panel = PlanPanel()
+            solution_panels = SolutionPanels(metric_name=metric_name, source_fp=source_fp)
+            eval_output_panel = EvaluationOutputPanel()
+            tree_panel = MetricTreePanel(maximize=maximize)
+            layout = create_optimization_layout()
+            end_optimization_layout = create_end_optimization_layout()
+
+            # --- Start Optimization Session ---
+            session_response = start_optimization_session(
+                console=console,
+                source_code=source_code,
+                evaluation_command=evaluation_command,
+                metric_name=metric_name,
+                maximize=maximize,
+                steps=steps,
+                code_generator_config=code_generator_config,
+                evaluator_config=evaluator_config,
+                search_policy_config=search_policy_config,
+                additional_instructions=additional_instructions,
+                api_keys=llm_api_keys,  # Pass client LLM keys
+                auth_headers=auth_headers,  # Pass Weco key if logged in
+                timeout=timeout,
             )
 
-            # Run evaluation on the initial solution
-            term_out = run_evaluation(eval_command=args.eval_command)
+            # --- Live Update Loop ---
+            refresh_rate = 4
+            with Live(layout, refresh_per_second=refresh_rate, screen=True) as live:
+                # Define the runs directory (.runs/<session-id>)
+                session_id = session_response["session_id"]
+                runs_dir = pathlib.Path(args.log_dir) / session_id
+                runs_dir.mkdir(parents=True, exist_ok=True)
 
-            # Update the evaluation output panel
-            eval_output_panel.update(output=term_out)
-            smooth_update(
-                live=live,
-                layout=layout,
-                sections_to_update=[("eval_output", eval_output_panel.get_display())],
-                transition_delay=0.1,
-            )
+                # Save the original code (.runs/<session-id>/original.<extension>)
+                runs_copy_source_fp = runs_dir / f"original{source_fp.suffix}"  # Use correct suffix
+                write_to_path(fp=runs_copy_source_fp, content=source_code)
 
-            for step in range(1, steps):
-                # Evaluate the current output and get the next solution
-                eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
-                    console=console,
-                    session_id=session_id,
-                    execution_output=term_out,
-                    additional_instructions=None,
-                    api_keys=api_keys,
-                    timeout=timeout,
-                )
-                # Save next solution (.runs/<session-id>/step_<step>.<extension>)
-                write_to_path(fp=runs_dir / f"step_{step}{source_fp.suffix}", content=eval_and_next_solution_response["code"])
-
-                # Write the next solution to the source file
+                # Write the initial code string to the source file path (if not preserving)
                 if not args.preserve_source:
-                    write_to_path(fp=source_fp, content=eval_and_next_solution_response["code"])
+                    write_to_path(fp=source_fp, content=session_response["code"])
 
-                # Get the optimization session status for
-                # the best solution, its score, and the history to plot the tree
-                status_response = get_optimization_session_status(
-                    console=console, session_id=session_id, include_history=True, timeout=timeout
-                )
-
-                # Update the step of the progress bar
-                summary_panel.set_step(step=step)
+                # Update the panels with the initial solution
+                summary_panel.set_session_id(session_id=session_id)  # Add session id now that we have it
+                # Set the step of the progress bar
+                summary_panel.set_step(step=0)
                 # Update the token counts
-                summary_panel.update_token_counts(usage=eval_and_next_solution_response["usage"])
+                summary_panel.update_token_counts(usage=session_response["usage"])
                 # Update the plan
-                plan_panel.update(plan=eval_and_next_solution_response["plan"])
+                plan_panel.update(plan=session_response["plan"])
                 # Build the metric tree
-                tree_panel.build_metric_tree(nodes=status_response["history"])
+                tree_panel.build_metric_tree(
+                    nodes=[
+                        {
+                            "solution_id": session_response["solution_id"],
+                            "parent_id": None,
+                            "code": session_response["code"],
+                            "step": 0,
+                            "metric_value": None,
+                            "is_buggy": False,
+                        }
+                    ]
+                )
                 # Set the current solution as unevaluated since we haven't run the evaluation function and fed it back to the model yet
-                tree_panel.set_unevaluated_node(node_id=eval_and_next_solution_response["solution_id"])
-
-                # Update the solution panels with the next solution and best solution (and score)
-                # Figure out if we have a best solution so far
-                if status_response["best_result"] is not None:
-                    best_solution_node = Node(
-                        id=status_response["best_result"]["solution_id"],
-                        parent_id=status_response["best_result"]["parent_id"],
-                        code=status_response["best_result"]["code"],
-                        metric=status_response["best_result"]["metric_value"],
-                        is_buggy=status_response["best_result"]["is_buggy"],
-                    )
-                else:
-                    best_solution_node = None
-
-                # Create a node for the current solution
-                current_solution_node = None
-                for node in status_response["history"]:
-                    if node["solution_id"] == eval_and_next_solution_response["solution_id"]:
-                        current_solution_node = Node(
-                            id=node["solution_id"],
-                            parent_id=node["parent_id"],
-                            code=node["code"],
-                            metric=node["metric_value"],
-                            is_buggy=node["is_buggy"],
-                        )
-                if current_solution_node is None:
-                    raise ValueError("Current solution node not found in history")
-                # Update the solution panels with the current and best solution
-                solution_panels.update(current_node=current_solution_node, best_node=best_solution_node)
-                current_solution_panel, best_solution_panel = solution_panels.get_display(current_step=step)
-
-                # Clear evaluation output since we are running a evaluation on a new solution
-                eval_output_panel.clear()
-
-                # Update displays with smooth transitions
+                tree_panel.set_unevaluated_node(node_id=session_response["solution_id"])
+                # Update the solution panels with the initial solution and get the panel displays
+                solution_panels.update(
+                    current_node=Node(
+                        id=session_response["solution_id"],
+                        parent_id=None,
+                        code=session_response["code"],
+                        metric=None,
+                        is_buggy=False,
+                    ),
+                    best_node=None,
+                )
+                current_solution_panel, best_solution_panel = solution_panels.get_display(current_step=0)
+                # Update the live layout with the initial solution panels
                 smooth_update(
                     live=live,
                     layout=layout,
                     sections_to_update=[
                         ("summary", summary_panel.get_display()),
                         ("plan", plan_panel.get_display()),
-                        ("tree", tree_panel.get_display()),
+                        ("tree", tree_panel.get_display(is_done=False)),
                         ("current_solution", current_solution_panel),
                         ("best_solution", best_solution_panel),
                         ("eval_output", eval_output_panel.get_display()),
                     ],
-                    transition_delay=0.08,  # Slightly longer delay for more noticeable transitions
+                    transition_delay=0.1,
                 )
 
-                # Run evaluation on the current solution
+                # Run evaluation on the initial solution
                 term_out = run_evaluation(eval_command=args.eval_command)
-                eval_output_panel.update(output=term_out)
 
-                # Update evaluation output with a smooth transition
+                # Update the evaluation output panel
+                eval_output_panel.update(output=term_out)
                 smooth_update(
                     live=live,
                     layout=layout,
                     sections_to_update=[("eval_output", eval_output_panel.get_display())],
-                    transition_delay=0.1,  # Slightly longer delay for evaluation results
+                    transition_delay=0.1,
                 )
 
-            # Ensure we pass evaluation results for the last step's generated solution
-            eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
-                console=console,
-                session_id=session_id,
-                execution_output=term_out,
-                additional_instructions=None,
-                api_keys=api_keys,
-                timeout=timeout,
-            )
+                for step in range(1, steps):
+                    # Re-read instructions from the original source (file path or string) BEFORE each suggest call
+                    current_additional_instructions = read_additional_instructions(
+                        additional_instructions=args.additional_instructions
+                    )
 
-            # Update the progress bar
-            summary_panel.set_step(step=steps)
-            # Update the token counts
-            summary_panel.update_token_counts(usage=eval_and_next_solution_response["usage"])
-            # No need to update the plan panel since we have finished the optimization
-            # Get the optimization session status for
-            # the best solution, its score, and the history to plot the tree
-            status_response = get_optimization_session_status(
-                console=console, session_id=session_id, include_history=True, timeout=timeout
-            )
-            # Build the metric tree
-            tree_panel.build_metric_tree(nodes=status_response["history"])
-            # No need to set any solution to unevaluated since we have finished the optimization
-            # and all solutions have been evaluated
-            # No neeed to update the current solution panel since we have finished the optimization
-            # We only need to update the best solution panel
-            # Figure out if we have a best solution so far
-            if status_response["best_result"] is not None:
-                best_solution_node = Node(
-                    id=status_response["best_result"]["solution_id"],
-                    parent_id=status_response["best_result"]["parent_id"],
-                    code=status_response["best_result"]["code"],
-                    metric=status_response["best_result"]["metric_value"],
-                    is_buggy=status_response["best_result"]["is_buggy"],
+                    # Send feedback and get next suggestion
+                    eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
+                        console=console,
+                        session_id=session_id,
+                        execution_output=term_out,
+                        additional_instructions=current_additional_instructions,  # Pass current instructions
+                        api_keys=llm_api_keys,  # Pass client LLM keys
+                        auth_headers=auth_headers,  # Pass Weco key if logged in
+                        timeout=timeout,
+                    )
+                    # Save next solution (.runs/<session-id>/step_<step>.<extension>)
+                    write_to_path(
+                        fp=runs_dir / f"step_{step}{source_fp.suffix}", content=eval_and_next_solution_response["code"]
+                    )
+
+                    # Write the next solution to the source file
+                    if not args.preserve_source:
+                        write_to_path(fp=source_fp, content=eval_and_next_solution_response["code"])
+
+                    # Get the optimization session status for
+                    # the best solution, its score, and the history to plot the tree
+                    status_response = get_optimization_session_status(
+                        console=console,
+                        session_id=session_id,
+                        include_history=True,
+                        timeout=timeout,
+                        auth_headers=auth_headers,
+                    )
+
+                    # Update the step of the progress bar
+                    summary_panel.set_step(step=step)
+                    # Update the token counts
+                    summary_panel.update_token_counts(usage=eval_and_next_solution_response["usage"])
+                    # Update the plan
+                    plan_panel.update(plan=eval_and_next_solution_response["plan"])
+                    # Build the metric tree
+                    tree_panel.build_metric_tree(nodes=status_response["history"])
+                    # Set the current solution as unevaluated since we haven't run the evaluation function and fed it back to the model yet
+                    tree_panel.set_unevaluated_node(node_id=eval_and_next_solution_response["solution_id"])
+
+                    # Update the solution panels with the next solution and best solution (and score)
+                    # Figure out if we have a best solution so far
+                    if status_response["best_result"] is not None:
+                        best_solution_node = Node(
+                            id=status_response["best_result"]["solution_id"],
+                            parent_id=status_response["best_result"]["parent_id"],
+                            code=status_response["best_result"]["code"],
+                            metric=status_response["best_result"]["metric_value"],
+                            is_buggy=status_response["best_result"]["is_buggy"],
+                        )
+                    else:
+                        best_solution_node = None
+
+                    # Create a node for the current solution
+                    current_solution_node = None
+                    for node in status_response["history"]:
+                        if node["solution_id"] == eval_and_next_solution_response["solution_id"]:
+                            current_solution_node = Node(
+                                id=node["solution_id"],
+                                parent_id=node["parent_id"],
+                                code=node["code"],
+                                metric=node["metric_value"],
+                                is_buggy=node["is_buggy"],
+                            )
+                    if current_solution_node is None:
+                        raise ValueError("Current solution node not found in history")
+                    # Update the solution panels with the current and best solution
+                    solution_panels.update(current_node=current_solution_node, best_node=best_solution_node)
+                    current_solution_panel, best_solution_panel = solution_panels.get_display(current_step=step)
+
+                    # Clear evaluation output since we are running a evaluation on a new solution
+                    eval_output_panel.clear()
+
+                    # Update displays with smooth transitions
+                    smooth_update(
+                        live=live,
+                        layout=layout,
+                        sections_to_update=[
+                            ("summary", summary_panel.get_display()),
+                            ("plan", plan_panel.get_display()),
+                            ("tree", tree_panel.get_display(is_done=False)),
+                            ("current_solution", current_solution_panel),
+                            ("best_solution", best_solution_panel),
+                            ("eval_output", eval_output_panel.get_display()),
+                        ],
+                        transition_delay=0.08,  # Slightly longer delay for more noticeable transitions
+                    )
+
+                    # Run evaluation on the current solution
+                    term_out = run_evaluation(eval_command=args.eval_command)
+                    eval_output_panel.update(output=term_out)
+
+                    # Update evaluation output with a smooth transition
+                    smooth_update(
+                        live=live,
+                        layout=layout,
+                        sections_to_update=[("eval_output", eval_output_panel.get_display())],
+                        transition_delay=0.1,  # Slightly longer delay for evaluation results
+                    )
+
+                # Re-read instructions from the original source (file path or string) BEFORE each suggest call
+                current_additional_instructions = read_additional_instructions(
+                    additional_instructions=args.additional_instructions
                 )
-            else:
-                best_solution_node = None
-            solution_panels.update(current_node=None, best_node=best_solution_node)
-            _, best_solution_panel = solution_panels.get_display(current_step=steps)
-
-            # Update the end optimization layout
-            final_message = (
-                f"{summary_panel.metric_name.capitalize()} {'maximized' if summary_panel.maximize else 'minimized'}! Best solution {summary_panel.metric_name.lower()} = [green]{status_response['best_result']['metric_value']}[/] 🏆"
-                if best_solution_node is not None and best_solution_node.metric is not None
-                else "[red] No valid solution found.[/]"
-            )
-            end_optimization_layout["summary"].update(summary_panel.get_display(final_message=final_message))
-            end_optimization_layout["tree"].update(tree_panel.get_display())
-            end_optimization_layout["best_solution"].update(best_solution_panel)
-
-            # Save optimization results
-            # If the best solution does not exist or is has not been measured at the end of the optimization
-            # save the original solution as the best solution
-            if best_solution_node is not None:
-                best_solution_code = best_solution_node.code
-                best_solution_score = best_solution_node.metric
-            else:
-                best_solution_code = None
-                best_solution_score = None
-
-            if best_solution_code is None or best_solution_score is None:
-                best_solution_content = (
-                    f"# Weco could not find a better solution\n\n{read_from_path(fp=runs_copy_source_fp, is_json=False)}"
+
+                # Ensure we pass evaluation results for the last step's generated solution
+                eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
+                    console=console,
+                    session_id=session_id,
+                    execution_output=term_out,
+                    additional_instructions=current_additional_instructions,
+                    api_keys=llm_api_keys,
+                    timeout=timeout,
+                    auth_headers=auth_headers,
                 )
-            else:
-                # Format score for the comment
-                best_score_str = (
-                    format_number(best_solution_score)
-                    if best_solution_score is not None and isinstance(best_solution_score, (int, float))
-                    else "N/A"
+
+                # Update the progress bar
+                summary_panel.set_step(step=steps)
+                # Update the token counts
+                summary_panel.update_token_counts(usage=eval_and_next_solution_response["usage"])
+                # No need to update the plan panel since we have finished the optimization
+                # Get the optimization session status for
+                # the best solution, its score, and the history to plot the tree
+                status_response = get_optimization_session_status(
+                    console=console, session_id=session_id, include_history=True, timeout=timeout, auth_headers=auth_headers
+                )
+                # Build the metric tree
+                tree_panel.build_metric_tree(nodes=status_response["history"])
+                # No need to set any solution to unevaluated since we have finished the optimization
+                # and all solutions have been evaluated
+                # No neeed to update the current solution panel since we have finished the optimization
+                # We only need to update the best solution panel
+                # Figure out if we have a best solution so far
+                if status_response["best_result"] is not None:
+                    best_solution_node = Node(
+                        id=status_response["best_result"]["solution_id"],
+                        parent_id=status_response["best_result"]["parent_id"],
+                        code=status_response["best_result"]["code"],
+                        metric=status_response["best_result"]["metric_value"],
+                        is_buggy=status_response["best_result"]["is_buggy"],
+                    )
+                else:
+                    best_solution_node = None
+                solution_panels.update(current_node=None, best_node=best_solution_node)
+                _, best_solution_panel = solution_panels.get_display(current_step=steps)
+
+                # Update the end optimization layout
+                final_message = (
+                    f"{summary_panel.metric_name.capitalize()} {'maximized' if summary_panel.maximize else 'minimized'}! Best solution {summary_panel.metric_name.lower()} = [green]{status_response['best_result']['metric_value']}[/] 🏆"
+                    if best_solution_node is not None and best_solution_node.metric is not None
+                    else "[red] No valid solution found.[/]"
                 )
-                best_solution_content = f"# Best solution from Weco with a score of {best_score_str}\n\n{best_solution_code}"
+                end_optimization_layout["summary"].update(summary_panel.get_display(final_message=final_message))
+                end_optimization_layout["tree"].update(tree_panel.get_display(is_done=True))
+                end_optimization_layout["best_solution"].update(best_solution_panel)
+
+                # Save optimization results
+                # If the best solution does not exist or is has not been measured at the end of the optimization
+                # save the original solution as the best solution
+                if best_solution_node is not None:
+                    best_solution_code = best_solution_node.code
+                    best_solution_score = best_solution_node.metric
+                else:
+                    best_solution_code = None
+                    best_solution_score = None
 
-            # Save best solution to .runs/<session-id>/best.<extension>
-            write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_content)
+                if best_solution_code is None or best_solution_score is None:
+                    best_solution_content = (
+                        f"# Weco could not find a better solution\n\n{read_from_path(fp=runs_copy_source_fp, is_json=False)}"
+                    )
+                else:
+                    # Format score for the comment
+                    best_score_str = (
+                        format_number(best_solution_score)
+                        if best_solution_score is not None and isinstance(best_solution_score, (int, float))
+                        else "N/A"
+                    )
+                    best_solution_content = (
+                        f"# Best solution from Weco with a score of {best_score_str}\n\n{best_solution_code}"
+                    )
 
-            # write the best solution to the source file
-            if not args.preserve_source:
-                write_to_path(fp=source_fp, content=best_solution_content)
+                # Save best solution to .runs/<session-id>/best.<extension>
+                write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_content)
 
-        console.print(end_optimization_layout)
+                # write the best solution to the source file
+                if not args.preserve_source:
+                    write_to_path(fp=source_fp, content=best_solution_content)
 
-    except Exception as e:
-        console.print(Panel(f"[bold red]Error: {str(e)}", title="[bold red]Error", border_style="red"))
-        sys.exit(1)
+            console.print(end_optimization_layout)
+
+        except Exception as e:
+            console.print(Panel(f"[bold red]Error: {str(e)}", title="[bold red]Error", border_style="red"))
+            # Print traceback for debugging
+            console.print_exception(show_locals=True)
+            sys.exit(1)

weco/panels.py

@@ -7,6 +7,7 @@ from rich.syntax import Syntax
 from typing import Dict, List, Optional, Union, Tuple
 from .utils import format_number
 import pathlib
+from .__init__ import __dashboard_url__
 
 
 class SummaryPanel:
@@ -22,6 +23,7 @@ class SummaryPanel:
         self.model = model
         self.runs_dir = runs_dir
         self.session_id = session_id if session_id is not None else "N/A"
+        self.dashboard_url = "N/A"
         self.progress = Progress(
             TextColumn("[progress.description]{task.description}"),
             BarColumn(bar_width=20),
@@ -32,6 +34,15 @@ class SummaryPanel:
         )
         self.task_id = self.progress.add_task("", total=total_steps)
 
+    def set_session_id(self, session_id: str):
+        """Set the session ID."""
+        self.session_id = session_id
+        self.set_dashboard_url(session_id=session_id)
+
+    def set_dashboard_url(self, session_id: str):
+        """Set the dashboard URL."""
+        self.dashboard_url = f"{__dashboard_url__}/runs/{session_id}"
+
     def set_step(self, step: int):
         """Set the current step."""
         self.progress.update(self.task_id, completed=step)
@@ -61,6 +72,9 @@ class SummaryPanel:
         # Log directory
         summary_table.add_row(f"[bold cyan]Logs:[/] [blue underline]{self.runs_dir}/{self.session_id}[/]")
         summary_table.add_row("")
+        # Dashboard link
+        summary_table.add_row(f"[bold cyan]Dashboard:[/] [blue underline]{self.dashboard_url}[/]")
+        summary_table.add_row("")
         # Token counts
         summary_table.add_row(
             f"[bold cyan]Tokens:[/] ↑[yellow]{format_number(self.total_input_tokens)}[/] ↓[yellow]{format_number(self.total_output_tokens)}[/] = [green]{format_number(self.total_input_tokens + self.total_output_tokens)}[/]"
@@ -229,11 +243,15 @@ class MetricTreePanel:
 
         return tree
 
-    def get_display(self) -> Panel:
+    def get_display(self, is_done: bool) -> Panel:
         """Get a panel displaying the solution tree."""
         # Make sure the metric tree is built before calling build_rich_tree
         return Panel(
-            self._build_rich_tree(), title="[bold]🔎 Exploring Solutions...", border_style="green", expand=True, padding=(0, 1)
+            self._build_rich_tree(),
+            title="[bold]🔎 Exploring Solutions..." if not is_done else "[bold]🔎 Optimization Complete!",
+            border_style="green",
+            expand=True,
+            padding=(0, 1),
         )
 
 

{weco-0.2.12.dist-info → weco-0.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weco
-Version: 0.2.12
+Version: 0.2.14
 Summary: Documentation for `weco`, a CLI for using Weco AI's code optimizer.
 Author-email: Weco AI Team <contact@weco.ai>
 License: MIT
@@ -32,7 +32,7 @@ Example applications include:
 
 - **GPU Kernel Optimization**: Reimplement PyTorch functions using CUDA, Triton or Metal, optimizing for `latency`, `throughput`, or `memory_bandwidth`.
 - **Model Development**: Tune feature transformations or architectures, optimizing for `validation_accuracy`, `AUC`, or `Sharpe Ratio`.
-- **Prompt Engineering**: Refine prompts for LLMs, optimizing for  `win_rate`, `relevance`, or `format_adherence`
+- **Prompt Engineering**: Refine prompts for LLMs, optimizing for `win_rate`, `relevance`, or `format_adherence`
 
 https://github.com/user-attachments/assets/cb724ef1-bff6-4757-b457-d3b2201ede81
 
@@ -42,7 +42,7 @@ https://github.com/user-attachments/assets/cb724ef1-bff6-4757-b457-d3b2201ede81
 
 The `weco` CLI leverages a tree search approach guided by Large Language Models (LLMs) to iteratively explore and refine your code. It automatically applies changes, runs your evaluation script, parses the results, and proposes further improvements based on the specified goal.
 
-![image](https://github.com/user-attachments/assets/a6ed63fa-9c40-498e-aa98-a873e5786509)
+[image](https://github.com/user-attachments/assets/a6ed63fa-9c40-498e-aa98-a873e5786509)
 
 ---
 
@@ -54,17 +54,38 @@ The `weco` CLI leverages a tree search approach guided by Large Language Models
     pip install weco
     ```
 
-2.  **Configure API Keys:**
+2.  **Set Up LLM API Keys (Required):**
 
-    Set the appropriate environment variables for your desired language model provider:
+    `weco` requires API keys for the Large Language Models (LLMs) it uses internally. You **must** provide these keys via environment variables:
 
-    -   **OpenAI:** `export OPENAI_API_KEY="your_key_here"`
-    -   **Anthropic:** `export ANTHROPIC_API_KEY="your_key_here"`
-    -   **Google DeepMind:** `export GEMINI_API_KEY="your_key_here"` (Google AI Studio has a free API usage quota. Create a key [here](https://aistudio.google.com/apikey) to use weco for free.)
+    - **OpenAI:** `export OPENAI_API_KEY="your_key_here"`
+    - **Anthropic:** `export ANTHROPIC_API_KEY="your_key_here"`
+    - **Google DeepMind:** `export GEMINI_API_KEY="your_key_here"` (Google AI Studio has a free API usage quota. Create a key [here](https://aistudio.google.com/apikey) to use `weco` for free.)
+
+    The optimization process will fail if the necessary keys for the chosen model are not found in your environment.
+
+3.  **Log In to Weco (Optional):**
+
+    To associate your optimization runs with your Weco account and view them on the Weco dashboard, you can log in. `weco` uses a device authentication flow:
+
+    - When you first run `weco run`, you'll be prompted if you want to log in or proceed anonymously.
+    - If you choose to log in (by pressing `l`), you'll be shown a URL and `weco` will attempt to open it in your default web browser.
+    - You then authenticate in the browser. Once authenticated, the CLI will detect this and complete the login.
+    - This saves a Weco-specific API key locally (typically at `~/.config/weco/credentials.json`).
+
+    If you choose to skip login (by pressing Enter or `s`), `weco` will still function using the environment variable LLM keys, but the run history will not be linked to a Weco account.
+
+    To log out and remove your saved Weco API key, use the `weco logout` command.
 
 ---
 
 ## Usage
+
+The CLI has two main commands:
+
+- `weco run`: Initiates the code optimization process.
+- `weco logout`: Logs you out of your Weco account.
+
 <div style="background-color: #fff3cd; border: 1px solid #ffeeba; padding: 15px; border-radius: 4px; margin-bottom: 15px;">
   <strong>⚠️ Warning: Code Modification</strong><br>
   <code>weco</code> directly modifies the file specified by <code>--source</code> during the optimization process. It is <strong>strongly recommended</strong> to use version control (like Git) to track changes and revert if needed. Alternatively, ensure you have a backup of your original file before running the command. Upon completion, the file will contain the best-performing version of the code found during the run.
@@ -72,7 +93,11 @@ The `weco` CLI leverages a tree search approach guided by Large Language Models
 
 ---
 
-### Example: Optimizing Simple PyTorch Operations
+### `weco run` Command
+
+This command starts the optimization process.
+
+**Example: Optimizing Simple PyTorch Operations**
 
 This basic example shows how to optimize a simple PyTorch function for speedup.
 
@@ -86,7 +111,7 @@ cd examples/hello-kernel-world
 pip install torch
 
 # Run Weco
-weco --source optimize.py \
+weco run --source optimize.py \
      --eval-command "python evaluate.py --solution-path optimize.py --device cpu" \
      --metric speedup \
      --maximize true \
@@ -99,19 +124,29 @@ weco --source optimize.py \
 
 ---
 
-### Command Line Arguments
+**Arguments for `weco run`:**
 
-| Argument                    | Description                                                                                                                                                              | Required |
-| :-------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------- |
-| `--source`                  | Path to the source code file that will be optimized (e.g., `optimize.py`).                                                                                               | Yes      |
-| `--eval-command`            | Command to run for evaluating the code in `--source`. This command should print the target `--metric` and its value to the terminal (stdout/stderr). See note below.     | Yes      |
-| `--metric`                  | The name of the metric you want to optimize (e.g., 'accuracy', 'speedup', 'loss'). This metric name should match what's printed by your `--eval-command`.                | Yes      |
-| `--maximize`                | Whether to maximize (`true`) or minimize (`false`) the metric.                                                                                                           | Yes      |
-| `--steps`                   | Number of optimization steps (LLM iterations) to run.                                                                                                                    | Yes      |
-| `--model`                   | Model identifier for the LLM to use (e.g., `gpt-4o`, `claude-3.7-sonnet`). Recommended models to try include `o4-mini`, and `gemini-2.5-pro-exp-03-25`.| Yes      |
-| `--additional-instructions` | (Optional) Natural language description of specific instructions OR path to a file containing detailed instructions to guide the LLM.                                    | No       |
-| `--log-dir`                 | (Optional) Path to the directory to log intermediate steps and final optimization result. Defaults to `.runs/`.                                                          | No       |
-| `--preserve-source`         | (Optional) If set, do not overwrite the original `--source` file. Modifications and the best solution will still be saved in the `--log-dir`.                                | No       |
+| Argument                    | Description                                                                                                                                                               | Required |
+| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------- |
+| `--source`                  | Path to the source code file that will be optimized (e.g., `optimize.py`).                                                                                                | Yes      |
+| `--eval-command`            | Command to run for evaluating the code in `--source`. This command should print the target `--metric` and its value to the terminal (stdout/stderr). See note below.      | Yes      |
+| `--metric`                  | The name of the metric you want to optimize (e.g., 'accuracy', 'speedup', 'loss'). This metric name should match what's printed by your `--eval-command`.                 | Yes      |
+| `--maximize`                | Whether to maximize (`true`) or minimize (`false`) the metric.                                                                                                            | Yes      |
+| `--steps`                   | Number of optimization steps (LLM iterations) to run.                                                                                                                     | Yes      |
+| `--model`                   | Model identifier for the LLM to use (e.g., `gpt-4o`, `claude-3.5-sonnet`). Recommended models to try include `o3-mini`, `claude-3-haiku`, and `gemini-2.5-pro-exp-03-25`. | Yes      |
+| `--additional-instructions` | (Optional) Natural language description of specific instructions OR path to a file containing detailed instructions to guide the LLM.                                     | No       |
+| `--log-dir`                 | (Optional) Path to the directory to log intermediate steps and final optimization result. Defaults to `.runs/`.                                                           | No       |
+| `--preserve-source`         | (Optional) If set, do not overwrite the original `--source` file. Modifications and the best solution will still be saved in the `--log-dir`.                             | No       |
+
+---
+
+### `weco logout` Command
+
+This command logs you out by removing the locally stored Weco API key.
+
+```bash
+weco logout
+```
 
 ---
 
@@ -120,6 +155,7 @@ weco --source optimize.py \
 Weco, powered by the AIDE algorithm, optimizes code iteratively based on your evaluation results. Achieving significant improvements, especially on complex research-level tasks, often requires substantial exploration time.
 
 The following plot from the independent [Research Engineering Benchmark (RE-Bench)](https://metr.org/AI_R_D_Evaluation_Report.pdf) report shows the performance of AIDE (the algorithm behind Weco) on challenging ML research engineering tasks over different time budgets.
+
 <p align="center">
 <img src="https://github.com/user-attachments/assets/ff0e471d-2f50-4e2d-b718-874862f533df" alt="RE-Bench Performance Across Time" width="60%"/>
 </p>
@@ -146,23 +182,25 @@ Final speedup value = 1.5
 
 Weco will parse this output to extract the numerical value (1.5 in this case) associated with the metric name ('speedup').
 
-
 ## Contributing
 
 We welcome contributions! To get started:
 
 1.  **Fork and Clone the Repository:**
+
     ```bash
     git clone https://github.com/WecoAI/weco-cli.git
     cd weco-cli
     ```
 
 2.  **Install Development Dependencies:**
+
     ```bash
     pip install -e ".[dev]"
     ```
 
 3.  **Create a Feature Branch:**
+
     ```bash
     git checkout -b feature/your-feature-name
     ```

weco-0.2.14.dist-info/RECORD

@@ -0,0 +1,12 @@
+weco/__init__.py,sha256=q4zeQ8CJq8NJyRcBMmST6zCzmK_HjNSFChrNBzJ9oks,426
+weco/api.py,sha256=z2DCe0kQJaaBHo-Vml52GRc9nwQBnrKATXoY3UfPojw,3842
+weco/auth.py,sha256=IPfiLthcNRkPyM8pWHTyDLvikw83sigacpY1PmeA03Y,2343
+weco/cli.py,sha256=7pGJiyoBO7n6Xocwusx9iVqsaPj8OuPaJ1A2ks83Ekw,28961
+weco/panels.py,sha256=gB4rZbCvqzewUCBcILvyyU4fnOQLwFgHCGmtn-ZlgSo,13385
+weco/utils.py,sha256=hhIebUPnetFMfNSFfcsKVw1TSpeu_Zw3rBPPnxDie0U,3911
+weco-0.2.14.dist-info/licenses/LICENSE,sha256=p_GQqJBvuZgkLNboYKyH-5dhpTDlKs2wq2TVM55WrWE,1065
+weco-0.2.14.dist-info/METADATA,sha256=855avaVBC-wUyFDWIvITw0t4o_v4s90Us-t_3lQnPGw,10851
+weco-0.2.14.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+weco-0.2.14.dist-info/entry_points.txt,sha256=ixJ2uClALbCpBvnIR6BXMNck8SHAab8eVkM9pIUowcs,39
+weco-0.2.14.dist-info/top_level.txt,sha256=F0N7v6e2zBSlsorFv-arAq2yDxQbzX3KVO8GxYhPUeE,5
+weco-0.2.14.dist-info/RECORD,,

weco-0.2.12.dist-info/RECORD

@@ -1,11 +0,0 @@
-weco/__init__.py,sha256=6mgJEq6p8NTpOgnccei6V4oZiwYU57om8m1g4-GW4BQ,125
-weco/api.py,sha256=89lB2572jApAxkA0DDppDnJKBwvZTa3kH9jFpC0LFDQ,3313
-weco/cli.py,sha256=TP1pAFjJNHO3rVJvpXegwWFu7oBUZnVSyJfaHgqTPYs,17920
-weco/panels.py,sha256=R_df-VAbWyLoqCA9A6UzbIGZ9sm2IgJO4idnyjmrHQk,12701
-weco/utils.py,sha256=hhIebUPnetFMfNSFfcsKVw1TSpeu_Zw3rBPPnxDie0U,3911
-weco-0.2.12.dist-info/licenses/LICENSE,sha256=p_GQqJBvuZgkLNboYKyH-5dhpTDlKs2wq2TVM55WrWE,1065
-weco-0.2.12.dist-info/METADATA,sha256=nSMO2Wa7ijmH_8u6C-TibsxpMFxooTso7o8j0TEL2x4,9379
-weco-0.2.12.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-weco-0.2.12.dist-info/entry_points.txt,sha256=ixJ2uClALbCpBvnIR6BXMNck8SHAab8eVkM9pIUowcs,39
-weco-0.2.12.dist-info/top_level.txt,sha256=F0N7v6e2zBSlsorFv-arAq2yDxQbzX3KVO8GxYhPUeE,5
-weco-0.2.12.dist-info/RECORD,,