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

pdd/commands/__init__.py

@@ -0,0 +1,48 @@
+"""
+Command registration module.
+"""
+import click
+
+from .generate import generate, test, example
+from .fix import fix
+from .modify import split, change, update
+from .maintenance import sync, auto_deps, setup
+from .analysis import detect_change, conflicts, bug, crash, trace
+from .connect import connect
+from .auth import auth_group
+from .misc import preprocess
+from .sessions import sessions
+from .report import report_core
+from .templates import templates_group
+from .utility import install_completion_cmd, verify
+
+def register_commands(cli: click.Group) -> None:
+    """Register all subcommands with the main CLI group."""
+    cli.add_command(generate)
+    cli.add_command(test)
+    cli.add_command(example)
+    cli.add_command(fix)
+    cli.add_command(split)
+    cli.add_command(change)
+    cli.add_command(update)
+    cli.add_command(sync)
+    cli.add_command(auto_deps)
+    cli.add_command(setup)
+    cli.add_command(detect_change)
+    cli.add_command(conflicts)
+    cli.add_command(bug)
+    cli.add_command(crash)
+    cli.add_command(trace)
+    cli.add_command(preprocess)
+    cli.add_command(report_core)
+    cli.add_command(install_completion_cmd, name="install_completion")
+    cli.add_command(verify)
+    
+    # Register templates group directly to commands dict to handle nesting if needed,
+    # or just add_command works for groups too.
+    # The original code did: cli.commands["templates"] = templates_group
+    # Using add_command is cleaner if it works for the structure.
+    cli.add_command(templates_group)
+    cli.add_command(connect)
+    cli.add_command(auth_group)
+    cli.add_command(sessions)

pdd/commands/analysis.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+"""
+Analysis commands (detect-change, conflicts, bug, crash, trace).
+"""
+import os
+import click
+from typing import Optional, Tuple, List
+
+from ..detect_change_main import detect_change_main
+from ..conflicts_main import conflicts_main
+from ..bug_main import bug_main
+from ..agentic_bug import run_agentic_bug
+from ..crash_main import crash_main
+from ..trace_main import trace_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+
+@click.command("detect")
+@click.argument("files", nargs=-1, type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the analysis results (CSV file).",
+)
+@click.pass_context
+@track_cost
+def detect_change(
+    ctx: click.Context,
+    files: Tuple[str, ...],
+    output: Optional[str],
+) -> Optional[Tuple[List, float, str]]:
+    """Detect if prompts need to be changed based on a description.
+    
+    Usage: pdd detect [PROMPT_FILES...] CHANGE_FILE
+    """
+    try:
+        if len(files) < 2:
+             raise click.UsageError("Requires at least one PROMPT_FILE and one CHANGE_FILE.")
+        
+        # According to usage conventions (and README), the last file is the change file
+        change_file = files[-1]
+        prompt_files = list(files[:-1])
+
+        result, total_cost, model_name = detect_change_main(
+            ctx=ctx,
+            prompt_files=prompt_files,
+            change_file=change_file,
+            output=output,
+        )
+        return result, total_cost, model_name
+    except (click.Abort, click.ClickException):
+        raise
+    except Exception as exception:
+        handle_error(exception, "detect", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("conflicts")
+@click.argument("prompt1", type=click.Path(exists=True, dir_okay=False))
+@click.argument("prompt2", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the conflict analysis results (CSV file).",
+)
+@click.pass_context
+@track_cost
+def conflicts(
+    ctx: click.Context,
+    prompt1: str,
+    prompt2: str,
+    output: Optional[str],
+) -> Optional[Tuple[List, float, str]]:
+    """Check for conflicts between two prompt files."""
+    try:
+        result, total_cost, model_name = conflicts_main(
+            ctx=ctx,
+            prompt1=prompt1,
+            prompt2=prompt2,
+            output=output,
+            verbose=ctx.obj.get("verbose", False),
+        )
+        return result, total_cost, model_name
+    except (click.Abort, click.ClickException):
+        raise
+    except Exception as exception:
+        handle_error(exception, "conflicts", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("bug")
+@click.option(
+    "--manual",
+    is_flag=True,
+    default=False,
+    help="Run in manual mode requiring 5 positional file arguments.",
+)
+@click.argument("args", nargs=-1)
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the generated unit test (file or directory).",
+)
+@click.option(
+    "--language",
+    type=str,
+    default="Python",
+    help="Programming language for the unit test (Manual mode only).",
+)
+@click.option(
+    "--timeout-adder",
+    type=float,
+    default=0.0,
+    help="Additional seconds to add to each step's timeout (agentic mode only).",
+)
+@click.option(
+    "--no-github-state",
+    is_flag=True,
+    default=False,
+    help="Disable GitHub state persistence (agentic mode only).",
+)
+@click.pass_context
+@track_cost
+def bug(
+    ctx: click.Context,
+    manual: bool,
+    args: Tuple[str, ...],
+    output: Optional[str],
+    language: str,
+    timeout_adder: float,
+    no_github_state: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """Generate a unit test (manual) or investigate a bug (agentic).
+
+    Agentic Mode (default):
+        pdd bug ISSUE_URL
+
+    Manual Mode:
+        pdd bug --manual PROMPT_FILE CODE_FILE PROGRAM_FILE CURRENT_OUTPUT DESIRED_OUTPUT
+    """
+    try:
+        if manual:
+            if len(args) != 5:
+                raise click.UsageError(
+                    "Manual mode requires 5 arguments: PROMPT_FILE CODE_FILE PROGRAM_FILE CURRENT_OUTPUT DESIRED_OUTPUT"
+                )
+            
+            # Validate files exist (replicating click.Path(exists=True))
+            for f in args:
+                if not os.path.exists(f):
+                    raise click.UsageError(f"File does not exist: {f}")
+                if os.path.isdir(f):
+                    raise click.UsageError(f"Path is a directory, not a file: {f}")
+
+            prompt_file, code_file, program_file, current_output, desired_output = args
+
+            result, total_cost, model_name = bug_main(
+                ctx=ctx,
+                prompt_file=prompt_file,
+                code_file=code_file,
+                program_file=program_file,
+                current_output=current_output,
+                desired_output=desired_output,
+                output=output,
+                language=language,
+            )
+            return result, total_cost, model_name
+        
+        else:
+            # Agentic mode
+            if len(args) != 1:
+                raise click.UsageError("Agentic mode requires exactly one argument: the GitHub Issue URL.")
+            
+            issue_url = args[0]
+            
+            success, message, cost, model, changed_files = run_agentic_bug(
+                issue_url=issue_url,
+                verbose=ctx.obj.get("verbose", False),
+                quiet=ctx.obj.get("quiet", False),
+                timeout_adder=timeout_adder,
+                use_github_state=not no_github_state,
+            )
+            
+            result_str = f"Success: {success}\nMessage: {message}\nChanged Files: {changed_files}"
+            return result_str, cost, model
+
+    except (click.Abort, click.ClickException):
+        raise
+    except Exception as exception:
+        handle_error(exception, "bug", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("crash")
+@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("code_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("program_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("error_file", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the fixed code file (file or directory).",
+)
+@click.option(
+    "--output-program",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the fixed program file (file or directory).",
+)
+@click.option(
+    "--loop",
+    is_flag=True,
+    default=False,
+    help="Enable iterative fixing process.",
+)
+@click.option(
+    "--max-attempts",
+    type=int,
+    default=None,
+    help="Maximum number of fix attempts (default: 3).",
+)
+@click.option(
+    "--budget",
+    type=float,
+    default=None,
+    help="Maximum cost allowed for the fixing process (default: 5.0).",
+)
+@click.pass_context
+@track_cost
+def crash(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    program_file: str,
+    error_file: str,
+    output: Optional[str],
+    output_program: Optional[str],
+    loop: bool,
+    max_attempts: Optional[int],
+    budget: Optional[float],
+) -> Optional[Tuple[str, float, str]]:
+    """Analyze a crash and fix the code and program."""
+    try:
+        # crash_main returns: success, final_code, final_program, attempts, total_cost, model_name
+        success, final_code, final_program, attempts, total_cost, model_name = crash_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            code_file=code_file,
+            program_file=program_file,
+            error_file=error_file,
+            output=output,
+            output_program=output_program,
+            loop=loop,
+            max_attempts=max_attempts,
+            budget=budget,
+        )
+        # Return a summary string as the result for track_cost/CLI output
+        result = f"Success: {success}, Attempts: {attempts}"
+        return result, total_cost, model_name
+    except (click.Abort, click.ClickException):
+        raise
+    except Exception as exception:
+        handle_error(exception, "crash", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("trace")
+@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("code_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("code_line", type=int)
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the trace analysis results.",
+)
+@click.pass_context
+@track_cost
+def trace(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    code_line: int,
+    output: Optional[str],
+) -> Optional[Tuple[str, float, str]]:
+    """Trace execution flow back to the prompt."""
+    try:
+        # trace_main returns: prompt_line, total_cost, model_name
+        result, total_cost, model_name = trace_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            code_file=code_file,
+            code_line=code_line,
+            output=output,
+        )
+        return str(result), total_cost, model_name
+    except (click.Abort, click.ClickException):
+        raise
+    except Exception as exception:
+        handle_error(exception, "trace", ctx.obj.get("quiet", False))
+        return None

pdd/commands/auth.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+import click
+from rich.console import Console
+
+# Internal imports
+try:
+    from ..auth_service import (
+        get_auth_status,
+        logout as service_logout,
+        JWT_CACHE_FILE,
+    )
+    from ..get_jwt_token import (
+        get_jwt_token,
+        AuthError,
+        NetworkError,
+        TokenError,
+        UserCancelledError,
+        RateLimitError,
+    )
+except ImportError:
+    pass
+
+console = Console()
+
+# Constants
+PDD_ENV = os.environ.get("PDD_ENV", "local")
+
+
+def _load_firebase_api_key() -> str:
+    """Load the Firebase API key from environment or .env files."""
+    # 1. Check direct env var
+    env_key = os.environ.get("NEXT_PUBLIC_FIREBASE_API_KEY")
+    if env_key:
+        return env_key
+
+    # 2. Check .env files in current directory
+    candidates = [Path(".env"), Path(".env.local")]
+    
+    for candidate in candidates:
+        if candidate.exists():
+            try:
+                content = candidate.read_text(encoding="utf-8")
+                for line in content.splitlines():
+                    if line.strip().startswith("NEXT_PUBLIC_FIREBASE_API_KEY="):
+                        return line.split("=", 1)[1].strip().strip('"').strip("'")
+            except Exception:
+                continue
+                
+    return ""
+
+
+def _get_client_id() -> Optional[str]:
+    """Get the GitHub Client ID for the current environment."""
+    return os.environ.get(f"GITHUB_CLIENT_ID_{PDD_ENV.upper()}") or os.environ.get("GITHUB_CLIENT_ID")
+
+
+def _decode_jwt_payload(token: str) -> Dict[str, Any]:
+    """Decode JWT payload without verification to extract claims."""
+    try:
+        # JWT is header.payload.signature
+        parts = token.split(".")
+        if len(parts) != 3:
+            return {}
+        
+        payload = parts[1]
+        # Add padding if needed
+        padding = len(payload) % 4
+        if padding:
+            payload += "=" * (4 - padding)
+            
+        decoded = base64.urlsafe_b64decode(payload)
+        return json.loads(decoded)
+    except Exception:
+        return {}
+
+
+@click.group("auth")
+def auth_group():
+    """Manage PDD Cloud authentication."""
+    pass
+
+
+@auth_group.command("login")
+@click.option(
+    "--browser/--no-browser",
+    default=None,
+    help="Control browser opening (auto-detect if not specified)"
+)
+def login(browser: Optional[bool]):
+    """Authenticate with PDD Cloud via GitHub."""
+
+    api_key = _load_firebase_api_key()
+    if not api_key:
+        console.print("[red]Error: NEXT_PUBLIC_FIREBASE_API_KEY not found.[/red]")
+        console.print("Please set it in your environment or .env file.")
+        sys.exit(1)
+
+    client_id = _get_client_id()
+    app_name = "PDD CLI"
+
+    async def run_login():
+        try:
+            # Import remote session detection
+            from ..core.remote_session import should_skip_browser
+
+            # Determine if browser should be skipped
+            skip_browser, reason = should_skip_browser(explicit_flag=browser)
+
+            if skip_browser:
+                console.print(f"[yellow]Note: {reason}[/yellow]")
+                console.print("[yellow]Please open the authentication URL manually in a browser.[/yellow]")
+
+            # Pass no_browser parameter to get_jwt_token
+            token = await get_jwt_token(
+                firebase_api_key=api_key,
+                github_client_id=client_id,
+                app_name=app_name,
+                no_browser=skip_browser
+            )
+            
+            if not token:
+                console.print("[red]Authentication failed: No token received.[/red]")
+                sys.exit(1)
+                
+            # Decode token to get expiration
+            payload = _decode_jwt_payload(token)
+            expires_at = payload.get("exp")
+            
+            # Ensure cache directory exists
+            if not JWT_CACHE_FILE.parent.exists():
+                JWT_CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Save token and expiration to cache
+            # We store id_token for retrieval and expires_at for auth_service checks
+            cache_data = {
+                "id_token": token,
+                "expires_at": expires_at
+            }
+            
+            JWT_CACHE_FILE.write_text(json.dumps(cache_data))
+            
+            console.print("[green]Successfully authenticated to PDD Cloud.[/green]")
+            
+        except AuthError as e:
+            console.print(f"[red]Authentication failed: {e}[/red]")
+            sys.exit(1)
+        except NetworkError as e:
+            console.print(f"[red]Network error: {e}[/red]")
+            sys.exit(1)
+        except TokenError as e:
+            console.print(f"[red]Token error: {e}[/red]")
+            sys.exit(1)
+        except UserCancelledError:
+            console.print("[yellow]Authentication cancelled by user.[/yellow]")
+            sys.exit(1)
+        except RateLimitError as e:
+            console.print(f"[red]Rate limit exceeded: {e}[/red]")
+            sys.exit(1)
+        except Exception as e:
+            console.print(f"[red]An unexpected error occurred: {e}[/red]")
+            sys.exit(1)
+
+    asyncio.run(run_login())
+
+
+@auth_group.command("status")
+def status():
+    """Check current authentication status."""
+    auth_status = get_auth_status()
+    
+    if not auth_status.get("authenticated"):
+        console.print("Not authenticated.")
+        return
+        
+    username = "Unknown"
+    
+    # If we have a cached token, try to extract user info
+    if auth_status.get("cached") and JWT_CACHE_FILE.exists():
+        try:
+            data = json.loads(JWT_CACHE_FILE.read_text())
+            token = data.get("id_token")
+            if token:
+                payload = _decode_jwt_payload(token)
+                # Try to find a meaningful identifier
+                username = payload.get("email") or payload.get("sub")
+                
+                # Check for GitHub specific claims if available in Firebase token
+                firebase_claims = payload.get("firebase", {})
+                identities = firebase_claims.get("identities", {})
+                if "github.com" in identities:
+                    # identities['github.com'] is a list of IDs, not usernames usually
+                    pass
+        except Exception:
+            pass
+            
+    console.print(f"Authenticated as: [bold green]{username}[/bold green]")
+    sys.exit(0)
+
+
+@auth_group.command("logout")
+def logout_cmd():
+    """Log out of PDD Cloud."""
+    success, error = service_logout()
+    if success:
+        console.print("Logged out of PDD Cloud.")
+    else:
+        console.print(f"[red]Failed to logout: {error}[/red]")
+        # We don't exit with 1 here as partial logout might have occurred
+        # and the user is effectively logged out locally anyway.
+
+
+@auth_group.command("token")
+@click.option("--format", "output_format", type=click.Choice(["raw", "json"]), default="raw", help="Output format.")
+def token_cmd(output_format: str):
+    """Print the current authentication token."""
+
+    token_str = None
+    expires_at = None
+
+    # Attempt to read valid token from cache
+    if JWT_CACHE_FILE.exists():
+        try:
+            data = json.loads(JWT_CACHE_FILE.read_text())
+            cached_token = data.get("id_token")
+            cached_exp = data.get("expires_at")
+
+            # Simple expiry check
+            if cached_token and cached_exp and cached_exp > time.time():
+                token_str = cached_token
+                expires_at = cached_exp
+        except Exception:
+            pass
+
+    if not token_str:
+        # Removed err=True because rich.console.Console.print does not support it
+        console.print("[red]No valid token available. Please login.[/red]")
+        sys.exit(1)
+
+    if output_format == "json":
+        output = {
+            "token": token_str,
+            "expires_at": expires_at
+        }
+        console.print_json(data=output)
+    else:
+        console.print(token_str)
+
+
+@auth_group.command("clear-cache")
+def clear_cache():
+    """Clear the JWT token cache.
+
+    This is useful when:
+    - Switching between environments (staging vs production)
+    - Experiencing authentication issues
+    - JWT token audience mismatch errors
+
+    After clearing the cache, you'll need to re-authenticate
+    with 'pdd auth login' or source the appropriate environment
+    setup script (e.g., setup_staging_env.sh).
+    """
+    if not JWT_CACHE_FILE.exists():
+        console.print("[yellow]No JWT cache found at ~/.pdd/jwt_cache[/yellow]")
+        console.print("Nothing to clear.")
+        return
+
+    try:
+        # Try to read cache before deleting to show what was cached
+        cache_data = json.loads(JWT_CACHE_FILE.read_text())
+        token = cache_data.get("id_token") or cache_data.get("jwt")
+        if token:
+            payload = _decode_jwt_payload(token)
+            aud = payload.get("aud") or payload.get("firebase", {}).get("aud")
+            exp = payload.get("exp")
+
+            console.print("[dim]Cached token info:[/dim]")
+            if aud:
+                console.print(f"  Audience: {aud}")
+            if exp:
+                if exp > time.time():
+                    time_remaining = int((exp - time.time()) / 60)
+                    console.print(f"  Expires in: {time_remaining} minutes")
+                else:
+                    console.print("  Status: [red]Expired[/red]")
+    except Exception:
+        # If we can't read the cache, that's fine - just proceed with deletion
+        pass
+
+    # Delete the cache file
+    try:
+        JWT_CACHE_FILE.unlink()
+        console.print("[green]✓[/green] JWT cache cleared successfully")
+        console.print()
+        console.print("[dim]To re-authenticate:[/dim]")
+        console.print("  - For production: [bold]pdd auth login[/bold]")
+        console.print("  - For staging: [bold]source setup_staging_env.sh[/bold]")
+    except OSError as e:
+        console.print(f"[red]Failed to clear cache: {e}[/red]")
+        sys.exit(1)