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

pdd/context_generator_main.py

@@ -1,11 +1,66 @@
 import sys
+import ast
 from typing import Tuple, Optional
+from pathlib import Path
 import click
 from rich import print as rprint
 
 from .construct_paths import construct_paths
 from .context_generator import context_generator
 
+
+def _validate_python_syntax(code: str) -> Tuple[bool, Optional[str]]:
+    """
+    Validate that the code is valid Python syntax.
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    try:
+        ast.parse(code)
+        return True, None
+    except SyntaxError as e:
+        return False, f"SyntaxError at line {e.lineno}: {e.msg}"
+
+
+def _try_fix_json_garbage(code: str) -> Optional[str]:
+    """
+    Attempt to fix code that has JSON metadata garbage appended at the end.
+    This is a common LLM extraction failure pattern.
+
+    Returns:
+        Fixed code if successful, None if not fixable.
+    """
+    lines = code.split('\n')
+
+    # Look for JSON-like patterns at the end
+    json_patterns = ['"explanation":', '"focus":', '"description":', '"code":']
+
+    for i in range(len(lines) - 1, -1, -1):
+        line = lines[i].strip()
+
+        # If we find a line that's clearly JSON garbage
+        if any(pattern in line for pattern in json_patterns):
+            # Go back and find where valid Python ends
+            for j in range(i - 1, -1, -1):
+                candidate = '\n'.join(lines[:j + 1])
+                is_valid, _ = _validate_python_syntax(candidate)
+                if is_valid:
+                    return candidate
+            break
+
+        # If line is just "}" or "]", likely JSON ending
+        if line in ['}', ']', '},', '],']:
+            continue
+
+        # If line ends with '",  (JSON string end)
+        if line.endswith('",') or line.endswith('"'):
+            # Check if this looks like inside a JSON object
+            if any(pattern in lines[i] if i < len(lines) else '' for pattern in json_patterns):
+                continue
+
+    return None
+
 def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str, output: Optional[str]) -> Tuple[str, float, str]:
     """
     Main function to generate example code from a prompt file and an existing code file.
@@ -30,13 +85,26 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="example",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context'),
+            confirm_callback=ctx.obj.get('confirm_callback')
         )
 
         # Load input files
         prompt_content = input_strings["prompt_file"]
         code_content = input_strings["code_file"]
 
+        # Get resolved output path for file path information
+        resolved_output = output_file_paths["output"]
+        
+        # Determine file path information for correct imports
+        from pathlib import Path
+        source_file_path = str(Path(code_file).resolve())
+        example_file_path = str(Path(resolved_output).resolve()) if resolved_output else ""
+        
+        # Extract module name from the code file
+        module_name = Path(code_file).stem
+
         # Generate example code
         strength = ctx.obj.get('strength', 0.5)
         temperature = ctx.obj.get('temperature', 0)
@@ -48,21 +116,51 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
             strength=strength,
             temperature=temperature,
             time=time,
-            verbose=ctx.obj.get('verbose', False)
+            verbose=ctx.obj.get('verbose', False),
+            source_file_path=source_file_path,
+            example_file_path=example_file_path,
+            module_name=module_name
         )
 
-        # Save results - prioritize orchestration output path over construct_paths result
-        final_output_path = output or output_file_paths["output"]
-        print(f"DEBUG: output param = {output}")
-        print(f"DEBUG: output_file_paths['output'] = {output_file_paths['output']}")
-        print(f"DEBUG: final_output_path = {final_output_path}")
+        # Save results - if output is a directory, use resolved file path from construct_paths
+        if output is None:
+            final_output_path = resolved_output
+        else:
+            try:
+                is_dir_hint = output.endswith('/')
+            except Exception:
+                is_dir_hint = False
+            if is_dir_hint or (Path(output).exists() and Path(output).is_dir()):
+                final_output_path = resolved_output
+            else:
+                final_output_path = output
         if final_output_path and example_code is not None:
+            # Validate Python syntax before saving
+            if language == "python":
+                is_valid, error_msg = _validate_python_syntax(example_code)
+                if not is_valid:
+                    if not ctx.obj.get('quiet', False):
+                        rprint(f"[yellow]Warning: Generated code has syntax error: {error_msg}[/yellow]")
+                        rprint("[yellow]Attempting to fix JSON garbage pattern...[/yellow]")
+
+                    # Try to fix JSON garbage at end of file
+                    fixed_code = _try_fix_json_garbage(example_code)
+                    if fixed_code:
+                        is_valid_fixed, _ = _validate_python_syntax(fixed_code)
+                        if is_valid_fixed:
+                            if not ctx.obj.get('quiet', False):
+                                rprint("[green]Successfully removed garbage and fixed syntax.[/green]")
+                            example_code = fixed_code
+                        else:
+                            rprint("[red]Could not fix syntax error. Saving as-is.[/red]")
+                    else:
+                        rprint("[red]Could not detect fixable pattern. Saving as-is.[/red]")
+
             with open(final_output_path, 'w') as f:
                 f.write(example_code)
         elif final_output_path and example_code is None:
