pdd-cli 0.0.25__py3-none-any.whl → 0.0.26__py3-none-any.whl

pdd/__init__.py

@@ -1,7 +1,14 @@
-__version__ = "0.0.25"
+__version__ = "0.0.26"
 
 # Strength parameter used for LLM extraction across the codebase
 # Used in postprocessing, XML tagging, code generation, and other extraction operations. The module should have a large context window and be affordable.
-EXTRACTION_STRENGTH = 0.97
+EXTRACTION_STRENGTH = 0.9
 
-DEFAULT_STRENGTH = 0.8
+DEFAULT_STRENGTH = 0.9
+
+"""PDD - Prompt Driven Development"""
+
+# Define constants used across the package
+DEFAULT_LLM_MODEL = "gpt-4.1-nano"
+
+# You can add other package-level initializations or imports here

pdd/bug_to_unit_test.py

@@ -91,7 +91,7 @@ def bug_to_unit_test(
         
         reasoning, is_finished, unfinished_cost, unfinished_model = unfinished_prompt(
             prompt_text=last_600_chars,
-            strength=strength,
+            strength=0.75,
             temperature=temperature,
             verbose=False
         )

pdd/continue_generation.py

@@ -11,9 +11,11 @@ from . import EXTRACTION_STRENGTH
 console = Console()
 
 class TrimResultsStartOutput(BaseModel):
+    explanation: str = Field(description="The explanation of how you determined what to cut out")
     code_block: str = Field(description="The trimmed code block from the start")
 
 class TrimResultsOutput(BaseModel):
+    explanation: str = Field(description="The explanation of the code block")
     trimmed_continued_generation: str = Field(description="The trimmed continuation of the generation")
 
 def continue_generation(
@@ -70,7 +72,7 @@ def continue_generation(
         trim_start_response = llm_invoke(
             prompt=processed_prompts['trim_start'],
             input_json={"LLM_OUTPUT": llm_output},
-            strength=0.8,
+            strength=0.75,
             temperature=0,
             output_pydantic=TrimResultsStartOutput,
             verbose=verbose

pdd/data/llm_model.csv

@@ -1,17 +1,18 @@
-provider,model,input,output,coding_arena_elo,base_url,api_key,counter,encoder,max_tokens,max_completion_tokens,structured_output
-OpenAI,"gpt-4.1-nano",0.1,0.40,1246,,OPENAI_API_KEY,tiktoken,o200k_base,,32768,True
-OpenAI,"grok-3-beta",3,15,1255,"https://api.x.ai/v1",XAI_API_KEY,tiktoken,o200k_base,131072,,False
-Anthropic,"claude-3-5-haiku-20241022",1,5,1259,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,8192,,False
-OpenAI,"deepseek-coder",0.14,0.28,1279,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,8192,,False
-Google,"gemini-2.5-flash-preview-04-17",.15,3.5,1291,,GOOGLE_API_KEY,,,65535,,False
-GoogleVertexAI,"gemini-2.5-pro-exp-03-25",1.25,10,1299,,VERTEX_AI_API_KEY,,,65535,,False
-Anthropic,claude-3-7-sonnet-20250219,3,15,1312,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,64000,,False
-Google,gemini-2.5-pro-exp-03-25,1.25,10,1313,,GOOGLE_API_KEY,,,65535,,False
-OpenAI,"deepseek-r1-distill-llama-70b-specdec",5,5,1314,https://api.groq.com/openai/v1,GROQ_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,16384,,False
-Ollama,"deepseek-r1:70b-llama-distill-q8_0",0.0,0.0,1315,,PWD,,,,,False
-Ollama,deepseek-r1:32b-qwen-distill-fp16,0.0,0.0,1316,,PWD,,,,,False
-OpenAI,"o4-mini",1.1,4.4,1319,,OPENAI_API_KEY,tiktoken,o200k_base,,100000,True
-OpenAI,"o3",10,40,1331,,OPENAI_API_KEY,tiktoken,o200k_base,,100000,True
-OpenAI,"gpt-4.1",2,8,1332,,OPENAI_API_KEY,tiktoken,o200k_base,,32768,True
-OpenAI,"deepseek-reasoner",0.55,2.19,1336,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,8192,,False
-Fireworks,accounts/fireworks/models/deepseek-r1,3,8,1338,,FIREWORKS_API_KEY,,,8192,,False
+provider,model,input,output,coding_arena_elo,base_url,api_key,max_reasoning_tokens,structured_output,reasoning_type
+OpenAI,gpt-4.1-nano,0.1,0.4,1249,,OPENAI_API_KEY,0,True,none
+xai,xai/grok-3-beta,3.0,15.0,1332,https://api.x.ai/v1,XAI_API_KEY,0,False,none
+Anthropic,claude-3-5-haiku-20241022,.8,4,1261,,ANTHROPIC_API_KEY,0,True,none
+OpenAI,deepseek/deepseek-chat,.27,1.1,1353,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,0,False,none
+Google,vertex_ai/gemini-2.5-flash-preview-04-17,0.15,0.6,1330,,VERTEX_CREDENTIALS,0,True,effort
+Google,gemini-2.5-pro-exp-03-25,1.25,10.0,1360,,GOOGLE_API_KEY,0,True,none
+Anthropic,claude-3-7-sonnet-20250219,3.0,15.0,1340,,ANTHROPIC_API_KEY,64000,True,budget
+Google,vertex_ai/gemini-2.5-pro-preview-05-06,1.25,10.0,1361,,VERTEX_CREDENTIALS,0,True,none
+OpenAI,o4-mini,1.1,4.4,1333,,OPENAI_API_KEY,0,True,effort
+OpenAI,o3,10.0,40.0,1389,,OPENAI_API_KEY,0,True,effort
+OpenAI,gpt-4.1,2.0,8.0,1335,,OPENAI_API_KEY,0,True,none
+OpenAI,deepseek/deepseek-reasoner,0.55,2.19,1337,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,0,False,none
+Fireworks,fireworks_ai/accounts/fireworks/models/deepseek-r1,3.0,8.0,1338,,FIREWORKS_API_KEY,0,False,none
+OpenAI,chatgpt-4o-latest,5,15,1369,,OPENAI_API_KEY,0,False,none
+Anthropic,bedrock/us.anthropic.claude-3-7-sonnet-20250219-v1:0,3.0,15.0,1339,,,64000,True,budget
+OpenAI,azure/o4-mini,1.1,4.4,1334,,OPENAI_API_KEY,0,True,effort
+OpenAI,openai/mlx-community/Qwen3-30B-A3B-4bit,0,0,1293,http://localhost:8080,,0,False,none

pdd/fix_main.py

@@ -289,6 +289,7 @@ def fix_main(
                  rprint(f"[bold red]Markup Error in fix_main:[/bold red]")
                  rprint(escape(str(e)))
             else:
-                 # Print other errors normally (might still fail if they contain markup)
-                 rprint(f"[bold red]Error:[/bold red] {str(e)}")
+                 # Print other errors normally, escaping the error string
+                 from rich.markup import escape # Ensure escape is imported
+                 rprint(f"[bold red]Error:[/bold red] {escape(str(e))}")
         sys.exit(1)

pdd/fix_verification_errors.py

@@ -1,10 +1,22 @@
 import re
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 from rich import print as rprint
 from rich.markdown import Markdown
+from pydantic import BaseModel, Field
 from .load_prompt_template import load_prompt_template
 from .llm_invoke import llm_invoke
 
+# Define Pydantic model for structured LLM output for VERIFICATION
+class VerificationOutput(BaseModel):
+    issues_count: int = Field(description="The number of issues found during verification.")
+    details: Optional[str] = Field(description="Detailed explanation of any discrepancies or issues found. Can be null or empty if issues_count is 0.", default=None)
+
+# Define Pydantic model for structured LLM output for FIXES
+class FixerOutput(BaseModel):
+    explanation: str = Field(description="Detailed explanation of the analysis and fixes applied.")
+    fixed_code: str = Field(description="The complete, runnable, and fixed code module.")
+    fixed_program: str = Field(description="The complete, runnable, and fixed program that uses the code module.")
+
 def fix_verification_errors(
     program: str,
     prompt: str,
@@ -41,18 +53,17 @@ def fix_verification_errors(
     verification_issues_count = 0
     verification_details = None
     fix_explanation = None
-    fixed_program = program
-    fixed_code = code
+    fixed_program = program # Initialize with original program
+    fixed_code = code       # Initialize with original code
     final_explanation = None
 
     # Check only essential inputs, allow empty output
     if not all([program, prompt, code]):
-        # Keep the error print for program, prompt, code missing
         rprint("[bold red]Error:[/bold red] Missing one or more required inputs (program, prompt, code).")
         return {
             "explanation": None,
-            "fixed_program": program, # Return original if possible
-            "fixed_code": code,       # Return original if possible
+            "fixed_program": program,
+            "fixed_code": code,
             "total_cost": 0.0,
             "model_name": None,
             "verification_issues_count": 0,
@@ -104,11 +115,11 @@ def fix_verification_errors(
             input_json=verification_input_json,
             strength=strength,
             temperature=temperature,
-            verbose=False, # Keep internal llm_invoke verbose off unless needed
+            verbose=False,
+            output_pydantic=VerificationOutput
         )
         total_cost += verification_response.get('cost', 0.0)
         model_name = verification_response.get('model_name', model_name)
-        verification_result = verification_response.get('result', '')
 
         if verbose:
             rprint(f"[cyan]Verification LLM call complete.[/cyan]")
@@ -123,73 +134,97 @@ def fix_verification_errors(
             "fixed_code": code,
             "total_cost": total_cost,
             "model_name": model_name,
-            "verification_issues_count": verification_issues_count,
+            "verification_issues_count": 0, # Reset on LLM call error
         }
 
-    if verbose:
-        rprint("\n[blue]Verification Result:[/blue]")
-        # Markdown object handles its own rendering, no extra needed here
-        rprint(Markdown(verification_result))
-
     issues_found = False
-    try:
-        # Attempt to match and extract digits directly
-        count_match = re.search(r"<issues_count>(\d+)</issues_count>", verification_result)
-        if count_match:
-            verification_issues_count = int(count_match.group(1)) # Safe due to \d+
-        else:
-            # Specific match failed, check if tag exists with invalid content or is missing
-            generic_count_match = re.search(r"<issues_count>(.*?)</issues_count>", verification_result, re.DOTALL)
-            if generic_count_match:
-                # Tag found, but content is not \d+ -> Parsing Error
-                rprint("[bold red]Error:[/bold red] Could not parse integer value from <issues_count> tag.")
-                # Return the specific error structure for parsing errors after verification call
-                return {
-                    "explanation": None,
-                    "fixed_program": program,
-                    "fixed_code": code,
-                    "total_cost": total_cost, # Cost incurred so far
-                    "model_name": model_name, # Model used so far
-                    "verification_issues_count": 0, # Reset count on parsing error
-                }
+    verification_result_obj = verification_response.get('result')
+
+    if isinstance(verification_result_obj, VerificationOutput):
+        verification_issues_count = verification_result_obj.issues_count
+        verification_details = verification_result_obj.details
+        if verbose:
+            rprint("[green]Successfully parsed structured output from verification LLM.[/green]")
+            rprint("\n[blue]Verification Result (parsed):[/blue]")
+            rprint(f"  Issues Count: {verification_issues_count}")
+            if verification_details:
+                rprint(Markdown(f"**Details:**\n{verification_details}"))
             else:
-                # Tag truly not found -> Warning
-                rprint("[yellow]Warning:[/yellow] Could not find <issues_count> tag in verification result. Assuming 0 issues.")
-                verification_issues_count = 0
+                rprint("  Details: None provided or no issues found.")
 
-        # Proceed to check for details tag if count > 0
         if verification_issues_count > 0:
-            details_match = re.search(r"<details>(.*?)</details>", verification_result, re.DOTALL)
-            if details_match:
-                verification_details = details_match.group(1).strip()
-                if verification_details:
-                    issues_found = True
-                    if verbose:
-                        rprint(f"\n[yellow]Found {verification_issues_count} potential issues. Proceeding to fix step.[/yellow]")
-                else:
-                    # Count > 0, but details empty -> Warning
-                    rprint("[yellow]Warning:[/yellow] <issues_count> is > 0, but <details> tag is empty. Treating as no issues found.")
-                    verification_issues_count = 0 # Reset count
+            if verification_details and verification_details.strip():
+                issues_found = True
+                if verbose:
+                    rprint(f"\n[yellow]Found {verification_issues_count} potential issues. Proceeding to fix step.[/yellow]")
             else:
-                # Count > 0, but no details tag -> Warning
-                rprint("[yellow]Warning:[/yellow] <issues_count> is > 0, but could not find <details> tag. Treating as no issues found.")
-                verification_issues_count = 0 # Reset count
+                rprint(f"[yellow]Warning:[/yellow] <issues_count> is {verification_issues_count}, but <details> field is empty or missing. Treating as no actionable issues found.")
+                verification_issues_count = 0
         else:
-            # verification_issues_count is 0 (either parsed as 0 or defaulted after warning)
             if verbose:
-                rprint("\n[green]No issues found during verification.[/green]")
+                rprint("\n[green]No issues found during verification based on structured output.[/green]")
+    elif isinstance(verification_result_obj, str):
+        try:
+            issues_match = re.search(r'<issues_count>(\d+)</issues_count>', verification_result_obj)
+            if issues_match:
+                parsed_issues_count = int(issues_match.group(1))
+                details_match = re.search(r'<details>(.*?)</details>', verification_result_obj, re.DOTALL)
+                parsed_verification_details = details_match.group(1).strip() if (details_match and details_match.group(1)) else None
 
-    # Removed ValueError catch as it's handled by the logic above
-    except Exception as e:
-        # Generic catch for other potential parsing issues
-        rprint(f"[bold red]Error parsing verification result:[/bold red] {e}")
+
+                if parsed_issues_count > 0:
+                    if parsed_verification_details: # Check if details exist and are not empty
+                        issues_found = True
+                        verification_issues_count = parsed_issues_count
+                        verification_details = parsed_verification_details
+                        if verbose:
+                            rprint(f"\n[yellow]Found {verification_issues_count} potential issues in string response. Proceeding to fix step.[/yellow]")
+                    else:
+                        rprint(f"[yellow]Warning:[/yellow] <issues_count> is {parsed_issues_count} in string response, but <details> field is empty or missing. Treating as no actionable issues found.")
+                        verification_issues_count = 0
+                        issues_found = False
+                else: # parsed_issues_count == 0
+                    verification_issues_count = 0
+                    issues_found = False
+                    if verbose:
+                         rprint("\n[green]No issues found in string verification based on <issues_count> being 0.[/green]")
+            else: # issues_match is None (tag not found or content not digits)
+                rprint("[bold red]Error:[/bold red] Could not find or parse integer value from <issues_count> tag in string response.")
+                return {
+                    "explanation": None,
+                    "fixed_program": program,
+                    "fixed_code": code,
+                    "total_cost": total_cost,
+                    "model_name": model_name,
+                    "verification_issues_count": 0,
+                }
+        except ValueError: # Should not be hit if regex is \d+, but as a safeguard
+            rprint("[bold red]Error:[/bold red] Invalid non-integer value in <issues_count> tag in string response.")
+            return {
+                "explanation": None,
+                "fixed_program": program,
+                "fixed_code": code,
+                "total_cost": total_cost,
+                "model_name": model_name,
+                "verification_issues_count": 0,
+            }
+    else: # Not VerificationOutput and not a successfully parsed string
+        rprint(f"[bold red]Error:[/bold red] Verification LLM call did not return the expected structured output (e.g., parsing failed).")
+        rprint(f"  [dim]Expected type:[/dim] {VerificationOutput} or str")
+        rprint(f"  [dim]Received type:[/dim] {type(verification_result_obj)}")
+        content_str = str(verification_result_obj)
+        rprint(f"  [dim]Received content:[/dim] {content_str[:500]}{'...' if len(content_str) > 500 else ''}")
+        raw_text = verification_response.get('result_text')
+        if raw_text:
+            raw_text_str = str(raw_text)
+            rprint(f"  [dim]Raw LLM text (if available from llm_invoke):[/dim] {raw_text_str[:500]}{'...' if len(raw_text_str) > 500 else ''}")
         return {
             "explanation": None,
             "fixed_program": program,
             "fixed_code": code,
             "total_cost": total_cost,
             "model_name": model_name,
-            "verification_issues_count": 0, # Reset count on parsing error
+            "verification_issues_count": 0,
         }
 
     if issues_found and verification_details:
@@ -210,71 +245,81 @@ def fix_verification_errors(
                 input_json=fix_input_json,
                 strength=strength,
                 temperature=temperature,
-                verbose=False, # Keep internal llm_invoke verbose off unless needed
+                verbose=False,
+                output_pydantic=FixerOutput
             )
             total_cost += fix_response.get('cost', 0.0)
-            model_name = fix_response.get('model_name', model_name) # Update model name to the last one used
-            fix_result = fix_response.get('result', '')
+            model_name = fix_response.get('model_name', model_name)
 
             if verbose:
                 rprint(f"[cyan]Fix LLM call complete.[/cyan]")
                 rprint(f"  [dim]Model Used:[/dim] {fix_response.get('model_name', 'N/A')}")
                 rprint(f"  [dim]Cost:[/dim] ${fix_response.get('cost', 0.0):.6f}")
-                rprint("\n[blue]Fix Result:[/blue]")
-                # Markdown object handles its own rendering, no extra needed here
-                rprint(Markdown(fix_result))
 
-            fixed_program_match = re.search(r"<fixed_program>(.*?)</fixed_program>", fix_result, re.DOTALL)
-            fixed_code_match = re.search(r"<fixed_code>(.*?)</fixed_code>", fix_result, re.DOTALL)
-            explanation_match = re.search(r"<explanation>(.*?)</explanation>", fix_result, re.DOTALL)
+            fix_result_obj = fix_response.get('result')
+            parsed_fix_successfully = False
 
-            if fixed_program_match:
-                fixed_program = fixed_program_match.group(1).strip()
-                if verbose: rprint("[green]Extracted fixed program.[/green]")
-            else:
-                if verbose: rprint("[yellow]Warning:[/yellow] Could not find <fixed_program> tag in fix result. Using original program.")
+            if isinstance(fix_result_obj, FixerOutput):
+                fixed_program = fix_result_obj.fixed_program
+                fixed_code = fix_result_obj.fixed_code
+                fix_explanation = fix_result_obj.explanation
+                parsed_fix_successfully = True
+                if verbose:
+                    rprint("[green]Successfully parsed structured output for fix.[/green]")
+                    rprint(Markdown(f"**Explanation from LLM:**\n{fix_explanation}"))
+            elif isinstance(fix_result_obj, str):
+                program_match = re.search(r'<fixed_program>(.*?)</fixed_program>', fix_result_obj, re.DOTALL)
+                code_match = re.search(r'<fixed_code>(.*?)</fixed_code>', fix_result_obj, re.DOTALL)
+                explanation_match = re.search(r'<explanation>(.*?)</explanation>', fix_result_obj, re.DOTALL)
 
-            if fixed_code_match:
-                fixed_code = fixed_code_match.group(1).strip()
-                if verbose: rprint("[green]Extracted fixed code module.[/green]")
-            else:
-                if verbose: rprint("[yellow]Warning:[/yellow] Could not find <fixed_code> tag in fix result. Using original code module.")
+                if program_match or code_match or explanation_match: # If any tag is found, attempt to parse
+                    fixed_program_candidate = program_match.group(1).strip() if (program_match and program_match.group(1)) else None
+                    fixed_code_candidate = code_match.group(1).strip() if (code_match and code_match.group(1)) else None
+                    fix_explanation_candidate = explanation_match.group(1).strip() if (explanation_match and explanation_match.group(1)) else None
 
-            if explanation_match:
-                fix_explanation = explanation_match.group(1).strip()
-                if verbose: rprint("[green]Extracted fix explanation.[/green]")
-            else:
-                if verbose: rprint("[yellow]Warning:[/yellow] Could not find <explanation> tag in fix result.")
-                fix_explanation = "[Fix explanation not provided by LLM]"
+                    fixed_program = fixed_program_candidate if fixed_program_candidate else program
+                    fixed_code = fixed_code_candidate if fixed_code_candidate else code
+                    fix_explanation = fix_explanation_candidate if fix_explanation_candidate else "[Fix explanation not provided by LLM]"
+                    parsed_fix_successfully = True
+
+                    if verbose:
+                        if not program_match or not fixed_program_candidate:
+                            rprint("[yellow]Warning:[/yellow] Could not find or parse <fixed_program> tag in fix result string. Using original program.")
+                        if not code_match or not fixed_code_candidate:
+                            rprint("[yellow]Warning:[/yellow] Could not find or parse <fixed_code> tag in fix result string. Using original code module.")
+                        if not explanation_match or not fix_explanation_candidate:
+                            rprint("[yellow]Warning:[/yellow] Could not find or parse <explanation> tag in fix result string. Using default explanation.")
+                # else: string, but no relevant tags. Will fall to parsed_fix_successfully = False below
+
+            if not parsed_fix_successfully:
+                rprint(f"[bold red]Error:[/bold red] Fix generation LLM call did not return the expected structured output (e.g., parsing failed).")
+                rprint(f"  [dim]Expected type:[/dim] {FixerOutput} or str (with XML tags)")
+                rprint(f"  [dim]Received type:[/dim] {type(fix_result_obj)}")
+                content_str = str(fix_result_obj)
+                rprint(f"  [dim]Received content:[/dim] {content_str[:500]}{'...' if len(content_str) > 500 else ''}")
+                raw_text = fix_response.get('result_text')
+                if raw_text:
+                    raw_text_str = str(raw_text)
+                    rprint(f"  [dim]Raw LLM text (if available from llm_invoke):[/dim] {raw_text_str[:500]}{'...' if len(raw_text_str) > 500 else ''}")
+                fix_explanation = "[Error: Failed to parse structured output from LLM for fix explanation]"
+                # fixed_program and fixed_code remain original (already initialized)
 
         except Exception as e:
-            rprint(f"[bold red]Error during fix LLM call or extraction:[/bold red] {e}")
-            # Combine verification details with the error message if fix failed
-            final_explanation = f"<error>Error during fix generation: {str(e)}</error>\n"
-            if verification_details:
-                fix_explanation = f"[Error during fix generation: {e}]"
-            # Note: verification_issues_count should retain its value from the verification step
+            rprint(f"[bold red]Error during fix LLM call or processing structured output:[/bold red] {e}")
+            fix_explanation = f"[Error during fix generation: {e}]"
+            # fixed_program and fixed_code remain original
+
+    if issues_found:
+        final_explanation = (
+            f"<verification_details>{verification_details}</verification_details>\n"
+            f"<fix_explanation>{fix_explanation}</fix_explanation>"
+        )
+    else:
+        final_explanation = None # Or "" if an empty list/None is preferred per prompt for "no issues"
 
     if verbose:
         rprint(f"\n[bold blue]Total Cost for fix_verification_errors run:[/bold blue] ${total_cost:.6f}")
 
-    # Construct final explanation only if issues were initially found and processed
-    if verification_details:
-        if fix_explanation:
-             final_explanation = (
-                 f"<verification_details>{verification_details}</verification_details>\n"
-                 f"<fix_explanation>{fix_explanation}</fix_explanation>"
-             )
-        else:
-             # This case might occur if fix step wasn't run due to parsing issues after verification,
-             # or if fix_explanation extraction failed silently (though we added a default).
-             # Let's ensure we always provide some context if details were found.
-             final_explanation = (
-                 f"<verification_details>{verification_details}</verification_details>\n"
-                 f"<fix_explanation>[Fix explanation not available or fix step skipped]</fix_explanation>"
-             )
-    # If no issues were found initially (verification_details is None), final_explanation remains None
-
     return {
         "explanation": final_explanation,
         "fixed_program": fixed_program,
@@ -282,4 +327,4 @@ def fix_verification_errors(
         "total_cost": total_cost,
         "model_name": model_name,
         "verification_issues_count": verification_issues_count,
-    }
+    }