pdd-cli 0.0.41__py3-none-any.whl → 0.0.43__py3-none-any.whl

pdd/crash_main.py

@@ -52,15 +52,13 @@ def crash_main(
     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
+    verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False))
 
-    # Get model parameters from context early, including time
     strength = ctx.obj.get("strength", DEFAULT_STRENGTH)
     temperature = ctx.obj.get("temperature", 0)
-    time_param = ctx.obj.get("time", DEFAULT_TIME) # Renamed from time_budget for clarity
+    time_param = ctx.obj.get("time", DEFAULT_TIME)
 
     try:
-        # Construct file paths
         input_file_paths = {
             "prompt_file": prompt_file,
             "code_file": code_file,
@@ -73,9 +71,8 @@ def crash_main(
         }
 
         force = ctx.params.get("force", ctx.obj.get("force", False))
-        # quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False)) # Already defined above
 
-        input_strings, output_file_paths, _ = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths,
             force=force,
             quiet=quiet,
@@ -83,78 +80,79 @@ def crash_main(
             command_options=command_options
         )
 
-        # Load input files
         prompt_content = input_strings["prompt_file"]
         code_content = input_strings["code_file"]
         program_content = input_strings["program_file"]
         error_content = input_strings["error_file"]
 
-        # Store original content for comparison later
         original_code_content = code_content
         original_program_content = program_content
 
-        # Get model parameters from context (strength, temperature, time already fetched)
-        # strength = ctx.obj.get("strength", DEFAULT_STRENGTH) # Moved up
-        # temperature = ctx.obj.get("temperature", 0) # Moved up
-        # time_budget = ctx.obj.get("time", DEFAULT_TIME) # Moved up and renamed
-
-        # verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False)) # Already defined above
-
         code_updated: bool = False
         program_updated: bool = False
 
         if loop:
-            # Use iterative fixing process
-            # Corrected parameter order for fix_code_loop, adding time_param
             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, time_param
             )
-            # Determine if content was updated by fix_code_loop
-            if success: # Only consider updates if the loop reported success
-                code_updated = bool(final_code and final_code != original_code_content)
-                program_updated = bool(final_program and final_program != original_program_content)
+            # Always set final_code/final_program to something non-empty
+            if not final_code:
+                final_code = original_code_content
+            if not final_program:
+                final_program = original_program_content
+            code_updated = final_code != original_code_content
+            program_updated = final_program != original_program_content
         else:
-            # Use single fix attempt
             if fix_code_module_errors is None:
-                 raise ImportError("fix_code_module_errors is required but not available.")
-            # Corrected parameter order for fix_code_module_errors, adding time_param
-            fm_update_program, fm_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, time_param
+                raise ImportError("fix_code_module_errors is required but not available.")
+
+            update_program, update_code, fixed_program, fixed_code, _, cost, model = fix_code_module_errors(
+                program_content, prompt_content, code_content, error_content,
+                strength, temperature, verbose, time_param
             )
-            success = True # Assume success after one attempt if no exception
+            success = True
             attempts = 1
-            # Use boolean flags from fix_code_module_errors and ensure content is not empty
-            code_updated = fm_update_code and bool(final_code)
-            program_updated = fm_update_program and bool(final_program)
 
-        # Removed fallback to original content if final_code/final_program are empty
-        # An empty string from a fix function means no valid update.
+            # Fallback if fixed_program is empty but update_program is True
+            if update_program and not fixed_program.strip():
+                fixed_program = program_content
+            if update_code and not fixed_code.strip():
+                fixed_code = code_content
+
+            final_code = fixed_code if update_code else code_content
+            final_program = fixed_program if update_program else program_content
+
+            # Always set final_code/final_program to something non-empty
+            if not final_code:
+                final_code = original_code_content
+            if not final_program:
+                final_program = original_program_content
+
+            code_updated = final_code != original_code_content
+            program_updated = final_program != original_program_content
 
