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

pdd/cmd_test_main.py

@@ -3,9 +3,11 @@ Main entry point for the 'test' command.
 """
 from __future__ import annotations
 import click
+from pathlib import Path
 # pylint: disable=redefined-builtin
 from rich import print
 
+from .config_resolution import resolve_effective_config
 from .construct_paths import construct_paths
 from .generate_test import generate_test
 from .increase_tests import increase_tests
@@ -19,9 +21,11 @@ def cmd_test_main(
     output: str | None,
     language: str | None,
     coverage_report: str | None,
-    existing_tests: str | None,
+    existing_tests: list[str] | None,
     target_coverage: float | None,
     merge: bool | None,
+    strength: float | None = None,
+    temperature: float | None = None,
 ) -> tuple[str, float, str]:
     """
     CLI wrapper for generating or enhancing unit tests.
@@ -36,7 +40,7 @@ def cmd_test_main(
         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.
+        existing_tests (list[str] | None): Paths to the existing unit test files.
         target_coverage (float | None): Desired code coverage percentage.
         merge (bool | None): Whether to merge new tests with existing tests.
 
@@ -51,9 +55,9 @@ def cmd_test_main(
     input_strings = {}
 
     verbose = ctx.obj["verbose"]
-    strength = ctx.obj["strength"]
-    temperature = ctx.obj["temperature"]
-    time = ctx.obj.get("time")
+    # Note: strength/temperature will be resolved after construct_paths using resolve_effective_config
+    param_strength = strength  # Store the parameter value for later resolution
+    param_temperature = temperature  # Store the parameter value for later resolution
 
     if verbose:
         print(f"[bold blue]Prompt file:[/bold blue] {prompt_file}")
@@ -72,7 +76,7 @@ def cmd_test_main(
         if coverage_report:
             input_file_paths["coverage_report"] = coverage_report
         if existing_tests:
-            input_file_paths["existing_tests"] = existing_tests
+            input_file_paths["existing_tests"] = existing_tests[0]
 
         command_options = {
             "output": output,
@@ -87,18 +91,58 @@ def cmd_test_main(
             quiet=ctx.obj["quiet"],
             command="test",
             command_options=command_options,
+            context_override=ctx.obj.get('context'),
+            confirm_callback=ctx.obj.get('confirm_callback')
         )
+
+        # Read multiple existing test files and concatenate their content
+        if existing_tests:
+            existing_tests_content = ""
+            for test_file in existing_tests:
+                with open(test_file, 'r') as f:
+                    existing_tests_content += f.read() + "\n"
+            input_strings["existing_tests"] = existing_tests_content
+
+        # Use centralized config resolution with proper priority:
+        # CLI > pddrc > defaults
+        effective_config = resolve_effective_config(
+            ctx,
+            resolved_config,
+            param_overrides={"strength": param_strength, "temperature": param_temperature}
+        )
+        strength = effective_config["strength"]
+        temperature = effective_config["temperature"]
+        time = effective_config["time"]
+    except click.Abort:
+        # User cancelled - re-raise to stop the sync loop
+        raise
     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, ""
+        # Return error result instead of ctx.exit(1) to allow orchestrator to handle gracefully
+        return "", 0.0, f"Error: {exception}"
 
     if verbose:
         print(f"[bold blue]Language detected:[/bold blue] {language}")
 
+    # Determine where the generated tests will be written so we can share it with the LLM
+    # Always use resolved_output since construct_paths handles numbering for test/bug commands
+    resolved_output = output_file_paths["output"]
+    output_file = resolved_output
+    if merge and existing_tests:
+        output_file = existing_tests[0]
+
+    if not output_file:
+        print("[bold red]Error: Output file path could not be determined.[/bold red]")
+        # Return error result instead of ctx.exit(1) to allow orchestrator to handle gracefully
+        return "", 0.0, "Error: Output file path could not be determined"
+
+    source_file_path_for_prompt = str(Path(code_file).expanduser().resolve())
+    test_file_path_for_prompt = str(Path(output_file).expanduser().resolve())
+    module_name_for_prompt = Path(source_file_path_for_prompt).stem if source_file_path_for_prompt else ""
+
     # Generate or enhance unit tests
     if not coverage_report:
         try:
@@ -110,22 +154,25 @@ def cmd_test_main(
                 time=time,
                 language=language,
                 verbose=verbose,
+                source_file_path=source_file_path_for_prompt,
+                test_file_path=test_file_path_for_prompt,
+                module_name=module_name_for_prompt,
             )
         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, ""
+            # Return error result instead of ctx.exit(1) to allow orchestrator to handle gracefully
+            return "", 0.0, f"Error: {exception}"
     else:
         if not existing_tests:
             print(
                 "[bold red]Error: --existing-tests is required "
                 "when using --coverage-report[/bold red]"
             )
-            ctx.exit(1)
-            return "", 0.0, ""
+            # Return error result instead of ctx.exit(1) to allow orchestrator to handle gracefully
+            return "", 0.0, "Error: --existing-tests is required when using --coverage-report"
         try:
             unit_test, total_cost, model_name = increase_tests(
                 existing_unit_tests=input_strings["existing_tests"],
@@ -143,19 +190,33 @@ def cmd_test_main(
             # 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, ""
+            # Return error result instead of ctx.exit(1) to allow orchestrator to handle gracefully
+            return "", 0.0, f"Error: {exception}"
 
-    # Handle output - prioritize orchestration output path over construct_paths result
-    output_file = output or output_file_paths["output"]
+    # Handle output - always use resolved file path since construct_paths handles numbering
+    resolved_output = output_file_paths["output"]
+    output_file = resolved_output
     if merge and existing_tests:
-        output_file = existing_tests
+        output_file = existing_tests[0] if existing_tests else None
 
     if not output_file:
         print("[bold red]Error: Output file path could not be determined.[/bold red]")
         ctx.exit(1)
         return "", 0.0, ""
+    
+    # Check if unit_test content is empty
+    if not unit_test or not unit_test.strip():
+        print(f"[bold red]Error: Generated unit test content is empty or whitespace-only.[/bold red]")
+        print(f"[bold yellow]Debug: unit_test length: {len(unit_test) if unit_test else 0}[/bold yellow]")
+        print(f"[bold yellow]Debug: unit_test content preview: {repr(unit_test[:100]) if unit_test else 'None'}[/bold yellow]")
+        # Return error result instead of ctx.exit(1) to allow orchestrator to handle gracefully
+        return "", 0.0, "Error: Generated unit test content is empty"
+    
     try:
+        # Ensure parent directory exists
+        output_path = Path(output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
         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}")
@@ -164,8 +225,8 @@ def cmd_test_main(
         # (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, ""
+        # Return error result instead of ctx.exit(1) to allow orchestrator to handle gracefully
+        return "", 0.0, f"Error: {exception}"
 
     if verbose:
         print(f"[bold blue]Total cost:[/bold blue] ${total_cost:.6f}")

pdd/code_generator.py

@@ -1,3 +1,5 @@
+import json
+import re
 from typing import Tuple, Optional
 from rich.console import Console
 from . import EXTRACTION_STRENGTH
@@ -17,6 +19,7 @@ def code_generator(
     time: Optional[float] = None,
     verbose: bool = False,
     preprocess_prompt: bool = True,
+    output_schema: Optional[dict] = None,
 ) -> Tuple[str, float, str]:
     """
     Generate code from a prompt using a language model.
@@ -28,6 +31,8 @@ def code_generator(
         temperature (float, optional): The temperature for the LLM model. Defaults to 0.0
         time (Optional[float], optional): The time for the LLM model. Defaults to None
         verbose (bool, optional): Whether to print detailed information. Defaults to False
+        preprocess_prompt (bool, optional): Whether to preprocess the prompt. Defaults to True
+        output_schema (Optional[dict], optional): JSON schema to enforce structured output. Defaults to None
 
     Returns:
         Tuple[str, float, str]: Tuple containing (runnable_code, total_cost, model_name)
@@ -62,14 +67,37 @@ def code_generator(
         # Step 2: Generate initial response
         if verbose:
             console.print("[bold blue]Step 2: Generating initial response[/bold blue]")
-        response = llm_invoke(
-            prompt=processed_prompt,
-            input_json={},
-            strength=strength,
-            temperature=temperature,
-            time=time,
-            verbose=verbose
-        )
+        
+        if 'data:image' in processed_prompt:
+            parts = re.split(r'(data:image/[^;]+;base64,[A-Za-z0-9+/=]+)', processed_prompt)
+            
+            content = []
+            for part in parts:
+                if part.startswith('data:image'):
+                    content.append({"type": "image_url", "image_url": {"url": part}})
+                elif part != "":
+                    content.append({"type": "text", "text": part})
+            
+            messages = [{"role": "user", "content": content}]
+
+            response = llm_invoke(
+                messages=messages,
+                strength=strength,
+                temperature=temperature,
+                time=time,
+                verbose=verbose,
+                output_schema=output_schema
+            )
+        else:
+            response = llm_invoke(
+                prompt=processed_prompt,
+                input_json={},
+                strength=strength,
+                temperature=temperature,
+                time=time,
+                verbose=verbose,
+                output_schema=output_schema
+            )
         initial_output = response['result']
         total_cost += response['cost']
         model_name = response['model_name']
@@ -83,6 +111,7 @@ def code_generator(
             strength=0.5,
             temperature=0.0,
             time=time,
+            language=language,
             verbose=verbose
         )
         total_cost += check_cost
@@ -97,6 +126,7 @@ def code_generator(
                 strength=strength,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=verbose
             )
             total_cost += continue_cost
@@ -107,15 +137,25 @@ def code_generator(
         # Step 4: Postprocess the output
         if verbose:
             console.print("[bold blue]Step 4: Postprocessing output[/bold blue]")
-        runnable_code, postprocess_cost, model_name_post = postprocess(
-            llm_output=final_output,
-            language=language,
-            strength=EXTRACTION_STRENGTH,
-            temperature=0.0,
-            time=time,
-            verbose=verbose
-        )
-        total_cost += postprocess_cost
+
+        # For structured JSON targets, skip extract_code to avoid losing or altering schema-constrained payloads.
+        if (isinstance(language, str) and language.strip().lower() == "json") or output_schema:
+            if isinstance(final_output, str):
+                runnable_code = final_output
+            else:
+                runnable_code = json.dumps(final_output)
+            postprocess_cost = 0.0
+            model_name_post = model_name
+        else:
+            runnable_code, postprocess_cost, model_name_post = postprocess(
+                llm_output=final_output,
+                language=language,
+                strength=EXTRACTION_STRENGTH,
+                temperature=0.0,
+                time=time,
+                verbose=verbose
+            )
+            total_cost += postprocess_cost
 
         return runnable_code, total_cost, model_name
 
@@ -126,4 +166,4 @@ def code_generator(
     except Exception as e:
         if verbose:
             console.print(f"[bold red]Unexpected Error: {str(e)}[/bold red]")
-        raise
+        raise