pdd-cli 0.0.42__py3-none-any.whl → 0.0.90__py3-none-any.whl

pdd/commands/maintenance.py

@@ -0,0 +1,174 @@
+"""
+Maintenance commands (sync, auto_deps, setup).
+"""
+import click
+from typing import Optional, Tuple
+from pathlib import Path
+
+from ..sync_main import sync_main
+from ..auto_deps_main import auto_deps_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+from ..core.utils import _run_setup_utility
+
+@click.command("sync")
+@click.argument("basename", required=True)
+@click.option(
+    "--max-attempts",
+    type=int,
+    default=None,
+    help="Maximum number of fix attempts. Default: 3 or .pddrc value.",
+)
+@click.option(
+    "--budget",
+    type=float,
+    default=None,
+    help="Maximum total cost for the sync process. Default: 20.0 or .pddrc value.",
+)
+@click.option(
+    "--skip-verify",
+    is_flag=True,
+    default=False,
+    help="Skip the functional verification step.",
+)
+@click.option(
+    "--skip-tests",
+    is_flag=True,
+    default=False,
+    help="Skip unit test generation and fixing.",
+)
+@click.option(
+    "--target-coverage",
+    default=None,
+    help="Desired code coverage percentage. Default: 10.0 or .pddrc value.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Analyze sync state without executing operations. Shows what sync would do.",
+)
+@click.option(
+    "--log",
+    is_flag=True,
+    default=False,
+    hidden=True,
+    help="Deprecated: Use --dry-run instead.",
+)
+@click.pass_context
+@track_cost
+def sync(
+    ctx: click.Context,
+    basename: str,
+    max_attempts: Optional[int],
+    budget: Optional[float],
+    skip_verify: bool,
+    skip_tests: bool,
+    target_coverage: float,
+    dry_run: bool,
+    log: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """
+    Synchronize prompts with code and tests.
+
+    BASENAME is the base name of the prompt file (e.g., 'my_module' for 'prompts/my_module_python.prompt').
+    """
+    # Handle deprecated --log flag
+    if log:
+        click.echo(
+            click.style(
+                "Warning: --log is deprecated, use --dry-run instead.",
+                fg="yellow"
+            ),
+            err=True
+        )
+        dry_run = True
+
+    try:
+        result, total_cost, model_name = sync_main(
+            ctx=ctx,
+            basename=basename,
+            max_attempts=max_attempts,
+            budget=budget,
+            skip_verify=skip_verify,
+            skip_tests=skip_tests,
+            target_coverage=target_coverage,
+            dry_run=dry_run,
+        )
+        return str(result), total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "sync", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("auto-deps")
+@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
+# exists=False to allow manual handling of quoted paths or paths with globs that shell didn't expand
+@click.argument("directory_path", type=click.Path(exists=False, file_okay=False))
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the modified prompt (file or directory).",
+)
+@click.option(
+    "--csv",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify the CSV file that contains or will contain dependency information.",
+)
+@click.option(
+    "--force-scan",
+    is_flag=True,
+    default=False,
+    help="Force rescanning of all potential dependency files even if they exist in the CSV file.",
+)
+@click.pass_context
+@track_cost
+def auto_deps(
+    ctx: click.Context,
+    prompt_file: str,
+    directory_path: str,
+    output: Optional[str],
+    csv: Optional[str],
+    force_scan: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """Analyze project dependencies and update the prompt file."""
+    try:
+        # Strip quotes from directory_path if present (e.g. passed incorrectly)
+        if directory_path:
+            directory_path = directory_path.strip('"').strip("'")
+
+        # auto_deps_main signature: (ctx, prompt_file, directory_path, auto_deps_csv_path, output, force_scan)
+        result, total_cost, model_name = auto_deps_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            directory_path=directory_path,
+            auto_deps_csv_path=csv,
+            output=output,
+            force_scan=force_scan
+        )
+        return result, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "auto-deps", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("setup")
+@click.pass_context
+def setup(ctx: click.Context):
+    """Run the interactive setup utility."""
+    try:
+        # Import here to allow proper mocking
+        from .. import cli as cli_module
+        quiet = ctx.obj.get("quiet", False) if ctx.obj else False
+        # First install completion
+        cli_module.install_completion(quiet=quiet)
+        # Then run setup utility
+        _run_setup_utility()
+    except Exception as e:
+        handle_error(e, "setup", False)

pdd/commands/misc.py