-        # Determine whether to write the files based on whether paths are provided
         output_code_path_str = output_file_paths.get("output")
         output_program_path_str = output_file_paths.get("output_program")
 
-        # Write output files if path provided (always write for regression compatibility)
-        # Use fixed content if available, otherwise use original content
+        # Always write output files if output paths are specified
         if output_code_path_str:
             output_code_path = Path(output_code_path_str)
-            output_code_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            output_code_path.parent.mkdir(parents=True, exist_ok=True)
             with open(output_code_path, "w") as f:
-                f.write(final_code if final_code else original_code_content)
+                f.write(final_code)
 
         if output_program_path_str:
             output_program_path = Path(output_program_path_str)
-            output_program_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            output_program_path.parent.mkdir(parents=True, exist_ok=True)
             with open(output_program_path, "w") as f:
-                f.write(final_program if final_program else original_program_content)
+                f.write(final_program)
 
-        # Provide user feedback
         if not quiet:
             if success:
-                rprint("[bold green]Crash fix attempt completed.[/bold green]") # Changed message slightly
+                rprint("[bold green]Crash fix attempt completed.[/bold green]")
             else:
-                rprint("[bold yellow]Crash fix attempt completed with issues or no changes made.[/bold yellow]") # Changed message
+                rprint("[bold yellow]Crash fix attempt completed with issues.[/bold yellow]")
             rprint(f"[bold]Model used:[/bold] {model}")
             rprint(f"[bold]Total attempts:[/bold] {attempts}")
             rprint(f"[bold]Total cost:[/bold] ${cost:.2f}")
@@ -163,25 +161,20 @@ def crash_main(
                 if code_updated:
                     rprint(f"[bold]Fixed code saved to:[/bold] {output_code_path_str}")
                 else:
-                    rprint(f"[info]Code file {Path(code_file).name} was not modified. Original content saved to {output_code_path_str}.[/info]")
-            
+                    rprint(f"[info]Code file '{Path(code_file).name}' was not modified (but output file was written).[/info]")
             if output_program_path_str:
                 if program_updated:
                     rprint(f"[bold]Fixed program saved to:[/bold] {output_program_path_str}")
                 else:
-                    rprint(f"[info]Program file {Path(program_file).name} was not modified. Original content saved to {output_program_path_str}.[/info]")
+                    rprint(f"[info]Program file '{Path(program_file).name}' was not modified (but output file was written).[/info]")
 
         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}")
+            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]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_main.py

