pdd-cli 0.0.24__py3-none-any.whl → 0.0.25__py3-none-any.whl

pdd/context_generator.py

@@ -5,6 +5,7 @@ from .llm_invoke import llm_invoke
 from .unfinished_prompt import unfinished_prompt
 from .continue_generation import continue_generation
 from .postprocess import postprocess
+from . import EXTRACTION_STRENGTH
 
 def context_generator(code_module: str, prompt: str, language: str = "python", strength: float = 0.5, temperature: float = 0, verbose: bool = False) -> tuple:
     """
@@ -115,7 +116,7 @@ def context_generator(code_module: str, prompt: str, language: str = "python", s
         example_code, postprocess_cost, postprocess_model = postprocess(
             llm_output=final_llm_output,
             language=language,
-            strength=0.97,
+            strength=EXTRACTION_STRENGTH,
             temperature=temperature,
             verbose=verbose
         )

pdd/continue_generation.py

@@ -6,6 +6,7 @@ from .load_prompt_template import load_prompt_template
 from .preprocess import preprocess
 from .llm_invoke import llm_invoke
 from .unfinished_prompt import unfinished_prompt
+from . import EXTRACTION_STRENGTH
 
 console = Console()
 
@@ -69,7 +70,7 @@ def continue_generation(
         trim_start_response = llm_invoke(
             prompt=processed_prompts['trim_start'],
             input_json={"LLM_OUTPUT": llm_output},
-            strength=0.9,
+            strength=0.8,
             temperature=0,
             output_pydantic=TrimResultsStartOutput,
             verbose=verbose
@@ -119,7 +120,7 @@ def continue_generation(
                         "CONTINUED_GENERATION": continue_result,
                         "GENERATED_RESULTS": code_block[-200:]
                     },
-                    strength=0.9,
+                    strength=EXTRACTION_STRENGTH,
                     temperature=0,
                     output_pydantic=TrimResultsOutput,
                     verbose=verbose

pdd/crash_main.py

@@ -1,10 +1,18 @@
 import sys
-from typing import Tuple, Optional
+from typing import Tuple, Optional, Dict, Any
 import click
 from rich import print as rprint
+from . import DEFAULT_STRENGTH
+from pathlib import Path
 
 from .construct_paths import construct_paths
 from .fix_code_loop import fix_code_loop
+# Import fix_code_module_errors conditionally or ensure it's always available
+try:
+    from .fix_code_module_errors import fix_code_module_errors
+except ImportError:
+    # Handle case where fix_code_module_errors might not be available if not needed
+    fix_code_module_errors = None
 
 def crash_main(
     ctx: click.Context,
@@ -39,6 +47,13 @@ def crash_main(
         - float: Total cost of all fix attempts
         - str: The name of the model used
     """
+    # Ensure ctx.obj and ctx.params exist and are dictionaries
+    ctx.obj = ctx.obj if isinstance(ctx.obj, dict) else {}
+    ctx.params = ctx.params if isinstance(ctx.params, dict) else {}
+
+    quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False))
+    verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False)) # Get verbose flag
+
     try:
         # Construct file paths
         input_file_paths = {
@@ -47,13 +62,13 @@ def crash_main(
             "program_file": program_file,
             "error_file": error_file
         }
-        command_options = {
+        command_options: Dict[str, Any] = {
             "output": output,
             "output_program": output_program
         }
 
         force = ctx.params.get("force", ctx.obj.get("force", False))
-        quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False))
+        # quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False)) # Already defined above
 
         input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
@@ -70,46 +85,58 @@ def crash_main(
         error_content = input_strings["error_file"]
 
         # Get model parameters from context
-        strength = ctx.obj.get("strength", 0.97)
+        strength = ctx.obj.get("strength", DEFAULT_STRENGTH)
         temperature = ctx.obj.get("temperature", 0)
 
-        verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False))
+        # verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False)) # Already defined above
 
         if loop:
             # Use iterative fixing process
