cli.py

"""
CLI Interface for Browser Agent

Provides command-line interface with argument parsing and task generation.
"""

import sys
import asyncio
import argparse
from typing import Optional

from browser_agent import (
    run_browser_agent,
    GOOGLE_API_KEY,
    MODEL,
    MAX_STEPS,
    OUTPUT_DIR,
    HEADLESS
)
from task_generator import generate_task


def create_parser() -> argparse.ArgumentParser:
    """Create and configure argument parser."""
    parser = argparse.ArgumentParser(
        prog="browser-agent",
        description="AI-powered browser automation with natural language commands",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  browser-agent "Go to example.com and save as example.pdf"
  browser-agent "find python docs" --generate
  browser-agent "search for AI" --generate --headless --max-steps 20
  browser-agent "Go to github.com" --quiet --output-dir ./pdfs

For more information, visit: https://github.com/yourusername/browser-agent
        """
    )

    # Positional argument
    parser.add_argument(
        "task",
        nargs="?",
        help="Task description in natural language"
    )

    # Optional flags
    parser.add_argument(
        "--generate", "-g",
        action="store_true",
        help="Use LLM to refine task into structured steps"
    )

    parser.add_argument(
        "--headless",
        action="store_true",
        help="Run browser invisibly (default: visible)"
    )

    parser.add_argument(
        "--max-steps",
        type=int,
        metavar="N",
        help=f"Maximum agent loop iterations (default: {MAX_STEPS})"
    )

    parser.add_argument(
        "--output-dir",
        type=str,
        metavar="DIR",
        help=f"Directory for saving PDFs (default: {OUTPUT_DIR})"
    )

    parser.add_argument(
        "--model",
        type=str,
        metavar="NAME",
        help=f"Gemini model name (default: {MODEL})"
    )

    # Verbosity control (mutually exclusive)
    verbosity = parser.add_mutually_exclusive_group()
    verbosity.add_argument(
        "--verbose", "-v",
        action="store_true",
        help="Print step-by-step progress (default)"
    )

    verbosity.add_argument(
        "--quiet", "-q",
        action="store_true",
        help="Suppress step-by-step output"
    )

    return parser


async def async_main(args: argparse.Namespace) -> int:
    """
    Main async entry point for CLI.

    Args:
        args: Parsed command-line arguments

    Returns:
        int: Exit code (0 for success, 1 for failure)
    """
    # 1. Validate API key exists
    if not GOOGLE_API_KEY:
        print("ERROR: GOOGLE_API_KEY not found in environment variables", file=sys.stderr)
        print("Please set GOOGLE_API_KEY in your .env file or environment", file=sys.stderr)
        return 1

    # 2. Validate task provided
    if not args.task:
        print("ERROR: No task provided", file=sys.stderr)
        print("\nUsage: browser-agent \"task description\"", file=sys.stderr)
        print("Run 'browser-agent --help' for more information", file=sys.stderr)
        return 1

    # Determine verbosity (default is verbose unless --quiet)
    verbose = not args.quiet

    # 3. Optional task generation
    task = args.task
    if args.generate:
        if verbose:
            print("Generating structured task...")

        try:
            refined_task = await generate_task(
                user_input=args.task,
                api_key=GOOGLE_API_KEY,
                model=args.model or MODEL,
                verbose=verbose
            )

            # Only show refined task if it's different from original
            if refined_task != args.task:
                if verbose:
                    print("\nRefined task:")
                    print("-" * 60)
                    print(refined_task)
                    print("-" * 60)
                    print()
                task = refined_task
            else:
                if verbose:
                    print("Using original task (generation did not refine it)\n")

        except Exception as e:
            if verbose:
                print(f"Warning: Task generation failed ({e}), continuing with original task\n")
            # Continue with original task

    # 4. Run browser agent
    try:
        result = await run_browser_agent(
            task=task,
            output_dir=args.output_dir,
            model=args.model,
            max_steps=args.max_steps,
            headless=args.headless or HEADLESS,
            verbose=verbose
        )
    except KeyboardInterrupt:
        if verbose:
            print("\n\nInterrupted by user (Ctrl+C)")
        return 1
    except Exception as e:
        print(f"ERROR: Unexpected error: {e}", file=sys.stderr)
        return 1

    # 5. Display results
    if verbose:
        print(f"\n{'='*60}")

    if result['success']:
        success_msg = f"✅ Completed in {result['steps']} steps"
        if result.get('message'):
            success_msg += f": {result['message']}"
        print(success_msg)
        if verbose:
            print(f"{'='*60}")
        return 0
    else:
        failure_msg = f"❌ Failed after {result['steps']} steps"
        if result.get('message'):
            failure_msg += f": {result['message']}"
        print(failure_msg)
        if verbose:
            print(f"{'='*60}")
        return 1


def main() -> None:
    """
    Synchronous entry point for CLI.

    Parses arguments and runs async_main with asyncio.
    """
    parser = create_parser()
    args = parser.parse_args()

    # Run async main
    exit_code = asyncio.run(async_main(args))
    sys.exit(exit_code)


if __name__ == "__main__":
    main()