@@ -39,7 +39,7 @@ def detect_change_main(
             "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),

pdd/fix_code_module_errors.py

@@ -81,6 +81,18 @@ def fix_code_module_errors(
         model_name = first_response.get('model_name', '')
         program_code_fix = first_response['result']
 
+        # Check if the LLM response is None or an error string
+        if program_code_fix is None:
+            error_msg = "LLM returned None result during error analysis"
+            if verbose:
+                print(f"[red]{error_msg}[/red]")
+            raise RuntimeError(error_msg)
+        elif isinstance(program_code_fix, str) and program_code_fix.startswith("ERROR:"):
+            error_msg = f"LLM failed to analyze errors: {program_code_fix}"
+            if verbose:
+                print(f"[red]{error_msg}[/red]")
+            raise RuntimeError(error_msg)
+
         if verbose:
             print("[green]Error analysis complete[/green]")
             print(Markdown(program_code_fix))

pdd/fix_main.py

@@ -91,7 +91,7 @@ def fix_main(
             "output_results": output_results
         }
 
-        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),
@@ -177,7 +177,7 @@ def fix_main(
                     try:
                         # Get JWT token for cloud authentication
                         jwt_token = asyncio.run(get_jwt_token(
-                            firebase_api_key=os.environ.get("REACT_APP_FIREBASE_API_KEY"),
+                            firebase_api_key=os.environ.get("NEXT_PUBLIC_FIREBASE_API_KEY"),
                             github_client_id=os.environ.get("GITHUB_CLIENT_ID"),
                             app_name="PDD Code Generator"
                         ))

pdd/fix_verification_main.py

@@ -183,7 +183,7 @@ def fix_verification_main(
 
     try:
         # First try the official helper.
-        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=force,
             quiet=quiet,

pdd/generate_output_paths.py

@@ -26,6 +26,7 @@ COMMAND_OUTPUT_KEYS: Dict[str, List[str]] = {
     'bug': ['output'],
     'auto-deps': ['output'],
     'verify': ['output_results', 'output_code', 'output_program'],
+    'sync': ['generate_output_path', 'test_output_path', 'example_output_path'],
 }
 
 # Define default filename patterns for each output key
@@ -48,8 +49,8 @@ DEFAULT_FILENAMES: Dict[str, Dict[str, str]] = {
     },
     'change': {'output': 'modified_{basename}.prompt'},
     'update': {'output': 'modified_{basename}.prompt'}, # Consistent with change/split default
-    'detect': {'output': '{basename}_detect.csv'}, # Using basename as change_file_basename isn't available here
-    'conflicts': {'output': '{basename}_conflict.csv'}, # Using basename as prompt1/2 basenames aren't available
+    'detect': {'output': '{basename}_detect.csv'}, # basename here is from change_file per construct_paths logic
+    'conflicts': {'output': '{basename}_conflict.csv'}, # basename here is combined sorted prompt basenames per construct_paths logic
     'crash': {
         'output': '{basename}_fixed{ext}',
         # Using basename as program_basename isn't available here
@@ -63,6 +64,11 @@ DEFAULT_FILENAMES: Dict[str, Dict[str, str]] = {
         'output_code': '{basename}_verified{ext}',
         'output_program': '{basename}_program_verified{ext}',
     },
+    'sync': {
+        'generate_output_path': '{basename}{ext}',
+        'test_output_path': 'test_{basename}{ext}',
+        'example_output_path': '{basename}_example{ext}',
+    },
 }
 
 # Define the mapping from command/output key to environment variables
@@ -96,6 +102,50 @@ ENV_VAR_MAP: Dict[str, Dict[str, str]] = {
         'output_code': 'PDD_VERIFY_CODE_OUTPUT_PATH',
         'output_program': 'PDD_VERIFY_PROGRAM_OUTPUT_PATH',
     },
+    'sync': {
+        'generate_output_path': 'PDD_GENERATE_OUTPUT_PATH',
+        'test_output_path': 'PDD_TEST_OUTPUT_PATH',
+        'example_output_path': 'PDD_EXAMPLE_OUTPUT_PATH',
+    },
+}
+
+# Define mapping from context config keys to output keys for different commands
+CONTEXT_CONFIG_MAP: Dict[str, Dict[str, str]] = {
+    'generate': {'output': 'generate_output_path'},
+    'example': {'output': 'example_output_path'},
+    'test': {'output': 'test_output_path'},
+    'sync': {
+        'generate_output_path': 'generate_output_path',
+        'test_output_path': 'test_output_path',
+        'example_output_path': 'example_output_path',
+    },
+    # For other commands, they can use the general mapping if needed
+    'preprocess': {'output': 'generate_output_path'},  # fallback
+    'fix': {
+        'output_test': 'test_output_path',
+        'output_code': 'generate_output_path',
+        'output_results': 'generate_output_path',  # fallback for results
+    },
+    'split': {
+        'output_sub': 'generate_output_path',      # fallback
+        'output_modified': 'generate_output_path', # fallback
+    },
+    'change': {'output': 'generate_output_path'},
+    'update': {'output': 'generate_output_path'},
+    'detect': {'output': 'generate_output_path'},
+    'conflicts': {'output': 'generate_output_path'},
+    'crash': {
+        'output': None,  # Use default CWD behavior, not context paths
+        'output_program': None,  # Use default CWD behavior, not context paths
+    },
+    'trace': {'output': 'generate_output_path'},
+    'bug': {'output': 'test_output_path'},
+    'auto-deps': {'output': 'generate_output_path'},
+    'verify': {
+        'output_results': 'generate_output_path',
+        'output_code': 'generate_output_path',
+        'output_program': 'generate_output_path',
+    },
 }
 
 # --- Helper Function ---
@@ -127,14 +177,15 @@ def generate_output_paths(
     output_locations: Dict[str, Optional[str]],
     basename: str,
     language: str,
-    file_extension: str
+    file_extension: str,
+    context_config: Optional[Dict[str, str]] = None
 ) -> Dict[str, str]:
     """
     Generates the full, absolute output paths for a given PDD command.
 
-    It prioritizes user-specified paths (--output options), then environment
-    variables, and finally falls back to default naming conventions in the
-    current working directory.
+    It prioritizes user-specified paths (--output options), then context 
+    configuration from .pddrc, then environment variables, and finally 
+    falls back to default naming conventions in the current working directory.
 
     Args:
         command: The PDD command being executed (e.g., 'generate', 'fix').
@@ -146,6 +197,8 @@ def generate_output_paths(
         language: The programming language associated with the operation.
         file_extension: The file extension (including '.') for the language,
                         used when default patterns require it.
+        context_config: Optional dictionary with context-specific paths from .pddrc
+                       configuration (e.g., {'generate_output_path': 'src/'}).
 
     Returns:
         A dictionary where keys are the standardized output identifiers
@@ -155,8 +208,10 @@ def generate_output_paths(
     """
     logger.debug(f"Generating output paths for command: {command}")
     logger.debug(f"User output locations: {output_locations}")
+    logger.debug(f"Context config: {context_config}")
     logger.debug(f"Basename: {basename}, Language: {language}, Extension: {file_extension}")
 
+    context_config = context_config or {}
     result_paths: Dict[str, str] = {}
 
     if not basename:
@@ -183,6 +238,11 @@ def generate_output_paths(
         logger.debug(f"Processing output key: {output_key}")
 
         user_path: Optional[str] = processed_output_locations.get(output_key)
+        
+        # Get context configuration path for this output key
+        context_config_key = CONTEXT_CONFIG_MAP.get(command, {}).get(output_key)
+        context_path: Optional[str] = context_config.get(context_config_key) if context_config_key else None
+        
         env_var_name: Optional[str] = ENV_VAR_MAP.get(command, {}).get(output_key)
         env_path: Optional[str] = os.environ.get(env_var_name) if env_var_name else None
 
@@ -215,7 +275,26 @@ def generate_output_paths(
                 logger.debug(f"User path '{user_path}' identified as a specific file path.")
                 final_path = user_path # Assume it's a full path or filename
 
-        # 2. Check Environment Variable Path
+        # 2. Check Context Configuration Path (.pddrc)
+        elif context_path:
+            source = "context"
+            # Check if the context path is a directory
+            is_dir = context_path.endswith(os.path.sep) or context_path.endswith('/')
+            if not is_dir:
+                 try:
+                     if os.path.exists(context_path) and os.path.isdir(context_path):
+                         is_dir = True
+                 except Exception as e:
+                     logger.warning(f"Could not check if context path '{context_path}' is a directory: {e}")
+
+            if is_dir:
+                logger.debug(f"Context path '{context_path}' identified as a directory.")
+                final_path = os.path.join(context_path, default_filename)
+            else:
+                logger.debug(f"Context path '{context_path}' identified as a specific file path.")
+                final_path = context_path
+
+        # 3. Check Environment Variable Path
         elif env_path:
             source = "environment"
             # Check if the environment variable points to a directory
@@ -234,7 +313,7 @@ def generate_output_paths(
                 logger.debug(f"Env path '{env_path}' identified as a specific file path.")
                 final_path = env_path # Assume it's a full path or filename
 
-        # 3. Use Default Naming Convention in CWD
+        # 4. Use Default Naming Convention in CWD
         else:
             source = "default"
             logger.debug(f"Using default filename '{default_filename}' in current directory.")
@@ -273,7 +352,8 @@ if __name__ == '__main__':
         output_locations={}, # No user input
         basename=mock_basename,
         language=mock_language,
-        file_extension=mock_extension
+        file_extension=mock_extension,
+        context_config={}
     )
     print(f"Result: {paths1}")
     # Expected: {'output': '/path/to/cwd/my_module.py'}
@@ -285,7 +365,8 @@ if __name__ == '__main__':
         output_locations={'output': 'generated_code.py'},
         basename=mock_basename,
         language=mock_language,
-        file_extension=mock_extension
+        file_extension=mock_extension,
+        context_config={}
     )
     print(f"Result: {paths2}")
     # Expected: {'output': '/path/to/cwd/generated_code.py'}
@@ -300,7 +381,8 @@ if __name__ == '__main__':
         output_locations={'output': test_dir_gen + os.path.sep}, # Explicit directory
         basename=mock_basename,
         language=mock_language,
-        file_extension=mock_extension
+        file_extension=mock_extension,
+        context_config={}
     )
     print(f"Result: {paths3}")
     # Expected: {'output': '/path/to/cwd/temp_gen_output/my_module.py'}
@@ -319,7 +401,8 @@ if __name__ == '__main__':
         },
         basename=mock_basename,
         language=mock_language,
-        file_extension=mock_extension
+        file_extension=mock_extension,
+        context_config={}
     )
     print(f"Result: {paths4}")
     # Expected: {
