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

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:

pdd/llm_invoke.py

@@ -81,6 +81,58 @@ from pdd import DEFAULT_LLM_MODEL
 # Opt-in to future pandas behavior regarding downcasting
 pd.set_option('future.no_silent_downcasting', True)
 
+
+def _is_wsl_environment() -> bool:
+    """
+    Detect if we're running in WSL (Windows Subsystem for Linux) environment.
+    
+    Returns:
+        True if running in WSL, False otherwise
+    """
+    try:
+        # Check for WSL-specific indicators
+        if os.path.exists('/proc/version'):
+            with open('/proc/version', 'r') as f:
+                version_info = f.read().lower()
+                return 'microsoft' in version_info or 'wsl' in version_info
+        
+        # Alternative check: WSL_DISTRO_NAME environment variable
+        if os.getenv('WSL_DISTRO_NAME'):
+            return True
+            
+        # Check for Windows-style paths in PATH
+        path_env = os.getenv('PATH', '')
+        return '/mnt/c/' in path_env.lower()
+        
+    except Exception:
+        return False
+
+
+def _get_environment_info() -> Dict[str, str]:
+    """
+    Get environment information for debugging and error reporting.
+    
+    Returns:
+        Dictionary containing environment details
+    """
+    import platform
+    
+    info = {
+        'platform': platform.system(),
+        'platform_release': platform.release(),
+        'platform_version': platform.version(),
+        'architecture': platform.machine(),
+        'is_wsl': str(_is_wsl_environment()),
+        'python_version': platform.python_version(),
+    }
+    
+    # Add WSL-specific information
+    if _is_wsl_environment():
+        info['wsl_distro'] = os.getenv('WSL_DISTRO_NAME', 'unknown')
+        info['wsl_interop'] = os.getenv('WSL_INTEROP', 'not_set')
+    
+    return info
+
 # <<< SET LITELLM DEBUG LOGGING >>>
 # os.environ['LITELLM_LOG'] = 'DEBUG' # Keep commented out unless debugging LiteLLM itself
 
@@ -164,6 +216,12 @@ GCS_REGION_NAME = os.getenv("GCS_REGION_NAME", "auto") # Often 'auto' works for
 GCS_HMAC_ACCESS_KEY_ID = os.getenv("GCS_HMAC_ACCESS_KEY_ID") # Load HMAC Key ID
 GCS_HMAC_SECRET_ACCESS_KEY = os.getenv("GCS_HMAC_SECRET_ACCESS_KEY") # Load HMAC Secret
 
+# Sanitize GCS credentials to handle WSL environment issues
+if GCS_HMAC_ACCESS_KEY_ID:
+    GCS_HMAC_ACCESS_KEY_ID = GCS_HMAC_ACCESS_KEY_ID.strip()
+if GCS_HMAC_SECRET_ACCESS_KEY:
+    GCS_HMAC_SECRET_ACCESS_KEY = GCS_HMAC_SECRET_ACCESS_KEY.strip()
+
 cache_configured = False
 
 if GCS_BUCKET_NAME and GCS_HMAC_ACCESS_KEY_ID and GCS_HMAC_SECRET_ACCESS_KEY:
