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

pdd/commands/__init__.py

@@ -0,0 +1,42 @@
+"""
+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 .misc import preprocess
+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)

pdd/commands/analysis.py

@@ -0,0 +1,248 @@
+"""
+Analysis commands (detect-change, conflicts, bug, crash, trace).
+"""
+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 ..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:
+        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:
+        raise
+    except Exception as exception:
+        handle_error(exception, "conflicts", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("bug")
+@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("current_output", type=click.Path(exists=True, dir_okay=False))
+@click.argument("desired_output", type=click.Path(exists=True, dir_okay=False))
+@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.",
+)
+@click.pass_context
+@track_cost
+def bug(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    program_file: str,
+    current_output: str,
+    desired_output: str,
+    output: Optional[str],
+    language: str,
+) -> Optional[Tuple[str, float, str]]:
+    """Generate a unit test reproducing a bug from inputs and outputs."""
+    try:
+        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
+    except click.Abort:
+        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, cost, model
+        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:
+        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:
+        raise
+    except Exception as exception:
+        handle_error(exception, "trace", ctx.obj.get("quiet", False))
+        return None

pdd/commands/fix.py

@@ -0,0 +1,140 @@
+"""
+Fix command.
+"""
+import click
+from typing import Dict, List, Optional, Tuple, Any
+
+from ..fix_main import fix_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+
+@click.command("fix")
+@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("unit_test_files", nargs=-1, type=click.Path(exists=True, dir_okay=False))
+@click.argument("error_file", type=click.Path(dir_okay=False))  # Allow non-existent for loop mode
+@click.option(
+    "--output-test",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the fixed unit test file (file or directory).",
+)
+@click.option(
+    "--output-code",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the fixed code file (file or directory).",
+)
+@click.option(
+    "--output-results",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the results log (file or directory).",
+)
+@click.option(
+    "--loop",
+    is_flag=True,
+    default=False,
+    help="Enable iterative fixing process."
+)
+@click.option(
+    "--verification-program",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to a Python program that verifies the fix.",
+)
+@click.option(
+    "--max-attempts",
+    type=int,
+    default=3,
+    show_default=True,
+    help="Maximum number of fix attempts.",
+)
+@click.option(
+    "--budget",
+    type=float,
+    default=5.0,
+    show_default=True,
+    help="Maximum cost allowed for the fixing process.",
+)
+@click.option(
+    "--auto-submit",
+    is_flag=True,
+    default=False,
+    help="Automatically submit the example if all unit tests pass.",
+)
+@click.option(
+    "--agentic-fallback/--no-agentic-fallback",
+    is_flag=True,
+    default=True,
+    help="Enable agentic fallback if the primary fix mechanism fails.",
+)
+@click.pass_context
+@track_cost
+def fix(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    unit_test_files: Tuple[str, ...],
+    error_file: str,
+    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[Dict[str, Any], float, str]]:
+    """Fix code based on a prompt and unit test errors.
+
+    Accepts one or more UNIT_TEST_FILES. Each test file is processed separately,
+    allowing the AI to run and fix tests individually rather than as a concatenated blob.
+    """
+    try:
+        all_results: List[Dict[str, Any]] = []
+        total_cost = 0.0
+        model_name = ""
+
+        # Process each unit test file separately
+        for unit_test_file in unit_test_files:
+            success, fixed_unit_test, fixed_code, attempts, cost, model = fix_main(
+                ctx=ctx,
+                prompt_file=prompt_file,
+                code_file=code_file,
+                unit_test_file=unit_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,
+            )
+            all_results.append({
+                "success": success,
+                "fixed_unit_test": fixed_unit_test,
+                "fixed_code": fixed_code,
+                "attempts": attempts,
+                "unit_test_file": unit_test_file,
+            })
+            total_cost += cost
+            model_name = model
+
+        # Aggregate results
+        overall_success = all(r["success"] for r in all_results)
+        result = {
+            "success": overall_success,
+            "results": all_results,
+            "total_attempts": sum(r["attempts"] for r in all_results),
+        }
+        return result, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "fix", ctx.obj.get("quiet", False))
+        ctx.exit(1)

pdd/commands/generate.py

@@ -0,0 +1,257 @@
+"""
+Generate, test, and example commands.
+"""
+import click
+from typing import Dict, Optional, Tuple, List
+
+from ..code_generator_main import code_generator_main
+from ..context_generator_main import context_generator_main
+from ..cmd_test_main import cmd_test_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error, console
+
+class GenerateCommand(click.Command):
+    """Ensure help shows PROMPT_FILE as required even when validated at runtime."""
+
+    def collect_usage_pieces(self, ctx: click.Context) -> List[str]:
+        pieces = super().collect_usage_pieces(ctx)
+        return ["PROMPT_FILE" if piece == "[PROMPT_FILE]" else piece for piece in pieces]
+
+
+@click.command("generate", cls=GenerateCommand)
+@click.argument("prompt_file", required=False, type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the generated code (file or directory).",
+)
+@click.option(
+    "--original-prompt",
+    "original_prompt_file_path",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to the original prompt file for incremental generation.",
+)
+@click.option(
+    "--incremental",
+    "incremental_flag",
+    is_flag=True,
+    default=False,
+    help="Force incremental patching even if changes are significant (requires existing output).",
+)
+@click.option(
+    "-e",
+    "--env",
+    "env_kv",
+    multiple=True,
+    help="Set template variable (KEY=VALUE) or read KEY from env",
+)
+@click.option(
+    "--template",
+    "template_name",
+    type=str,
+    default=None,
+    help="Use a packaged/project template by name (e.g., architecture/architecture_json)",
+)
+@click.option(
+    "--unit-test",
+    "unit_test_file",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to a unit test file to include in the prompt.",
+)
+@click.option(
+    "--exclude-tests",
+    "exclude_tests",
+    is_flag=True,
+    default=False,
+    help="Do not automatically include test files found in the default tests directory.",
+)
+@click.pass_context
+@track_cost
+def generate(
+    ctx: click.Context,
+    prompt_file: Optional[str],
+    output: Optional[str],
+    original_prompt_file_path: Optional[str],
+    incremental_flag: bool,
+    env_kv: Tuple[str, ...],
+    template_name: Optional[str],
+    unit_test_file: Optional[str],
+    exclude_tests: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """
+    Generate code from a prompt file.
+
+       \b
+    Related commands:
+      test      Generate unit tests for a prompt.
+      example   Generate example code for a prompt.
+
+    \b
+    Note:
+      Global options (for example ``--force``, ``--temperature``, ``--time``)
+      can be placed either before or after the subcommand. For example:
+
+        pdd generate my.prompt --force --temperature 0.5
+    """
+    try:
+        # Resolve template to a prompt path when requested
+        if template_name and prompt_file:
+            raise click.UsageError("Provide either --template or a PROMPT_FILE path, not both.")
+        if template_name:
+            try:
+                from .. import template_registry as _tpl
+                meta = _tpl.load_template(template_name)
+                prompt_file = meta.get("path")
+                if not prompt_file:
+                    raise click.UsageError(f"Template '{template_name}' did not return a valid path")
+            except Exception as e:
+                raise click.UsageError(f"Failed to load template '{template_name}': {e}")
+        if not template_name and not prompt_file:
+            raise click.UsageError("Missing PROMPT_FILE. To use a template, pass --template NAME instead.")
+        # Parse -e/--env arguments into a dict
+        env_vars: Dict[str, str] = {}
+        import os as _os
+        for item in env_kv or ():
+            if "=" in item:
+                key, value = item.split("=", 1)
+                key = key.strip()
+                if key:
+                    env_vars[key] = value
+            else:
+                key = item.strip()
+                if key:
+                    val = _os.environ.get(key)
+                    if val is not None:
+                        env_vars[key] = val
+                    else:
+                        if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                            console.print(f"[warning]-e {key} not found in environment; skipping[/warning]")
+        generated_code, incremental, total_cost, model_name = code_generator_main(
+            ctx=ctx,
+            prompt_file=prompt_file,  # resolved template path or user path
+            output=output,
+            original_prompt_file_path=original_prompt_file_path,
+            force_incremental_flag=incremental_flag,
+            env_vars=env_vars or None,
+            unit_test_file=unit_test_file,
+            exclude_tests=exclude_tests,
+        )
+        return generated_code, total_cost, model_name
+    except click.Abort:
+        # Let user cancellation (e.g., pressing 'no' on overwrite prompt) propagate
+        # to PDDCLI.invoke() for graceful handling (fix for issue #186)
+        raise
+    except Exception as exception:
+        handle_error(exception, "generate", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("example")
+@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.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the generated example code (file or directory).",
+)
+@click.pass_context
+@track_cost
+def example(
+    ctx: click.Context, 
+    prompt_file: str, 
+    code_file: str, 
+    output: Optional[str]
+) -> Optional[Tuple[str, float, str]]:
+    """Generate example code for a given prompt and implementation."""
+    try:
+        example_code, total_cost, model_name = context_generator_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            code_file=code_file,
+            output=output,
+        )
+        return example_code, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "example", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("test")
+@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.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the generated test file (file or directory).",
+)
+@click.option(
+    "--language", 
+    type=str, 
+    default=None, 
+    help="Specify the programming language."
+)
+@click.option(
+    "--coverage-report",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to the coverage report file for existing tests.",
+)
+@click.option(
+    "--existing-tests",
+    type=click.Path(exists=True, dir_okay=False),
+    multiple=True,
+    help="Path to existing unit test file(s). Can be specified multiple times.",
+)
+@click.option(
+    "--target-coverage",
+    type=click.FloatRange(0.0, 100.0),
+    default=None,  # Use None, default handled in cmd_test_main or env var
+    help="Desired code coverage percentage (default: 10.0 or PDD_TEST_COVERAGE_TARGET).",
+)
+@click.option(
+    "--merge",
+    is_flag=True,
+    default=False,
+    help="Merge new tests with existing test file instead of creating a separate file.",
+)
+@click.pass_context
+@track_cost
+def test(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    output: Optional[str],
+    language: Optional[str],
+    coverage_report: Optional[str],
+    existing_tests: Tuple[str, ...],
+    target_coverage: Optional[float],
+    merge: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """Generate unit tests for a given prompt and implementation."""
+    try:
+        # Convert empty tuple to None for cmd_test_main compatibility
+        existing_tests_list = list(existing_tests) if existing_tests else None
+        test_code, total_cost, model_name = cmd_test_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            code_file=code_file,
+            output=output,
+            language=language,
+            coverage_report=coverage_report,
+            existing_tests=existing_tests_list,
+            target_coverage=target_coverage,
+            merge=merge,
+        )
+        return test_code, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "test", ctx.obj.get("quiet", False))
+        return None