@@ -344,7 +427,8 @@ if __name__ == '__main__':
         output_locations={}, # No user input
         basename=mock_basename,
         language=mock_language,
-        file_extension=mock_extension
+        file_extension=mock_extension,
+        context_config={}
     )
     print(f"Result: {paths5}")
     # Expected: {
@@ -365,7 +449,8 @@ if __name__ == '__main__':
         output_locations={},
         basename=mock_basename,
         language=mock_language,
-        file_extension=mock_extension # This extension is ignored for preprocess default
+        file_extension=mock_extension, # This extension is ignored for preprocess default
+        context_config={}
     )
     print(f"Result: {paths6}")
     # Expected: {'output': '/path/to/cwd/my_module_python_preprocessed.prompt'}
@@ -377,7 +462,8 @@ if __name__ == '__main__':
         output_locations={},
         basename=mock_basename,
         language=mock_language,
-        file_extension=mock_extension
+        file_extension=mock_extension,
+        context_config={}
     )
     print(f"Result: {paths7}")
     # Expected: {}
@@ -389,7 +475,8 @@ if __name__ == '__main__':
         output_locations={},
         basename="complex_prompt",
         language="javascript",
-        file_extension=".js" # Ignored for split defaults
+        file_extension=".js", # Ignored for split defaults
+        context_config={}
     )
     print(f"Result: {paths8}")
     # Expected: {
