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

pdd/commands/modify.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional, Tuple, Any
+
+import click
+from rich.console import Console
+
+# Relative imports from parent package
+from ..split_main import split_main
+from ..change_main import change_main
+from ..agentic_change import run_agentic_change
+from ..update_main import update_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+
+console = Console()
+
+@click.command()
+@click.argument("input_prompt", type=click.Path(exists=True))
+@click.argument("input_code", type=click.Path(exists=True))
+@click.argument("example_code", type=click.Path(exists=True))
+@click.option("--output-sub", help="Optional path for saving the sub-prompt.")
+@click.option("--output-modified", help="Optional path for saving the modified prompt.")
+@click.pass_context
+@track_cost
+def split(
+    ctx: click.Context,
+    input_prompt: str,
+    input_code: str,
+    example_code: str,
+    output_sub: Optional[str],
+    output_modified: Optional[str],
+) -> Optional[Tuple[Any, float, str]]:
+    """
+    Split large complex prompt files into smaller, more manageable prompt files.
+    """
+    ctx.ensure_object(dict)
+    try:
+        # Call split_main with required arguments
+        result_data, total_cost, model_name = split_main(
+            ctx,
+            input_prompt_file=input_prompt,
+            input_code_file=input_code,
+            example_code_file=example_code,
+            output_sub=output_sub,
+            output_modified=output_modified,
+        )
+        return result_data, total_cost, model_name
+
+    except click.Abort:
+        raise
+    except Exception as e:
+        handle_error(e, "split", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command()
+@click.argument("args", nargs=-1)
+@click.option("--manual", is_flag=True, default=False, help="Use legacy manual mode.")
+@click.option("--budget", type=float, default=5.0, help="Budget for the operation.")
+@click.option("--output", help="Output path.")
+@click.option("--csv", is_flag=True, help="Use CSV input for batch processing.")
+@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 change(
+    ctx: click.Context,
+    args: Tuple[str, ...],
+    manual: bool,
+    budget: float,
+    output: Optional[str],
+    csv: bool,
+    timeout_adder: float,
+    no_github_state: bool,
+) -> Optional[Tuple[Any, float, str]]:
+    """
+    Modify an input prompt file based on a change prompt or issue.
+
+    Agentic Mode (default):
+        pdd change ISSUE_URL
+
+    Manual Mode (--manual):
+        pdd change --manual CHANGE_PROMPT_FILE INPUT_CODE_FILE [INPUT_PROMPT_FILE]
+    """
+    ctx.ensure_object(dict)
+    
+    try:
+        # Set budget in context for manual mode usage
+        ctx.obj["budget"] = budget
+        
+        quiet = ctx.obj.get("quiet", False)
+        verbose = ctx.obj.get("verbose", False)
+
+        if manual:
+            # Manual Mode Validation and Execution
+            if csv:
+                # CSV Mode: Expecting CSV_FILE and CODE_DIRECTORY (no input_prompt)
+                if len(args) == 3:
+                    raise click.UsageError("Cannot use --csv and specify an INPUT_PROMPT_FILE simultaneously.")
+                if len(args) != 2:
+                    raise click.UsageError("CSV mode requires 2 arguments: CSV_FILE CODE_DIRECTORY")
+
+                change_file, input_code = args
+                input_prompt = None
+
+                # CSV mode requires input_code to be a directory
+                if not Path(input_code).is_dir():
+                    raise click.UsageError("INPUT_CODE must be a directory when using --csv")
+            else:
+                # Standard Manual Mode: Expecting 2 or 3 arguments
+                if len(args) == 3:
+                    change_file, input_code, input_prompt = args
+                    # Non-CSV mode requires input_code to be a file, not a directory
+                    if Path(input_code).is_dir():
+                        raise click.UsageError("INPUT_CODE must be a file when not using --csv")
+                elif len(args) == 2:
+                    change_file, input_code = args
+                    input_prompt = None
+                    # Without CSV mode, input_prompt_file is required
+                    raise click.UsageError("INPUT_PROMPT_FILE is required when not using --csv")
+                else:
+                    raise click.UsageError(
+                        "Manual mode requires 2 or 3 arguments: CHANGE_PROMPT INPUT_CODE [INPUT_PROMPT]"
+                    )
+
+            # Validate file existence
+            if not Path(change_file).exists():
+                raise click.UsageError(f"Change file not found: {change_file}")
+            if not Path(input_code).exists():
+                raise click.UsageError(f"Input code path not found: {input_code}")
+            if input_prompt and not Path(input_prompt).exists():
+                raise click.UsageError(f"Input prompt file not found: {input_prompt}")
+
+            # Call change_main
+            result, cost, model = change_main(
+                ctx=ctx,
+                change_prompt_file=change_file,
+                input_code=input_code,
+                input_prompt_file=input_prompt,
+                output=output,
+                use_csv=csv,
+                budget=budget
+            )
+            return result, cost, model
+
+        else:
+            # Agentic Mode Validation and Execution
+            if len(args) != 1:
+                raise click.UsageError("Agentic mode requires exactly 1 argument: ISSUE_URL")
+            
+            issue_url = args[0]
+            
+            # Call run_agentic_change
+            success, message, cost, model, changed_files = run_agentic_change(
+                issue_url=issue_url,
+                verbose=verbose,
+                quiet=quiet,
+                timeout_adder=timeout_adder,
+                use_github_state=not no_github_state
+            )
+
+            # Display results using click.echo as requested
+            if not quiet:
+                status = "Success" if success else "Failed"
+                click.echo(f"Status: {status}")
+                click.echo(f"Message: {message}")
+                click.echo(f"Cost: ${cost:.4f}")
+                click.echo(f"Model: {model}")
+                if changed_files:
+                    click.echo("Changed files:")
+                    for f in changed_files:
+                        click.echo(f"  - {f}")
+            
+            return message, cost, model
+
+    except click.Abort:
+        raise
+    except Exception as e:
+        handle_error(e, "change", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command()
+@click.argument("files", nargs=-1)
+@click.option("--extensions", help="Comma-separated extensions for repo mode.")
+@click.option("--directory", help="Directory to scan for repo mode.")
+@click.option("--git", is_flag=True, help="Use git history for original code.")
+@click.option("--output", help="Output path for the updated prompt.")
+@click.option("--simple", is_flag=True, default=False, help="Use legacy simple update.")
+@click.pass_context
+@track_cost
+def update(
+    ctx: click.Context,
+    files: Tuple[str, ...],
+    extensions: Optional[str],
+    directory: Optional[str],
+    git: bool,
+    output: Optional[str],
+    simple: bool,
+) -> Optional[Tuple[Any, float, str]]:
+    """
+    Update the original prompt file based on code changes.
+
+    Repo-wide mode (no args): Scan entire repo.
+    Single-file mode (1 arg): Update prompt for specific code file.
+    """
+    ctx.ensure_object(dict)
+    try:
+        # Determine mode based on argument count
+        is_repo_mode = len(files) == 0
+
+        # Validate mode-specific options
+        if is_repo_mode:
+            # Repo-wide mode: --git and --output are not allowed
+            if git:
+                raise click.UsageError(
+                    "Cannot use file-specific arguments or flags like --git in repository-wide mode"
+                )
+        else:
+            # Single-file mode: --extensions and --directory are not allowed
+            if extensions:
+                raise click.UsageError(
+                    "--extensions can only be used in repository-wide mode"
+                )
+            if directory:
+                raise click.UsageError(
+                    "--directory can only be used in repository-wide mode"
+                )
+
+        # In single-file mode, the one arg is the modified code file
+        modified_code_file = files[0] if len(files) > 0 else None
+
+        # Call update_main with correct parameters
+        result, cost, model = update_main(
+            ctx=ctx,
+            input_prompt_file=None,
+            modified_code_file=modified_code_file,
+            input_code_file=None,
+            output=output,
+            use_git=git,
+            repo=is_repo_mode,
+            extensions=extensions,
+            directory=directory,
+            simple=simple
+        )
+
+        return result, cost, model
+
+    except click.Abort:
+        raise
+    except Exception as e:
+        handle_error(e, "update", ctx.obj.get("quiet", False))
+        return None

pdd/commands/report.py

@@ -0,0 +1,144 @@
+"""
+Report commands (report-core).
+"""
+import os
+import click
+import json
+import webbrowser
+import urllib.parse
+from pathlib import Path
+from typing import Optional
+
+from ..core.errors import handle_error, console
+from ..core.dump import _build_issue_markdown, _github_config, _post_issue_to_github, _create_gist_with_files
+
+@click.command("report-core")
+@click.argument("core_file", type=click.Path(exists=True, dir_okay=False), required=False)
+@click.option(
+    "--api",
+    is_flag=True,
+    default=False,
+    help="Create issue directly via GitHub API instead of opening browser. Requires authentication."
+)
+@click.option(
+    "--repo",
+    default=None,
+    help="GitHub repository in format 'owner/repo'. Defaults to 'promptdriven/pdd' or PDD_GITHUB_REPO env var."
+)
+@click.option(
+    "--description",
+    "-d",
+    default="",
+    help="Optional description of what happened to include in the issue."
+)
+@click.pass_context
+def report_core(ctx: click.Context, core_file: Optional[str], api: bool, repo: Optional[str], description: str):
+    """Report a bug by creating a GitHub issue with the core dump file.
+
+    If CORE_FILE is not provided, the most recent core dump in .pdd/core_dumps is used.
+
+    By default, opens a browser with a pre-filled issue template. Use --api to create
+    the issue directly via GitHub API (requires authentication via gh CLI or GITHUB_TOKEN).
+    """
+    try:
+        if not core_file:
+            # Find latest core dump
+            core_dump_dir = Path.cwd() / ".pdd" / "core_dumps"
+            if not core_dump_dir.exists():
+                raise click.UsageError("No core dumps found in .pdd/core_dumps.")
+
+            dumps = sorted(core_dump_dir.glob("pdd-core-*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+            if not dumps:
+                raise click.UsageError("No core dumps found in .pdd/core_dumps.")
+            core_file = str(dumps[0])
+            console.print(f"[info]Using most recent core dump: {core_file}[/info]")
+
+        core_path = Path(core_file)
+        try:
+            payload = json.loads(core_path.read_text(encoding="utf-8"))
+        except Exception as e:
+            raise click.UsageError(f"Failed to parse core dump: {e}")
+
+        # Determine repository
+        target_repo = repo or os.getenv("PDD_GITHUB_REPO", "promptdriven/pdd")
+
+        # For API submission, create a gist with all files
+        gist_url = None
+        if api:
+            console.print("[info]Attempting to create issue via GitHub API...[/info]")
+
+            github_config = _github_config(target_repo)
+            if not github_config:
+                console.print(
+                    "[error]No GitHub authentication found. Please either:[/error]\n"
+                    "  1. Install and authenticate with GitHub CLI: gh auth login\n"
+                    "  2. Set GITHUB_TOKEN or GH_TOKEN environment variable\n"
+                    "  3. Set PDD_GITHUB_TOKEN environment variable\n"
+                    "\n"
+                    "[info]Falling back to browser-based submission...[/info]"
+                )
+                api = False
+            else:
+                token, resolved_repo = github_config
+
+                # Create gist with all files
+                console.print(f"[info]Creating Gist with all files...[/info]")
+                gist_url = _create_gist_with_files(token, payload, core_path)
+
+                if gist_url:
+                    console.print(f"[success]Gist created: {gist_url}[/success]")
+                else:
+                    console.print("[warning]Failed to create Gist, including files in issue body...[/warning]")
+
+                # Build issue with gist link
+                title, body = _build_issue_markdown(
+                    payload=payload,
+                    description=description,
+                    core_path=core_path,
+                    replay_path=None,
+                    attachments=[],
+                    truncate_files=False,
+                    gist_url=gist_url
+                )
+
+                console.print(f"[info]Creating issue in {resolved_repo}...[/info]")
+                issue_url = _post_issue_to_github(token, resolved_repo, title, body)
+                if issue_url:
+                    console.print(f"[success]Issue created successfully: {issue_url}[/success]")
+                    return
+                else:
+                    console.print(
+                        "[warning]Failed to create issue via API. Falling back to browser...[/warning]"
+                    )
+                    api = False
+
+        # Build issue content for browser mode (if not already built for API)
+        if not api:
+            # For browser-based submission, we'll truncate files to avoid URL length limits
+            title, body = _build_issue_markdown(
+                payload=payload,
+                description=description,
+                core_path=core_path,
+                replay_path=None,
+                attachments=[],
+                truncate_files=True  # Truncate for browser
+            )
+
+        # Browser-based submission (default or fallback)
+        if not api:
+            # URL encode
+            encoded_title = urllib.parse.quote(title)
+            encoded_body = urllib.parse.quote(body)
+
+            url = f"https://github.com/{target_repo}/issues/new?title={encoded_title}&body={encoded_body}"
+
+            console.print(f"[info]Opening GitHub issue creation page for {target_repo}...[/info]")
+            console.print("[info]Note: File contents are truncated for browser submission. Use --api for full contents.[/info]")
+
+            if len(url) > 8000:
+                console.print("[warning]The issue body is large. Browser might truncate it.[/warning]")
+
+            webbrowser.open(url)
+
+    except Exception as e:
+        handle_error(e, "report-core", ctx.obj.get("quiet", False))

pdd/commands/sessions.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Dict, List, Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..core.cloud import CloudConfig
+from ..remote_session import RemoteSessionManager, RemoteSessionError
+
+console = Console()
+
+
+@click.group(name="sessions")
+def sessions() -> None:
+    """Manage remote PDD sessions."""
+    pass
+
+
+@sessions.command(name="list")
+@click.option("--json", "json_output", is_flag=True, help="Output as JSON.")
+def list_sessions(json_output: bool) -> None:
+    """List active remote sessions.
+
+    Retrieves a list of active remote sessions associated with the current
+    authenticated user and displays them in a table or as JSON.
+    """
+    jwt_token = CloudConfig.get_jwt_token()
+    if not jwt_token:
+        console.print("[red]Error: Not authenticated. Please run 'pdd auth login'.[/red]")
+        return
+
+    try:
+        sessions_list = asyncio.run(RemoteSessionManager.list_sessions(jwt_token))
+    except Exception as e:
+        console.print(f"[red]Error listing sessions: {e}[/red]")
+        return
+
+    if json_output:
+        output_data = []
+        for s in sessions_list:
+            # Handle Pydantic v1/v2 or dataclasses
+            if hasattr(s, "model_dump"):
+                output_data.append(s.model_dump())
+            elif hasattr(s, "dict"):
+                output_data.append(s.dict())
+            else:
+                output_data.append(s.__dict__)
+        console.print_json(data=output_data)
+        return
+
+    if not sessions_list:
+        console.print("[yellow]No active remote sessions found.[/yellow]")
+        return
+
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("SESSION ID", style="dim", width=12)
+    table.add_column("PROJECT")
+    table.add_column("CLOUD URL", style="blue")
+    table.add_column("STATUS")
+    table.add_column("LAST SEEN")
+
+    for session in sessions_list:
+        # Safely access attributes with defaults
+        s_id = getattr(session, "session_id", "unknown")
+        project = getattr(session, "project_name", "default")
+        url = getattr(session, "cloud_url", "")
+        status = getattr(session, "status", "unknown")
+        last_seen = getattr(session, "last_heartbeat", "never")
+
+        # Truncate ID for display
+        display_id = s_id[:8] if len(s_id) > 8 else s_id
+
+        # Colorize status
+        status_str = str(status)
+        if status_str.lower() == "active":
+            status_render = f"[green]{status_str}[/green]"
+        elif status_str.lower() == "stale":
+            status_render = f"[yellow]{status_str}[/yellow]"
+        else:
+            status_render = status_str
+
+        table.add_row(
+            display_id,
+            str(project),
+            str(url),
+            status_render,
+            str(last_seen)
+        )
+
+    console.print(table)
+
+
+@sessions.command(name="info")
+@click.argument("session_id")
+def session_info(session_id: str) -> None:
+    """Display detailed info about a specific session.
+
+    Args:
+        session_id: The unique identifier of the session to inspect.
+    """
+    jwt_token = CloudConfig.get_jwt_token()
+    if not jwt_token:
+        console.print("[red]Error: Not authenticated. Please run 'pdd auth login'.[/red]")
+        return
+
+    try:
+        # Attempt to fetch specific session details
+        # Note: Assuming get_session exists on RemoteSessionManager
+        session = asyncio.run(RemoteSessionManager.get_session(jwt_token, session_id))
+    except Exception as e:
+        console.print(f"[red]Error fetching session: {e}[/red]")
+        return
+
+    if not session:
+        console.print(f"[red]Session '{session_id}' not found.[/red]")
+        return
+
+    console.print(f"[bold blue]Session Information: {session_id}[/bold blue]")
+
+    # Convert session object to dictionary for iteration
+    if hasattr(session, "model_dump"):
+        data = session.model_dump()
+    elif hasattr(session, "dict"):
+        data = session.dict()
+    else:
+        data = session.__dict__
+
+    # Display metadata in a clean table
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Field", style="bold cyan", justify="right")
+    table.add_column("Value", style="white")
+
+    # Sort keys for consistent display
+    for key in sorted(data.keys()):
+        value = data[key]
+        # Format key for display (snake_case to Title Case)
+        display_key = key.replace("_", " ").title()
+        table.add_row(display_key, str(value))
+
+    console.print(table)
+
+
+@sessions.command(name="cleanup")
+@click.option("--all", "cleanup_all", is_flag=True, help="Cleanup all sessions (including active).")
+@click.option("--stale", "cleanup_stale", is_flag=True, help="Cleanup only stale sessions.")
+@click.option("--force", is_flag=True, help="Skip confirmation prompt.")
+def cleanup_sessions(cleanup_all: bool, cleanup_stale: bool, force: bool) -> None:
+    """Cleanup (deregister) remote sessions.
+
+    By default, lists sessions and prompts for cleanup.
+    Use --all to cleanup all sessions, or --stale to cleanup only stale sessions.
+    """
+    jwt_token = CloudConfig.get_jwt_token()
+    if not jwt_token:
+        console.print("[red]Error: Not authenticated. Please run 'pdd login'.[/red]")
+        return
+
+    try:
+        sessions_list = asyncio.run(RemoteSessionManager.list_sessions(jwt_token))
+    except Exception as e:
+        console.print(f"[red]Error listing sessions: {e}[/red]")
+        return
+
+    if not sessions_list:
+        console.print("[yellow]No active remote sessions found.[/yellow]")
+        return
+
+    # Filter sessions based on flags
+    if cleanup_stale:
+        sessions_to_cleanup = [s for s in sessions_list if getattr(s, "status", "").lower() == "stale"]
+        if not sessions_to_cleanup:
+            console.print("[yellow]No stale sessions found.[/yellow]")
+            return
+    elif cleanup_all:
+        sessions_to_cleanup = sessions_list
+    else:
+        # Interactive mode - show sessions and ask which to cleanup
+        console.print("[bold]Current remote sessions:[/bold]")
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("#", style="dim", width=3)
+        table.add_column("SESSION ID", style="dim", width=12)
+        table.add_column("PROJECT")
+        table.add_column("STATUS")
+        table.add_column("LAST SEEN")
+
+        for idx, session in enumerate(sessions_list, 1):
+            s_id = getattr(session, "session_id", "unknown")
+            project = getattr(session, "project_name", "default")
+            status = getattr(session, "status", "unknown")
+            last_seen = getattr(session, "last_heartbeat", "never")
+
+            display_id = s_id[:8] if len(s_id) > 8 else s_id
+
+            status_str = str(status)
+            if status_str.lower() == "active":
+                status_render = f"[green]{status_str}[/green]"
+            elif status_str.lower() == "stale":
+                status_render = f"[yellow]{status_str}[/yellow]"
+            else:
+                status_render = status_str
+
+            table.add_row(
+                str(idx),
+                display_id,
+                str(project),
+                status_render,
+                str(last_seen)
+            )
+
+        console.print(table)
+        console.print("\n[bold]Options:[/bold]")
+        console.print("  - Enter session numbers (comma-separated) to cleanup specific sessions")
+        console.print("  - Enter 'stale' to cleanup all stale sessions")
+        console.print("  - Enter 'all' to cleanup all sessions")
+        console.print("  - Press Enter to cancel")
+
+        choice = click.prompt("\nYour choice", default="", show_default=False)
+
+        if not choice:
+            console.print("[yellow]Cancelled.[/yellow]")
+            return
+
+        if choice.lower() == "all":
+            sessions_to_cleanup = sessions_list
+        elif choice.lower() == "stale":
+            sessions_to_cleanup = [s for s in sessions_list if getattr(s, "status", "").lower() == "stale"]
+            if not sessions_to_cleanup:
+                console.print("[yellow]No stale sessions found.[/yellow]")
+                return
+        else:
+            # Parse comma-separated numbers
+            try:
+                indices = [int(x.strip()) - 1 for x in choice.split(",")]
+                sessions_to_cleanup = [sessions_list[i] for i in indices if 0 <= i < len(sessions_list)]
+                if not sessions_to_cleanup:
+                    console.print("[red]Invalid selection.[/red]")
+                    return
+            except (ValueError, IndexError):
+                console.print("[red]Invalid input. Please enter numbers separated by commas.[/red]")
+                return
+
+    # Confirm cleanup
+    if not force:
+        console.print(f"\n[bold yellow]About to cleanup {len(sessions_to_cleanup)} session(s):[/bold yellow]")
+        for session in sessions_to_cleanup:
+            s_id = getattr(session, "session_id", "unknown")
+            project = getattr(session, "project_name", "default")
+            console.print(f"  - {s_id[:8]} ({project})")
+
+        if not click.confirm("\nProceed with cleanup?", default=False):
+            console.print("[yellow]Cancelled.[/yellow]")
+            return
+
+    # Perform cleanup
+    success_count = 0
+    fail_count = 0
+
+    async def cleanup_session(session_id: str) -> bool:
+        """Helper to deregister a single session."""
+        from pathlib import Path
+        manager = RemoteSessionManager(jwt_token, project_path=Path.cwd())
+        manager.session_id = session_id
+        try:
+            await manager.deregister()
+            return True
+        except Exception as e:
+            console.print(f"[red]Failed to cleanup {session_id[:8]}: {e}[/red]")
+            return False
+
+    with console.status("[bold green]Cleaning up sessions..."):
+        for session in sessions_to_cleanup:
+            s_id = getattr(session, "session_id", "unknown")
+            if asyncio.run(cleanup_session(s_id)):
+                success_count += 1
+            else:
+                fail_count += 1
+
+    console.print(f"\n[bold green]✓[/bold green] Successfully cleaned up {success_count} session(s)")
+    if fail_count > 0:
+        console.print(f"[bold red]✗[/bold red] Failed to cleanup {fail_count} session(s)")