@@ -448,6 +506,54 @@ def _select_model_candidates(
     return candidates
 
 
+def _sanitize_api_key(key_value: str) -> str:
+    """
+    Sanitize API key by removing whitespace and carriage returns.
+    
+    This fixes WSL environment issues where API keys may contain trailing \r characters
+    that make them invalid for HTTP headers.
+    
+    Args:
+        key_value: The raw API key value from environment
+        
+    Returns:
+        Sanitized API key with whitespace and carriage returns removed
+        
+    Raises:
+        ValueError: If the API key format is invalid after sanitization
+    """
+    if not key_value:
+        return key_value
+    
+    # Strip all whitespace including carriage returns, newlines, etc.
+    sanitized = key_value.strip()
+    
+    # Additional validation: ensure no remaining control characters
+    if any(ord(c) < 32 for c in sanitized):
+        logger.warning("API key contains control characters that may cause issues")
+        # Remove any remaining control characters
+        sanitized = ''.join(c for c in sanitized if ord(c) >= 32)
+    
+    # Validate API key format (basic checks)
+    if sanitized:
+        # Check for common API key patterns
+        if len(sanitized) < 10:
+            logger.warning(f"API key appears too short ({len(sanitized)} characters) - may be invalid")
+        
+        # Check for invalid characters in API keys (should be printable ASCII)
+        if not all(32 <= ord(c) <= 126 for c in sanitized):
+            logger.warning("API key contains non-printable characters")
+            
+        # Check for WSL-specific issues (detect if original had carriage returns)
+        if key_value != sanitized and '\r' in key_value:
+            if _is_wsl_environment():
+                logger.info("Detected and fixed WSL line ending issue in API key")
+            else:
+                logger.info("Detected and fixed line ending issue in API key")
+    
+    return sanitized
+
+
 def _ensure_api_key(model_info: Dict[str, Any], newly_acquired_keys: Dict[str, bool], verbose: bool) -> bool:
     """Checks for API key in env, prompts user if missing, and updates .env."""
     key_name = model_info.get('api_key')
@@ -458,6 +564,8 @@ def _ensure_api_key(model_info: Dict[str, Any], newly_acquired_keys: Dict[str, b
         return True # Assume key is handled elsewhere or not needed
 
     key_value = os.getenv(key_name)
+    if key_value:
+        key_value = _sanitize_api_key(key_value)
 
     if key_value:
         if verbose:
@@ -473,6 +581,9 @@ def _ensure_api_key(model_info: Dict[str, Any], newly_acquired_keys: Dict[str, b
                 logger.error("No API key provided. Cannot proceed with this model.")
                 return False
 
+            # Sanitize the user-provided key
+            user_provided_key = _sanitize_api_key(user_provided_key)
+            
             # Set environment variable for the current process
             os.environ[key_name] = user_provided_key
             logger.info(f"API key '{key_name}' set for the current session.")
@@ -767,6 +878,7 @@ def llm_invoke(
             elif api_key_name_from_csv: # For other api_key_names specified in CSV (e.g., OPENAI_API_KEY, or a direct VERTEX_AI_API_KEY string)
                 key_value = os.getenv(api_key_name_from_csv)
                 if key_value:
+                    key_value = _sanitize_api_key(key_value)
                     litellm_kwargs["api_key"] = key_value
                     if verbose:
                         logger.info(f"[INFO] Explicitly passing API key from env var '{api_key_name_from_csv}' as 'api_key' parameter to LiteLLM.")
@@ -932,6 +1044,46 @@ def llm_invoke(
                     # Result (String or Pydantic)
                     try:
                         raw_result = resp_item.choices[0].message.content
+                        
+                        # Check if raw_result is None (likely cached corrupted data)
+                        if raw_result is None:
+                            logger.warning(f"[WARNING] LLM returned None content for item {i}, likely due to corrupted cache. Retrying with cache bypass...")
+                            # Retry with cache bypass by modifying the prompt slightly
+                            if not use_batch_mode and prompt and input_json is not None:
+                                # Add a small space to bypass cache
+                                modified_prompt = prompt + " "
+                                try:
+                                    retry_messages = _format_messages(modified_prompt, input_json, use_batch_mode)
+                                    # Disable cache for retry
+                                    litellm.cache = None
+                                    retry_response = litellm.completion(
+                                        model=model_name_litellm,
+                                        messages=retry_messages,
+                                        temperature=temperature,
+                                        response_format=response_format,
+                                        max_completion_tokens=max_tokens,
+                                        **time_kwargs
+                                    )
+                                    # Re-enable cache
+                                    litellm.cache = Cache()
+                                    # Extract result from retry
+                                    retry_raw_result = retry_response.choices[0].message.content
+                                    if retry_raw_result is not None:
+                                        logger.info(f"[SUCCESS] Cache bypass retry succeeded for item {i}")
+                                        raw_result = retry_raw_result
+                                    else:
+                                        logger.error(f"[ERROR] Cache bypass retry also returned None for item {i}")
+                                        results.append("ERROR: LLM returned None content even after cache bypass")
+                                        continue
+                                except Exception as retry_e:
+                                    logger.error(f"[ERROR] Cache bypass retry failed for item {i}: {retry_e}")
+                                    results.append(f"ERROR: LLM returned None content and retry failed: {retry_e}")
+                                    continue
+                            else:
+                                logger.error(f"[ERROR] Cannot retry - batch mode or missing prompt/input_json")
+                                results.append("ERROR: LLM returned None content and cannot retry")
+                                continue
+                        
                         if output_pydantic:
                             parsed_result = None
                             json_string_to_parse = None
@@ -1064,6 +1216,16 @@ def llm_invoke(
             # --- 6b. Handle Invocation Errors ---
             except openai.AuthenticationError as e:
                 last_exception = e
+                error_message = str(e)
+                
+                # Check for WSL-specific issues in authentication errors
+                if _is_wsl_environment() and ('Illegal header value' in error_message or '\r' in error_message):
+                    logger.warning(f"[WSL AUTH ERROR] Authentication failed for {model_name_litellm} - detected WSL line ending issue")
+                    logger.warning("[WSL AUTH ERROR] This is likely caused by API key environment variables containing carriage returns")
+                    logger.warning("[WSL AUTH ERROR] Try setting your API key again or check your .env file for line ending issues")
+                    env_info = _get_environment_info()
+                    logger.debug(f"Environment info: {env_info}")
+                    
                 if newly_acquired_keys.get(api_key_name):
                     logger.warning(f"[AUTH ERROR] Authentication failed for {model_name_litellm} with the newly provided key for '{api_key_name}'. Please check the key and try again.")
                     # Invalidate the key in env for this session to force re-prompt on retry