@@ -404,7 +491,8 @@ if __name__ == '__main__':
         output_locations={},
         basename="feature_analysis", # Used instead of change_file_basename
         language="", # Not relevant for detect default
-        file_extension="" # Not relevant for detect default
+        file_extension="", # Not relevant for detect default
+        context_config={}
     )
     print(f"Result: {paths9}")
     # Expected: {'output': '/path/to/cwd/feature_analysis_detect.csv'}
@@ -416,7 +504,8 @@ if __name__ == '__main__':
         output_locations={},
         basename="crashed_module", # Used for both code and program defaults
         language="java",
-        file_extension=".java"
+        file_extension=".java",
+        context_config={}
     )
     print(f"Result: {paths10}")
     # Expected: {
@@ -431,7 +520,8 @@ if __name__ == '__main__':
         output_locations={},
         basename="module_to_verify",
         language="python",
-        file_extension=".py"
+        file_extension=".py",
+        context_config={}
     )
     print(f"Result: {paths11}")
     # Expected: {
@@ -449,7 +539,8 @@ if __name__ == '__main__':
         output_locations={'output_program': test_dir_verify_prog + os.path.sep},
         basename="module_to_verify",
         language="python",
-        file_extension=".py"
+        file_extension=".py",
+        context_config={}
     )
     print(f"Result: {paths12}")
     # Expected: {
