pdd-cli 0.0.28__py3-none-any.whl → 0.0.30__py3-none-any.whl

pdd/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.28"
+__version__ = "0.0.30"
 
 # Strength parameter used for LLM extraction across the codebase
 # Used in postprocessing, XML tagging, code generation, and other extraction operations. The module should have a large context window and be affordable.

pdd/cli.py

@@ -26,7 +26,7 @@ from .crash_main import crash_main
 from .detect_change_main import detect_change_main
 from .fix_main import fix_main
 from .fix_verification_main import fix_verification_main
-from .install_completion import install_completion
+from .install_completion import install_completion, get_local_pdd_path
 from .preprocess_main import preprocess_main
 from .split_main import split_main
 from .trace_main import trace_main
@@ -136,6 +136,9 @@ def cli(
     Main entry point for the PDD CLI. Handles global options and initializes context.
     Supports multi-command chaining.
     """
+    # Ensure PDD_PATH is set before any commands run
+    get_local_pdd_path()
+    
     ctx.ensure_object(dict)
     ctx.obj["force"] = force
     ctx.obj["strength"] = strength

{pdd_cli-0.0.28.dist-info → pdd_cli-0.0.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdd-cli
-Version: 0.0.28
+Version: 0.0.30
 Summary: PDD (Prompt-Driven Development) Command Line Interface
 Author: Greg Tanaka
 Author-email: glt@alumni.caltech.edu
@@ -46,7 +46,7 @@ Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: z3-solver; extra == "dev"
 Dynamic: license-file
 
-.. image:: https://img.shields.io/badge/pdd--cli-v0.0.28-blue
+.. image:: https://img.shields.io/badge/pdd--cli-v0.0.30-blue
    :alt: PDD-CLI Version
 
 PDD (Prompt-Driven Development) Command Line Interface
@@ -97,6 +97,29 @@ Key Features
 Quick Installation
 ------------------
 
+**Recommended: Using uv (Faster & Better Dependency Management)**
+
+We recommend installing PDD using the `uv <https://github.com/astral-sh/uv>`_ package manager for better dependency management and automatic environment configuration:
+
+.. code-block:: console
+
+   # Install uv if you haven't already
+   curl -sSf https://astral.sh/uv/install.sh | sh
+
+   # Install PDD using uv tool install
+   uv tool install pdd-cli
+
+This installation method ensures:
+
+- Faster installations with optimized dependency resolution
+- Automatic environment setup without manual configuration
+- Proper handling of the PDD_PATH environment variable
+- Better isolation from other Python packages
+
+**Alternative: Using pip**
+
+If you prefer, you can install with pip:
+
 .. code-block:: console
 
    pip install pdd-cli
@@ -107,7 +130,7 @@ After installation, verify:
 
    pdd --version
 
-You'll see the current PDD version (e.g., 0.0.28).
+You'll see the current PDD version (e.g., 0.0.30).
 
 Advanced Installation Tips
 --------------------------
@@ -127,7 +150,9 @@ Create and activate a virtual environment, then install pdd-cli:
     # On Unix/MacOS:
    source pdd-env/bin/activate
 
-    # Install PDD
+    # Install PDD (with uv - recommended)
+   uv tool install pdd-cli
+    # OR with pip
    pip install pdd-cli
 
 

{pdd_cli-0.0.28.dist-info → pdd_cli-0.0.30.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pdd/__init__.py,sha256=CycaqzrnXoqfdnmd7eip_wy6yA3MHNhHK0n9EMo6YHc,477
+pdd/__init__.py,sha256=UlmLFvxuZysa-xxH1RaK3HNVs1VCgVD7DZxe8y-jEv8,477
 pdd/auto_deps_main.py,sha256=NVLqL5FHxe2eorViXTuh8z2zH9Sb-b6MNN9aZ1hqevY,3552
 pdd/auto_include.py,sha256=aCa2QXDlOdKbh4vS3uDjWptkHB_Qv3QBNCbZe6mGWoo,6074
 pdd/auto_update.py,sha256=Pfav1hrqQIDjZIPuIvryBeM7k-Rc72feVUTJZPtigaU,2889
@@ -6,8 +6,7 @@ pdd/bug_main.py,sha256=cSGBnHmFIA8WrkGiohJFVRuM2086v-wlPvTJqTv00WQ,4631
 pdd/bug_to_unit_test.py,sha256=oejqoKomLseKknYDFlQKQ04TNT3soqOjMPghxty8Guo,6311
 pdd/change.py,sha256=EKmv7WvXNX24rjLCnrcaoo4xOVkNhCa9HLRbpMAxQSw,5036
 pdd/change_main.py,sha256=5IAFW1_eazYCr3F1DlfO6FDpNDZ4LgkXBWLb6rKW-PQ,25643
-pdd/cli.py,sha256=oYQJiuc5txvR24YJyCt9jwBJlwr3ufAGhzxVhIjj0oI,37360
-pdd/cli_1_0_1_0_20250510_005101.py,sha256=oYQJiuc5txvR24YJyCt9jwBJlwr3ufAGhzxVhIjj0oI,37360
+pdd/cli.py,sha256=Z5AE8uVUnzZiuEyZqe9lMu6hUG6pK2_qg9NBwEPNIks,37463
 pdd/cmd_test_main.py,sha256=aSCxRnSurg15AvPcJDAPp9xy8p_qqnjU1oV14Hi2R54,5301
 pdd/code_generator.py,sha256=DqQNN6jCNjSJvHi0IFyqkSfak6LeDG-yQHPYnvd4AJQ,4424
 pdd/code_generator_main.py,sha256=G2eRBPXc1cGszkk0PbIPmJZHPaf_dw5d2yZbsvQZA3c,4793
@@ -99,9 +98,9 @@ pdd/prompts/trim_results_start_LLM.prompt,sha256=OKz8fAf1cYWKWgslFOHEkUpfaUDARh3
 pdd/prompts/unfinished_prompt_LLM.prompt,sha256=-JgBpiPTQZdWOAwOG1XpfpD9waynFTAT3Jo84eQ4bTw,1543
 pdd/prompts/update_prompt_LLM.prompt,sha256=prIc8uLp2jqnLTHt6JvWDZGanPZipivhhYeXe0lVaYw,1328
 pdd/prompts/xml_convertor_LLM.prompt,sha256=YGRGXJeg6EhM9690f-SKqQrKqSJjLFD51UrPOlO0Frg,2786
-pdd_cli-0.0.28.dist-info/licenses/LICENSE,sha256=-1bjYH-CEjGEQ8VixtnRYuu37kN6F9NxmZSDkBuUQ9o,1062
-pdd_cli-0.0.28.dist-info/METADATA,sha256=z1ybx-VFXHKkNrUztLK-Hmq8sEZIOjsnFTynL8bLBNg,6949
-pdd_cli-0.0.28.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-pdd_cli-0.0.28.dist-info/entry_points.txt,sha256=Kr8HtNVb8uHZtQJNH4DnF8j7WNgWQbb7_Pw5hECSR-I,36
-pdd_cli-0.0.28.dist-info/top_level.txt,sha256=xjnhIACeMcMeDfVNREgQZl4EbTni2T11QkL5r7E-sbE,4
-pdd_cli-0.0.28.dist-info/RECORD,,
+pdd_cli-0.0.30.dist-info/licenses/LICENSE,sha256=-1bjYH-CEjGEQ8VixtnRYuu37kN6F9NxmZSDkBuUQ9o,1062
+pdd_cli-0.0.30.dist-info/METADATA,sha256=P77AbVeiMa4ylyAk6skGkZ73Lx5LY9gZSXlRBUmcJJ8,7762
+pdd_cli-0.0.30.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+pdd_cli-0.0.30.dist-info/entry_points.txt,sha256=Kr8HtNVb8uHZtQJNH4DnF8j7WNgWQbb7_Pw5hECSR-I,36
+pdd_cli-0.0.30.dist-info/top_level.txt,sha256=xjnhIACeMcMeDfVNREgQZl4EbTni2T11QkL5r7E-sbE,4
+pdd_cli-0.0.30.dist-info/RECORD,,

pdd/cli_1_0_1_0_20250510_005101.py

@@ -1,1054 +0,0 @@
-# pdd/cli.py
-from __future__ import annotations
-
-import os
-from typing import Any, Dict, List, Optional, Tuple
-from pathlib import Path # Import Path
-
-import click
-from rich.console import Console
-from rich.theme import Theme
-from rich.markup import MarkupError, escape
-
-# --- Relative Imports for Internal Modules ---
-from . import DEFAULT_STRENGTH, __version__
-from .auto_deps_main import auto_deps_main
-from .auto_update import auto_update
-from .bug_main import bug_main
-from .change_main import change_main
-from .cmd_test_main import cmd_test_main
-from .code_generator_main import code_generator_main
-from .conflicts_main import conflicts_main
-# Need to import construct_paths for tests patching pdd.cli.construct_paths
-from .construct_paths import construct_paths
-from .context_generator_main import context_generator_main
-from .crash_main import crash_main
-from .detect_change_main import detect_change_main
-from .fix_main import fix_main
-from .fix_verification_main import fix_verification_main
-from .install_completion import install_completion
-from .preprocess_main import preprocess_main
-from .split_main import split_main
-from .trace_main import trace_main
-from .track_cost import track_cost
-from .update_main import update_main
-
-
-# --- Initialize Rich Console ---
-# Define a custom theme for consistent styling
-custom_theme = Theme({
-    "info": "cyan",
-    "warning": "yellow",
-    "error": "bold red",
-    "success": "green",
-    "path": "dim blue",
-    "command": "bold magenta",
-})
-console = Console(theme=custom_theme)
-
-# --- Helper Function for Error Handling ---
-def handle_error(e: Exception, command_name: str, quiet: bool):
-    """Prints error messages using Rich console.""" # Modified docstring
-    if not quiet:
-        console.print(f"[error]Error during '{command_name}' command:[/error]", style="error")
-        if isinstance(e, FileNotFoundError):
-            console.print(f"  [error]File not found:[/error] {e}", style="error")
-        elif isinstance(e, (ValueError, IOError)):
-            console.print(f"  [error]Input/Output Error:[/error] {e}", style="error")
-        elif isinstance(e, click.UsageError): # Handle Click usage errors explicitly if needed
-             console.print(f"  [error]Usage Error:[/error] {e}", style="error")
-             # click.UsageError should typically exit with 2, but we are handling it.
-        elif isinstance(e, MarkupError):
-            console.print("  [error]Markup Error:[/error] Invalid Rich markup encountered.", style="error")
-            # Print the error message safely escaped
-            console.print(escape(str(e)))
-        else:
-            console.print(f"  [error]An unexpected error occurred:[/error] {e}", style="error")
-    # Do NOT re-raise e here. Let the command function return None.
-
-
-# --- Main CLI Group ---
-@click.group(chain=True, help="PDD (Prompt-Driven Development) Command Line Interface.")
-@click.option(
-    "--force",
-    is_flag=True,
-    default=False,
-    help="Overwrite existing files without asking for confirmation.",
-)
-@click.option(
-    "--strength",
-    type=click.FloatRange(0.0, 1.0),
-    default=DEFAULT_STRENGTH,
-    show_default=True,
-    help="Set the strength of the AI model (0.0 to 1.0).",
-)
-@click.option(
-    "--temperature",
-    type=click.FloatRange(0.0, 2.0), # Allow higher temperatures if needed
-    default=0.0,
-    show_default=True,
-    help="Set the temperature of the AI model.",
-)
-@click.option(
-    "--verbose",
-    is_flag=True,
-    default=False,
-    help="Increase output verbosity for more detailed information.",
-)
-@click.option(
-    "--quiet",
-    is_flag=True,
-    default=False,
-    help="Decrease output verbosity for minimal information.",
-)
-@click.option(
-    "--output-cost",
-    type=click.Path(dir_okay=False, writable=True),
-    default=None,
-    help="Enable cost tracking and output a CSV file with usage details.",
-)
-@click.option(
-    "--review-examples",
-    is_flag=True,
-    default=False,
-    help="Review and optionally exclude few-shot examples before command execution.",
-)
-@click.option(
-    "--local",
-    is_flag=True,
-    default=False,
-    help="Run commands locally instead of in the cloud.",
-)
-@click.version_option(version=__version__, package_name="pdd-cli")
-@click.pass_context
-def cli(
-    ctx: click.Context,
-    force: bool,
-    strength: float,
-    temperature: float,
-    verbose: bool,
-    quiet: bool,
-    output_cost: Optional[str],
-    review_examples: bool,
-    local: bool,
-):
-    """
-    Main entry point for the PDD CLI. Handles global options and initializes context.
-    Supports multi-command chaining.
-    """
-    ctx.ensure_object(dict)
-    ctx.obj["force"] = force
-    ctx.obj["strength"] = strength
-    ctx.obj["temperature"] = temperature
-    ctx.obj["verbose"] = verbose
-    ctx.obj["quiet"] = quiet
-    ctx.obj["output_cost"] = output_cost
-    ctx.obj["review_examples"] = review_examples
-    ctx.obj["local"] = local
-
-    # Suppress verbose if quiet is enabled
-    if quiet:
-        ctx.obj["verbose"] = False
-
-    # Perform auto-update check unless disabled
-    if os.getenv("PDD_AUTO_UPDATE", "true").lower() != "false":
-        try:
-            if not quiet:
-                console.print("[info]Checking for updates...[/info]")
-            # Removed quiet=quiet argument as it caused TypeError
-            auto_update()
-        except Exception as e:
-            if not quiet:
-                console.print(f"[warning]Auto-update check failed:[/warning] {e}", style="warning")
-
-# --- Result Callback for Chained Commands ---
-@cli.result_callback()
-@click.pass_context
-def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float, str]]], **kwargs):
-    """
-    Processes the results from chained commands.
-
-    Receives a list of tuples, typically (result, cost, model_name),
-    or None from each command function.
-    """
-    total_chain_cost = 0.0
-    # Get invoked subcommands directly from the group context if available (safer for testing)
-    # Note: This might yield "Unknown Command" during tests with CliRunner
-    invoked_subcommands = getattr(ctx, 'invoked_subcommands', [])
-    num_commands = len(invoked_subcommands)
-    num_results = len(results) # Number of results actually received
-
-    if not ctx.obj.get("quiet"):
-        console.print("\n[info]--- Command Chain Execution Summary ---[/info]")
-
-    for i, result_tuple in enumerate(results):
-        # Use the retrieved subcommand name (might be "Unknown Command X" in tests)
-        command_name = invoked_subcommands[i] if i < num_commands else f"Unknown Command {i+1}"
-
-        # Check if the command failed (returned None)
-        if result_tuple is None:
-             if not ctx.obj.get("quiet"):
-                 # Check if it was install_completion (which normally returns None)
-                 if command_name == "install_completion":
-                     console.print(f"  [info]Step {i+1} ({command_name}):[/info] Command completed.")
-                 # Check if it was preprocess (which returns a dummy tuple on success)
-                 # This case handles actual failure for preprocess
-                 elif command_name == "preprocess":
-                      console.print(f"  [error]Step {i+1} ({command_name}):[/error] Command failed.")
-                 else:
-                     console.print(f"  [error]Step {i+1} ({command_name}):[/error] Command failed.")
-        # Check if the result is the expected tuple structure from @track_cost or preprocess success
-        elif isinstance(result_tuple, tuple) and len(result_tuple) == 3:
-            _result_data, cost, model_name = result_tuple
-            total_chain_cost += cost
-            if not ctx.obj.get("quiet"):
-                 # Special handling for preprocess success message (check actual command name)
-                 actual_command_name = invoked_subcommands[i] if i < num_commands else None # Get actual name if possible
-                 if actual_command_name == "preprocess" and cost == 0.0 and model_name == "local":
-                     console.print(f"  [info]Step {i+1} ({command_name}):[/info] Command completed (local).")
-                 else:
-                     # Generic output using potentially "Unknown Command" name
-                     console.print(f"  [info]Step {i+1} ({command_name}):[/info] Cost: ${cost:.6f}, Model: {model_name}")
-        else:
-            # Handle unexpected return types if necessary
-            if not ctx.obj.get("quiet"):
-                 # Provide more detail on the unexpected type
-                 console.print(f"  [warning]Step {i+1} ({command_name}):[/warning] Unexpected result format: {type(result_tuple).__name__} - {str(result_tuple)[:50]}...")
-
-
-    if not ctx.obj.get("quiet"):
-        # Only print total cost if at least one command potentially contributed cost
-        if any(res is not None and isinstance(res, tuple) and len(res) == 3 for res in results):
-             console.print(f"[info]Total Estimated Cost for Chain:[/info] ${total_chain_cost:.6f}")
-        # Indicate if the chain might have been incomplete due to errors
-        if num_results < num_commands and not all(res is None for res in results): # Avoid printing if all failed
-             console.print("[warning]Note: Chain may have terminated early due to errors.[/warning]")
-        console.print("[info]-------------------------------------[/info]")
-
-
-# --- Command Definitions ---
-
-@cli.command("generate")
-@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
-@click.option(
-    "--output",
-    type=click.Path(writable=True), # Allows file or dir
-    default=None,
-    help="Specify where to save the generated code (file or directory).",
-)
-@click.pass_context
-@track_cost
-def generate(ctx: click.Context, prompt_file: str, output: Optional[str]) -> Optional[Tuple[str, float, str]]: # Modified return type
-    """Create runnable code from a prompt file."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "generate"
-    try:
-        generated_code, total_cost, model_name = code_generator_main(
-            ctx=ctx,
-            prompt_file=prompt_file,
-            output=output,
-        )
-        return generated_code, total_cost, model_name
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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]]: # Modified return type
-    """Create a compact example demonstrating functionality."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "example"
-    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 Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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),
-    default=None,
-    help="Path to the existing unit test file.",
-)
-@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: 90.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: Optional[str],
-    target_coverage: Optional[float],
-    merge: bool,
-) -> Optional[Tuple[str, float, str]]: # Modified return type
-    """Generate or enhance unit tests."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "test"
-    try:
-        generated_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,
-            target_coverage=target_coverage,
-            merge=merge,
-        )
-        return generated_test_code, total_cost, model_name
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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]]: # Modified return type (Optional)
-    """Preprocess prompt files and save the results."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "preprocess"
-    try:
-        preprocess_main(
-            ctx=ctx,
-            prompt_file=prompt_file,
-            output=output,
-            xml=xml,
-            recursive=recursive,
-            double=double,
-            exclude=list(exclude) if exclude else [],
-        )
-        # Return dummy values ONLY on success
-        return "Preprocessing complete.", 0.0, "local"
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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_file", 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.pass_context
-@track_cost # fix_main returns cost/model info
-def fix(
-    ctx: click.Context,
-    prompt_file: str,
-    code_file: str,
-    unit_test_file: 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,
-) -> Optional[Tuple[Dict[str, Any], float, str]]: # Modified return type
-    """Fix errors in code and unit tests based on error messages."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "fix"
-    try:
-
-        # fix_main returns: success, fixed_test_content, fixed_code_content, attempts, cost, model
-        # We need to adapt this to the (result, cost, model) structure for the callback
-        success, fixed_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,
-        )
-        # Package results into a dictionary for the first element of the tuple
-        result_data = {
-            "success": success,
-            "attempts": attempts,
-            "fixed_test_path": output_test,
-            "fixed_code_path": output_code,
-            "results_log_path": output_results,
-        }
-        return result_data, cost, model
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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]]: # Modified return type
-    """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 Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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(
-    "--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,
-) -> Optional[Tuple[str | Dict, float, str]]: # Modified return type
-    """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,
-        )
-        return result_data, total_cost, model_name
-    except (click.UsageError, Exception) as e: # Catch specific and general exceptions
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.command("update")
-@click.argument("input_prompt_file", type=click.Path(exists=True, dir_okay=False))
-@click.argument("modified_code_file", type=click.Path(exists=True, dir_okay=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 (file or directory).",
-)
-@click.option(
-    "--git",
-    is_flag=True,
-    default=False,
-    help="Use git history to find the original code file.",
-)
-@click.pass_context
-@track_cost
-def update(
-    ctx: click.Context,
-    input_prompt_file: str,
-    modified_code_file: str,
-    input_code_file: Optional[str],
-    output: Optional[str],
-    git: bool,
-) -> Optional[Tuple[str, float, str]]: # Modified return type
-    """Update the original prompt file based on modified code."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "update"
-    try:
-        if git and input_code_file:
-            raise click.UsageError("Cannot use --git and specify an INPUT_CODE_FILE simultaneously.")
-        if not git and not input_code_file:
-            raise click.UsageError("INPUT_CODE_FILE is required when not using --git.")
-
-        updated_prompt, total_cost, model_name = update_main(
-            ctx=ctx,
-            input_prompt_file=input_prompt_file,
-            modified_code_file=modified_code_file,
-            input_code_file=input_code_file,
-            output=output,
-            git=git,
-        )
-        return updated_prompt, total_cost, model_name
-    except (click.UsageError, Exception) as e: # Catch specific and general exceptions
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.command("detect")
-@click.argument("prompt_files", nargs=-1, type=click.Path(exists=True, dir_okay=False))
-@click.argument("change_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 CSV analysis results (file or directory).",
-)
-@click.pass_context
-@track_cost
-def detect(
-    ctx: click.Context,
-    prompt_files: Tuple[str, ...],
-    change_file: str,
-    output: Optional[str],
-) -> Optional[Tuple[List[Dict[str, str]], float, str]]: # Modified return type
-    """Analyze prompts and a change description to find needed changes."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "detect"
-    try:
-        if not prompt_files:
-             raise click.UsageError("At least one PROMPT_FILE must be provided.")
-
-        changes_list, total_cost, model_name = detect_change_main(
-            ctx=ctx,
-            prompt_files=list(prompt_files),
-            change_file=change_file,
-            output=output,
-        )
-        return changes_list, total_cost, model_name
-    except (click.UsageError, Exception) as e: # Catch specific and general exceptions
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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 CSV conflict analysis results (file or directory).",
-)
-@click.pass_context
-@track_cost
-def conflicts(
-    ctx: click.Context,
-    prompt1: str,
-    prompt2: str,
-    output: Optional[str],
-) -> Optional[Tuple[List[Dict[str, str]], float, str]]: # Modified return type
-    """Analyze two prompt files to find conflicts."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "conflicts"
-    try:
-        conflicts_list, total_cost, model_name = conflicts_main(
-            ctx=ctx,
-            prompt1=prompt1,
-            prompt2=prompt2,
-            output=output,
-        )
-        return conflicts_list, total_cost, model_name
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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(dir_okay=False)) # Allow non-existent
-@click.option(
-    "--output", # Corresponds to output_code in crash_main
-    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=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.pass_context
-@track_cost
-def crash(
-    ctx: click.Context,
-    prompt_file: str,
-    code_file: str,
-    program_file: str,
-    error_file: str,
-    output: Optional[str], # Maps to output_code
-    output_program: Optional[str],
-    loop: bool,
-    max_attempts: int,
-    budget: float,
-) -> Optional[Tuple[Dict[str, Any], float, str]]: # Modified return type
-    """Fix errors in a code module and calling program that caused a crash."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "crash"
-    try:
-        success, fixed_code, fixed_program, attempts, cost, model = 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,
-        )
-        result_data = {
-            "success": success,
-            "attempts": attempts,
-            "fixed_code_path": output,
-            "fixed_program_path": output_program,
-        }
-        return result_data, cost, model
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.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 log (file or directory).",
-)
-@click.pass_context
-@track_cost
-def trace(
-    ctx: click.Context,
-    prompt_file: str,
-    code_file: str,
-    code_line: int,
-    output: Optional[str],
-) -> Optional[Tuple[int | str, float, str]]: # Modified return type
-    """Find the associated line number between a prompt file and generated code."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "trace"
-    try:
-        prompt_line_result, total_cost, model_name = trace_main(
-            ctx=ctx,
-            prompt_file=prompt_file,
-            code_file=code_file,
-            code_line=code_line,
-            output=output,
-        )
-        # Check if trace_main indicated failure (e.g., by returning None or specific error)
-        # This depends on trace_main's implementation; assuming it raises exceptions for now.
-        if prompt_line_result is None and total_cost == 0.0 and model_name == 'local_error': # Example check if trace_main returns specific tuple on failure
-             # Optionally handle specific non-exception failures differently if needed
-             # For now, rely on exceptions being raised for errors like out-of-range.
-             pass
-        return prompt_line_result, total_cost, model_name
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        # Exit with non-zero status code on any exception
-        ctx.exit(1)
-
-
-@cli.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_file", type=click.Path(exists=True, dir_okay=False))
-@click.argument("desired_output_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 unit test (file or directory).",
-)
-@click.option("--language", type=str, default=None, help="Specify the programming language (default: Python).")
-@click.pass_context
-@track_cost
-def bug(
-    ctx: click.Context,
-    prompt_file: str,
-    code_file: str,
-    program_file: str,
-    current_output_file: str,
-    desired_output_file: str,
-    output: Optional[str],
-    language: Optional[str],
-) -> Optional[Tuple[str, float, str]]: # Modified return type
-    """Generate a unit test based on observed and desired outputs."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "bug"
-    try:
-        unit_test_content, total_cost, model_name = bug_main(
-            ctx=ctx,
-            prompt_file=prompt_file,
-            code_file=code_file,
-            program_file=program_file,
-            current_output=current_output_file,
-            desired_output=desired_output_file,
-            output=output,
-            language=language,
-        )
-        return unit_test_content, total_cost, model_name
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.command("auto-deps")
-@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
-@click.argument("directory_path", type=str) # Path with potential glob pattern
-@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",
-    "auto_deps_csv_path",
-    type=click.Path(dir_okay=False), # CSV path is a file
-    default=None, # Default handled by auto_deps_main or env var
-    help="Specify the CSV file for dependency info (default: project_dependencies.csv or PDD_AUTO_DEPS_CSV_PATH).",
-)
-@click.option(
-    "--force-scan",
-    is_flag=True,
-    default=False,
-    help="Force rescanning of all potential dependency files.",
-)
-@click.pass_context
-@track_cost
-def auto_deps(
-    ctx: click.Context,
-    prompt_file: str,
-    directory_path: str,
-    output: Optional[str],
-    auto_deps_csv_path: Optional[str],
-    force_scan: bool,
-) -> Optional[Tuple[str, float, str]]: # Modified return type
-    """Analyze prompt and insert dependencies from a directory."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "auto-deps"
-    try:
-        clean_directory_path = directory_path.strip('\"')
-
-        modified_prompt, total_cost, model_name = auto_deps_main(
-            ctx=ctx,
-            prompt_file=prompt_file,
-            directory_path=clean_directory_path,
-            auto_deps_csv_path=auto_deps_csv_path,
-            output=output,
-            force_scan=force_scan,
-        )
-        return modified_prompt, total_cost, model_name
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.command("verify")
-@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.option(
-    "--output-results",
-    type=click.Path(writable=True),
-    default=None,
-    help="Specify where to save the verification results log (file or directory).",
-)
-@click.option(
-    "--output-code",
-    type=click.Path(writable=True),
-    default=None,
-    help="Specify where to save the verified code file (file or directory).",
-)
-@click.option(
-    "--output-program",
-    type=click.Path(writable=True),
-    default=None,
-    help="Specify where to save the verified program file (file or directory).",
-)
-@click.option(
-    "--max-attempts",
-    type=int,
-    default=3,
-    show_default=True,
-    help="Maximum number of fix attempts within the verification loop.",
-)
-@click.option(
-    "--budget",
-    type=float,
-    default=5.0,
-    show_default=True,
-    help="Maximum cost allowed for the verification and fixing process.",
-)
-@click.pass_context
-@track_cost
-def verify(
-    ctx: click.Context,
-    prompt_file: str,
-    code_file: str,
-    program_file: str,
-    output_results: Optional[str],
-    output_code: Optional[str],
-    output_program: Optional[str],
-    max_attempts: int,
-    budget: float,
-) -> Optional[Tuple[Dict[str, Any], float, str]]: # Modified return type
-    """Verify code correctness against prompt using LLM judgment."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "verify"
-    try:
-        success, final_program, final_code, attempts, cost, model = fix_verification_main(
-            ctx=ctx,
-            prompt_file=prompt_file,
-            code_file=code_file,
-            program_file=program_file,
-            output_results=output_results,
-            output_code=output_code,
-            output_program=output_program,
-            loop=True,
-            verification_program=program_file,
-            max_attempts=max_attempts,
-            budget=budget,
-        )
-        result_data = {
-            "success": success,
-            "attempts": attempts,
-            "verified_code_path": output_code,
-            "verified_program_path": output_program,
-            "results_log_path": output_results,
-        }
-        return result_data, cost, model
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
-
-
-@cli.command("install_completion")
-@click.pass_context
-# No @track_cost
-def install_completion_cmd(ctx: click.Context) -> None: # Return type remains None
-    """Install shell completion for PDD."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "install_completion"
-    try:
-        install_completion(quiet=quiet)
-        # Return None on success (as intended)
-        return None
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        # Explicitly return None on failure as well, consistent with other commands
-        return None
-
-
-# --- Entry Point ---
-if __name__ == "__main__":
-    cli()