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

pdd/fix_main.py

@@ -2,10 +2,12 @@ import sys
 from typing import Tuple, Optional
 import click
 from rich import print as rprint
+from rich.markup import MarkupError, escape
 
 import requests
 import asyncio
 import os
+from pathlib import Path
 
 from .preprocess import preprocess
 
@@ -15,6 +17,9 @@ from .fix_error_loop import fix_error_loop
 from .get_jwt_token import get_jwt_token
 from .get_language import get_language
 
+# Import DEFAULT_STRENGTH from the package
+from . import DEFAULT_STRENGTH
+
 def fix_main(
     ctx: click.Context,
     prompt_file: str,
@@ -65,6 +70,12 @@ def fix_main(
     analysis_results = None
 
     try:
+        # Verify error file exists if not in loop mode
+        if not loop:
+            error_path = Path(error_file)
+            if not error_path.exists():
+                raise FileNotFoundError(f"Error file '{error_file}' does not exist.")
+                
         # Construct file paths
         input_file_paths = {
             "prompt_file": prompt_file,
@@ -85,11 +96,12 @@ def fix_main(
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="fix",
-            command_options=command_options
+            command_options=command_options,
+            create_error_file=loop  # Only create error file if in loop mode
         )
 
         # Get parameters from context
-        strength = ctx.obj.get('strength', 0.9)
+        strength = ctx.obj.get('strength', DEFAULT_STRENGTH)
         temperature = ctx.obj.get('temperature', 0)
         verbose = ctx.obj.get('verbose', False)
         if loop:
@@ -139,7 +151,16 @@ def fix_main(
             if verbose and analysis_results:
                 # Log the first 200 characters of analysis if in verbose mode
                 analysis_preview = analysis_results[:200] + "..." if len(analysis_results) > 200 else analysis_results
-                rprint(f"[bold]Analysis preview:[/bold] {analysis_preview}")
+                try:
+                    # Attempt to print the preview using rich markup parsing
+                    rprint(f"[bold]Analysis preview:[/bold] {analysis_preview}")
+                except MarkupError as me:
+                    # If markup fails, print a warning and the escaped preview
+                    rprint(f"[bold yellow]Warning:[/bold yellow] Analysis preview contained invalid markup: {me}")
+                    rprint(f"[bold]Raw Analysis preview (escaped):[/bold] {escape(analysis_preview)}")
+                except Exception as e:
+                    # Handle other potential errors during preview printing
+                    rprint(f"[bold red]Error printing analysis preview: {e}[/bold red]")
             if success:
                 rprint("[bold green]Fixed files saved:[/bold green]")
                 rprint(f"  Test file: {output_file_paths['output_test']}")
@@ -263,5 +284,12 @@ def fix_main(
 
     except Exception as e:
         if not ctx.obj.get('quiet', False):
-            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+            # Safely handle and print MarkupError
+            if isinstance(e, MarkupError):
+                 rprint(f"[bold red]Markup Error in fix_main:[/bold red]")
+                 rprint(escape(str(e)))
+            else:
+                 # 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,12 +53,13 @@ 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
 
-    if not all([program, prompt, code, output]):
-        rprint("[bold red]Error:[/bold red] Missing one or more required inputs (program, prompt, code, output).")
+    # Check only essential inputs, allow empty output
+    if not all([program, prompt, code]):
+        rprint("[bold red]Error:[/bold red] Missing one or more required inputs (program, prompt, code).")
         return {
             "explanation": None,
             "fixed_program": program,
@@ -103,10 +116,10 @@ def fix_verification_errors(
             strength=strength,
             temperature=temperature,
             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]")
@@ -121,52 +134,90 @@ 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]")
-        rprint(Markdown(verification_result))
-
     issues_found = False
-    try:
-        count_match = re.search(r"<issues_count>(\d+)</issues_count>", verification_result)
-        if count_match:
-            verification_issues_count = int(count_match.group(1))
-        else:
-            rprint("[yellow]Warning:[/yellow] Could not find <issues_count> tag in verification result. Assuming 0 issues.")
-            verification_issues_count = 0
+    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:
+                rprint("  Details: None provided or no issues found.")
 
         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:
-                    rprint("[yellow]Warning:[/yellow] <issues_count> is > 0, but <details> tag is empty. Treating as no issues found.")
-                    verification_issues_count = 0
+            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:
-                rprint("[yellow]Warning:[/yellow] <issues_count> is > 0, but could not find <details> tag. Treating as no issues found.")
+                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:
             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
 
-    except ValueError:
-        rprint("[bold red]Error:[/bold red] Could not parse integer value from <issues_count> tag.")
-        return {
-            "explanation": None,
-            "fixed_program": program,
-            "fixed_code": code,
-            "total_cost": total_cost,
-            "model_name": model_name,
-            "verification_issues_count": 0,
-        }
-    except Exception as e:
-        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,
@@ -195,59 +246,79 @@ def fix_verification_errors(
                 strength=strength,
                 temperature=temperature,
                 verbose=False,
+                output_pydantic=FixerOutput
             )
             total_cost += fix_response.get('cost', 0.0)
             model_name = fix_response.get('model_name', model_name)
-            fix_result = fix_response.get('result', '')
 
             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]")
-                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
 
-        except Exception as e:
-            rprint(f"[bold red]Error during fix LLM call or extraction:[/bold red] {e}")
-            if verification_details and fix_explanation is None:
-                fix_explanation = f"[Error during fix generation: {e}]"
+                    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 verbose:
-        rprint(f"\n[bold blue]Total Cost for fix_verification_errors run:[/bold blue] ${total_cost:.6f}")
+            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 processing structured output:[/bold red] {e}")
+            fix_explanation = f"[Error during fix generation: {e}]"
+            # fixed_program and fixed_code remain original
 
-    if issues_found and verification_details and fix_explanation:
+    if issues_found:
         final_explanation = (
             f"<verification_details>{verification_details}</verification_details>\n"
             f"<fix_explanation>{fix_explanation}</fix_explanation>"
         )
-    elif issues_found and verification_details:
-        final_explanation = (
-            f"<verification_details>{verification_details}</verification_details>\n"
-            f"<fix_explanation>[Fix explanation not available or extraction failed]</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}")
 
     return {
         "explanation": final_explanation,
@@ -256,4 +327,4 @@ def fix_verification_errors(
         "total_cost": total_cost,
         "model_name": model_name,
         "verification_issues_count": verification_issues_count,
-    }
+    }