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

pdd/__init__.py

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

pdd/cli.py

@@ -34,6 +34,7 @@ from .fix_main import fix_main
 from .fix_verification_main import fix_verification_main
 from .install_completion import install_completion, get_local_pdd_path
 from .preprocess_main import preprocess_main
+from .pytest_output import run_pytest_and_capture_output
 from .split_main import split_main
 from .sync_main import sync_main
 from .trace_main import trace_main
@@ -1176,6 +1177,47 @@ def sync(
         return None
 
 
+@cli.command("pytest-output")
+@click.argument("test_file", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--json-only",
+    is_flag=True,
+    default=False,
+    help="Output only JSON to stdout for programmatic use.",
+)
+@click.pass_context
+# No @track_cost since this is a utility command
+def pytest_output_cmd(ctx: click.Context, test_file: str, json_only: bool) -> None:
+    """Run pytest on a test file and capture structured output.
+    
+    This is a utility command used internally by PDD for capturing pytest results
+    in a structured format. It can also be used directly for debugging test issues.
+    
+    Examples:
+        pdd pytest-output tests/test_example.py
+        pdd pytest-output tests/test_example.py --json-only
+    """
+    command_name = "pytest-output"
+    quiet_mode = ctx.obj.get("quiet", False)
+
+    try:
+        import json
+        pytest_output = run_pytest_and_capture_output(test_file)
+        
+        if json_only:
+            # Print only valid JSON to stdout for programmatic use
+            print(json.dumps(pytest_output))
+        else:
+            # Pretty print the output for interactive use
+            if not quiet_mode:
+                console.print(f"Running pytest on: [blue]{test_file}[/blue]")
+                from rich.pretty import pprint
+                pprint(pytest_output, console=console)
+                
+    except Exception as e:
+        handle_error(e, command_name, quiet_mode)
+
+
 @cli.command("install_completion")
 @click.pass_context
 # No @track_cost

pdd/cmd_test_main.py

@@ -3,6 +3,7 @@ Main entry point for the 'test' command.
 """
 from __future__ import annotations
 import click
+from pathlib import Path
 # pylint: disable=redefined-builtin
 from rich import print
 
@@ -165,6 +166,10 @@ def cmd_test_main(
         return "", 0.0, ""
     
     try:
+        # Ensure parent directory exists
+        output_path = Path(output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
         with open(output_file, "w", encoding="utf-8") as file_handle:
             file_handle.write(unit_test)
         print(f"[bold green]Unit tests saved to:[/bold green] {output_file}")

pdd/construct_paths.py

@@ -497,11 +497,15 @@ def construct_paths(
     for key, path_str in input_file_paths.items():
         try:
             path = Path(path_str).expanduser()
-            # Resolve non-error files strictly first
+            # Resolve non-error files strictly first, but be more lenient for sync command
             if key != "error_file":
-                 # Let FileNotFoundError propagate naturally if path doesn't exist
-                 resolved_path = path.resolve(strict=True)
-                 input_paths[key] = resolved_path
+                 # For sync command, be more tolerant of non-existent files since we're just determining paths
+                 if command == "sync":
+                     input_paths[key] = path.resolve()
+                 else:
+                     # Let FileNotFoundError propagate naturally if path doesn't exist
+                     resolved_path = path.resolve(strict=True)
+                     input_paths[key] = resolved_path
             else:
                  # Resolve error file non-strictly, existence checked later
                  input_paths[key] = path.resolve()
@@ -531,9 +535,14 @@ def construct_paths(
 
         # Check existence again, especially for error_file which might have been created
         if not path.exists():
-             # This case should ideally be caught by resolve(strict=True) earlier for non-error files
-             # Raise standard FileNotFoundError
-             raise FileNotFoundError(f"{path}")
+             # For sync command, be more tolerant of non-existent files since we're just determining paths
+             if command == "sync":
+                 # Skip reading content for non-existent files in sync mode
+                 continue
+             else:
+                 # This case should ideally be caught by resolve(strict=True) earlier for non-error files
+                 # Raise standard FileNotFoundError
+                 raise FileNotFoundError(f"{path}")
 
         if path.is_file(): # Read only if it's a file
              try:

pdd/fix_error_loop.py

@@ -26,15 +26,46 @@ def run_pytest_on_file(test_file: str) -> tuple[int, int, int, str]:
     Returns a tuple: (failures, errors, warnings, logs)
     """
     try:
-        # Include "--json-only" to ensure only valid JSON is printed.
-        # 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]
+        # Try using the pdd pytest-output command first (works with uv tool installs)
+        cmd = ["pdd", "pytest-output", "--json-only", test_file]
         result = subprocess.run(cmd, capture_output=True, text=True)
         
+        # If pdd command failed, try fallback approaches
+        if result.returncode != 0 and ("command not found" in result.stderr.lower() or "not found" in result.stderr.lower()):
+            # Fallback 1: Try direct function call (fastest for development)
+            try:
+                from .pytest_output import run_pytest_and_capture_output
+                pytest_output = run_pytest_and_capture_output(test_file)
+                result_stdout = json.dumps(pytest_output)
+                result = type('MockResult', (), {'stdout': result_stdout, 'stderr': '', 'returncode': 0})()
+            except ImportError:
+                # Fallback 2: Try python -m approach for development installs where pdd isn't in PATH
+                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
         try:
-            output = json.loads(result.stdout)
+            # Extract just the JSON part from stdout (handles CLI contamination)
+            stdout_clean = result.stdout
+            json_start = stdout_clean.find('{')
+            if json_start == -1:
+                raise json.JSONDecodeError("No JSON found in output", stdout_clean, 0)
+            
+            # Find the end of the JSON object by counting braces
+            brace_count = 0
+            json_end = json_start
+            for i, char in enumerate(stdout_clean[json_start:], json_start):
+                if char == '{':
+                    brace_count += 1
+                elif char == '}':
+                    brace_count -= 1
+                    if brace_count == 0:
+                        json_end = i + 1
+                        break
+            
+            json_str = stdout_clean[json_start:json_end]
+            output = json.loads(json_str)
             test_results = output.get('test_results', [{}])[0]
             
             # Check pytest's return code first

pdd/llm_invoke.py

@@ -5,6 +5,7 @@ import os
 import pandas as pd
 import litellm
 import logging # ADDED FOR DETAILED LOGGING
+import importlib.resources
 
 # --- Configure Standard Python Logging ---
 logger = logging.getLogger("pdd.llm_invoke")
@@ -190,12 +191,20 @@ ENV_PATH = PROJECT_ROOT / ".env"
 user_pdd_dir = Path.home() / ".pdd"
 user_model_csv_path = user_pdd_dir / "llm_model.csv"
 
+# Check in order: user-specific, project-specific, package default
 if user_model_csv_path.is_file():
     LLM_MODEL_CSV_PATH = user_model_csv_path
     logger.info(f"Using user-specific LLM model CSV: {LLM_MODEL_CSV_PATH}")
 else:
-    LLM_MODEL_CSV_PATH = PROJECT_ROOT / "data" / "llm_model.csv"
-    logger.info(f"Using project LLM model CSV: {LLM_MODEL_CSV_PATH}")
+    # Check project-specific location (.pdd directory)
+    project_model_csv_path = PROJECT_ROOT / ".pdd" / "llm_model.csv"
+    if project_model_csv_path.is_file():
+        LLM_MODEL_CSV_PATH = project_model_csv_path
+        logger.info(f"Using project-specific LLM model CSV: {LLM_MODEL_CSV_PATH}")
+    else:
+        # Neither exists, we'll use a marker path that _load_model_data will handle
+        LLM_MODEL_CSV_PATH = None
+        logger.info("No local LLM model CSV found, will use package default")
 # ---------------------------------
 
 # Load environment variables from .env file
@@ -356,12 +365,41 @@ litellm.success_callback = [_litellm_success_callback]
 
 # --- Helper Functions ---
 
-def _load_model_data(csv_path: Path) -> pd.DataFrame:
-    """Loads and preprocesses the LLM model data from CSV."""
-    if not csv_path.exists():
-        raise FileNotFoundError(f"LLM model CSV not found at {csv_path}")
+def _load_model_data(csv_path: Optional[Path]) -> pd.DataFrame:
+    """Loads and preprocesses the LLM model data from CSV.
+    
+    Args:
+        csv_path: Path to CSV file, or None to use package default
+        
+    Returns:
+        DataFrame with model configuration data
+    """
+    # If csv_path is provided, try to load from it
+    if csv_path is not None:
+        if not csv_path.exists():
+            logger.warning(f"Specified LLM model CSV not found at {csv_path}, trying package default")
+            csv_path = None
+        else:
+            try:
+                df = pd.read_csv(csv_path)
+                logger.debug(f"Loaded model data from {csv_path}")
+                # Continue with the rest of the function...
+            except Exception as e:
+                logger.warning(f"Failed to load CSV from {csv_path}: {e}, trying package default")
+                csv_path = None
+    
+    # If csv_path is None or loading failed, use package default
+    if csv_path is None:
+        try:
+            # Use importlib.resources to load the packaged CSV
+            csv_data = importlib.resources.files('pdd').joinpath('data/llm_model.csv').read_text()
+            import io
+            df = pd.read_csv(io.StringIO(csv_data))
+            logger.info("Loaded model data from package default")
+        except Exception as e:
+            raise FileNotFoundError(f"Failed to load default LLM model CSV from package: {e}")
+    
     try:
-        df = pd.read_csv(csv_path)
         # Basic validation and type conversion
         required_cols = ['provider', 'model', 'input', 'output', 'coding_arena_elo', 'api_key', 'structured_output', 'reasoning_type']
         for col in required_cols: