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

pdd/__init__.py

@@ -1,6 +1,6 @@
 """PDD - Prompt Driven Development"""
 
-__version__ = "0.0.42"
+__version__ = "0.0.44"
 
 # 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/construct_paths.py

@@ -392,6 +392,7 @@ def construct_paths(
     pddrc_config = {}
     context = None
     context_config = {}
+    original_context_config = {}  # Keep track of original context config for sync discovery
     
     try:
         # Find and load .pddrc file
@@ -405,6 +406,7 @@ def construct_paths(
             
             # Get context-specific configuration
             context_config = _get_context_config(pddrc_config, context)
+            original_context_config = context_config.copy()  # Store original before modifications
             
             if not quiet and context:
                 console.print(f"[info]Using .pddrc context:[/info] {context}")
@@ -451,8 +453,30 @@ def construct_paths(
             )
             # Infer base directories from a sample output path
             gen_path = Path(output_paths_str.get("generate_output_path", "src"))
-            resolved_config["prompts_dir"] = str(gen_path.parent.parent / "prompts")
-            resolved_config["code_dir"] = str(gen_path.parent)
+            
+            # First, check current working directory for prompt files matching the basename pattern
+            current_dir = Path.cwd()
+            prompt_pattern = f"{basename}_*.prompt"
+            if list(current_dir.glob(prompt_pattern)):
+                # Found prompt files in current working directory
+                resolved_config["prompts_dir"] = str(current_dir)
+                resolved_config["code_dir"] = str(current_dir)
+                if not quiet:
+                    console.print(f"[info]Found prompt files in current directory:[/info] {current_dir}")
+            else:
+                # Fall back to context-aware logic
+                # Use original_context_config to avoid checking augmented config with env vars
+                if original_context_config and any(key.endswith('_output_path') for key in original_context_config):
+                    # For configured contexts, prompts are typically at the same level as output dirs
+                    # e.g., if code goes to "pdd/", prompts should be at "prompts/" (siblings)
+                    resolved_config["prompts_dir"] = "prompts"
+                    resolved_config["code_dir"] = str(gen_path.parent)
+                else:
+                    # For default contexts, maintain relative relationship 
+                    # e.g., if code goes to "pi.py", prompts should be at "prompts/" (siblings)
+                    resolved_config["prompts_dir"] = str(gen_path.parent / "prompts")
+                    resolved_config["code_dir"] = str(gen_path.parent)
+            
             resolved_config["tests_dir"] = str(Path(output_paths_str.get("test_output_path", "tests")).parent)
             resolved_config["examples_dir"] = str(Path(output_paths_str.get("example_output_path", "examples")).parent)
 

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()

pdd/prompts/extract_program_code_fix_LLM.prompt

@@ -1,4 +1,10 @@
-% You are an expert Software Engineer. Your goal is to extract a JSON from a analysis of a program and code module bug fix report. If there is a choice of updating the program or the code module, you should chose to update the code module.
+% You are an expert Software Engineer. Your goal is to extract a JSON from a analysis of a program and code module bug fix report. 
+
+% IMPORTANT: The crash command is designed to fix errors in BOTH the code module AND the calling program that caused the crash. You should fix whatever needs to be fixed to make the program run successfully:
+- If the code module has bugs, fix the code module
+- If the calling program has bugs, fix the calling program  
+- If both have issues that contribute to the crash, fix BOTH
+- The goal is to ensure the program runs without errors after the fix
 
 % Here is the original program: <program>{program}</program>
 

pdd/prompts/fix_code_module_errors_LLM.prompt

@@ -1,4 +1,10 @@
-% You are an expert Software Engineer. Your goal is to fix the errors in a code_module or program that is causing that program to crash.
+% You are an expert Software Engineer. Your goal is to fix the errors in a code_module AND/OR program that is causing that program to crash.
+
+% IMPORTANT: The crash command should fix whatever needs to be fixed to make the program run successfully:
+- If the code module has bugs, fix the code module
+- If the calling program has bugs, fix the calling program  
+- If both have issues that contribute to the crash, fix BOTH
+- The goal is to ensure the program runs without errors after all fixes are applied
 
 % Here is the program that is running the code_module that crashed and/or has errors: <program>{program}</program>
 
@@ -41,6 +47,10 @@
     Step 1. Compare the prompt to the code_module and explain differences, if any.
     Step 2. Compare the prompt to the program and explain differences, if any.
     Step 3. Explain in detail step by step why there might be an an error and why prior attempted fixes, if any, may not have worked. Write several paragraphs explaining the root cause of each of the errors.
-    Step 4. Explain in detail step by step how to solve each of the errors. For each error, there should be several paragraphs description of the steps. Sometimes logging or print statements can help debug the code_module or program.
+    Step 4. Explain in detail step by step how to solve each of the errors. For each error, there should be several paragraphs description of the steps. Consider whether the fix requires:
+        - Updating the code_module only
+        - Updating the calling program only  
+        - Updating BOTH the code_module AND the calling program
+        Sometimes logging or print statements can help debug the code_module or program.
     Step 5. Review the above steps and correct for any errors in the logic.
-    Step 6. For the code that need changes, write the corrected code_module and/or corrected program in its/their entirety.
+    Step 6. For ALL code that needs changes, write the corrected code_module and/or corrected program in their entirety. If both need fixes, provide both complete fixed versions.

pdd/pytest_output.py

@@ -3,9 +3,11 @@ import json
 import io
 import sys
 import pytest
+import subprocess
 from rich.console import Console
 from rich.pretty import pprint
 import os
+from .python_env_detector import detect_host_python_executable
 
 console = Console()
 
@@ -80,27 +82,77 @@ def run_pytest_and_capture_output(test_file: str) -> dict:
         )
         return {}
 
-    collector = TestResultCollector()
+    # Use environment-aware Python executable for pytest execution
+    python_executable = detect_host_python_executable()
+    
     try:
-        collector.capture_logs()
-        result = pytest.main([test_file], plugins=[collector])
-    finally:
-        stdout, stderr = collector.get_logs()
-
-    return {
-        "test_file": test_file,
-        "test_results": [
-            {
-                "standard_output": stdout,
-                "standard_error": stderr,
-                "return_code": int(result),
-                "warnings": collector.warnings,
-                "errors": collector.errors,
-                "failures": collector.failures,
-                "passed": collector.passed,
-            }
-        ],
-    }
+        # Run pytest using subprocess with the detected Python executable
+        result = subprocess.run(
+            [python_executable, "-m", "pytest", test_file, "-v"],
+            capture_output=True,
+            text=True,
+            timeout=300
+        )
+        
+        stdout = result.stdout
+        stderr = result.stderr
+        return_code = result.returncode
+        
+        # Parse the output to extract test results
+        # Count passed, failed, and skipped tests from the output
+        passed = stdout.count(" PASSED")
+        failures = stdout.count(" FAILED") + stdout.count(" ERROR")
+        errors = 0  # Will be included in failures for subprocess execution
+        warnings = stdout.count("warning")
+        
+        # If return code is 2, it indicates a pytest error
+        if return_code == 2:
+            errors = 1
+        
+        return {
+            "test_file": test_file,
+            "test_results": [
+                {
+                    "standard_output": stdout,
+                    "standard_error": stderr,
+                    "return_code": return_code,
+                    "warnings": warnings,
+                    "errors": errors,
+                    "failures": failures,
+                    "passed": passed,
+                }
+            ],
+        }
+    except subprocess.TimeoutExpired:
+        return {
+            "test_file": test_file,
+            "test_results": [
+                {
+                    "standard_output": "",
+                    "standard_error": "Test execution timed out",
+                    "return_code": -1,
+                    "warnings": 0,
+                    "errors": 1,
+                    "failures": 0,
+                    "passed": 0,
+                }
+            ],
+        }
+    except Exception as e:
+        return {
+            "test_file": test_file,
+            "test_results": [
+                {
+                    "standard_output": "",
+                    "standard_error": f"Error running pytest: {str(e)}",
+                    "return_code": -1,
+                    "warnings": 0,
+                    "errors": 1,
+                    "failures": 0,
+                    "passed": 0,
+                }
+            ],
+        }
 
 def save_output_to_json(output: dict, output_file: str = "pytest.json"):
     """