@@ -0,0 +1,79 @@
+"""
+Miscellaneous commands (preprocess).
+"""
+import click
+from typing import Optional, Tuple
+
+from ..preprocess_main import preprocess_main
+from ..core.errors import handle_error
+
+@click.command("preprocess")
+@click.argument("prompt_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 preprocessed prompt file (file or directory).",
+)
+@click.option(
+    "--xml",
+    is_flag=True,
+    default=False,
+    help="Insert XML delimiters for structure (minimal preprocessing).",
+)
+@click.option(
+    "--recursive",
+    is_flag=True,
+    default=False,
+    help="Recursively preprocess includes.",
+)
+@click.option(
+    "--double",
+    is_flag=True,
+    default=False,
+    help="Double curly brackets.",
+)
+@click.option(
+    "--exclude",
+    multiple=True,
+    default=None,
+    help="List of keys to exclude from curly bracket doubling.",
+)
+@click.pass_context
+# No @track_cost as preprocessing is local, but return dummy tuple for callback
+def preprocess(
+    ctx: click.Context,
+    prompt_file: str,
+    output: Optional[str],
+    xml: bool,
+    recursive: bool,
+    double: bool,
+    exclude: Optional[Tuple[str, ...]],
+) -> Optional[Tuple[str, float, str]]:
+    """Preprocess a prompt file to prepare it for LLM use."""
+    try:
+        # Since preprocess is a local operation, we don't track cost
+        # But we need to return a tuple in the expected format for result callback
+        result = preprocess_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            output=output,
+            xml=xml,
+            recursive=recursive,
+            double=double,
+            exclude=list(exclude) if exclude else [],
+        )
+        
+        # Handle the result from preprocess_main
+        if result is None:
+            # If preprocess_main returns None, still return a dummy tuple for the callback
+            return "", 0.0, "local"
+        else:
+            # Unpack the return value from preprocess_main
+            processed_prompt, total_cost, model_name = result
+            return processed_prompt, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "preprocess", ctx.obj.get("quiet", False))
+        return None

pdd/commands/modify.py

@@ -0,0 +1,230 @@
+"""
+Modify commands (change, split, update).
+"""
+import click
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+
+from ..split_main import split_main
+from ..change_main import change_main
+from ..update_main import update_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+
+@click.command("split")
+@click.argument("input_prompt", type=click.Path(exists=True, dir_okay=False))
+@click.argument("input_code", type=click.Path(exists=True, dir_okay=False))
+@click.argument("example_code", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output-sub",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the generated sub-prompt file (file or directory).",
+)
+@click.option(
+    "--output-modified",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the modified prompt file (file or directory).",
+)
+@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[Dict[str, str], float, str]]:
+    """Split large complex prompt files into smaller ones."""
+    quiet = ctx.obj.get("quiet", False)
+    command_name = "split"
+    try:
+        result_data, total_cost, model_name = split_main(
+            ctx=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, command_name, quiet)
+        return None
+
+
+@click.command("change")
+@click.argument("change_prompt_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("input_code", type=click.Path(exists=True)) # Can be file or dir
+@click.argument("input_prompt_file", type=click.Path(exists=True, dir_okay=False), required=False)
+@click.option(
+    "--budget",
+    type=float,
+    default=5.0,
+    show_default=True,
+    help="Maximum cost allowed for the change process.",
+)
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the modified prompt file (file or directory).",
+)
+@click.option(
+    "--csv",
+    "use_csv",
+    is_flag=True,
+    default=False,
+    help="Use a CSV file for batch change prompts.",
+)
+@click.pass_context
+@track_cost
+def change(
+    ctx: click.Context,
+    change_prompt_file: str,
+    input_code: str,
+    input_prompt_file: Optional[str],
+    output: Optional[str],
+    use_csv: bool,
+    budget: float,
+) -> Optional[Tuple[Union[str, Dict], float, str]]:
+    """Modify prompt(s) based on change instructions."""
+    quiet = ctx.obj.get("quiet", False)
+    command_name = "change"
+    try:
+        # --- ADD VALIDATION LOGIC HERE ---
+        input_code_path = Path(input_code) # Convert to Path object
+        if use_csv:
+            if not input_code_path.is_dir():
+                raise click.UsageError("INPUT_CODE must be a directory when using --csv.")
+            if input_prompt_file:
+                raise click.UsageError("Cannot use --csv and specify an INPUT_PROMPT_FILE simultaneously.")
+        else: # Not using CSV
+            if not input_prompt_file:
+                 # This check might be better inside change_main, but can be here too
+                 raise click.UsageError("INPUT_PROMPT_FILE is required when not using --csv.")
+            if not input_code_path.is_file():
+                 # This check might be better inside change_main, but can be here too
+                 raise click.UsageError("INPUT_CODE must be a file when not using --csv.")
+        # --- END VALIDATION LOGIC ---
+
+        result_data, total_cost, model_name = change_main(
+            ctx=ctx,
+            change_prompt_file=change_prompt_file,
+            input_code=input_code,
+            input_prompt_file=input_prompt_file,
+            output=output,
+            use_csv=use_csv,
+            budget=budget,
+        )
+        return result_data, total_cost, model_name
+    except click.Abort:
+        raise
+    except (click.UsageError, Exception) as e: # Catch specific and general exceptions
+        handle_error(e, command_name, quiet)
+        return None
+
+
+@click.command("update")
+@click.argument("input_prompt_file", type=click.Path(exists=True, dir_okay=False), required=False)
+@click.argument("modified_code_file", type=click.Path(exists=True, dir_okay=False), required=False)
+@click.argument("input_code_file", type=click.Path(exists=True, dir_okay=False), required=False)
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the updated prompt file(s). For single files: saves to this specific path or directory. For repository mode: saves all prompts to this directory. If not specified, uses the original prompt location (single file) or 'prompts' directory (repository mode).",
+)
+@click.option(
+    "--git",
+    "use_git",
+    is_flag=True,
+    default=False,
+    help="Use git history to find the original code file.",
+)
+@click.option(
+    "--extensions",
+    type=str,
+    default=None,
+    help="Comma-separated list of file extensions to update in repo mode (e.g., 'py,js,ts').",
+)
+@click.option(
+    "--simple",
+    is_flag=True,
+    default=False,
+    help="Use legacy 2-stage LLM update instead of agentic mode.",
+)
+@click.pass_context
+@track_cost
+def update(
+    ctx: click.Context,
+    input_prompt_file: Optional[str],
+    modified_code_file: Optional[str],
+    input_code_file: Optional[str],
+    output: Optional[str],
+    use_git: bool,
+    extensions: Optional[str],
+    simple: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """
+    Update prompts based on code changes.
+
+    This command operates in two modes:
+
+    1.  **Single-File Mode:** When you provide at least a code file, it updates
+        or generates a single prompt.
+        - `pdd update <CODE_FILE>`: Generates a new prompt for the code.
+        - `pdd update [PROMPT_FILE] <CODE_FILE>`: Updates prompt based on code.
+        - `pdd update [PROMPT_FILE] <CODE_FILE> <ORIGINAL_CODE_FILE>`: Updates prompt using explicit original code.
+
+    2.  **Repository-Wide Mode:** When you provide no file arguments, it scans the
+        entire repository, finds all code/prompt pairs, creates missing prompts,
+        and updates them all based on the latest git changes.
+        - `pdd update`: Updates all prompts for modified files in the repo.
+    """
+    quiet = ctx.obj.get("quiet", False)
+    command_name = "update"
+    try:
+        # In single-file generation mode, when only one positional argument is provided,
+        # it is treated as the code file (not the prompt file). This enables the workflow:
+        # `pdd update <CODE_FILE>` to generate a new prompt for the given code file.
+        # So if input_prompt_file has a value but modified_code_file is None,
+        # we reassign input_prompt_file to actual_modified_code_file.
+        if input_prompt_file is not None and modified_code_file is None:
+            actual_modified_code_file = input_prompt_file
+            actual_input_prompt_file = None
+        else:
+            actual_modified_code_file = modified_code_file
+            actual_input_prompt_file = input_prompt_file
+
+        is_repo_mode = actual_input_prompt_file is None and actual_modified_code_file is None
+
+        if is_repo_mode:
+            if any([input_code_file, use_git]):
+                raise click.UsageError(
+                    "Cannot use file-specific arguments or flags like --git or --input-code in repository-wide mode (when no files are provided)."
+                )
+        elif extensions:
+            raise click.UsageError("--extensions can only be used in repository-wide mode (when no files are provided).")
+
+        result, total_cost, model_name = update_main(
+            ctx=ctx,
+            input_prompt_file=actual_input_prompt_file,
+            modified_code_file=actual_modified_code_file,
+            input_code_file=input_code_file,
+            output=output,
+            use_git=use_git,
+            repo=is_repo_mode,
+            extensions=extensions,
+            simple=simple,
+        )
+        return result, total_cost, model_name
+    except click.Abort:
+        raise
+    except (click.UsageError, Exception) as exception:
+        handle_error(exception, command_name, quiet)
+        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))