weco 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

weco/cli.py

@@ -137,6 +137,13 @@ Default models for providers:
 {default_models_for_providers}
 """,
     )
+    run_parser.add_argument(
+        "--output",
+        type=str,
+        choices=["rich", "plain"],
+        default="rich",
+        help="Output mode: 'rich' for interactive terminal UI (default), 'plain' for machine-readable text output suitable for LLM agents.",
+    )
 
 
 def configure_credits_parser(credits_parser: argparse.ArgumentParser) -> None:
@@ -178,6 +185,13 @@ def configure_credits_parser(credits_parser: argparse.ArgumentParser) -> None:
     )
 
 
+def configure_setup_parser(setup_parser: argparse.ArgumentParser) -> None:
+    """Configure the setup command parser and its subcommands."""
+    setup_subparsers = setup_parser.add_subparsers(dest="tool", help="AI tool to set up")
+    setup_subparsers.add_parser("claude-code", help="Set up Weco skill for Claude Code")
+    setup_subparsers.add_parser("cursor", help="Set up Weco rules for Cursor")
+
+
 def configure_resume_parser(resume_parser: argparse.ArgumentParser) -> None:
     """Configure arguments for the resume command."""
     resume_parser.add_argument(
@@ -208,6 +222,13 @@ Example:
 Supported provider names: {supported_providers}.
 """,
     )
+    resume_parser.add_argument(
+        "--output",
+        type=str,
+        choices=["rich", "plain"],
+        default="rich",
+        help="Output mode: 'rich' for interactive terminal UI (default), 'plain' for machine-readable text output suitable for LLM agents.",
+    )
 
 
 def execute_run_command(args: argparse.Namespace) -> None:
@@ -253,6 +274,7 @@ def execute_run_command(args: argparse.Namespace) -> None:
         api_keys=api_keys,
         apply_change=args.apply_change,
         require_review=args.require_review,
+        output_mode=args.output,
     )
 
     exit_code = 0 if success else 1
@@ -269,7 +291,9 @@ def execute_resume_command(args: argparse.Namespace) -> None:
         console.print(f"[bold red]Error parsing API keys: {e}[/]")
         sys.exit(1)
 
-    success = resume_optimization(run_id=args.run_id, api_keys=api_keys, apply_change=args.apply_change)
+    success = resume_optimization(
+        run_id=args.run_id, api_keys=api_keys, apply_change=args.apply_change, output_mode=args.output
+    )
 
     sys.exit(0 if success else 1)
 
@@ -322,6 +346,10 @@ def _main() -> None:
     )
     configure_resume_parser(resume_parser)
 
+    # --- Setup Command Parser Setup ---
+    setup_parser = subparsers.add_parser("setup", help="Set up Weco for use with AI tools")
+    configure_setup_parser(setup_parser)
+
     args = parser.parse_args()
 
     if args.command == "login":
@@ -349,6 +377,11 @@ def _main() -> None:
         sys.exit(0)
     elif args.command == "resume":
         execute_resume_command(args)
+    elif args.command == "setup":
+        from .setup import handle_setup_command
+
+        handle_setup_command(args, console)
+        sys.exit(0)
     else:
         # This case should be hit if 'weco' is run alone and chatbot logic didn't catch it,
         # or if an invalid command is provided.

weco/optimizer.py

@@ -25,7 +25,7 @@ from .api import (
 )
 from .auth import handle_authentication
 from .browser import open_browser
-from .ui import OptimizationUI, LiveOptimizationUI
+from .ui import OptimizationUI, LiveOptimizationUI, PlainOptimizationUI
 from .utils import read_additional_instructions, read_from_path, write_to_path, run_evaluation_with_file_swap
 
 