@@ -468,7 +559,8 @@ if __name__ == '__main__':
         output_locations={},
         basename="another_module_verify",
         language="python",
-        file_extension=".py"
+        file_extension=".py",
+        context_config={}
     )
     print(f"Result: {paths13}")
     # Expected: {

pdd/generate_test.py

@@ -72,19 +72,34 @@ def generate_test(
         model_name = response['model_name']
         result = response['result']
 
+        # Validate that we got a non-empty result
+        if not result or not result.strip():
+            raise ValueError(f"LLM test generation returned empty result. Model: {model_name}, Cost: ${response['cost']:.6f}")
+
         if verbose:
             console.print(Markdown(result))
             console.print(f"[bold green]Initial generation cost: ${total_cost:.6f}[/bold green]")
 
         # Step 4: Check if generation is complete
         last_600_chars = result[-600:] if len(result) > 600 else result
-        reasoning, is_finished, check_cost, check_model = unfinished_prompt(
-            prompt_text=last_600_chars,
-            strength=strength,
-            temperature=temperature,
-            time=time,
-            verbose=verbose
-        )
+        
+        # Validate that the last_600_chars is not empty after stripping
+        if not last_600_chars.strip():
+            # If the tail is empty, assume generation is complete
+            if verbose:
+                console.print("[bold yellow]Last 600 chars are empty, assuming generation is complete[/bold yellow]")
+            reasoning = "Generation appears complete (tail is empty)"
+            is_finished = True
+            check_cost = 0.0
+            check_model = model_name
+        else:
+            reasoning, is_finished, check_cost, check_model = unfinished_prompt(
+                prompt_text=last_600_chars,
+                strength=strength,
+                temperature=temperature,
+                time=time,
+                verbose=verbose
+            )
         total_cost += check_cost
 
         if not is_finished:
@@ -104,15 +119,37 @@ def generate_test(
             model_name = continue_model
 
         # Process the final result
-        processed_result, post_cost, post_model = postprocess(
-            result,
-            language=language,
-            strength=EXTRACTION_STRENGTH,
-            temperature=temperature,
-            time=time,
-            verbose=verbose
-        )
-        total_cost += post_cost
+        try:
+            processed_result, post_cost, post_model = postprocess(
+                result,
+                language=language,
+                strength=EXTRACTION_STRENGTH,
+                temperature=temperature,
+                time=time,
+                verbose=verbose
+            )
+            total_cost += post_cost
+        except Exception as e:
+            console.print(f"[bold red]Postprocess failed: {str(e)}[/bold red]")
+            console.print(f"[bold yellow]Falling back to raw result[/bold yellow]")
+            
+            # Try to extract code blocks directly from the raw result
+            import re
+            code_blocks = re.findall(r'```(?:python)?\s*(.*?)```', result, re.DOTALL | re.IGNORECASE)
+            
+            if code_blocks:
+                # Use the first substantial code block
+                for block in code_blocks:
+                    if len(block.strip()) > 100 and ('def test_' in block or 'import' in block):
+                        processed_result = block.strip()
+                        break
+                else:
+                    processed_result = code_blocks[0].strip() if code_blocks else result
+            else:
+                # No code blocks found, use raw result
+                processed_result = result
+            
+            post_cost = 0.0
 
         # Step 5: Print total cost if verbose
         if verbose: