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

pdd/cli.py

@@ -1,4 +1,10 @@
 # pdd/cli.py
+"""
+Command Line Interface (CLI) for the PDD (Prompt-Driven Development) tool.
+
+This module provides the main CLI functionality for PDD, including commands for
+generating code, tests, fixing issues, and managing prompts.
+"""
 from __future__ import annotations
 
 import os
@@ -29,6 +35,7 @@ from .fix_verification_main import fix_verification_main
 from .install_completion import install_completion, get_local_pdd_path
 from .preprocess_main import preprocess_main
 from .split_main import split_main
+from .sync_main import sync_main
 from .trace_main import trace_main
 from .track_cost import track_cost
 from .update_main import update_main
@@ -47,23 +54,23 @@ custom_theme = Theme({
 console = Console(theme=custom_theme)
 
 # --- Helper Function for Error Handling ---
-def handle_error(e: Exception, command_name: str, quiet: bool):
+def handle_error(exception: 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")
+        if isinstance(exception, FileNotFoundError):
+            console.print(f"  [error]File not found:[/error] {exception}", style="error")
+        elif isinstance(exception, (ValueError, IOError)):
+            console.print(f"  [error]Input/Output Error:[/error] {exception}", style="error")
+        elif isinstance(exception, click.UsageError): # Handle Click usage errors explicitly if needed
+             console.print(f"  [error]Usage Error:[/error] {exception}", style="error")
              # click.UsageError should typically exit with 2, but we are handling it.
-        elif isinstance(e, MarkupError):
+        elif isinstance(exception, MarkupError):
             console.print("  [error]Markup Error:[/error] Invalid Rich markup encountered.", style="error")
             # Print the error message safely escaped
-            console.print(escape(str(e)))
+            console.print(escape(str(exception)))
         else:
-            console.print(f"  [error]An unexpected error occurred:[/error] {e}", style="error")
+            console.print(f"  [error]An unexpected error occurred:[/error] {exception}", style="error")
     # Do NOT re-raise e here. Let the command function return None.
 
 
@@ -170,9 +177,12 @@ def cli(
                 console.print("[info]Checking for updates...[/info]")
             # Removed quiet=quiet argument as it caused TypeError
             auto_update()
-        except Exception as e:
+        except Exception as exception:  # Using more descriptive name
             if not quiet:
-                console.print(f"[warning]Auto-update check failed:[/warning] {e}", style="warning")
+                console.print(
+                    f"[warning]Auto-update check failed:[/warning] {exception}", 
+                    style="warning"
+                )
 
 # --- Result Callback for Chained Commands ---
 @cli.result_callback()
@@ -200,45 +210,45 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
 
         # 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.")
-                 # If command name is unknown, and it might be install_completion which prints its own status
-                 elif command_name.startswith("Unknown Command"):
-                     console.print(f"  [info]Step {i+1} ({command_name}):[/info] Command executed (see output above for status details).")
-                 # 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.")
+            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.")
+                # If command name is unknown, and it might be install_completion which prints its own status
+                elif command_name.startswith("Unknown Command"):
+                    console.print(f"  [info]Step {i+1} ({command_name}):[/info] Command executed (see output above for status details).")
+                # 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}")
+                # 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]}...")
+                # 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}")
+            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("[warning]Note: Chain may have terminated early due to errors.[/warning]")
         console.print("[info]-------------------------------------[/info]")
 
 
@@ -248,7 +258,7 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
 @click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
 @click.option(
     "--output",
-    type=click.Path(writable=True), # Allows file or dir
+    type=click.Path(writable=True),
     default=None,
     help="Specify where to save the generated code (file or directory).",
 )
@@ -274,10 +284,8 @@ def generate(
     output: Optional[str],
     original_prompt_file_path: Optional[str],
     force_incremental_flag: bool,
-) -> Optional[Tuple[str, float, str]]: # Modified return type
-    """Create runnable code from a prompt file."""
-    quiet = ctx.obj.get("quiet", False)
-    command_name = "generate"
+) -> Optional[Tuple[str, float, str]]:
+    """Generate code from a prompt file."""
     try:
         generated_code, incremental, total_cost, model_name = code_generator_main(
             ctx=ctx,
@@ -287,9 +295,9 @@ def generate(
             force_incremental_flag=force_incremental_flag,
         )
         return generated_code, total_cost, model_name
-    except Exception as e:
-        handle_error(e, command_name, quiet)
-        return None # Return None on failure
+    except Exception as exception:
+        handle_error(exception, "generate", ctx.obj.get("quiet", False))
+        return None
 
 
 @cli.command("example")
@@ -303,10 +311,13 @@ def generate(
 )
 @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"
+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,
@@ -315,9 +326,9 @@ def example(ctx: click.Context, prompt_file: str, code_file: str, output: Option
             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
+    except Exception as exception:
+        handle_error(exception, "example", ctx.obj.get("quiet", False))
+        return None
 
 
 @cli.command("test")
@@ -329,7 +340,12 @@ def example(ctx: click.Context, prompt_file: str, code_file: str, output: Option
     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(
+    "--language", 
+    type=str, 
+    default=None, 
+    help="Specify the programming language."
+)
 @click.option(
     "--coverage-report",
     type=click.Path(exists=True, dir_okay=False),
@@ -345,7 +361,7 @@ def example(ctx: click.Context, prompt_file: str, code_file: str, output: Option
 @click.option(
     "--target-coverage",
     type=click.FloatRange(0.0, 100.0),
-    default=None, # Use None, default handled in cmd_test_main or env var
+    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(
@@ -366,12 +382,10 @@ def test(
     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"
+) -> Optional[Tuple[str, float, str]]:
+    """Generate unit tests for a given prompt and implementation."""
     try:
-        generated_test_code, total_cost, model_name = cmd_test_main(
+        test_code, total_cost, model_name = cmd_test_main(
             ctx=ctx,
             prompt_file=prompt_file,
             code_file=code_file,
@@ -382,10 +396,10 @@ def test(
             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
+        return test_code, total_cost, model_name
+    except Exception as exception:
+        handle_error(exception, "test", ctx.obj.get("quiet", False))
+        return None
 
 
 @cli.command("preprocess")
@@ -430,12 +444,12 @@ def preprocess(
     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"
+) -> Optional[Tuple[str, float, str]]:
+    """Preprocess a prompt file to prepare it for LLM use."""
     try:
-        preprocess_main(
+        # 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,
@@ -444,18 +458,25 @@ def preprocess(
             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
+        
+        # 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 Exception as exception:
+        handle_error(exception, "preprocess", ctx.obj.get("quiet", False))
+        return None
 
 
 @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.argument("error_file", type=click.Path(dir_okay=False))  # Allow non-existent for loop mode
 @click.option(
     "--output-test",
     type=click.Path(writable=True),
@@ -474,7 +495,12 @@ def preprocess(
     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(
+    "--loop", 
+    is_flag=True, 
+    default=False, 
+    help="Enable iterative fixing process."
+)
 @click.option(
     "--verification-program",
     type=click.Path(exists=True, dir_okay=False),
@@ -502,7 +528,7 @@ def preprocess(
     help="Automatically submit the example if all unit tests pass.",
 )
 @click.pass_context
-@track_cost # fix_main returns cost/model info
+@track_cost
 def fix(
     ctx: click.Context,
     prompt_file: str,
@@ -517,15 +543,11 @@ def fix(
     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"
+) -> Optional[Tuple[Dict[str, Any], float, str]]:
+    """Fix code based on a prompt and unit test errors."""
     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(
+        # The actual logic is in fix_main
+        success, fixed_unit_test, fixed_code, attempts, total_cost, model_name = fix_main(
             ctx=ctx,
             prompt_file=prompt_file,
             code_file=code_file,
@@ -540,18 +562,16 @@ def fix(
             budget=budget,
             auto_submit=auto_submit,
         )
-        # Package results into a dictionary for the first element of the tuple
-        result_data = {
+        result = {
             "success": success,
+            "fixed_unit_test": fixed_unit_test,
+            "fixed_code": fixed_code,
             "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
+        return result, total_cost, model_name
+    except Exception as exception:
+        handle_error(exception, "fix", ctx.obj.get("quiet", False))
+        return None
 
 
 @cli.command("split")
@@ -676,7 +696,7 @@ def change(
     "--output",
     type=click.Path(writable=True),
     default=None,
-    help="Specify where to save the updated prompt file (file or directory).",
+    help="Specify where to save the updated prompt file. If not specified, overwrites the original prompt file to maintain it as the source of truth.",
 )
 @click.option(
     "--git",
@@ -851,8 +871,8 @@ def crash(
         result_data = {
             "success": success,
             "attempts": attempts,
-            "fixed_code_path": output,
-            "fixed_program_path": output_program,
+            "fixed_code": fixed_code,
+            "fixed_program": fixed_program,
         }
         return result_data, cost, model
     except Exception as e:
@@ -1079,6 +1099,83 @@ def verify(
         return None # Return None on failure
 
 
+@cli.command("sync")
+@click.argument("basename", type=str)
+@click.option(
+    "--max-attempts",
+    type=int,
+    default=3,
+    show_default=True,
+    help="Maximum number of sync attempts.",
+)
+@click.option(
+    "--budget",
+    type=float,
+    default=10.0,
+    show_default=True,
+    help="Maximum total cost allowed for the entire sync process.",
+)
+@click.option(
+    "--skip-verify",
+    is_flag=True,
+    default=False,
+    help="Skip verification step during sync.",
+)
+@click.option(
+    "--skip-tests",
+    is_flag=True,
+    default=False,
+    help="Skip test generation during sync.",
+)
+@click.option(
+    "--target-coverage",
+    type=click.FloatRange(0.0, 100.0),
+    default=90.0,
+    show_default=True,
+    help="Target code coverage percentage for generated tests.",
+)
+@click.option(
+    "--log",
+    is_flag=True,
+    default=False,
+    help="Enable detailed logging during sync.",
+)
+@click.pass_context
+@track_cost
+def sync(
+    ctx: click.Context,
+    basename: str,
+    max_attempts: int,
+    budget: float,
+    skip_verify: bool,
+    skip_tests: bool,
+    target_coverage: float,
+    log: bool,
+) -> Optional[Tuple[Dict[str, Any], float, str]]:
+    """Automatically execute the complete PDD workflow loop for a given basename. 
+    
+    This command implements the entire synchronized cycle, intelligently determining 
+    what steps are needed and executing them in the correct order. It detects 
+    programming languages by scanning for prompt files matching the pattern 
+    {basename}_{language}.prompt in the prompts directory.
+    """
+    try:
+        results, total_cost, model = sync_main(
+            ctx=ctx,
+            basename=basename,
+            max_attempts=max_attempts,
+            budget=budget,
+            skip_verify=skip_verify,
+            skip_tests=skip_tests,
+            target_coverage=target_coverage,
+            log=log,
+        )
+        return results, total_cost, model
+    except Exception as exception:
+        handle_error(exception, "sync", ctx.obj.get("quiet", False))
+        return None
+
+
 @cli.command("install_completion")
 @click.pass_context
 # No @track_cost

pdd/cmd_test_main.py

@@ -1,24 +1,28 @@
-from typing import Optional, Tuple
+"""
+Main entry point for the 'test' command.
+"""
+from __future__ import annotations
 import click
+# pylint: disable=redefined-builtin
 from rich import print
-from rich.progress import track
-import os
 
 from .construct_paths import construct_paths
 from .generate_test import generate_test
 from .increase_tests import increase_tests
 
+
+# pylint: disable=too-many-arguments, too-many-locals, too-many-return-statements, too-many-branches, too-many-statements, broad-except
 def cmd_test_main(
     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: Optional[bool],
-) -> Tuple[str, float, str]:
+    output: str | None,
+    language: str | None,
+    coverage_report: str | None,
+    existing_tests: str | None,
+    target_coverage: float | None,
+    merge: bool | None,
+) -> tuple[str, float, str]:
     """
     CLI wrapper for generating or enhancing unit tests.
 
@@ -29,15 +33,15 @@ def cmd_test_main(
         ctx (click.Context): The Click context object.
         prompt_file (str): Path to the prompt file.
         code_file (str): Path to the code file.
-        output (Optional[str]): Path to save the generated test file.
-        language (Optional[str]): Programming language.
-        coverage_report (Optional[str]): Path to the coverage report file.
-        existing_tests (Optional[str]): Path to the existing unit test file.
-        target_coverage (Optional[float]): Desired code coverage percentage.
-        merge (Optional[bool]): Whether to merge new tests with existing tests.
+        output (str | None): Path to save the generated test file.
+        language (str | None): Programming language.
+        coverage_report (str | None): Path to the coverage report file.
+        existing_tests (str | None): Path to the existing unit test file.
+        target_coverage (float | None): Desired code coverage percentage.
+        merge (bool | None): Whether to merge new tests with existing tests.
 
     Returns:
-        Tuple[str, float, str]: Generated unit test code, total cost, and model name.
+        tuple[str, float, str]: Generated unit test code, total cost, and model name.
     """
     # Initialize variables
     unit_test = ""
@@ -77,15 +81,18 @@ def cmd_test_main(
             "target_coverage": target_coverage,
         }
 
-        input_strings, output_file_paths, language = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj["force"],
             quiet=ctx.obj["quiet"],
             command="test",
             command_options=command_options,
         )
-    except Exception as e:
-        print(f"[bold red]Error constructing paths: {e}[/bold red]")
+    except Exception as exception:
+        # Catching a general exception is necessary here to handle a wide range of
+        # potential errors during file I/O and path construction, ensuring the
+        # CLI remains robust.
+        print(f"[bold red]Error constructing paths: {exception}[/bold red]")
         ctx.exit(1)
         return "", 0.0, ""
 
@@ -102,16 +109,20 @@ def cmd_test_main(
                 temperature=temperature,
                 time=time,
                 language=language,
-                verbose=verbose
+                verbose=verbose,
             )
-        except Exception as e:
-            print(f"[bold red]Error generating tests: {e}[/bold red]")
+        except Exception as exception:
+            # A general exception is caught to handle various errors that can occur
+            # during the test generation process, which involves external model
+            # interactions and complex logic.
+            print(f"[bold red]Error generating tests: {exception}[/bold red]")
             ctx.exit(1)
             return "", 0.0, ""
     else:
         if not existing_tests:
             print(
-                "[bold red]Error: --existing-tests is required when using --coverage-report[/bold red]"
+                "[bold red]Error: --existing-tests is required "
+                "when using --coverage-report[/bold red]"
             )
             ctx.exit(1)
             return "", 0.0, ""
@@ -127,13 +138,16 @@ def cmd_test_main(
                 time=time,
                 verbose=verbose,
             )
-        except Exception as e:
-            print(f"[bold red]Error increasing test coverage: {e}[/bold red]")
+        except Exception as exception:
+            # This broad exception is used to catch any issue that might arise
+            # while increasing test coverage, including problems with parsing
+            # reports or interacting with the language model.
+            print(f"[bold red]Error increasing test coverage: {exception}[/bold red]")
             ctx.exit(1)
             return "", 0.0, ""
 
-    # Handle output
-    output_file = output_file_paths["output"]
+    # Handle output - prioritize orchestration output path over construct_paths result
+    output_file = output or output_file_paths["output"]
     if merge and existing_tests:
         output_file = existing_tests
 
@@ -142,13 +156,14 @@ def cmd_test_main(
         ctx.exit(1)
         return "", 0.0, ""
     try:
-        with open(output_file, "w") as f:
-            f.write(unit_test)
-        print(
-            f"[bold green]Unit tests saved to:[/bold green] {output_file}"
-        )
-    except Exception as e:
-        print(f"[bold red]Error saving tests to file: {e}[/bold red]")
+        with open(output_file, "w", encoding="utf-8") as file_handle:
+            file_handle.write(unit_test)
+        print(f"[bold green]Unit tests saved to:[/bold green] {output_file}")
+    except Exception as exception:
+        # A broad exception is caught here to handle potential file system errors
+        # (e.g., permissions, disk space) that can occur when writing the
+        # output file, preventing the program from crashing unexpectedly.
+        print(f"[bold red]Error saving tests to file: {exception}[/bold red]")
         ctx.exit(1)
         return "", 0.0, ""
 
@@ -156,4 +171,4 @@ def cmd_test_main(
         print(f"[bold blue]Total cost:[/bold blue] ${total_cost:.6f}")
         print(f"[bold blue]Model used:[/bold blue] {model_name}")
 
-    return unit_test, total_cost, model_name
+    return unit_test, total_cost, model_name

pdd/code_generator_main.py

@@ -157,7 +157,7 @@ def code_generator_main(
     command_options: Dict[str, Any] = {"output": output}
 
     try:
-        input_strings, output_file_paths, language = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths_dict,
             force=force_overwrite,
             quiet=quiet,
@@ -165,7 +165,8 @@ def code_generator_main(
             command_options=command_options,
         )
         prompt_content = input_strings["prompt_file"]
-        output_path = output_file_paths.get("output")
+        # Prioritize orchestration output path over construct_paths result
+        output_path = output or output_file_paths.get("output")
 
     except FileNotFoundError as e:
         console.print(f"[red]Error: Input file not found: {e.filename}[/red]")

pdd/conflicts_main.py

@@ -28,7 +28,7 @@ def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optio
         command_options = {
             "output": output
         }
-        input_strings, output_file_paths, _ = construct_paths(
+        resolved_config, input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),