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

pdd/__init__.py

@@ -1,6 +1,6 @@
 """PDD - Prompt Driven Development"""
 
-__version__ = "0.0.43"
+__version__ = "0.0.45"
 
 # Strength parameter used for LLM extraction across the codebase
 # Used in postprocessing, XML tagging, code generation, and other extraction

pdd/cli.py

@@ -362,7 +362,7 @@ def example(
     "--target-coverage",
     type=click.FloatRange(0.0, 100.0),
     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).",
+    help="Desired code coverage percentage (default: 10.0 or PDD_TEST_COVERAGE_TARGET).",
 )
 @click.option(
     "--merge",
@@ -1130,7 +1130,7 @@ def verify(
 @click.option(
     "--target-coverage",
     type=click.FloatRange(0.0, 100.0),
-    default=90.0,
+    default=10.0,
     show_default=True,
     help="Target code coverage percentage for generated tests.",
 )

pdd/cmd_test_main.py

@@ -155,6 +155,15 @@ def cmd_test_main(
         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]")
+        ctx.exit(1)
+        return "", 0.0, ""
+    
     try:
         with open(output_file, "w", encoding="utf-8") as file_handle:
             file_handle.write(unit_test)

pdd/data/language_format.csv

@@ -31,6 +31,7 @@ Dart,//,.dart
 F#,//,.fs
 YAML,#,.yml
 JSON,del,.json
+JSONL,del,.jsonl
 XML,"<!-- -->",.xml
 Makefile,#,
 CSV,del,.csv

pdd/data/llm_model.csv

@@ -3,8 +3,8 @@ OpenAI,gpt-4.1-nano,0.1,0.4,1249,,OPENAI_API_KEY,0,True,none
 xai,xai/grok-3-beta,3.0,15.0,1332,https://api.x.ai/v1,XAI_API_KEY,0,False,none
 Anthropic,claude-3-5-haiku-20241022,.8,4,1261,,ANTHROPIC_API_KEY,0,True,none
 OpenAI,deepseek/deepseek-chat,.27,1.1,1353,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,0,False,none
-Google,vertex_ai/gemini-2.5-flash-preview-04-17,0.15,0.6,1330,,VERTEX_CREDENTIALS,0,True,effort
-Google,gemini-2.5-pro-exp-03-25,1.25,10.0,1360,,GOOGLE_API_KEY,0,True,none
+Google,vertex_ai/gemini-2.5-flash,0.15,0.6,1330,,VERTEX_CREDENTIALS,0,True,effort
+Google,gemini-2.5-pro,1.25,10.0,1360,,GOOGLE_API_KEY,0,True,none
 Anthropic,claude-sonnet-4-20250514,3.0,15.0,1340,,ANTHROPIC_API_KEY,64000,True,budget
 Google,vertex_ai/gemini-2.5-pro,1.25,10.0,1361,,VERTEX_CREDENTIALS,0,True,none
 OpenAI,o4-mini,1.1,4.4,1333,,OPENAI_API_KEY,0,True,effort

pdd/fix_code_loop.py

@@ -3,7 +3,7 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Tuple
+from typing import Tuple, Optional, Union
 from . import DEFAULT_TIME # Added DEFAULT_TIME
 
 # Use Rich for pretty printing to the console
@@ -38,7 +38,7 @@ def fix_code_loop(
     error_log_file: str,
     verbose: bool = False,
     time: float = DEFAULT_TIME,
-) -> Tuple[bool, str, str, int, float, str | None]:
+) -> Tuple[bool, str, str, int, float, Optional[str]]:
     """
     Attempts to fix errors in a code module through multiple iterations.
 

pdd/fix_error_loop.py

@@ -12,6 +12,7 @@ from rich.console import Console
 # Relative import from an internal module.
 from .fix_errors_from_unit_tests import fix_errors_from_unit_tests
 from . import DEFAULT_TIME # Import DEFAULT_TIME
+from .python_env_detector import detect_host_python_executable
 
 console = Console()
 
@@ -26,7 +27,9 @@ def run_pytest_on_file(test_file: str) -> tuple[int, int, int, str]:
     """
     try:
         # Include "--json-only" to ensure only valid JSON is printed.
-        cmd = [sys.executable, "-m", "pdd.pytest_output", "--json-only", test_file]
+        # Use environment-aware Python executable for pytest execution
+        python_executable = detect_host_python_executable()
+        cmd = [python_executable, "-m", "pdd.pytest_output", "--json-only", test_file]
         result = subprocess.run(cmd, capture_output=True, text=True)
         
         # Parse the JSON output from stdout
@@ -380,7 +383,7 @@ def fix_error_loop(unit_test_file: str,
 
             # Run the verification:
             try:
-                verify_cmd = [sys.executable, verification_program]
+                verify_cmd = [detect_host_python_executable(), verification_program]
                 verify_result = subprocess.run(verify_cmd, capture_output=True, text=True)
                 # Safely handle None for stdout or stderr:
                 verify_stdout = verify_result.stdout or ""

pdd/fix_verification_errors_loop.py

@@ -2,6 +2,7 @@ import os
 import shutil
 import subprocess
 import datetime
+import sys
 from pathlib import Path
 from typing import Dict, Tuple, Any, Optional
 from xml.sax.saxutils import escape
@@ -25,6 +26,7 @@ except ImportError:
         )
 
 from . import DEFAULT_TIME # Import DEFAULT_TIME
+from .python_env_detector import detect_host_python_executable
 
 # Initialize Rich Console for pretty printing
 console = Console()
@@ -49,19 +51,30 @@ def _run_program(
     if not program_path.is_file():
         return -1, f"Error: Program file not found at {program_path}"
 
-    command = ["python", str(program_path)]
+    command = [detect_host_python_executable(), str(program_path)]
     if args:
         command.extend(args)
 
     try:
+        # Run from staging root directory instead of examples/ directory
+        # This allows imports from both pdd/ and examples/ subdirectories
+        staging_root = program_path.parent.parent  # Go up from examples/ to staging root
+        
         result = subprocess.run(
             command,
             capture_output=True,
             text=True,
             timeout=timeout,
             check=False,  # Don't raise exception for non-zero exit codes
+            env=os.environ.copy(),  # Pass current environment variables
+            cwd=staging_root  # Set working directory to staging root
         )
         combined_output = result.stdout + result.stderr
+        
+        # Check for syntax errors
+        if result.returncode != 0 and "SyntaxError" in result.stderr:
+            return result.returncode, f"SYNTAX_ERROR: {combined_output}"
+        
         return result.returncode, combined_output
     except FileNotFoundError:
         return -1, f"Error: Python interpreter not found or '{program_path}' not found."

pdd/fix_verification_main.py

@@ -17,6 +17,7 @@ from .fix_verification_errors import fix_verification_errors
 from .fix_verification_errors_loop import fix_verification_errors_loop
 # Import DEFAULT_STRENGTH from the main package
 from . import DEFAULT_STRENGTH, DEFAULT_TIME
+from .python_env_detector import detect_host_python_executable
 
 # Default values from the README
 DEFAULT_TEMPERATURE = 0.0
@@ -48,7 +49,7 @@ def run_program(program_path: str, args: List[str] = []) -> Tuple[bool, str, str
         # A more robust solution might use the 'language' from construct_paths
         interpreter = []
         if program_path.endswith(".py"):
-            interpreter = [sys.executable] # Use the current Python interpreter
+            interpreter = [detect_host_python_executable()] # Use environment-aware Python executable
         elif program_path.endswith(".js"):
             interpreter = ["node"]
         elif program_path.endswith(".sh"):
@@ -57,13 +58,21 @@ def run_program(program_path: str, args: List[str] = []) -> Tuple[bool, str, str
 
         command = interpreter + [program_path] + args
         rich_print(f"[dim]Running command:[/dim] {' '.join(command)}")
+        rich_print(f"[dim]Working directory:[/dim] {os.path.dirname(program_path) if program_path else 'None'}")
+        rich_print(f"[dim]Environment PYTHONPATH:[/dim] {os.environ.get('PYTHONPATH', 'Not set')}")
 
+        # Create a copy of environment with PYTHONUNBUFFERED set
+        env = os.environ.copy()
+        env['PYTHONUNBUFFERED'] = '1'  # Force unbuffered output
+        
         process = subprocess.run(
             command,
             capture_output=True,
             text=True,
             check=False, # Don't raise exception on non-zero exit code
-            timeout=60 # Add a timeout to prevent hangs
+            timeout=60, # Add a timeout to prevent hangs
+            env=env, # Pass modified environment variables
+            cwd=os.path.dirname(program_path) if program_path else None # Set working directory
         )
 
         success = process.returncode == 0
@@ -71,11 +80,17 @@ def run_program(program_path: str, args: List[str] = []) -> Tuple[bool, str, str
         stderr = process.stderr
 
         if not success:
-             rich_print(f"[yellow]Warning:[/yellow] Program '{os.path.basename(program_path)}' exited with code {process.returncode}.")
-             if stderr:
-                 rich_print("[yellow]Stderr:[/yellow]")
-                 rich_print(Panel(stderr, border_style="yellow"))
-
+            rich_print(f"[yellow]Warning:[/yellow] Program '{os.path.basename(program_path)}' exited with code {process.returncode}.")
+            
+            # Check for syntax errors specifically
+            if "SyntaxError" in stderr:
+                rich_print("[bold red]Syntax Error Detected:[/bold red]")
+                rich_print(Panel(stderr, border_style="red", title="Python Syntax Error"))
+                # Return with special indicator for syntax errors
+                return False, stdout, f"SYNTAX_ERROR: {stderr}"
+            elif stderr:
+                rich_print("[yellow]Stderr:[/yellow]")
+                rich_print(Panel(stderr, border_style="yellow"))
 
         return success, stdout, stderr
 
@@ -354,7 +369,13 @@ def fix_verification_main(
             results_log_content += f"Model Used: {model_name}\n"
             results_log_content += f"Total Cost: ${total_cost:.6f}\n"
             results_log_content += "\n--- LLM Explanation ---\n"
-            results_log_content += "\n".join(fix_results.get('explanation', ['N/A']))
+            # The original code here was:
+            # results_log_content += "\n".join(fix_results.get('explanation', ['N/A']))
+            # This was incorrect because fix_results['explanation'] is a single string.
+            # The list constructor would then iterate through it character-by-character,
+            # causing the single-character-per-line output.
+            # The fix is to just append the string directly, using a default value if it is None.
+            results_log_content += fix_results.get('explanation') or 'N/A'
             results_log_content += "\n\n--- Program Output Used for Verification ---\n"
             results_log_content += program_output
 

pdd/get_jwt_token.py

@@ -2,7 +2,20 @@ import asyncio
 import time
 from typing import Dict, Optional, Tuple
 
-import keyring
+# Cross-platform keyring import with fallback for WSL compatibility
+try:
+    import keyring
+    KEYRING_AVAILABLE = True
+except ImportError:
+    try:
+        import keyrings.alt.file
+        keyring = keyrings.alt.file.PlaintextKeyring()
+        KEYRING_AVAILABLE = True
+        print("Warning: Using alternative keyring (PlaintextKeyring) - tokens stored in plaintext")
+    except ImportError:
+        keyring = None
+        KEYRING_AVAILABLE = False
+        print("Warning: No keyring available - token storage disabled")
 import requests
 
 # Custom exception classes for better error handling
@@ -128,20 +141,39 @@ class FirebaseAuthenticator:
 
     def _store_refresh_token(self, refresh_token: str):
         """Stores the Firebase refresh token in the system keyring."""
-        keyring.set_password(self.keyring_service_name, self.keyring_user_name, refresh_token)
+        if not KEYRING_AVAILABLE or keyring is None:
+            print("Warning: No keyring available, refresh token not stored")
+            return
+        try:
+            keyring.set_password(self.keyring_service_name, self.keyring_user_name, refresh_token)
+        except Exception as e:
+            print(f"Warning: Failed to store refresh token in keyring: {e}")
 
     def _get_stored_refresh_token(self) -> Optional[str]:
         """Retrieves the Firebase refresh token from the system keyring."""
-        return keyring.get_password(self.keyring_service_name, self.keyring_user_name)
+        if not KEYRING_AVAILABLE or keyring is None:
+            return None
+        try:
+            return keyring.get_password(self.keyring_service_name, self.keyring_user_name)
+        except Exception as e:
+            print(f"Warning: Failed to retrieve refresh token from keyring: {e}")
+            return None
 
     def _delete_stored_refresh_token(self):
         """Deletes the stored Firebase refresh token from the keyring."""
+        if not KEYRING_AVAILABLE or keyring is None:
+            print("No keyring available. Token deletion skipped.")
+            return
         try:
             keyring.delete_password(self.keyring_service_name, self.keyring_user_name)
-        except keyring.errors.NoKeyringError:
-            print("No keyring found. Token deletion skipped.")
-        except keyring.errors.PasswordDeleteError:
-            print("Failed to delete token from keyring.")
+        except Exception as e:
+            # Handle both keyring.errors and generic exceptions for cross-platform compatibility
+            if "NoKeyringError" in str(type(e)) or "no keyring" in str(e).lower():
+                print("No keyring found. Token deletion skipped.")
+            elif "PasswordDeleteError" in str(type(e)) or "delete" in str(e).lower():
+                print("Failed to delete token from keyring.")
+            else:
+                print(f"Warning: Error deleting token from keyring: {e}")
 
     async def _refresh_firebase_token(self, refresh_token: str) -> str:
         """

pdd/increase_tests.py

@@ -78,6 +78,13 @@ def increase_tests(
             time=time,
             verbose=verbose
         )
+        
+        # Debug: Check LLM response
+        console.print(f"[blue]DEBUG increase_tests: LLM response type: {type(llm_response)}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM response keys: {llm_response.keys() if isinstance(llm_response, dict) else 'Not a dict'}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM result type: {type(llm_response.get('result', 'No result key'))}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM result length: {len(llm_response['result']) if 'result' in llm_response and llm_response['result'] else 0}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM result preview: {repr(llm_response['result'][:300]) if 'result' in llm_response and llm_response['result'] else 'Empty or no result'}[/blue]")
 
         increase_test_function, total_cost, model_name = postprocess(
             llm_response['result'], 

pdd/llm_invoke.py

@@ -79,7 +79,11 @@ import time as time_module # Alias to avoid conflict with 'time' parameter
 from pdd import DEFAULT_LLM_MODEL
 
 # Opt-in to future pandas behavior regarding downcasting
-pd.set_option('future.no_silent_downcasting', True)
+try:
+    pd.set_option('future.no_silent_downcasting', True)
+except pd._config.config.OptionError:
+    # Skip if option doesn't exist in older pandas versions
+    pass
 
 
 def _is_wsl_environment() -> bool:
@@ -152,8 +156,8 @@ if PDD_PATH_ENV:
 
 if PROJECT_ROOT is None: # If PDD_PATH wasn't set or was invalid
     try:
-        # Start from the directory containing this script
-        current_dir = Path(__file__).resolve().parent
+        # Start from the current working directory (where user is running PDD)
+        current_dir = Path.cwd().resolve()
         # Look for project markers (e.g., .git, pyproject.toml, data/, .env)
         # Go up a maximum of 5 levels to prevent infinite loops
         for _ in range(5):
@@ -164,7 +168,7 @@ if PROJECT_ROOT is None: # If PDD_PATH wasn't set or was invalid
 
             if has_git or has_pyproject or has_data or has_dotenv:
                 PROJECT_ROOT = current_dir
-                logger.debug(f"Determined PROJECT_ROOT by marker search: {PROJECT_ROOT}")
+                logger.debug(f"Determined PROJECT_ROOT by marker search from CWD: {PROJECT_ROOT}")
                 break
 
             parent_dir = current_dir.parent
@@ -172,10 +176,8 @@ if PROJECT_ROOT is None: # If PDD_PATH wasn't set or was invalid
                 break
             current_dir = parent_dir
 
-    except NameError: # __file__ might not be defined (e.g., interactive session)
-        warnings.warn("__file__ not defined. Cannot automatically detect project root from script location.")
     except Exception as e: # Catch potential permission errors etc.
-        warnings.warn(f"Error during project root auto-detection: {e}")
+        warnings.warn(f"Error during project root auto-detection from current working directory: {e}")
 
 if PROJECT_ROOT is None: # Fallback to CWD if no method succeeded
     PROJECT_ROOT = Path.cwd().resolve()