-            # Log the error but don't crash
-            if not ctx.obj.get('quiet', False):
-                rprint("[bold red]Warning:[/bold red] Example generation failed, skipping file write")
+            # Raise error instead of just warning
+            raise click.UsageError("Example generation failed, no code produced.")
 
         # Provide user feedback
         if not ctx.obj.get('quiet', False):
@@ -85,7 +183,11 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
 
         return example_code, total_cost, model_name
 
+    except click.Abort:
+        # User cancelled - re-raise to stop the sync loop
+        raise
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        # Return error result instead of sys.exit(1) to allow orchestrator to handle gracefully
+        return "", 0.0, f"Error: {e}"

pdd/continue_generation.py

@@ -1,4 +1,5 @@
-from typing import Tuple
+from typing import Tuple, Optional
+import logging
 from rich.console import Console
 from rich.syntax import Syntax
 from pydantic import BaseModel, Field
@@ -9,6 +10,10 @@ from .unfinished_prompt import unfinished_prompt
 from . import EXTRACTION_STRENGTH, DEFAULT_TIME
 
 console = Console()
+logger = logging.getLogger(__name__)
+
+# Maximum number of generation loops to prevent infinite loops
+MAX_GENERATION_LOOPS = 20
 
 class TrimResultsStartOutput(BaseModel):
     explanation: str = Field(description="The explanation of how you determined what to cut out")
@@ -24,6 +29,7 @@ def continue_generation(
     strength: float,
     temperature: float,
     time: float = DEFAULT_TIME,
+    language: Optional[str] = None,
     verbose: bool = False
 ) -> Tuple[str, float, str]:
     """
@@ -84,10 +90,16 @@ def continue_generation(
         code_block = trim_start_response['result'].code_block
 
         # Step 4: Continue generation loop
-        while True:
+        while loop_count < MAX_GENERATION_LOOPS:
             loop_count += 1
             if verbose:
                 console.print(f"[cyan]Generation loop {loop_count}[/cyan]")
+            
+            # Check for maximum loops reached
+            if loop_count >= MAX_GENERATION_LOOPS:
+                logger.warning(f"Reached maximum generation loops ({MAX_GENERATION_LOOPS}), terminating")
+                console.print(f"[yellow]Warning: Reached maximum generation loops ({MAX_GENERATION_LOOPS}), terminating[/yellow]")
+                break
 
             # Generate continuation
             continue_response = llm_invoke(
@@ -106,19 +118,47 @@ def continue_generation(
             model_name = continue_response['model_name']
             continue_result = continue_response['result']
 
-            # Check if generation is complete
-            last_chunk = code_block[-600:] if len(code_block) > 600 else code_block
-            _, is_finished, check_cost, _ = unfinished_prompt(
+            if verbose:
+                try:
+                    preview = (continue_result[:160] + '...') if isinstance(continue_result, str) and len(continue_result) > 160 else continue_result
+                except Exception:
+                    preview = "<non-str>"
+                console.print(f"[blue]Continue model:[/blue] {model_name}")
+                console.print(f"[blue]Continue preview:[/blue] {preview!r}")
+
+            # If the model produced no continuation, avoid an endless loop
+            if not isinstance(continue_result, str) or not continue_result.strip():
+                logger.warning("Empty continuation received; stopping to avoid loop.")
+                break
+
+            # Build prospective new block and check completeness on the updated tail
+            new_code_block = code_block + continue_result
+            last_chunk = new_code_block[-600:] if len(new_code_block) > 600 else new_code_block
+            reasoning, is_finished, check_cost, check_model = unfinished_prompt(
                 prompt_text=last_chunk,
                 strength=0.5,
                 temperature=0,
                 time=time,
+                language=language,
                 verbose=verbose
             )
             total_cost += check_cost
 
+            if verbose:
+                console.print(f"[magenta]Tail length:[/magenta] {len(last_chunk)}")
+                # Show a safe, shortened representation of the tail
+                try:
+                    tail_preview = (last_chunk[-200:] if len(last_chunk) > 200 else last_chunk)
+                except Exception:
+                    tail_preview = "<unprintable tail>"
+                console.print(f"[magenta]Tail preview (last 200 chars):[/magenta]\n{tail_preview}")
+                console.print(f"[magenta]Unfinished check model:[/magenta] {check_model}")
+                console.print(f"[magenta]is_finished:[/magenta] {is_finished}")
+                console.print(f"[magenta]Reasoning:[/magenta] {reasoning}")
+
             if not is_finished:
-                code_block += continue_result
+                code_block = new_code_block
+                # Continue to next iteration
             else:
                 # Trim and append final continuation
                 trim_response = llm_invoke(
@@ -146,4 +186,4 @@ def continue_generation(
 
     except Exception as e:
         console.print(f"[bold red]Error in continue_generation: {str(e)}[/bold red]")
-        raise
+        raise