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

pdd/fix_verification_main.py

@@ -3,6 +3,7 @@ import os
 import subprocess
 import click
 import logging
+from pathlib import Path
 from typing import Optional, Tuple, List, Dict, Any
 
 # Use Rich for pretty printing to the console
@@ -17,6 +18,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 +50,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 +59,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 +81,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
 
@@ -101,6 +117,9 @@ def fix_verification_main(
     verification_program: Optional[str],  # Only used if loop=True
     max_attempts: int = DEFAULT_MAX_ATTEMPTS,
     budget: float = DEFAULT_BUDGET,
+    agentic_fallback: bool = True,
+    strength: Optional[float] = None,
+    temperature: Optional[float] = None,
 ) -> Tuple[bool, str, str, int, float, str]:
     """
     CLI wrapper for the 'verify' command. Verifies code correctness by running
@@ -129,9 +148,9 @@ def fix_verification_main(
             - total_cost (float): Total cost incurred.
             - model_name (str): Name of the LLM used.
     """
-    # Extract global options from context
-    strength: float = ctx.obj.get('strength', DEFAULT_STRENGTH)
-    temperature: float = ctx.obj.get('temperature', DEFAULT_TEMPERATURE)
+    # Extract global options from context (prefer passed parameters over ctx.obj)
+    strength: float = strength if strength is not None else ctx.obj.get('strength', DEFAULT_STRENGTH)
+    temperature: float = temperature if temperature is not None else ctx.obj.get('temperature', DEFAULT_TEMPERATURE)
     force: bool = ctx.obj.get('force', False)
     quiet: bool = ctx.obj.get('quiet', False)
     verbose: bool = ctx.obj.get('verbose', False)
@@ -189,6 +208,8 @@ def fix_verification_main(
             quiet=quiet,
             command="verify",
             command_options=command_options,
+            context_override=ctx.obj.get('context'),
+            confirm_callback=ctx.obj.get('confirm_callback')
         )
         output_code_path = output_file_paths.get("output_code")
         output_results_path = output_file_paths.get("output_results")
