pdd-cli 0.0.45__py3-none-any.whl → 0.0.118__py3-none-any.whl

pdd/commands/connect.py

@@ -0,0 +1,290 @@
+"""
+PDD Connect Command.
+
+This module provides the `pdd connect` CLI command which launches a local
+REST server to enable the web frontend to interact with PDD.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import webbrowser
+from pathlib import Path
+from typing import Optional
+
+import click
+
+# Handle optional dependencies - uvicorn may not be installed
+try:
+    import uvicorn
+except ImportError:
+    uvicorn = None
+
+# Internal imports
+# We wrap this in a try/except block to allow the module to be imported
+# even if the server dependencies are not present (e.g. in partial environments)
+try:
+    from ..server.app import create_app
+except (ImportError, ValueError):
+    def create_app(*args, **kwargs):
+        raise ImportError("Could not import pdd.server.app.create_app. Ensure server dependencies are installed.")
+
+
+@click.command("connect")
+@click.option(
+    "--port",
+    default=9876,
+    help="Port to listen on",
+    show_default=True,
+    type=int,
+)
+@click.option(
+    "--host",
+    default="127.0.0.1",
+    help="Host to bind to",
+    show_default=True,
+)
+@click.option(
+    "--allow-remote",
+    is_flag=True,
+    help="Allow non-localhost connections",
+)
+@click.option(
+    "--token",
+    help="Bearer token for authentication",
+    default=None,
+)
+@click.option(
+    "--no-browser",
+    is_flag=True,
+    help="Don't open browser automatically",
+)
+@click.option(
+    "--frontend-url",
+    help="Custom frontend URL",
+    default=None,
+)
+@click.option(
+    "--local-only",
+    is_flag=True,
+    help="Skip cloud registration (local access only)",
+)
+@click.option(
+    "--session-name",
+    help="Custom session name for identification",
+    default=None,
+)
+@click.pass_context
+def connect(
+    ctx: click.Context,
+    port: int,
+    host: str,
+    allow_remote: bool,
+    token: Optional[str],
+    no_browser: bool,
+    frontend_url: Optional[str],
+    local_only: bool,
+    session_name: Optional[str],
+) -> None:
+    """
+    Launch the local REST server for the PDD web frontend.
+
+    This command starts a FastAPI server that exposes the PDD functionality
+    via a REST API. It automatically opens the web interface in your default
+    browser unless --no-browser is specified.
+
+    For authenticated users, the session is automatically registered with
+    PDD Cloud for remote access. Use --local-only to skip cloud registration.
+    """
+    # Check uvicorn is available
+    if uvicorn is None:
+        click.echo(click.style("Error: 'uvicorn' is not installed. Please install it to use the connect command.", fg="red"))
+        ctx.exit(1)
+
+    # 1. Determine Project Root
+    # We assume the current working directory is the project root
+    project_root = Path.cwd()
+
+    # 2. Security Checks & Configuration
+    if allow_remote:
+        if not token:
+            click.echo(click.style(
+                "SECURITY WARNING: You are allowing remote connections without an authentication token.",
+                fg="red", bold=True
+            ))
+            click.echo("Anyone with access to your network could execute code on your machine.")
+            if not click.confirm("Do you want to proceed?"):
+                ctx.exit(1)
+
+        # If user explicitly asked for remote but left host as localhost,
+        # bind to all interfaces to actually allow remote connections.
+        if host == "127.0.0.1":
+            host = "0.0.0.0"
+            click.echo(click.style("Binding to 0.0.0.0 to allow remote connections.", fg="yellow"))
+    else:
+        # Warn if binding to non-localhost without explicit allow-remote
+        if host not in ("127.0.0.1", "localhost"):
+            click.echo(click.style(
+                f"Warning: Binding to {host} without --allow-remote flag. "
+                "External connections may be blocked or insecure.",
+                fg="yellow"
+            ))
+
+    # 3. Determine URLs
+    # The server URL is where the API lives
+    server_url = f"http://{host}:{port}"
+
+    # The frontend URL is what we open in the browser
+    # If binding to 0.0.0.0, we still use localhost for the local browser
+    browser_host = "localhost" if host == "0.0.0.0" else host
+    target_url = frontend_url if frontend_url else f"http://{browser_host}:{port}"
+
+    # 4. Configure CORS
+    # We need to allow the frontend to talk to the backend
+    allowed_origins = [
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        "http://localhost:5173",
+        "http://127.0.0.1:5173",
+        f"http://localhost:{port}",
+        f"http://127.0.0.1:{port}",
+        # PDD Cloud frontend
+        "https://pdd.dev",
+        "https://www.pdd.dev",
+    ]
+    if frontend_url:
+        allowed_origins.append(frontend_url)
+
+    # 4.5 Cloud Session Registration (automatic for authenticated users)
+    session_manager = None
+    cloud_url = None
+    if not local_only:
+        try:
+            from ..core.cloud import CloudConfig
+            from ..remote_session import (
+                RemoteSessionManager,
+                RemoteSessionError,
+                set_active_session_manager,
+            )
+
+            # Check if user is authenticated
+            jwt_token = CloudConfig.get_jwt_token(verbose=False)
+            if not jwt_token:
+                click.echo(click.style(
+                    "Not authenticated. Running in local-only mode.",
+                    dim=True
+                ))
+                click.echo(click.style(
+                    "Run 'pdd login' to enable remote access via cloud.",
+                    dim=True
+                ))
+            else:
+                click.echo("Registering session with PDD Cloud...")
+                session_manager = RemoteSessionManager(jwt_token, project_root)
+                try:
+                    # Register with cloud - no public URL needed, cloud hosts everything
+                    cloud_url = asyncio.run(session_manager.register(
+                        session_name=session_name,
+                    ))
+                    # Heartbeat will be started by the app's lifespan manager
+                    set_active_session_manager(session_manager)
+
+                    click.echo(click.style(
+                        "Session registered with PDD Cloud!", fg="green", bold=True
+                    ))
+                    # TODO: Re-enable when production /connect page is deployed
+                    # click.echo(f"  Access URL: {click.style(cloud_url, fg='cyan', underline=True)}")
+                    # click.echo(click.style(
+                    #     "  Share this URL to access your PDD session from any browser.",
+                    #     dim=True
+                    # ))
+                except RemoteSessionError as e:
+                    click.echo(click.style(
+                        f"Warning: Failed to register with cloud: {e.message}",
+                        fg="yellow"
+                    ))
+                    click.echo(click.style(
+                        "Running in local-only mode.",
+                        dim=True
+                    ))
+                    session_manager = None
+        except ImportError as e:
+            click.echo(click.style(
+                f"Running in local-only mode (cloud dependencies not available).",
+                dim=True
+            ))
+    else:
+        click.echo(click.style(
+            "Running in local-only mode (--local-only flag set).",
+            dim=True
+        ))
+
+    # 5. Initialize Server App
+    try:
+        # Pass token via environment variable if provided, as create_app might not take it directly
+        if token:
+            os.environ["PDD_ACCESS_TOKEN"] = token
+
+        app = create_app(project_root, allowed_origins=allowed_origins)
+    except Exception as e:
+        click.echo(click.style(f"Failed to initialize server: {e}", fg="red", bold=True))
+        ctx.exit(1)
+
+    # 6. Print Status Messages
+    click.echo(click.style(f"Starting PDD server on {server_url}", fg="green", bold=True))
+    click.echo(f"Project Root: {click.style(str(project_root), fg='blue')}")
+    click.echo(f"API Documentation: {click.style(f'{server_url}/docs', underline=True)}")
+    click.echo(f"Local Frontend: {click.style(target_url, underline=True)}")
+    # TODO: Re-enable when production /connect page is deployed
+    # if cloud_url:
+    #     click.echo(f"Remote Access: {click.style(cloud_url, fg='cyan', underline=True)}")
+    click.echo(click.style("Press Ctrl+C to stop the server", dim=True))
+
+    # 7. Open Browser
+    if not no_browser:
+        # Import remote session detection
+        from ..core.remote_session import is_remote_session
+
+        is_remote, reason = is_remote_session()
+        if is_remote:
+            click.echo(click.style(f"Note: {reason}", fg="yellow"))
+            click.echo("Opening browser may not work in remote sessions. Use the URL above to connect manually.")
+
+        click.echo("Opening browser...")
+        try:
+            webbrowser.open(target_url)
+        except Exception as e:
+            click.echo(click.style(f"Could not open browser: {e}", fg="yellow"))
+            click.echo(f"Please open {target_url} manually in your browser.")
+
+    # 8. Run Server
+    try:
+        # Run uvicorn
+        # Disable access_log to avoid noisy polling logs - custom middleware handles important logging
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+            log_level="warning",  # Only show warnings and errors from uvicorn
+            access_log=False  # Custom middleware handles request logging
+        )
+    except KeyboardInterrupt:
+        click.echo(click.style("\nServer stopping...", fg="yellow", bold=True))
+    except Exception as e:
+        click.echo(click.style(f"\nServer error: {e}", fg="red", bold=True))
+        ctx.exit(1)
+    finally:
+        # Clean up cloud session if registered
+        if session_manager is not None:
+            click.echo("Deregistering from PDD Cloud...")
+            try:
+                from ..remote_session import set_active_session_manager
+                asyncio.run(session_manager.stop_heartbeat())
+                asyncio.run(session_manager.deregister())
+                set_active_session_manager(None)
+                click.echo(click.style("Session deregistered.", fg="green"))
+            except Exception as e:
+                click.echo(click.style(f"Warning: Error during session cleanup: {e}", fg="yellow"))
+
+        click.echo(click.style("Goodbye!", fg="blue"))

pdd/commands/fix.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import sys
+import click
+from typing import Optional, Tuple, Any
+from rich.console import Console
+
+# Relative imports for internal modules
+from ..fix_main import fix_main
+from ..agentic_e2e_fix import run_agentic_e2e_fix
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+
+console = Console()
+
+@click.command(name="fix")
+@click.argument("args", nargs=-1)
+@click.option("--manual", is_flag=True, help="Use manual mode with explicit file arguments.")
+@click.option("--timeout-adder", type=float, default=0.0, help="Additional seconds to add to each step's timeout (Agentic mode).")
+@click.option("--max-cycles", type=int, default=5, help="Maximum number of outer loop cycles (Agentic mode).")
+@click.option("--resume/--no-resume", default=True, help="Resume from saved state if available (Agentic mode).")
+@click.option("--force", is_flag=True, help="Override branch mismatch safety check (Agentic mode).")
+@click.option("--no-github-state", is_flag=True, help="Disable GitHub issue comment-based state persistence (Agentic mode).")
+@click.option("--output-test", type=click.Path(), help="Specify where to save the fixed unit test file.")
+@click.option("--output-code", type=click.Path(), help="Specify where to save the fixed code file.")
+@click.option("--output-results", type=click.Path(), help="Specify where to save the results log.")
+@click.option("--loop", is_flag=True, help="Enable iterative fixing process.")
+@click.option("--verification-program", type=click.Path(), help="Path to verification program (required for --loop).")
+@click.option("--max-attempts", type=int, default=3, help="Maximum number of fix attempts.")
+@click.option("--budget", type=float, default=5.0, help="Maximum cost allowed for the fixing process.")
+@click.option("--auto-submit", is_flag=True, help="Automatically submit example if tests pass.")
+@click.option("--agentic-fallback/--no-agentic-fallback", default=True, help="Enable agentic fallback in loop mode.")
+@click.pass_context
+@track_cost
+def fix(
+    ctx: click.Context,
+    args: Tuple[str, ...],
+    manual: bool,
+    timeout_adder: float,
+    max_cycles: int,
+    resume: bool,
+    force: bool,
+    no_github_state: bool,
+    output_test: Optional[str],
+    output_code: Optional[str],
+    output_results: Optional[str],
+    loop: bool,
+    verification_program: Optional[str],
+    max_attempts: int,
+    budget: float,
+    auto_submit: bool,
+    agentic_fallback: bool,
+) -> Optional[Tuple[Any, float, str]]:
+    """
+    Fix errors in code and unit tests.
+
+    Supports two modes:
+    1. Agentic E2E Fix: pdd fix <GITHUB_ISSUE_URL>
+    2. Manual Mode: pdd fix --manual PROMPT_FILE CODE_FILE UNIT_TEST_FILE... ERROR_FILE
+    """
+    try:
+        if not args:
+            raise click.UsageError("Missing arguments. See 'pdd fix --help'.")
+
+        # Determine mode based on first argument
+        # If it looks like a URL and --manual is not set, use Agentic mode
+        is_url = args[0].startswith("http") or "github.com" in args[0]
+        
+        # --- Agentic E2E Fix Mode ---
+        if is_url and not manual:
+            if len(args) > 1:
+                console.print("[yellow]Warning: Extra arguments ignored in Agentic E2E Fix mode.[/yellow]")
+            
+            issue_url = args[0]
+            verbose = ctx.obj.get("verbose", False)
+            quiet = ctx.obj.get("quiet", False)
+            
+            # Call the agentic fix workflow
+            success, message, cost, model, _ = run_agentic_e2e_fix(
+                issue_url=issue_url,
+                timeout_adder=timeout_adder,
+                max_cycles=max_cycles,
+                resume=resume,
+                force=force,
+                verbose=verbose,
+                quiet=quiet,
+                use_github_state=not no_github_state
+            )
+            
+            if not success:
+                console.print(f"[bold red]Agentic fix failed:[/bold red] {message}")
+            else:
+                console.print(f"[bold green]Agentic fix completed:[/bold green] {message}")
+                
+            return message, cost, model
+
+        # --- Manual Mode ---
+        else:
+            # Validate arguments for manual mode
+            # Expected structure: PROMPT_FILE CODE_FILE UNIT_TEST_FILE [UNIT_TEST_FILE...] ERROR_FILE
+            if len(args) < 4:
+                raise click.UsageError(
+                    "Manual mode requires at least 4 arguments: PROMPT_FILE CODE_FILE UNIT_TEST_FILE... ERROR_FILE"
+                )
+
+            prompt_file = args[0]
+            code_file = args[1]
+            error_file = args[-1]
+            # All arguments between code file and error file are treated as unit test files
+            unit_test_files = args[2:-1]
+
+            total_cost = 0.0
+            last_model = "unknown"
+            all_success = True
+            results_summary = []
+
+            # Process each unit test file
+            for i, test_file in enumerate(unit_test_files):
+                if len(unit_test_files) > 1:
+                    console.print(f"[bold blue]Processing test file {i+1}/{len(unit_test_files)}: {test_file}[/bold blue]")
+
+                # Call the core fix logic
+                # Note: If multiple test files are processed, output_test will overwrite 
+                # the same location if specified, as per documentation warning.
+                success, _, _, _, cost, model = fix_main(
+                    ctx=ctx,
+                    prompt_file=prompt_file,
+                    code_file=code_file,
+                    unit_test_file=test_file,
+                    error_file=error_file,
+                    output_test=output_test,
+                    output_code=output_code,
+                    output_results=output_results,
+                    loop=loop,
+                    verification_program=verification_program,
+                    max_attempts=max_attempts,
+                    budget=budget,
+                    auto_submit=auto_submit,
+                    agentic_fallback=agentic_fallback,
+                    strength=None,  # Use context defaults inside fix_main
+                    temperature=None # Use context defaults inside fix_main
+                )
+                
+                total_cost += cost
+                last_model = model
+                if not success:
+                    all_success = False
+                
+                status = "Fixed" if success else "Failed"
+                results_summary.append(f"{test_file}: {status}")
+
+            # Construct return message
+            summary_str = "\n".join(results_summary)
+            if all_success:
+                return f"All files processed successfully.\n{summary_str}", total_cost, last_model
+            else:
+                return f"Some files failed to fix.\n{summary_str}", total_cost, last_model
+
+    except click.Abort:
+        raise
+    except Exception as e:
+        handle_error(e)
+        return None