@@ -324,7 +324,11 @@ def _offer_apply_best_solution(
 
 
 def resume_optimization(
-    run_id: str, api_keys: Optional[dict] = None, poll_interval: float = 2.0, apply_change: bool = False
+    run_id: str,
+    api_keys: Optional[dict] = None,
+    poll_interval: float = 2.0,
+    apply_change: bool = False,
+    output_mode: str = "rich",
 ) -> bool:
     """
     Resume an interrupted run using the queue-based optimization loop.
@@ -337,11 +341,12 @@ def resume_optimization(
         api_keys: Optional API keys for LLM providers.
         poll_interval: Seconds between polling attempts.
         apply_change: If True, automatically apply best solution; if False, prompt user.
+        output_mode: "rich" for interactive terminal UI, "plain" for machine-readable output.
 
     Returns:
         True if optimization completed successfully, False otherwise.
     """
-    console = Console()
+    console = Console(force_terminal=output_mode == "rich")
 
     # Authenticate
     weco_api_key, auth_headers = handle_authentication(console)
@@ -431,9 +436,17 @@ def resume_optimization(
 
     result: Optional[OptimizationResult] = None
     try:
-        with LiveOptimizationUI(
-            console, run_id, run_name, total_steps, dashboard_url, model=model_name, metric_name=metric_name
-        ) as ui:
+        # Select UI implementation based on output mode
+        if output_mode == "plain":
+            ui_instance = PlainOptimizationUI(
+                run_id, run_name, total_steps, dashboard_url, model=model_name, metric_name=metric_name
+            )
+        else:
+            ui_instance = LiveOptimizationUI(
+                console, run_id, run_name, total_steps, dashboard_url, model=model_name, metric_name=metric_name
+            )
+
+        with ui_instance as ui:
             # Populate UI with best solution from previous run if available
             if best_metric_value is not None and best_step is not None:
                 ui.on_metric(best_step, best_metric_value)
@@ -459,7 +472,10 @@ def resume_optimization(
 
         # Show resume message if interrupted
         if result.status == "terminated":
-            console.print(f"\n[cyan]To resume this run, use:[/] [bold]weco resume {run_id}[/]\n")
+            if output_mode == "plain":
+                print(f"\nTo resume this run, use: weco resume {run_id}\n", flush=True)
+            else:
+                console.print(f"\n[cyan]To resume this run, use:[/] [bold]weco resume {run_id}[/]\n")
 
         # Offer to apply best solution
         _offer_apply_best_solution(
@@ -507,6 +523,7 @@ def optimize(
     poll_interval: float = 2.0,
     apply_change: bool = False,
     require_review: bool = False,
+    output_mode: str = "rich",
 ) -> bool:
     """
     Simplified queue-based optimization loop.
@@ -528,11 +545,12 @@ def optimize(
         api_keys: Optional API keys for LLM providers.
         poll_interval: Seconds between polling attempts.
         apply_change: If True, automatically apply best solution; if False, prompt user.
+        output_mode: "rich" for interactive terminal UI, "plain" for machine-readable output.
 
     Returns:
         True if optimization completed successfully, False otherwise.
     """
-    console = Console()
+    console = Console(force_terminal=output_mode == "rich")
 
     # Authenticate
     weco_api_key, auth_headers = handle_authentication(console)
@@ -596,7 +614,13 @@ def optimize(
 
     result: Optional[OptimizationResult] = None
     try:
-        with LiveOptimizationUI(console, run_id, run_name, steps, dashboard_url, model=model, metric_name=metric) as ui:
+        # Select UI implementation based on output mode
+        if output_mode == "plain":
+            ui_instance = PlainOptimizationUI(run_id, run_name, steps, dashboard_url, model=model, metric_name=metric)
+        else:
+            ui_instance = LiveOptimizationUI(console, run_id, run_name, steps, dashboard_url, model=model, metric_name=metric)
+
+        with ui_instance as ui:
             result = _run_optimization_loop(
                 ui=ui,
                 run_id=run_id,
@@ -618,7 +642,10 @@ def optimize(
 
         # Show resume message if interrupted
         if result.status == "terminated":
-            console.print(f"\n[cyan]To resume this run, use:[/] [bold]weco resume {run_id}[/]\n")
+            if output_mode == "plain":
+                print(f"\nTo resume this run, use: weco resume {run_id}\n", flush=True)
+            else:
+                console.print(f"\n[cyan]To resume this run, use:[/] [bold]weco resume {run_id}[/]\n")
 
         # Offer to apply best solution
         _offer_apply_best_solution(

weco/setup.py

@@ -0,0 +1,367 @@
+# weco/setup.py
+"""
+Setup commands for integrating Weco with various AI tools.
+"""
+
+import pathlib
+import shutil
+import subprocess
+from rich.console import Console
+from rich.prompt import Confirm
+
+# Claude Code paths
+CLAUDE_DIR = pathlib.Path.home() / ".claude"
+CLAUDE_SKILLS_DIR = CLAUDE_DIR / "skills"
+CLAUDE_MD_PATH = CLAUDE_DIR / "CLAUDE.md"
+WECO_SKILL_DIR = CLAUDE_SKILLS_DIR / "weco"
+WECO_SKILL_REPO = "git@github.com:WecoAI/weco-skill.git"
+WECO_RULES_SNIPPET_PATH = WECO_SKILL_DIR / "rules-snippet.md"
+
+# Cursor paths
+CURSOR_DIR = pathlib.Path.home() / ".cursor"
+CURSOR_RULES_DIR = CURSOR_DIR / "rules"
+CURSOR_WECO_RULES_PATH = CURSOR_RULES_DIR / "weco.mdc"
+CURSOR_SKILLS_DIR = CURSOR_DIR / "skills"
+CURSOR_WECO_SKILL_DIR = CURSOR_SKILLS_DIR / "weco"
+CURSOR_RULES_SNIPPET_PATH = CURSOR_WECO_SKILL_DIR / "rules-snippet.md"
+
+# Delimiters for agent rules files - allows automatic updates
+WECO_RULES_BEGIN_DELIMITER = "<!-- BEGIN WECO_RULES -->"
+WECO_RULES_END_DELIMITER = "<!-- END WECO_RULES -->"
+
+
+def is_git_available() -> bool:
+    """Check if git is available on the system."""
+    return shutil.which("git") is not None
+
+
+def read_rules_snippet(snippet_path: pathlib.Path, console: Console) -> str | None:
+    """
+    Read the rules snippet from the cloned skill repository.
+
+    Args:
+        snippet_path: Path to the rules-snippet.md file.
+        console: Rich console for output.
+
+    Returns:
+        The snippet content wrapped in delimiters, or None if not found.
+    """
+    if not snippet_path.exists():
+        console.print(f"[bold red]Error:[/] Snippet file not found at {snippet_path}")
+        return None
+
+    try:
+        snippet_content = snippet_path.read_text().strip()
+        return f"\n{WECO_RULES_BEGIN_DELIMITER}\n{snippet_content}\n{WECO_RULES_END_DELIMITER}\n"
+    except Exception as e:
+        console.print(f"[bold red]Error:[/] Failed to read snippet file: {e}")
+        return None
+
+
+def read_rules_snippet_raw(snippet_path: pathlib.Path, console: Console) -> str | None:
+    """
+    Read the raw rules snippet from the cloned skill repository (without delimiters).
+
+    Args:
+        snippet_path: Path to the rules-snippet.md file.
+        console: Rich console for output.
+
+    Returns:
+        The raw snippet content, or None if not found.
+    """
+    if not snippet_path.exists():
+        console.print(f"[bold red]Error:[/] Snippet file not found at {snippet_path}")
+        return None
+
+    try:
+        return snippet_path.read_text().strip()
+    except Exception as e:
+        console.print(f"[bold red]Error:[/] Failed to read snippet file: {e}")
+        return None
+
+
+def generate_cursor_mdc_content(snippet_content: str) -> str:
+    """
+    Generate Cursor MDC file content with YAML frontmatter.
+
+    Args:
+        snippet_content: The raw rules snippet content.
+
+    Returns:
+        MDC formatted content with frontmatter.
+    """
+    return f"""---
+description: Weco code optimization skill - invoke for speed, accuracy, loss optimization
+alwaysApply: true
+---
+{snippet_content}
+"""
+
+
+def is_git_repo(path: pathlib.Path) -> bool:
+    """Check if a directory is a git repository."""
+    return (path / ".git").is_dir()
+
+
+def clone_skill_repo(skill_dir: pathlib.Path, console: Console) -> bool:
+    """
+    Clone or update the weco-skill repository to the specified directory.
+
+    Args:
+        skill_dir: The directory to clone/update the skill repository in.
+        console: Rich console for output.
+
+    Returns:
+        True if successful, False otherwise.
+    """
+    if not is_git_available():
+        console.print("[bold red]Error:[/] git is not installed or not in PATH.")
+        console.print("Please install git and try again.")
+        return False
+
+    # Ensure the parent skills directory exists
+    skill_dir.parent.mkdir(parents=True, exist_ok=True)
+
+    if skill_dir.exists():
+        if is_git_repo(skill_dir):
+            # Directory exists and is a git repo - pull latest
+            console.print(f"[cyan]Updating existing skill at {skill_dir}...[/]")
+            try:
+                result = subprocess.run(["git", "pull"], cwd=skill_dir, capture_output=True, text=True)
+                if result.returncode != 0:
+                    console.print("[bold red]Error:[/] Failed to update skill repository.")
+                    console.print(f"[dim]{result.stderr}[/]")
+                    return False
+                console.print("[green]Skill updated successfully.[/]")
+                return True
+            except Exception as e:
+                console.print(f"[bold red]Error:[/] Failed to update skill repository: {e}")
+                return False
+        else:
+            # Directory exists but is not a git repo
+            console.print(f"[bold red]Error:[/] Directory {skill_dir} exists but is not a git repository.")
+            console.print("Please remove it manually and try again.")
+            return False
+    else:
+        # Clone the repository
+        console.print(f"[cyan]Cloning Weco skill to {skill_dir}...[/]")
+        try:
+            result = subprocess.run(["git", "clone", WECO_SKILL_REPO, str(skill_dir)], capture_output=True, text=True)
+            if result.returncode != 0:
+                console.print("[bold red]Error:[/] Failed to clone skill repository.")
+                console.print(f"[dim]{result.stderr}[/]")
+                return False
+            console.print("[green]Skill cloned successfully.[/]")
+            return True
+        except Exception as e:
+            console.print(f"[bold red]Error:[/] Failed to clone skill repository: {e}")
+            return False
+
+
+def update_agent_rules_file(
+    rules_file: pathlib.Path, snippet_path: pathlib.Path, skill_dir: pathlib.Path, console: Console
+) -> bool:
+    """
+    Update an agent's rules file with the Weco skill reference.
+
+    Uses delimiters to allow automatic updates if the snippet changes.
+
+    Args:
+        rules_file: Path to the agent's rules file (e.g., ~/.claude/CLAUDE.md)
+        snippet_path: Path to the rules-snippet.md file.
+        skill_dir: Path to the skill directory (for user messaging).
+        console: Rich console for output.
+
+    Returns:
+        True if updated or user declined, False on error.
+    """
+    import re
+
+    rules_file_name = rules_file.name
+
+    # Read the snippet from the cloned skill repo
+    snippet_section = read_rules_snippet(snippet_path, console)
+    if snippet_section is None:
+        return False
+
+    # Check if the section already exists with delimiters
+    existing_content = ""
+    has_existing_section = False
+    if rules_file.exists():
+        try:
+            existing_content = rules_file.read_text()
+            has_existing_section = (
+                WECO_RULES_BEGIN_DELIMITER in existing_content and WECO_RULES_END_DELIMITER in existing_content
+            )
+        except Exception as e:
+            console.print(f"[bold yellow]Warning:[/] Could not read {rules_file_name}: {e}")
+
+    # Determine what action to take
+    if has_existing_section:
+        # Check if content is already up to date
+        pattern = re.escape(WECO_RULES_BEGIN_DELIMITER) + r".*?" + re.escape(WECO_RULES_END_DELIMITER)
+        match = re.search(pattern, existing_content, re.DOTALL)
+        if match and match.group(0).strip() == snippet_section.strip():
+            console.print(f"[dim]{rules_file_name} already contains the latest Weco rules.[/]")
+            return True
+
+        # Prompt for update
+        console.print(f"\n[bold yellow]{rules_file_name} Update[/]")
+        console.print(f"The Weco rules in your {rules_file_name} can be updated to the latest version.")
+        should_update = Confirm.ask("Would you like to update the Weco section?", default=True)
+    elif rules_file.exists():
+        console.print(f"\n[bold yellow]{rules_file_name} Update[/]")
+        console.print(f"To enable automatic skill discovery, we can add Weco rules to your {rules_file_name} file.")
+        should_update = Confirm.ask(f"Would you like to update your {rules_file_name}?", default=True)
+    else:
+        console.print(f"\n[bold yellow]{rules_file_name} Creation[/]")
+        console.print(f"To enable automatic skill discovery, we can create a {rules_file_name} file.")
+        should_update = Confirm.ask(f"Would you like to create {rules_file_name}?", default=True)
+
+    if not should_update:
+        console.print(f"\n[yellow]Skipping {rules_file_name} update.[/]")
+        console.print(
+            "[dim]The Weco skill has been installed but may not be discovered automatically.\n"
+            f"You can manually reference it at {skill_dir}[/]"
+        )
+        return True
+
+    # Update or create the file
+    try:
+        rules_file.parent.mkdir(parents=True, exist_ok=True)
+
+        if has_existing_section:
+            # Replace existing section between delimiters
+            pattern = re.escape(WECO_RULES_BEGIN_DELIMITER) + r".*?" + re.escape(WECO_RULES_END_DELIMITER)
+            new_content = re.sub(pattern, snippet_section.strip(), existing_content, flags=re.DOTALL)
+            rules_file.write_text(new_content)
+            console.print(f"[green]{rules_file_name} updated successfully.[/]")
+        elif rules_file.exists():
+            # Append to existing file
+            with open(rules_file, "a") as f:
+                f.write(snippet_section)
+            console.print(f"[green]{rules_file_name} updated successfully.[/]")
+        else:
+            # Create new file
+            with open(rules_file, "w") as f:
+                f.write(snippet_section.lstrip())
+            console.print(f"[green]{rules_file_name} created successfully.[/]")
+        return True
+    except Exception as e:
+        console.print(f"[bold red]Error:[/] Failed to update {rules_file_name}: {e}")
+        return False
+
+
+def setup_claude_code(console: Console) -> bool:
+    """
+    Set up Weco skill for Claude Code.
+
+    Returns:
+        True if setup was successful, False otherwise.
+    """
+    console.print("[bold blue]Setting up Weco for Claude Code...[/]\n")
+
+    # Step 1: Clone or update the skill repository
+    if not clone_skill_repo(WECO_SKILL_DIR, console):
+        return False
+
+    # Step 2: Update CLAUDE.md
+    if not update_agent_rules_file(CLAUDE_MD_PATH, WECO_RULES_SNIPPET_PATH, WECO_SKILL_DIR, console):
+        return False
+
+    console.print("\n[bold green]Setup complete![/]")
+    console.print(f"[dim]Skill installed at: {WECO_SKILL_DIR}[/]")
+    return True
+
+
+def setup_cursor(console: Console) -> bool:
+    """
+    Set up Weco rules for Cursor.
+
+    Creates a weco.mdc file in ~/.cursor/rules/ with the Weco optimization rules.
+
+    Returns:
+        True if setup was successful, False otherwise.
+    """
+    console.print("[bold blue]Setting up Weco for Cursor...[/]\n")
+
+    # Step 1: Clone or update the skill repository to Cursor's path
+    if not clone_skill_repo(CURSOR_WECO_SKILL_DIR, console):
+        return False
+
+    # Step 2: Read the rules snippet
+    snippet_content = read_rules_snippet_raw(CURSOR_RULES_SNIPPET_PATH, console)
+    if snippet_content is None:
+        return False
+
+    # Step 3: Check if weco.mdc already exists
+    if CURSOR_WECO_RULES_PATH.exists():
+        try:
+            existing_content = CURSOR_WECO_RULES_PATH.read_text()
+            new_content = generate_cursor_mdc_content(snippet_content)
+            if existing_content.strip() == new_content.strip():
+                console.print("[dim]weco.mdc already contains the latest Weco rules.[/]")
+                console.print("\n[bold green]Setup complete![/]")
+                console.print(f"[dim]Rules file at: {CURSOR_WECO_RULES_PATH}[/]")
+                return True
+        except Exception as e:
+            console.print(f"[bold yellow]Warning:[/] Could not read existing weco.mdc: {e}")
+
+        console.print("\n[bold yellow]weco.mdc Update[/]")
+        console.print("The Weco rules file can be updated to the latest version.")
+        should_update = Confirm.ask("Would you like to update weco.mdc?", default=True)
+    else:
+        console.print("\n[bold yellow]weco.mdc Creation[/]")
+        console.print("To enable Weco optimization rules, we can create a weco.mdc file.")
+        should_update = Confirm.ask("Would you like to create weco.mdc?", default=True)
+
+    if not should_update:
+        console.print("\n[yellow]Skipping weco.mdc update.[/]")
+        console.print(
+            "[dim]The Weco skill has been installed but rules are not configured.\n"
+            f"You can manually create the rules file at {CURSOR_WECO_RULES_PATH}[/]"
+        )
+        return True
+
+    # Step 4: Write the MDC file
+    try:
+        CURSOR_RULES_DIR.mkdir(parents=True, exist_ok=True)
+        mdc_content = generate_cursor_mdc_content(snippet_content)
+        CURSOR_WECO_RULES_PATH.write_text(mdc_content)
+        console.print("[green]weco.mdc created successfully.[/]")
+    except Exception as e:
+        console.print(f"[bold red]Error:[/] Failed to write weco.mdc: {e}")
+        return False
+
+    console.print("\n[bold green]Setup complete![/]")
+    console.print(f"[dim]Rules file at: {CURSOR_WECO_RULES_PATH}[/]")
+    return True
+
+
+def handle_setup_command(args, console: Console) -> None:
+    """Handle the setup command with its subcommands."""
+    if args.tool == "claude-code":
+        success = setup_claude_code(console)
+        if not success:
+            import sys
+
+            sys.exit(1)
+    elif args.tool == "cursor":
+        success = setup_cursor(console)
+        if not success:
+            import sys
+
+            sys.exit(1)
+    elif args.tool is None:
+        console.print("[bold red]Error:[/] Please specify a tool to set up.")
+        console.print("Available tools: claude-code, cursor")
+        console.print("\nUsage: weco setup <tool>")
+        import sys
+
+        sys.exit(1)
+    else:
+        console.print(f"[bold red]Error:[/] Unknown tool: {args.tool}")
+        console.print("Available tools: claude-code, cursor")
+        import sys
+
+        sys.exit(1)

weco/ui.py

@@ -313,3 +313,109 @@ class LiveOptimizationUI:
         self.state.error = message
         self.state.status = "error"
         self._update()
+
+
+class PlainOptimizationUI:
+    """
+    Plain text implementation of OptimizationUI for machine-readable output.
+
+    Designed to be consumed by LLM agents - outputs structured, parseable text
+    without Rich formatting, ANSI codes, or interactive elements.
+    Includes full execution output for agent consumption.
+    """
+
+    def __init__(
+        self, run_id: str, run_name: str, total_steps: int, dashboard_url: str, model: str = "", metric_name: str = ""
+    ):
+        self.run_id = run_id
+        self.run_name = run_name
+        self.total_steps = total_steps
+        self.dashboard_url = dashboard_url
+        self.model = model
+        self.metric_name = metric_name
+        self.current_step = 0
+        self.metrics: List[tuple] = []  # (step, value)
+        self._header_printed = False
+
+    def _print(self, message: str) -> None:
+        """Print a message to stdout with flush for immediate output."""
+        print(message, flush=True)
+
+    def _print_header(self) -> None:
+        """Print run header info once at start."""
+        if self._header_printed:
+            return
+        self._header_printed = True
+        self._print("=" * 60)
+        self._print("WECO OPTIMIZATION RUN")
+        self._print("=" * 60)
+        self._print(f"Run ID: {self.run_id}")
+        self._print(f"Run Name: {self.run_name}")
+        self._print(f"Dashboard: {self.dashboard_url}")
+        if self.model:
+            self._print(f"Model: {self.model}")
+        if self.metric_name:
+            self._print(f"Metric: {self.metric_name}")
+        self._print(f"Total Steps: {self.total_steps}")
+        self._print("=" * 60)
+        self._print("")
+
+    # --- Context manager (no-op for plain output) ---
+    def __enter__(self) -> "PlainOptimizationUI":
+        self._print_header()
+        return self
+
+    def __exit__(self, *args) -> None:
+        pass
+
+    # --- OptimizationUI Protocol Implementation ---
+    def on_polling(self, step: int) -> None:
+        self.current_step = step
+        self._print(f"[STEP {step}/{self.total_steps}] Polling for task...")
+
+    def on_task_claimed(self, task_id: str, plan: Optional[str]) -> None:
+        self._print(f"[TASK CLAIMED] {task_id}")
+        if plan:
+            self._print(f"[PLAN] {plan}")
+
+    def on_executing(self, step: int) -> None:
+        self.current_step = step
+        self._print(f"[STEP {step}/{self.total_steps}] Executing code...")
+
+    def on_output(self, output: str, max_preview: int = 200) -> None:
+        # For plain mode, output the full execution result for LLM consumption
+        self._print("[EXECUTION OUTPUT START]")
+        self._print(output)
+        self._print("[EXECUTION OUTPUT END]")
+
+    def on_submitting(self) -> None:
+        self._print("[SUBMITTING] Sending result to backend...")
+
+    def on_metric(self, step: int, value: float) -> None:
+        self.metrics.append((step, value))
+        best = max(m[1] for m in self.metrics) if self.metrics else value
+        self._print(f"[METRIC] Step {step}: {value:.6g} (best so far: {best:.6g})")
+
+    def on_complete(self, total_steps: int) -> None:
+        self._print("")
+        self._print("=" * 60)
+        self._print("[COMPLETE] Optimization finished successfully")
+        self._print(f"Total steps completed: {total_steps}")
+        if self.metrics:
+            values = [m[1] for m in self.metrics]
+            self._print(f"Best metric value: {max(values):.6g}")
+        self._print("=" * 60)
+
+    def on_stop_requested(self) -> None:
+        self._print("")
+        self._print("[STOPPED] Run stopped by user request")
+
+    def on_interrupted(self) -> None:
+        self._print("")
+        self._print("[INTERRUPTED] Run interrupted (Ctrl+C)")
+
+    def on_warning(self, message: str) -> None:
+        self._print(f"[WARNING] {message}")
+
+    def on_error(self, message: str) -> None:
+        self._print(f"[ERROR] {message}")

{weco-0.3.8.dist-info → weco-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weco
-Version: 0.3.8
+Version: 0.3.10
 Summary: Documentation for `weco`, a CLI for using Weco AI's code optimizer.
 Author-email: Weco AI Team <contact@weco.ai>
 License: 
@@ -336,7 +336,28 @@ For more advanced examples, including [Triton](/examples/triton/README.md), [CUD
 |---------|-------------|-------------|
 | `weco run [options]` | Direct optimization execution | **For advanced users** - When you know exactly what to optimize and how |
 | `weco resume <run-id>` | Resume an interrupted run | Continue from the last completed step |
+| `weco login` | Authenticate with Weco | First-time setup or switching accounts |
 | `weco logout` | Clear authentication credentials | To switch accounts or troubleshoot authentication issues |
+| `weco credits balance` | Check your current credit balance | Monitor usage |
+| `weco credits topup [amount]` | Purchase additional credits | When you need more credits (default: 10) |
+| `weco credits autotopup` | Configure automatic top-up | Set up automatic credit replenishment |
+
+### Setup Commands (Experimental)
+
+| Command | Description |
+|---------|-------------|
+| `weco setup claude-code` | Set up Weco skill for Claude Code |
+| `weco setup cursor` | Set up Weco rules for Cursor |
+
+The `setup` command installs Weco skills for AI coding assistants:
+
+```bash
+weco setup claude-code  # For Claude Code
+weco setup cursor       # For Cursor
+```
+
+- **Claude Code**: Clones the Weco skill to `~/.claude/skills/weco/` and updates `~/.claude/CLAUDE.md`
+- **Cursor**: Clones the Weco skill to `~/.cursor/skills/weco/` and creates `~/.cursor/rules/weco.mdc`
 
 ### Model Selection
 

weco-0.3.10.dist-info/RECORD

@@ -0,0 +1,19 @@
+weco/__init__.py,sha256=ClO0uT6GKOA0iSptvP0xbtdycf0VpoPTq37jHtvlhtw,303
+weco/api.py,sha256=hy0D01x-AJ26DURtKEywQAS7nQgo38A-wAJfPKHGGqM,17395
+weco/auth.py,sha256=O31Hoj-Loi8DWJJG2LfeWgUMuNqAUeGDpd2ZGjA9Ah0,9997
+weco/browser.py,sha256=nsqQtLqbNOe9Zhu9Zogc8rMmBMyuDxuHzKZQL_w10Ps,923
+weco/cli.py,sha256=WaFkdIOQZIkBcPfWbUhOvUExNeDVdrmax5-tVGY3uNE,14000
+weco/constants.py,sha256=rxL6yrpIzK8zvPTmPqOYl7LUMZ01vUJ9zUqfZD2n-0U,519
+weco/credits.py,sha256=C08x-TRcLg3ccfKqMGNRY7zBn7t3r7LZ119bxgfztaI,7629
+weco/optimizer.py,sha256=l9TrAsie5yPbhq71kStW5jfdz9jfIXuN6Azdn6hUMZo,25224
+weco/panels.py,sha256=POHt0MdRKDykwUJYXcry92O41lpB9gxna55wFI9abWU,16272
+weco/setup.py,sha256=Zv1CbxYHamnoOcVfpCn68ymHgjzCTHHGMKep_WSFLCk,13981
+weco/ui.py,sha256=Y7ASIQydwuYFdSYrvme5aGvkplFMi-cjhsnCj5Ebgoc,15092
+weco/utils.py,sha256=v_rvgw-ktRoXrpPA2copngI8QDCB8UXmbiN-wAiYvEE,9450
+weco/validation.py,sha256=n5aDuF3BFgwVb4eZ9PuU48nogrseXYNI8S3ePqWZCoc,3736
+weco-0.3.10.dist-info/licenses/LICENSE,sha256=9LUfoGHjLPtak2zps2kL2tm65HAZIICx_FbLaRuS4KU,11337
+weco-0.3.10.dist-info/METADATA,sha256=1eJxhWSGbdrHcOeBxjmxJ_T6Hruva1YNNn9fxOb59FE,30804
+weco-0.3.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+weco-0.3.10.dist-info/entry_points.txt,sha256=ixJ2uClALbCpBvnIR6BXMNck8SHAab8eVkM9pIUowcs,39
+weco-0.3.10.dist-info/top_level.txt,sha256=F0N7v6e2zBSlsorFv-arAq2yDxQbzX3KVO8GxYhPUeE,5
+weco-0.3.10.dist-info/RECORD,,

{weco-0.3.8.dist-info → weco-0.3.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

weco-0.3.8.dist-info/RECORD

@@ -1,18 +0,0 @@
-weco/__init__.py,sha256=ClO0uT6GKOA0iSptvP0xbtdycf0VpoPTq37jHtvlhtw,303
-weco/api.py,sha256=hy0D01x-AJ26DURtKEywQAS7nQgo38A-wAJfPKHGGqM,17395
-weco/auth.py,sha256=O31Hoj-Loi8DWJJG2LfeWgUMuNqAUeGDpd2ZGjA9Ah0,9997
-weco/browser.py,sha256=nsqQtLqbNOe9Zhu9Zogc8rMmBMyuDxuHzKZQL_w10Ps,923
-weco/cli.py,sha256=u5DSt2YGLOha-ldaW6qg3NO2z3rNfYw37FNtaIs-Kz4,12656
-weco/constants.py,sha256=rxL6yrpIzK8zvPTmPqOYl7LUMZ01vUJ9zUqfZD2n-0U,519
-weco/credits.py,sha256=C08x-TRcLg3ccfKqMGNRY7zBn7t3r7LZ119bxgfztaI,7629
-weco/optimizer.py,sha256=XygxTOTPaPx0dDVI9oWaMQHZ0-YAg1JFcMvGPcnEx-A,23990
-weco/panels.py,sha256=POHt0MdRKDykwUJYXcry92O41lpB9gxna55wFI9abWU,16272
-weco/ui.py,sha256=1shfWxeyfhjTzRZsuODuMx5XzeP9SngqpNpN4vIiDCI,11203
-weco/utils.py,sha256=v_rvgw-ktRoXrpPA2copngI8QDCB8UXmbiN-wAiYvEE,9450
-weco/validation.py,sha256=n5aDuF3BFgwVb4eZ9PuU48nogrseXYNI8S3ePqWZCoc,3736
-weco-0.3.8.dist-info/licenses/LICENSE,sha256=9LUfoGHjLPtak2zps2kL2tm65HAZIICx_FbLaRuS4KU,11337
-weco-0.3.8.dist-info/METADATA,sha256=a9A-tvBbsaojDEXmi1DYsoBAJALFQ6kPeIlWlf2Of0Y,29861
-weco-0.3.8.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-weco-0.3.8.dist-info/entry_points.txt,sha256=ixJ2uClALbCpBvnIR6BXMNck8SHAab8eVkM9pIUowcs,39
-weco-0.3.8.dist-info/top_level.txt,sha256=F0N7v6e2zBSlsorFv-arAq2yDxQbzX3KVO8GxYhPUeE,5
-weco-0.3.8.dist-info/RECORD,,