pdd-cli 0.0.46__py3-none-any.whl → 0.0.48__py3-none-any.whl

pdd/__init__.py

@@ -1,6 +1,6 @@
 """PDD - Prompt Driven Development"""
 
-__version__ = "0.0.46"
+__version__ = "0.0.48"
 
 # 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
 
@@ -146,8 +147,20 @@ def cmd_test_main(
             ctx.exit(1)
             return "", 0.0, ""
 
-    # Handle output - prioritize orchestration output path over construct_paths result
-    output_file = output or output_file_paths["output"]
+    # Handle output - if output is a directory, use resolved file path from construct_paths
+    resolved_output = output_file_paths["output"]
+    if output is None:
+        output_file = resolved_output
+    else:
+        try:
+            is_dir_hint = output.endswith('/')
+        except Exception:
+            is_dir_hint = False
+        # Prefer resolved file if user passed a directory path
+        if is_dir_hint or (Path(output).exists() and Path(output).is_dir()):
+            output_file = resolved_output
+        else:
+            output_file = output
     if merge and existing_tests:
         output_file = existing_tests
 
@@ -165,6 +178,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/code_generator_main.py

@@ -165,8 +165,19 @@ def code_generator_main(
             command_options=command_options,
         )
         prompt_content = input_strings["prompt_file"]
-        # Prioritize orchestration output path over construct_paths result
-        output_path = output or output_file_paths.get("output")
+        # Determine final output path: if user passed a directory, use resolved file path
+        resolved_output = output_file_paths.get("output")
+        if output is None:
+            output_path = resolved_output
+        else:
+            try:
+                is_dir_hint = output.endswith(os.path.sep) or output.endswith("/")
+            except Exception:
+                is_dir_hint = False
+            if is_dir_hint or os.path.isdir(output):
+                output_path = resolved_output
+            else:
+                output_path = output
 
     except FileNotFoundError as e:
         console.print(f"[red]Error: Input file not found: {e.filename}[/red]")
@@ -442,4 +453,4 @@ def code_generator_main(
         if verbose: console.print(traceback.format_exc())
         return "", was_incremental_operation, total_cost, "error"
         
-    return generated_code_content or "", was_incremental_operation, total_cost, model_name
+    return generated_code_content or "", was_incremental_operation, total_cost, model_name

pdd/construct_paths.py

@@ -181,47 +181,29 @@ def _candidate_prompt_path(input_files: Dict[str, Path]) -> Path | None:
 
 # New helper function to check if a language is known
 def _is_known_language(language_name: str) -> bool:
-    """Checks if a language name is present in the language_format.csv."""
+    """Return True if the language is recognized.
+
+    Prefer CSV in PDD_PATH if available; otherwise fall back to a built-in set
+    so basename/language inference does not fail when PDD_PATH is unset.
+    """
+    language_name_lower = (language_name or "").lower()
+    if not language_name_lower:
+        return False
+
+    builtin_languages = {
+        'python', 'javascript', 'typescript', 'java', 'cpp', 'c', 'go', 'ruby', 'rust',
+        'kotlin', 'swift', 'csharp', 'php', 'scala', 'r', 'lua', 'perl', 'bash', 'shell',
+        'powershell', 'sql', 'prompt', 'html', 'css', 'makefile'
+    }
+
     pdd_path_str = os.getenv('PDD_PATH')
     if not pdd_path_str:
-        # Consistent with get_extension, raise ValueError if PDD_PATH is not set.
-        # Or, for an internal helper, we might decide to log and return False,
-        # but raising an error for missing config is generally safer.
-        # However, _determine_language (the caller) already raises ValueError
-        # if language cannot be found, so this path might not be strictly necessary
-        # if we assume PDD_PATH is validated earlier or by other get_extension/get_language calls.
-        # For robustness here, let's keep a check but perhaps make it less severe if called internally.
-        # For now, align with how get_extension might handle it.
-        # console.print("[error]PDD_PATH environment variable is not set. Cannot validate language.", style="error")
-        # return False # Or raise error
-        # Given this is internal and other functions (get_extension) already depend on PDD_PATH,
-        # we can assume if those ran, PDD_PATH is set. If not, they'd fail first.
-        # So, we can simplify or rely on that pre-condition.
-        # Let's assume PDD_PATH will be set if other language functions are working.
-        # If it's critical, an explicit check and raise ValueError is better.
-        # For now, let's proceed assuming PDD_PATH is available if this point is reached.
-        pass # Assuming PDD_PATH is checked by get_extension/get_language if they are called
-
-    # If PDD_PATH is not set, this will likely fail earlier if get_extension/get_language are used.
-    # If we want this helper to be fully independent, it needs robust PDD_PATH handling.
-    # Let's assume for now, PDD_PATH is available if this point is reached through normal flow.
-    
-    # Re-evaluate: PDD_PATH is critical for this function. Let's keep the check.
-    if not pdd_path_str:
-        # This helper might be called before get_extension in some logic paths
-        # if _determine_language prioritizes suffix checking first.
-        # So, it needs its own PDD_PATH check.
-        # Raise ValueError to be consistent with get_extension's behavior.
-        raise ValueError("PDD_PATH environment variable is not set. Cannot validate language.")
+        return language_name_lower in builtin_languages
 
     csv_file_path = Path(pdd_path_str) / 'data' / 'language_format.csv'
-    
     if not csv_file_path.is_file():
-        # Raise FileNotFoundError if CSV is missing, consistent with get_extension
-        raise FileNotFoundError(f"The language format CSV file does not exist: {csv_file_path}")
-            
-    language_name_lower = language_name.lower()
-    
+        return language_name_lower in builtin_languages
+
     try:
         with open(csv_file_path, mode='r', encoding='utf-8', newline='') as csvfile:
             reader = csv.DictReader(csvfile)
@@ -229,10 +211,10 @@ def _is_known_language(language_name: str) -> bool:
                 if row.get('language', '').lower() == language_name_lower:
                     return True
     except csv.Error as e:
-        # Log and return False or raise a custom error
         console.print(f"[error]CSV Error reading {csv_file_path}: {e}", style="error")
-        return False # Indicates language could not be confirmed due to CSV issue
-    return False
+        return language_name_lower in builtin_languages
+
+    return language_name_lower in builtin_languages
 
 
 def _strip_language_suffix(path_like: os.PathLike[str]) -> str:
@@ -354,7 +336,7 @@ def _determine_language(
 
     # 4 - Special handling for detect command - default to prompt for LLM prompts
     if command == "detect" and "change_file" in input_file_paths:
-        return "prompt"  # Default to prompt for detect command
+        return "prompt"
 
     # 5 - If no language determined, raise error
     raise ValueError("Could not determine language from input files or options.")
@@ -497,11 +479,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 +517,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:
@@ -598,7 +589,23 @@ def construct_paths(
                 style="warning"
             )
 
-    file_extension = get_extension(language) # Pass determined language
+    
+    # Try to get extension from CSV; fallback to built-in mapping if PDD_PATH/CSV unavailable
+    try:
+        file_extension = get_extension(language)  # Pass determined language
+        if not file_extension and (language or '').lower() != 'prompt':
+            raise ValueError('empty extension')
+    except Exception:
+        builtin_ext_map = {
+            'python': '.py', 'javascript': '.js', 'typescript': '.ts', 'java': '.java',
+            'cpp': '.cpp', 'c': '.c', 'go': '.go', 'ruby': '.rb', 'rust': '.rs',
+            'kotlin': '.kt', 'swift': '.swift', 'csharp': '.cs', 'php': '.php',
+            'scala': '.scala', 'r': '.r', 'lua': '.lua', 'perl': '.pl', 'bash': '.sh',
+            'shell': '.sh', 'powershell': '.ps1', 'sql': '.sql', 'html': '.html', 'css': '.css',
+            'prompt': '.prompt', 'makefile': ''
+        }
+        file_extension = builtin_ext_map.get(language.lower(), f".{language.lower()}" if language else '')
+
 
 
     # ------------- Step 3b: build output paths ---------------
@@ -688,4 +695,4 @@ def construct_paths(
     resolved_config["examples_dir"] = str(Path(resolved_config.get("example_output_path", "examples")).parent)
 
 
-    return resolved_config, input_strings, output_file_paths_str_return, language
+    return resolved_config, input_strings, output_file_paths_str_return, language

pdd/context_generator_main.py

@@ -1,5 +1,6 @@
 import sys
 from typing import Tuple, Optional
+from pathlib import Path
 import click
 from rich import print as rprint
 
@@ -51,11 +52,19 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
             verbose=ctx.obj.get('verbose', False)
         )
 
-        # Save results - prioritize orchestration output path over construct_paths result
-        final_output_path = output or output_file_paths["output"]
-        print(f"DEBUG: output param = {output}")
-        print(f"DEBUG: output_file_paths['output'] = {output_file_paths['output']}")
-        print(f"DEBUG: final_output_path = {final_output_path}")
+        # Save results - if output is a directory, use resolved file path from construct_paths
+        resolved_output = output_file_paths["output"]
+        if output is None:
+            final_output_path = resolved_output
+        else:
+            try:
+                is_dir_hint = output.endswith('/')
+            except Exception:
+                is_dir_hint = False
+            if is_dir_hint or (Path(output).exists() and Path(output).is_dir()):
+                final_output_path = resolved_output
+            else:
+                final_output_path = output
         if final_output_path and example_code is not None:
             with open(final_output_path, 'w') as f:
                 f.write(example_code)
@@ -88,4 +97,4 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        sys.exit(1)

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
@@ -250,7 +281,15 @@ def fix_error_loop(unit_test_file: str,
                 elog.write(format_log_for_output(log_structure))
             
             # Set success to True (already determined)
-            # No need to read the files - keep empty strings for passing cases
+            # Read the actual fixed files to return the successful state
+            try:
+                with open(unit_test_file, "r") as f:
+                    final_unit_test = f.read()
+                with open(code_file, "r") as f:  
+                    final_code = f.read()
+            except Exception as e:
+                rprint(f"[yellow]Warning: Could not read fixed files: {e}[/yellow]")
+                # Keep empty strings as fallback
             break
         
         iteration_header = f"=== Attempt iteration {iteration} ==="

pdd/llm_invoke.py

@@ -5,6 +5,8 @@ import os
 import pandas as pd
 import litellm
 import logging # ADDED FOR DETAILED LOGGING
+import importlib.resources
+from litellm.caching.caching import Cache  # Fix for LiteLLM v1.49.3+
 
 # --- Configure Standard Python Logging ---
 logger = logging.getLogger("pdd.llm_invoke")
@@ -190,12 +192,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
@@ -225,6 +235,7 @@ if GCS_HMAC_SECRET_ACCESS_KEY:
     GCS_HMAC_SECRET_ACCESS_KEY = GCS_HMAC_SECRET_ACCESS_KEY.strip()
 
 cache_configured = False
+configured_cache = None  # Store the configured cache instance for restoration
 
 if GCS_BUCKET_NAME and GCS_HMAC_ACCESS_KEY_ID and GCS_HMAC_SECRET_ACCESS_KEY:
     # Store original AWS credentials before overwriting for GCS cache setup
@@ -238,12 +249,13 @@ if GCS_BUCKET_NAME and GCS_HMAC_ACCESS_KEY_ID and GCS_HMAC_SECRET_ACCESS_KEY:
         os.environ['AWS_SECRET_ACCESS_KEY'] = GCS_HMAC_SECRET_ACCESS_KEY
         # os.environ['AWS_REGION_NAME'] = GCS_REGION_NAME  # Uncomment if needed
 
-        litellm.cache = litellm.Cache(
+        configured_cache = Cache(
             type="s3",
             s3_bucket_name=GCS_BUCKET_NAME,
             s3_region_name=GCS_REGION_NAME, # Pass region explicitly to cache
             s3_endpoint_url=GCS_ENDPOINT_URL,
         )
+        litellm.cache = configured_cache
         logger.info(f"LiteLLM cache configured for GCS bucket (S3 compatible): {GCS_BUCKET_NAME}")
         cache_configured = True
 
@@ -272,7 +284,8 @@ if not cache_configured:
     try:
         # Try SQLite-based cache as a fallback
         sqlite_cache_path = PROJECT_ROOT / "litellm_cache.sqlite"
-        litellm.cache = litellm.Cache(type="sqlite", cache_path=str(sqlite_cache_path))
+        configured_cache = Cache(type="sqlite", cache_path=str(sqlite_cache_path))
+        litellm.cache = configured_cache
         logger.info(f"LiteLLM SQLite cache configured at {sqlite_cache_path}")
         cache_configured = True
     except Exception as e2:
@@ -356,12 +369,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:
@@ -1066,8 +1108,8 @@ def llm_invoke(
                                         max_completion_tokens=max_tokens,
                                         **time_kwargs
                                     )
-                                    # Re-enable cache
-                                    litellm.cache = Cache()
+                                    # Re-enable cache - restore original configured cache (restore to original state, even if None)
+                                    litellm.cache = configured_cache
                                     # Extract result from retry
                                     retry_raw_result = retry_response.choices[0].message.content
                                     if retry_raw_result is not None: