pdd-cli 0.0.45__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
@@ -116,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
@@ -144,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)
@@ -204,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")
@@ -212,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():
@@ -230,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:
@@ -252,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
@@ -273,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,
@@ -283,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
@@ -407,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:
@@ -427,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:
@@ -437,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

@@ -248,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:
         """
@@ -319,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

pdd/git_update.py

@@ -4,6 +4,8 @@ from rich import print
 from rich.console import Console
 from rich.panel import Panel
 from .update_prompt import update_prompt
+from .agentic_common import get_available_agents
+from .agentic_update import run_agentic_update
 import git
 from . import DEFAULT_TIME
 console = Console()
@@ -14,21 +16,33 @@ def git_update(
     strength: float,
     temperature: float,
     verbose: bool = False,
-    time: float = DEFAULT_TIME
+    time: float = DEFAULT_TIME,
+    simple: bool = False,
+    quiet: bool = False,
+    prompt_file: Optional[str] = None
 ) -> Tuple[Optional[str], float, str]:
     """
-    Read in modified code, restore the prior checked-in version from GitHub,
-    update the prompt, write back the modified code, and return outputs.
+    Read in modified code, restore the prior checked-in version from Git,
+    update the prompt (via agentic or legacy path), write back the modified code,
+    and return outputs.
 
     Args:
-        input_prompt (str): The prompt that generated the original code.
+        input_prompt (str): The prompt TEXT content (not a file path).
         modified_code_file (str): Filepath of the modified code.
         strength (float): Strength parameter for the LLM model.
         temperature (float): Temperature parameter for the LLM model.
+        verbose (bool): Enable verbose logging.
+        time (float): Time parameter for the LLM model.
+        simple (bool): If True, skip agentic and use legacy update_prompt().
+        quiet (bool): Suppress non-error logging.
+        prompt_file (Optional[str]): Path to prompt file (required for agentic path).
 
     Returns:
-        Tuple[Optional[str], float, str]: Modified prompt, total cost, and model name.
+        Tuple[Optional[str], float, str]: Updated prompt content, total cost, and model name.
     """
+    modified_code: Optional[str] = None
+    agentic_cost = 0.0
+
     try:
         # Check if inputs are valid
         if not input_prompt or not modified_code_file:
@@ -37,26 +51,57 @@ def git_update(
         if not os.path.exists(modified_code_file):
             raise FileNotFoundError(f"Modified code file not found: {modified_code_file}")
 
-        # Initialize git repository
-        repo = git.Repo(search_parent_directories=True)
+        # Initialize git repository object once
+        repo = git.Repo(modified_code_file, search_parent_directories=True)
+        repo_root = repo.working_tree_dir
 
         # Get the file's relative path to the repo root
-        repo_root = repo.git.rev_parse("--show-toplevel")
         relative_path = os.path.relpath(modified_code_file, repo_root)
 
-        # Read the modified code
+        # Read the modified code FIRST (before any git operations)
         with open(modified_code_file, 'r') as file:
             modified_code = file.read()
 
-        # Restore the prior checked-in version
+        # Restore the prior checked-in version using the relative path
         repo.git.checkout('HEAD', '--', relative_path)
 
         # Read the original input code
         with open(modified_code_file, 'r') as file:
             original_input_code = file.read()
 
-        # Call update_prompt function
-        modified_prompt, total_cost, model_name = update_prompt(
+        # Routing decision: agentic vs legacy
+        use_agentic = (
+            not simple
+            and prompt_file is not None
+            and get_available_agents()
+        )
+
+        if use_agentic:
+            # Agentic path
+            success, message, agentic_cost, provider, changed_files = run_agentic_update(
+                prompt_file=prompt_file,
+                code_file=modified_code_file,
+                verbose=verbose,
+                quiet=quiet
+            )
+            if success:
+                # Read updated prompt content from file
+                with open(prompt_file, 'r') as file:
+                    updated_prompt = file.read()
+
+                # Pretty print the results
+                console.print(Panel.fit(
+                    f"[bold green]Success (agentic):[/bold green]\n"
+                    f"Provider: {provider}\n"
+                    f"Total cost: ${agentic_cost:.6f}\n"
+                    f"Changed files: {', '.join(changed_files)}"
+                ))
+
+                return updated_prompt, agentic_cost, provider
+            # Fall through to legacy on agentic failure
+
+        # Legacy path
+        result_prompt, legacy_cost, model_name = update_prompt(
             input_prompt=input_prompt,
             input_code=original_input_code,
             modified_code=modified_code,
@@ -66,21 +111,27 @@ def git_update(
             time=time
         )
 
-        # Write back the modified code
-        with open(modified_code_file, 'w') as file:
-            file.write(modified_code)
-
+        total_cost = agentic_cost + legacy_cost
 
         # Pretty print the results
         console.print(Panel.fit(
             f"[bold green]Success:[/bold green]\n"
-            f"Modified prompt: {modified_prompt}\n"
+            f"Modified prompt: {result_prompt}\n"
             f"Total cost: ${total_cost:.6f}\n"
             f"Model name: {model_name}"
         ))
 
-        return modified_prompt, total_cost, model_name
+        return result_prompt, total_cost, model_name
 
     except Exception as e:
         console.print(Panel(f"[bold red]Error:[/bold red] {str(e)}", title="Error", expand=False))
-        return None, 0.0, ""
+        return None, agentic_cost, ""
+
+    finally:
+        # Always restore user's modified code to disk before returning
+        if modified_code is not None and modified_code_file:
+            try:
+                with open(modified_code_file, 'w') as file:
+                    file.write(modified_code)
+            except Exception:
+                pass  # Best effort restoration

pdd/incremental_code_generator.py

@@ -59,8 +59,8 @@ def incremental_code_generator(
     if not original_prompt or not new_prompt or not existing_code or not language:
         raise ValueError("All required inputs (original_prompt, new_prompt, existing_code, language) must be provided.")
 
-    if not 0 <= strength <= 1 or not 0 <= temperature <= 1 or not 0 <= time <= 1:
-        raise ValueError("Strength, temperature, and time must be between 0 and 1.")
+    if not 0 <= strength <= 1 or not 0 <= temperature <= 2 or not 0 <= time <= 1:
+        raise ValueError("Strength and time must be between 0 and 1. Temperature must be between 0 and 2.")
 
     try:
         total_cost = 0.0