@@ -197,6 +218,9 @@ def fix_verification_main(
         if verbose:
             rich_print("[dim]Resolved output paths via construct_paths.[/dim]")
 
+    except click.Abort:
+        # User cancelled - re-raise to stop the sync loop
+        raise
     except Exception as e:
         # If the helper does not understand the "verify" command fall back.
         if "invalid command" in str(e).lower():
@@ -215,7 +239,8 @@ def fix_verification_main(
                     input_strings["program_file"] = f.read()
             except FileNotFoundError as fe:
                 rich_print(f"[bold red]Error:[/bold red] {fe}")
-                sys.exit(1)
+                # Return error result instead of sys.exit(1) to allow orchestrator to handle gracefully
+                return False, "", "", 0, 0.0, f"FileNotFoundError: {fe}"
 
             # Pick or build output paths
             if output_code_path is None:
@@ -237,7 +262,8 @@ def fix_verification_main(
             if verbose:
                 import traceback
                 rich_print(Panel(traceback.format_exc(), title="Traceback", border_style="red"))
-            sys.exit(1)
+            # Return error result instead of sys.exit(1) to allow orchestrator to handle gracefully
+            return False, "", "", 0, 0.0, f"Error: {e}"
 
     # --- Core Logic ---
     success: bool = False
@@ -258,6 +284,7 @@ def fix_verification_main(
                     program_file=program_file,                  # Changed to pass the program_file path
                     code_file=code_file,                        # Changed to pass the code_file path
                     prompt=input_strings["prompt_file"],        # Correctly passing prompt content
+                    prompt_file=prompt_file,
                     verification_program=verification_program,      # Path to the verifier program
                     strength=strength,
                     temperature=temperature,
@@ -268,7 +295,8 @@ def fix_verification_main(
                     # output_code_path should not be passed here
                     # output_program_path should not be passed here
                     verbose=verbose,
-                    program_args=[] # Pass an empty list for program_args
+                    program_args=[], # Pass an empty list for program_args
+                    agentic_fallback=agentic_fallback,
                 )
                 success = loop_results.get('success', False)
                 final_program = loop_results.get('final_program', "") # Use .get for safety
@@ -354,7 +382,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
 
@@ -386,7 +420,9 @@ def fix_verification_main(
         try:
             if verbose:
                 rich_print(f"[cyan bold DEBUG] In fix_verification_main, ATTEMPTING to write code to: {output_code_path!r}")
-            with open(output_code_path, "w") as f:
+            output_code_path_obj = Path(output_code_path)
+            output_code_path_obj.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_code_path_obj, "w") as f:
                 f.write(final_code)
             saved_code_path = output_code_path
             if not quiet:
@@ -406,7 +442,9 @@ def fix_verification_main(
         try:
             if verbose:
                 rich_print(f"[cyan bold DEBUG] In fix_verification_main, ATTEMPTING to write program to: {output_program_path!r}")
-            with open(output_program_path, "w") as f:
+            output_program_path_obj = Path(output_program_path)
+            output_program_path_obj.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_program_path_obj, "w") as f:
                 f.write(final_program)
             saved_program_path = output_program_path
             if not quiet:
@@ -416,7 +454,9 @@ def fix_verification_main(
 
     if not loop and output_results_path:
         try:
-            with open(output_results_path, "w") as f:
+            output_results_path_obj = Path(output_results_path)
+            output_results_path_obj.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_results_path_obj, "w") as f:
                 f.write(results_log_content)
             saved_results_path = output_results_path
             if not quiet:

pdd/generate_output_paths.py

@@ -1,13 +1,18 @@
 import os
 import logging
-from typing import Dict, List, Optional
+from typing import Dict, List, Literal, Optional
+
+# Type alias for path resolution mode
+PathResolutionMode = Literal["config_base", "cwd"]
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # --- Configuration Data ---
 
+# Default directory names
+EXAMPLES_DIR = "examples"
+
 # Define the expected output keys for each command
 # Use underscores for keys as requested
 COMMAND_OUTPUT_KEYS: Dict[str, List[str]] = {
@@ -178,14 +183,19 @@ def generate_output_paths(
     basename: str,
     language: str,
     file_extension: str,
-    context_config: Optional[Dict[str, str]] = None
+    context_config: Optional[Dict[str, str]] = None,
+    input_file_dir: Optional[str] = None,
+    input_file_dirs: Optional[Dict[str, str]] = None,
+    config_base_dir: Optional[str] = None,
+    path_resolution_mode: PathResolutionMode = "config_base",
 ) -> Dict[str, str]:
     """
     Generates the full, absolute output paths for a given PDD command.
 
-    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.
+    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 input file's directory
+    (or current working directory if input_file_dir is not provided).
 
     Args:
         command: The PDD command being executed (e.g., 'generate', 'fix').
@@ -199,6 +209,23 @@ def generate_output_paths(
                         used when default patterns require it.
         context_config: Optional dictionary with context-specific paths from .pddrc
                        configuration (e.g., {'generate_output_path': 'src/'}).
+        input_file_dir: Optional path to the input file's directory. When provided,
+                       default output files will be placed in this directory instead
+                       of the current working directory.
+        input_file_dirs: Optional dictionary mapping output keys to specific input
+                         file directories. When provided, each output will use its
+                         corresponding input file directory (e.g., {'output_code': 'src/main/java'}).
+        config_base_dir: Optional base directory to resolve relative `.pddrc` and
+                        environment variable output paths. When set, relative
+                        config paths resolve under this directory (typically the
+                        directory containing `.pddrc`) instead of the input file
+                        directory.
+        path_resolution_mode: Controls how relative paths from `.pddrc` and
+                             environment variables are resolved. "config_base"
+                             (default) resolves relative to config_base_dir,
+                             "cwd" resolves relative to the current working
+                             directory. Use "cwd" for sync command to ensure
+                             output files are created where the user is.
 
     Returns:
         A dictionary where keys are the standardized output identifiers
@@ -209,9 +236,14 @@ 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"Input file dirs: {input_file_dirs}")
+    logger.debug(f"Config base dir: {config_base_dir}")
+    logger.debug(f"Path resolution mode: {path_resolution_mode}")
     logger.debug(f"Basename: {basename}, Language: {language}, Extension: {file_extension}")
 
     context_config = context_config or {}
+    input_file_dirs = input_file_dirs or {}
+    config_base_dir_abs = os.path.abspath(config_base_dir) if config_base_dir else None
     result_paths: Dict[str, str] = {}
 
     if not basename:
@@ -278,6 +310,20 @@ def generate_output_paths(
         # 2. Check Context Configuration Path (.pddrc)
         elif context_path:
             source = "context"
+
+            # Resolve relative `.pddrc` paths based on path_resolution_mode.
+            # "cwd" mode: resolve relative to current working directory (for sync)
+            # "config_base" mode: resolve relative to config_base_dir (for fix, etc.)
+            # Fall back to the input file directory for backwards compatibility.
+            if not os.path.isabs(context_path):
+                if path_resolution_mode == "cwd":
+                    context_path = os.path.join(os.getcwd(), context_path)
+                elif config_base_dir_abs:
+                    context_path = os.path.join(config_base_dir_abs, context_path)
+                elif input_file_dir:
+                    context_path = os.path.join(input_file_dir, context_path)
+                logger.debug(f"Resolved relative context path to: {context_path}")
+
             # Check if the context path is a directory
             is_dir = context_path.endswith(os.path.sep) or context_path.endswith('/')
             if not is_dir:
@@ -297,6 +343,18 @@ def generate_output_paths(
         # 3. Check Environment Variable Path
         elif env_path:
             source = "environment"
+
+            # Resolve relative env paths based on path_resolution_mode.
+            # Same logic as .pddrc paths for consistency.
+            if not os.path.isabs(env_path):
+                if path_resolution_mode == "cwd":
+                    env_path = os.path.join(os.getcwd(), env_path)
+                elif config_base_dir_abs:
+                    env_path = os.path.join(config_base_dir_abs, env_path)
+                elif input_file_dir:
+                    env_path = os.path.join(input_file_dir, env_path)
+                logger.debug(f"Resolved relative env path to: {env_path}")
+
             # Check if the environment variable points to a directory
             is_dir = env_path.endswith(os.path.sep)
             if not is_dir:
@@ -313,11 +371,33 @@ 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
 
-        # 4. Use Default Naming Convention in CWD
+        # 4. Use Default Naming Convention
         else:
             source = "default"
-            logger.debug(f"Using default filename '{default_filename}' in current directory.")
-            final_path = default_filename # Relative to CWD initially
+            # For example command, default to examples/ directory if no .pddrc config
+            if command == "example":
+                examples_dir = EXAMPLES_DIR  # Fallback constant
+                # Create examples directory if it doesn't exist
+                try:
+                    os.makedirs(examples_dir, exist_ok=True)
+                    logger.debug(f"Created examples directory: {examples_dir}")
+                except OSError as e:
+                    logger.warning(f"Could not create examples directory: {e}")
+                final_path = os.path.join(examples_dir, default_filename)
+                logger.debug(f"Using default filename '{default_filename}' in examples directory.")
+            else:
+                # First check if there's a specific directory for this output key
+                specific_dir = input_file_dirs.get(output_key)
+                if specific_dir:
+                    final_path = os.path.join(specific_dir, default_filename)
+                    logger.debug(f"Using default filename '{default_filename}' in specific input file directory: {specific_dir}")
+                # Otherwise use the general input file directory if provided
+                elif input_file_dir:
+                    final_path = os.path.join(input_file_dir, default_filename)
+                    logger.debug(f"Using default filename '{default_filename}' in input file directory: {input_file_dir}")
+                else:
+                    final_path = default_filename # Relative to CWD initially
+                    logger.debug(f"Using default filename '{default_filename}' in current directory.")
 
         # Resolve to absolute path
         if final_path:
@@ -340,6 +420,9 @@ def generate_output_paths(
 
 # --- Example Usage (for testing) ---
 if __name__ == '__main__':
+    # Configure logging for standalone execution
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
     # Mock inputs
     mock_basename = "my_module"
     mock_language = "python"
@@ -568,4 +651,4 @@ if __name__ == '__main__':
     #   'output_code': '/path/to/cwd/another_module_verify_verified.py',
     #   'output_program': f'/path/to/cwd/{env_verify_prog_path}'
     # }
-    del os.environ['PDD_VERIFY_PROGRAM_OUTPUT_PATH'] # Clean up
+    del os.environ['PDD_VERIFY_PROGRAM_OUTPUT_PATH'] # Clean up

pdd/generate_test.py

@@ -15,11 +15,14 @@ console = Console()
 def generate_test(
     prompt: str,
     code: str,
-    strength: float=DEFAULT_STRENGTH,
-    temperature: float=0.0,
+    strength: float = DEFAULT_STRENGTH,
+    temperature: float = 0.0,
     time: float = DEFAULT_TIME,
     language: str = "python",
-    verbose: bool = False
+    verbose: bool = False,
+    source_file_path: Optional[str] = None,
+    test_file_path: Optional[str] = None,
+    module_name: Optional[str] = None
 ) -> Tuple[str, float, str]:
     """
     Generate a unit test from a code file using LLM.
@@ -32,6 +35,9 @@ def generate_test(
         language (str): The programming language for the unit test.
         time (float, optional): Time budget for LLM calls. Defaults to DEFAULT_TIME.
         verbose (bool): Whether to print detailed information.
+        source_file_path (Optional[str]): Absolute or relative path to the code under test.
+        test_file_path (Optional[str]): Destination path for the generated test file.
+        module_name (Optional[str]): Module name (without extension) for proper imports.
 
     Returns:
         Tuple[str, float, str]: (unit_test, total_cost, model_name)
@@ -53,7 +59,10 @@ def generate_test(
         input_json = {
             "prompt_that_generated_code": processed_prompt,
             "code": code,
-            "language": language
+            "language": language,
+            "source_file_path": source_file_path or "",
+            "test_file_path": test_file_path or "",
+            "module_name": module_name or ""
         }
 
         if verbose:
@@ -98,6 +107,7 @@ def generate_test(
                 strength=strength,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=verbose
             )
         total_cost += check_cost
@@ -112,6 +122,7 @@ def generate_test(
                 strength=strength,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=verbose
             )
             total_cost += continue_cost
@@ -181,4 +192,4 @@ def _validate_inputs(
     if not isinstance(temperature, float):
         raise ValueError("Temperature must be a float")
     if not language or not isinstance(language, str):
-        raise ValueError("Language must be a non-empty string")
+        raise ValueError("Language must be a non-empty string")

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:
         """
@@ -216,7 +248,14 @@ class FirebaseAuthenticator:
         except requests.exceptions.ConnectionError as e:
             raise NetworkError(f"Failed to connect to Firebase: {e}")
         except requests.exceptions.RequestException as e:
-            raise TokenError(f"Error exchanging GitHub token for Firebase token: {e}")
+            # Capture more detail to help diagnose provider configuration or audience mismatches
+            extra = ""
+            if getattr(e, "response", None) is not None:
+                try:
+                    extra = f" | response: {e.response.text}"
+                except Exception:
+                    pass
+            raise TokenError(f"Error exchanging GitHub token for Firebase token: {e}{extra}")
 
     def verify_firebase_token(self, id_token: str) -> bool:
         """
@@ -287,4 +326,4 @@ async def get_jwt_token(firebase_api_key: str, github_client_id: str, app_name:
     # Store refresh token
     firebase_auth._store_refresh_token(refresh_token)
 
-    return id_token
+    return id_token

pdd/get_run_command.py

@@ -0,0 +1,73 @@
+"""Module to retrieve run commands for programming languages."""
+
+import os
+import csv
+
+
+def get_run_command(extension: str) -> str:
+    """
+    Retrieves the run command for a given file extension.
+
+    Args:
+        extension: The file extension (e.g., ".py", ".js").
+
+    Returns:
+        The run command template with {file} placeholder (e.g., "python {file}"),
+        or an empty string if not found or not executable.
+
+    Raises:
+        ValueError: If the PDD_PATH environment variable is not set.
+    """
+    # Step 1: Load environment variable PDD_PATH
+    pdd_path = os.environ.get('PDD_PATH')
+    if not pdd_path:
+        raise ValueError("PDD_PATH environment variable is not set")
+
+    # Step 2: Ensure the extension starts with a dot and convert to lowercase
+    if not extension.startswith('.'):
+        extension = '.' + extension
+    extension = extension.lower()
+
+    # Step 3: Look up the run command
+    csv_path = os.path.join(pdd_path, 'data', 'language_format.csv')
+    try:
+        with open(csv_path, 'r') as csvfile:
+            reader = csv.DictReader(csvfile)
+            for row in reader:
+                if row['extension'].lower() == extension:
+                    run_command = row.get('run_command', '').strip()
+                    return run_command if run_command else ''
+    except FileNotFoundError:
+        print(f"CSV file not found at {csv_path}")
+    except csv.Error as e:
+        print(f"Error reading CSV file: {e}")
+    except KeyError:
+        # run_command column doesn't exist
+        pass
+
+    return ''
+
+
+def get_run_command_for_file(file_path: str) -> str:
+    """
+    Retrieves the run command for a given file, with the {file} placeholder replaced.
+
+    Args:
+        file_path: The path to the file to run.
+
+    Returns:
+        The complete run command (e.g., "python /path/to/script.py"),
+        or an empty string if no run command is available for this file type.
+
+    Raises:
+        ValueError: If the PDD_PATH environment variable is not set.
+    """
+    _, extension = os.path.splitext(file_path)
+    if not extension:
+        return ''
+
+    run_command_template = get_run_command(extension)
+    if not run_command_template:
+        return ''
+
+    return run_command_template.replace('{file}', file_path)

pdd/get_test_command.py

@@ -0,0 +1,68 @@
+# pdd/get_test_command.py
+"""Get language-appropriate test commands.
+
+This module provides functions to resolve the appropriate test command
+for a given test file based on:
+1. CSV run_test_command (if non-empty)
+2. Smart detection via default_verify_cmd_for()
+3. None (triggers agentic fallback)
+"""
+from pathlib import Path
+from typing import Optional
+import csv
+
+from .agentic_langtest import default_verify_cmd_for
+from .get_language import get_language
+
+
+def _load_language_format() -> dict:
+    """Load language_format.csv into a dict keyed by extension."""
+    csv_path = Path(__file__).parent.parent / "data" / "language_format.csv"
+    result = {}
+    with open(csv_path, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            ext = row.get('extension', '')
+            if ext:
+                result[ext] = row
+    return result
+
+
+def get_test_command_for_file(test_file: str, language: Optional[str] = None) -> Optional[str]:
+    """
+    Get the appropriate test command for a test file.
+
+    Resolution order:
+    1. CSV run_test_command (if non-empty)
+    2. Smart detection via default_verify_cmd_for()
+    3. None (triggers agentic fallback)
+
+    Args:
+        test_file: Path to the test file
+        language: Optional language override
+
+    Returns:
+        Test command string with {file} placeholder replaced, or None
+    """
+    test_path = Path(test_file)
+    ext = test_path.suffix
+
+    resolved_language = language
+    if resolved_language is None:
+        resolved_language = get_language(ext)
+
+    # 1. Check CSV for run_test_command
+    lang_formats = _load_language_format()
+    if ext in lang_formats:
+        csv_cmd = lang_formats[ext].get('run_test_command', '').strip()
+        if csv_cmd:
+            return csv_cmd.replace('{file}', str(test_file))
+
+    # 2. Smart detection
+    if resolved_language:
+        smart_cmd = default_verify_cmd_for(resolved_language.lower(), str(test_file))
+        if smart_cmd:
+            return smart_cmd
+
+    # 3. No command available
+    return None