-            success, final_code, final_program, attempts, cost, model = fix_code_loop(
+            success, final_program, final_code, attempts, cost, model = fix_code_loop(
                 code_file, prompt_content, program_file, strength, temperature, max_attempts or 3, budget or 5.0, error_file, verbose
             )
         else:
             # Use single fix attempt
-            from .fix_code_module_errors import fix_code_module_errors
-            update_program, update_code, final_program, final_code, cost, model = fix_code_module_errors(
+            if fix_code_module_errors is None:
+                 raise ImportError("fix_code_module_errors is required but not available.")
+            # Note: fix_code_module_errors returns 7 values according to example
+            # update_program, update_code, fixed_program, fixed_code, program_code_fix, cost, model
+            # The current code unpacks 7 values, which matches the example.
+            update_program, update_code, final_program, final_code, program_code_fix, cost, model = fix_code_module_errors(
                 program_content, prompt_content, code_content, error_content, strength, temperature, verbose
             )
-            success = True
+            success = True # Assume success after one attempt if no exception
             attempts = 1
 
         # Ensure we have content to write, falling back to original content if needed
-        if final_code == "":
-            final_code = code_content
-        
         if final_program == "":
             final_program = program_content
 
+        if final_code == "":
+            final_code = code_content
+
         # Determine whether to write the files based on whether paths are provided
-        should_write_code = output_file_paths.get("output") is not None
-        should_write_program = output_file_paths.get("output_program") is not None
+        output_code_path_str = output_file_paths.get("output")
+        output_program_path_str = output_file_paths.get("output_program")
+
+        should_write_code = output_code_path_str is not None
+        should_write_program = output_program_path_str is not None
 
         # Write output files
         if should_write_code:
-            with open(output_file_paths["output"], "w") as f:
+            output_code_path = Path(output_code_path_str)
+            output_code_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            with open(output_code_path, "w") as f:
                 f.write(final_code)
 
         if should_write_program:
-            with open(output_file_paths["output_program"], "w") as f:
+            output_program_path = Path(output_program_path_str)
+            output_program_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            with open(output_program_path, "w") as f:
                 f.write(final_program)
 
-        # Provide user feedback
+        # Provide user feedback (using quiet flag as per current implementation)
+        # To strictly follow the prompt's last note, change 'if not quiet:' to 'if verbose:'
         if not quiet:
             if success:
                 rprint("[bold green]Crash fix completed successfully.[/bold green]")
@@ -119,13 +146,21 @@ def crash_main(
             rprint(f"[bold]Total attempts:[/bold] {attempts}")
             rprint(f"[bold]Total cost:[/bold] ${cost:.2f}")
             if should_write_code:
-                rprint(f"[bold]Fixed code saved to:[/bold] {output_file_paths['output']}")
+                rprint(f"[bold]Fixed code saved to:[/bold] {output_code_path_str}")
             if should_write_program:
-                rprint(f"[bold]Fixed program saved to:[/bold] {output_file_paths['output_program']}")
+                rprint(f"[bold]Fixed program saved to:[/bold] {output_program_path_str}")
 
         return success, final_code, final_program, attempts, cost, model
     
+    except FileNotFoundError as e:
+        if not quiet:
+             # Provide a more specific error message for file not found
+             rprint(f"[bold red]Error:[/bold red] Input file not found: {e}")
+        sys.exit(1)
     except Exception as e:
         if not quiet:
-            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+            rprint(f"[bold red]An unexpected error occurred:[/bold red] {str(e)}")
+        # Consider logging the full traceback here for debugging
+        # import traceback
+        # traceback.print_exc()
         sys.exit(1)

pdd/detect_change.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from rich.console import Console
 from rich.markdown import Markdown
 from pydantic import BaseModel, Field
+from . import EXTRACTION_STRENGTH
 
 from .preprocess import preprocess
 from .load_prompt_template import load_prompt_template
@@ -101,7 +102,7 @@ def detect_change(
         extract_response = llm_invoke(
             prompt=extract_prompt,
             input_json={"llm_output": detect_response['result']},
-            strength=0.97,
+            strength=EXTRACTION_STRENGTH,
             temperature=0.0,
             verbose=verbose,
             output_pydantic=ChangesList