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

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/increase_tests.py

@@ -78,6 +78,13 @@ def increase_tests(
             time=time,
             verbose=verbose
         )
+        
+        # Debug: Check LLM response
+        console.print(f"[blue]DEBUG increase_tests: LLM response type: {type(llm_response)}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM response keys: {llm_response.keys() if isinstance(llm_response, dict) else 'Not a dict'}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM result type: {type(llm_response.get('result', 'No result key'))}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM result length: {len(llm_response['result']) if 'result' in llm_response and llm_response['result'] else 0}[/blue]")
+        console.print(f"[blue]DEBUG increase_tests: LLM result preview: {repr(llm_response['result'][:300]) if 'result' in llm_response and llm_response['result'] else 'Empty or no result'}[/blue]")
 
         increase_test_function, total_cost, model_name = postprocess(
             llm_response['result'], 

pdd/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

pdd/insert_includes.py

@@ -1,4 +1,4 @@
-from typing import Tuple
+from typing import Callable, Optional, Tuple
 from pathlib import Path
 from rich import print
 from pydantic import BaseModel, Field
@@ -16,10 +16,12 @@ def insert_includes(
     input_prompt: str,
     directory_path: str,
     csv_filename: str,
+    prompt_filename: Optional[str] = None,
     strength: float = DEFAULT_STRENGTH,
     temperature: float = 0.0,
     time: float = DEFAULT_TIME,
-    verbose: bool = False
+    verbose: bool = False,
+    progress_callback: Optional[Callable[[int, int], None]] = None
 ) -> Tuple[str, str, float, str]:
     """
     Determine needed dependencies and insert them into a prompt.
@@ -28,10 +30,14 @@ def insert_includes(
         input_prompt (str): The prompt to process
         directory_path (str): Directory path where the prompt file is located
         csv_filename (str): Name of the CSV file containing dependencies
+        prompt_filename (Optional[str]): The prompt filename being processed,
+            used to filter out self-referential example files
         strength (float): Strength parameter for the LLM model
         temperature (float): Temperature parameter for the LLM model
         time (float): Time budget for the LLM model
         verbose (bool, optional): Whether to print detailed information. Defaults to False.
+        progress_callback (Optional[Callable[[int, int], None]]): Callback for progress updates.
+            Called with (current, total) for each file processed.
 
     Returns:
         Tuple[str, str, float, str]: Tuple containing:
@@ -75,10 +81,12 @@ def insert_includes(
             input_prompt=input_prompt,
             directory_path=directory_path,
             csv_file=csv_content,
+            prompt_filename=prompt_filename,
             strength=strength,
             temperature=temperature,
             time=time,
-            verbose=verbose
+            verbose=verbose,
+            progress_callback=progress_callback
         )
 
         if verbose: