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

pdd/construct_paths.py

@@ -4,9 +4,12 @@ from __future__ import annotations
 import sys
 import os
 from pathlib import Path
-from typing import Dict, Tuple, Any, Optional # Added Optional
+from typing import Dict, Tuple, Any, Optional, List
+import fnmatch
+import logging
 
 import click
+import yaml
 from rich.console import Console
 from rich.theme import Theme
 
@@ -21,6 +24,114 @@ import csv
 
 console = Console(theme=Theme({"info": "cyan", "warning": "yellow", "error": "bold red"}))
 
+# Configuration loading functions
+def _find_pddrc_file(start_path: Optional[Path] = None) -> Optional[Path]:
+    """Find .pddrc file by searching upward from the given path."""
+    if start_path is None:
+        start_path = Path.cwd()
+    
+    # Search upward through parent directories
+    for path in [start_path] + list(start_path.parents):
+        pddrc_file = path / ".pddrc"
+        if pddrc_file.is_file():
+            return pddrc_file
+    return None
+
+def _load_pddrc_config(pddrc_path: Path) -> Dict[str, Any]:
+    """Load and parse .pddrc configuration file."""
+    try:
+        with open(pddrc_path, 'r', encoding='utf-8') as f:
+            config = yaml.safe_load(f)
+        
+        if not isinstance(config, dict):
+            raise ValueError(f"Invalid .pddrc format: expected dictionary at root level")
+        
+        # Validate basic structure
+        if 'contexts' not in config:
+            raise ValueError(f"Invalid .pddrc format: missing 'contexts' section")
+        
+        return config
+    except yaml.YAMLError as e:
+        raise ValueError(f"YAML syntax error in .pddrc: {e}")
+    except Exception as e:
+        raise ValueError(f"Error loading .pddrc: {e}")
+
+def _detect_context(current_dir: Path, config: Dict[str, Any], context_override: Optional[str] = None) -> Optional[str]:
+    """Detect the appropriate context based on current directory path."""
+    if context_override:
+        # Validate that the override context exists
+        contexts = config.get('contexts', {})
+        if context_override not in contexts:
+            available = list(contexts.keys())
+            raise ValueError(f"Unknown context '{context_override}'. Available contexts: {available}")
+        return context_override
+    
+    contexts = config.get('contexts', {})
+    current_path_str = str(current_dir)
+    
+    # Try to match against each context's paths
+    for context_name, context_config in contexts.items():
+        if context_name == 'default':
+            continue  # Handle default as fallback
+        
+        paths = context_config.get('paths', [])
+        for path_pattern in paths:
+            # Convert glob pattern to match current directory
+            if fnmatch.fnmatch(current_path_str, f"*/{path_pattern}") or \
+               fnmatch.fnmatch(current_path_str, path_pattern) or \
+               current_path_str.endswith(f"/{path_pattern.rstrip('/**')}"):
+                return context_name
+    
+    # Return default context if available
+    if 'default' in contexts:
+        return 'default'
+    
+    return None
+
+def _get_context_config(config: Dict[str, Any], context_name: Optional[str]) -> Dict[str, Any]:
+    """Get configuration settings for the specified context."""
+    if not context_name:
+        return {}
+    
+    contexts = config.get('contexts', {})
+    context_config = contexts.get(context_name, {})
+    return context_config.get('defaults', {})
+
+def _resolve_config_hierarchy(
+    cli_options: Dict[str, Any],
+    context_config: Dict[str, Any],
+    env_vars: Dict[str, str]
+) -> Dict[str, Any]:
+    """Apply configuration hierarchy: CLI > context > environment > defaults."""
+    resolved = {}
+    
+    # Configuration keys to resolve
+    config_keys = {
+        'generate_output_path': 'PDD_GENERATE_OUTPUT_PATH',
+        'test_output_path': 'PDD_TEST_OUTPUT_PATH', 
+        'example_output_path': 'PDD_EXAMPLE_OUTPUT_PATH',
+        'default_language': 'PDD_DEFAULT_LANGUAGE',
+        'target_coverage': 'PDD_TEST_COVERAGE_TARGET',
+        'strength': None,
+        'temperature': None,
+        'budget': None,
+        'max_attempts': None,
+    }
+    
+    for config_key, env_var in config_keys.items():
+        # 1. CLI options (highest priority)
+        if config_key in cli_options and cli_options[config_key] is not None:
+            resolved[config_key] = cli_options[config_key]
+        # 2. Context configuration
+        elif config_key in context_config:
+            resolved[config_key] = context_config[config_key]
+        # 3. Environment variables
+        elif env_var and env_var in env_vars:
+            resolved[config_key] = env_vars[env_var]
+        # 4. Defaults are handled elsewhere
+    
+    return resolved
+
 
 def _read_file(path: Path) -> str:
     """Read a text file safely and return its contents."""
@@ -126,29 +237,24 @@ def _is_known_language(language_name: str) -> bool:
 
 def _strip_language_suffix(path_like: os.PathLike[str]) -> str:
     """
-    Remove trailing '_<language>.prompt' or '_<language>' from a filename stem
-    if it matches a known language.
+    Remove trailing '_<language>' from a filename stem if it matches a known language.
     """
     p = Path(path_like)
-    stem = p.stem # removes last extension (e.g. '.prompt', '.py')
+    stem = p.stem  # removes last extension (e.g., '.prompt', '.py')
 
-    if "_" not in stem: # No underscore, nothing to strip
+    if "_" not in stem:
         return stem
 
     parts = stem.split("_")
-    # Avoid splitting single-word stems like "Makefile_" if that's possible
-    if len(parts) < 2:
-        return stem
-
     candidate_lang = parts[-1]
 
-    # Check if the last part is a known language
     if _is_known_language(candidate_lang):
-        # If the last part is a language, strip it
+        # Do not strip '_prompt' from a non-.prompt file (e.g., 'test_prompt.txt')
+        if candidate_lang == 'prompt' and p.suffix != '.prompt':
+            return stem
         return "_".join(parts[:-1])
-    else:
-        # Last part is not a language, return original stem
-        return stem
+    
+    return stem
 
 
 def _extract_basename(
@@ -267,20 +373,101 @@ def construct_paths(
     command: str,
     command_options: Optional[Dict[str, Any]], # Allow None
     create_error_file: bool = True,  # Added parameter to control error file creation
-) -> Tuple[Dict[str, str], Dict[str, str], str]:
+    context_override: Optional[str] = None,  # Added parameter for context override
+) -> Tuple[Dict[str, Any], Dict[str, str], Dict[str, str], str]:
     """
     High‑level orchestrator that loads inputs, determines basename/language,
     computes output locations, and verifies overwrite rules.
+    
+    Supports .pddrc configuration with context-aware settings and configuration hierarchy:
+    CLI options > .pddrc context > environment variables > defaults
 
     Returns
     -------
-    (input_strings, output_file_paths, language)
+    (resolved_config, input_strings, output_file_paths, language)
     """
     command_options = command_options or {} # Ensure command_options is a dict
 
+    # ------------- Load .pddrc configuration -----------------
+    pddrc_config = {}
+    context = None
+    context_config = {}
+    
+    try:
+        # Find and load .pddrc file
+        pddrc_path = _find_pddrc_file()
+        if pddrc_path:
+            pddrc_config = _load_pddrc_config(pddrc_path)
+            
+            # Detect appropriate context
+            current_dir = Path.cwd()
+            context = _detect_context(current_dir, pddrc_config, context_override)
+            
+            # Get context-specific configuration
+            context_config = _get_context_config(pddrc_config, context)
+            
+            if not quiet and context:
+                console.print(f"[info]Using .pddrc context:[/info] {context}")
+        
+        # Apply configuration hierarchy
+        env_vars = dict(os.environ)
+        resolved_config = _resolve_config_hierarchy(command_options, context_config, env_vars)
+        
+        # Update command_options with resolved configuration for internal use
+        for key, value in resolved_config.items():
+            if key not in command_options or command_options[key] is None:
+                command_options[key] = value
+        
+        # Also update context_config with resolved environment variables for generate_output_paths
+        # This ensures environment variables are available when context config doesn't override them
+        for key, value in resolved_config.items():
+            if key.endswith('_output_path') and key not in context_config:
+                context_config[key] = value
+                
+    except Exception as e:
+        error_msg = f"Configuration error: {e}"
+        console.print(f"[error]{error_msg}[/error]", style="error")
+        if not quiet:
+            console.print("[warning]Continuing with default configuration...[/warning]", style="warning")
+        # Initialize resolved_config on error to avoid downstream issues
+        resolved_config = command_options.copy()
+
+
+    # ------------- Handle sync discovery mode ----------------
+    if command == "sync" and not input_file_paths:
+        basename = command_options.get("basename")
+        if not basename:
+            raise ValueError("Basename must be provided in command_options for sync discovery mode.")
+        
+        # For discovery, we only need directory paths. Call generate_output_paths with dummy values.
+        try:
+            output_paths_str = generate_output_paths(
+                command="sync",
+                output_locations={},
+                basename=basename,
+                language="python", # Dummy language
+                file_extension=".py", # Dummy extension
+                context_config=context_config,
+            )
+            # Infer base directories from a sample output path
+            gen_path = Path(output_paths_str.get("generate_output_path", "src"))
+            resolved_config["prompts_dir"] = str(gen_path.parent.parent / "prompts")
+            resolved_config["code_dir"] = str(gen_path.parent)
+            resolved_config["tests_dir"] = str(Path(output_paths_str.get("test_output_path", "tests")).parent)
+            resolved_config["examples_dir"] = str(Path(output_paths_str.get("example_output_path", "examples")).parent)
+
+        except Exception as e:
+            console.print(f"[error]Failed to determine initial paths for sync: {e}", style="error")
+            raise
+        
+        # Return early for discovery mode
+        return resolved_config, {}, {}, ""
+
+
     if not input_file_paths:
         raise ValueError("No input files provided")
 
+
     # ------------- normalise & resolve Paths -----------------
     input_paths: Dict[str, Path] = {}
     for key, path_str in input_file_paths.items():
@@ -407,6 +594,7 @@ def construct_paths(
             basename=basename,
             language=language,
             file_extension=file_extension,
+            context_config=context_config,
         )
         # Convert to Path objects for internal use
         output_paths_resolved: Dict[str, Path] = {k: Path(v) for k, v in output_paths_str.items()}
@@ -440,8 +628,12 @@ def construct_paths(
                 click.secho("Operation cancelled.", fg="red", err=True)
                 sys.exit(1) # Exit if user chooses not to overwrite
         except Exception as e: # Catch potential errors during confirm (like EOFError in non-interactive)
-             click.secho(f"Confirmation failed: {e}. Aborting.", fg="red", err=True)
-             sys.exit(1)
+            if 'EOF' in str(e) or 'end-of-file' in str(e).lower():
+                # Non-interactive environment, default to not overwriting
+                click.secho("Non-interactive environment detected. Use --force to overwrite existing files.", fg="yellow", err=True)
+            else:
+                click.secho(f"Confirmation failed: {e}. Aborting.", fg="red", err=True)
+            sys.exit(1)
 
 
     # ------------- Final reporting ---------------------------
@@ -462,4 +654,14 @@ def construct_paths(
     # Since we converted to Path, convert back now.
     output_file_paths_str_return = {k: str(v) for k, v in output_paths_resolved.items()}
 
-    return input_strings, output_file_paths_str_return, language
+    # Add resolved paths to the config that gets returned
+    resolved_config.update(output_file_paths_str_return)
+    # Also add inferred directory paths
+    gen_path = Path(resolved_config.get("generate_output_path", "src"))
+    resolved_config["prompts_dir"] = str(next(iter(input_paths.values())).parent)
+    resolved_config["code_dir"] = str(gen_path.parent)
+    resolved_config["tests_dir"] = str(Path(resolved_config.get("test_output_path", "tests")).parent)
+    resolved_config["examples_dir"] = str(Path(resolved_config.get("example_output_path", "examples")).parent)
+
+
+    return resolved_config, input_strings, output_file_paths_str_return, language

pdd/context_generator_main.py

@@ -25,7 +25,7 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
         command_options = {
             "output": output
         }
-        input_strings, output_file_paths, language = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
@@ -51,22 +51,37 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
             verbose=ctx.obj.get('verbose', False)
         )
 
-        # Save results
-        if output_file_paths["output"]:
-            with open(output_file_paths["output"], 'w') as f:
+        # 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}")
+        if final_output_path and example_code is not None:
+            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")
 
         # Provide user feedback
         if not ctx.obj.get('quiet', False):
-            rprint("[bold green]Example code generated successfully.[/bold green]")
-            rprint(f"[bold]Model used:[/bold] {model_name}")
-            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
-            if output:
-                rprint(f"[bold]Example code saved to:[/bold] {output_file_paths['output']}")
+            if example_code is not None:
+                rprint("[bold green]Example code generated successfully.[/bold green]")
+                rprint(f"[bold]Model used:[/bold] {model_name}")
+                rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+                if final_output_path and example_code is not None:
+                    rprint(f"[bold]Example code saved to:[/bold] {final_output_path}")
+            else:
+                rprint("[bold red]Example code generation failed.[/bold red]")
+                rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
 
-        # Always print example code, even in quiet mode
-        rprint("[bold]Generated Example Code:[/bold]")
-        rprint(example_code)
+        # Always print example code, even in quiet mode (if it exists)
+        if example_code is not None:
+            rprint("[bold]Generated Example Code:[/bold]")
+            rprint(example_code)
+        else:
+            rprint("[bold red]No example code generated due to errors.[/bold red]")
 
         return example_code, total_cost, model_name
 

pdd/crash_main.py

@@ -52,15 +52,13 @@ def crash_main(
     ctx.params = ctx.params if isinstance(ctx.params, dict) else {}
 
     quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False))
-    verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False)) # Get verbose flag
+    verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False))
 
-    # Get model parameters from context early, including time
     strength = ctx.obj.get("strength", DEFAULT_STRENGTH)
     temperature = ctx.obj.get("temperature", 0)
-    time_param = ctx.obj.get("time", DEFAULT_TIME) # Renamed from time_budget for clarity
+    time_param = ctx.obj.get("time", DEFAULT_TIME)
 
     try:
-        # Construct file paths
         input_file_paths = {
             "prompt_file": prompt_file,
             "code_file": code_file,
@@ -73,9 +71,8 @@ def crash_main(
         }
 
         force = ctx.params.get("force", ctx.obj.get("force", False))
-        # quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False)) # Already defined above
 
-        input_strings, output_file_paths, _ = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths,
             force=force,
             quiet=quiet,
@@ -83,77 +80,79 @@ def crash_main(
             command_options=command_options
         )
 
-        # Load input files
         prompt_content = input_strings["prompt_file"]
         code_content = input_strings["code_file"]
         program_content = input_strings["program_file"]
         error_content = input_strings["error_file"]
 
-        # Store original content for comparison later
         original_code_content = code_content
         original_program_content = program_content
 
-        # Get model parameters from context (strength, temperature, time already fetched)
-        # strength = ctx.obj.get("strength", DEFAULT_STRENGTH) # Moved up
-        # temperature = ctx.obj.get("temperature", 0) # Moved up
-        # time_budget = ctx.obj.get("time", DEFAULT_TIME) # Moved up and renamed
-
-        # verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False)) # Already defined above
-
         code_updated: bool = False
         program_updated: bool = False
 
         if loop:
-            # Use iterative fixing process
-            # Corrected parameter order for fix_code_loop, adding time_param
             success, final_program, final_code, attempts, cost, model = fix_code_loop(
                 code_file, prompt_content, program_file, strength, temperature,
                 max_attempts or 3, budget or 5.0, error_file, verbose, time_param
             )
-            # Determine if content was updated by fix_code_loop
-            if success: # Only consider updates if the loop reported success
-                code_updated = bool(final_code and final_code != original_code_content)
-                program_updated = bool(final_program and final_program != original_program_content)
+            # Always set final_code/final_program to something non-empty
+            if not final_code:
+                final_code = original_code_content
+            if not final_program:
+                final_program = original_program_content
+            code_updated = final_code != original_code_content
+            program_updated = final_program != original_program_content
         else:
-            # Use single fix attempt
             if fix_code_module_errors is None:
-                 raise ImportError("fix_code_module_errors is required but not available.")
-            # Corrected parameter order for fix_code_module_errors, adding time_param
-            fm_update_program, fm_update_code, final_program, final_code, program_code_fix, cost, model = fix_code_module_errors(
-                program_content, prompt_content, code_content, error_content, strength, temperature, verbose, time_param
+                raise ImportError("fix_code_module_errors is required but not available.")
+
+            update_program, update_code, fixed_program, fixed_code, _, cost, model = fix_code_module_errors(
+                program_content, prompt_content, code_content, error_content,
+                strength, temperature, verbose, time_param
             )
-            success = True # Assume success after one attempt if no exception
+            success = True
             attempts = 1
-            # Use boolean flags from fix_code_module_errors and ensure content is not empty
-            code_updated = fm_update_code and bool(final_code)
-            program_updated = fm_update_program and bool(final_program)
 
-        # Removed fallback to original content if final_code/final_program are empty
-        # An empty string from a fix function means no valid update.
+            # Fallback if fixed_program is empty but update_program is True
+            if update_program and not fixed_program.strip():
+                fixed_program = program_content
+            if update_code and not fixed_code.strip():
+                fixed_code = code_content
+
+            final_code = fixed_code if update_code else code_content
+            final_program = fixed_program if update_program else program_content
+
+            # Always set final_code/final_program to something non-empty
+            if not final_code:
+                final_code = original_code_content
+            if not final_program:
+                final_program = original_program_content
+
+            code_updated = final_code != original_code_content
+            program_updated = final_program != original_program_content
 
-        # Determine whether to write the files based on whether paths are provided AND content was updated
         output_code_path_str = output_file_paths.get("output")
         output_program_path_str = output_file_paths.get("output_program")
 
-        # Write output files only if updated and path provided
-        if output_code_path_str and code_updated:
+        # Always write output files if output paths are specified
+        if output_code_path_str:
             output_code_path = Path(output_code_path_str)
-            output_code_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            output_code_path.parent.mkdir(parents=True, exist_ok=True)
             with open(output_code_path, "w") as f:
                 f.write(final_code)
 
-        if output_program_path_str and program_updated:
+        if output_program_path_str:
             output_program_path = Path(output_program_path_str)
-            output_program_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            output_program_path.parent.mkdir(parents=True, exist_ok=True)
             with open(output_program_path, "w") as f:
                 f.write(final_program)
 
-        # Provide user feedback
         if not quiet:
             if success:
-                rprint("[bold green]Crash fix attempt completed.[/bold green]") # Changed message slightly
+                rprint("[bold green]Crash fix attempt completed.[/bold green]")
             else:
-                rprint("[bold yellow]Crash fix attempt completed with issues or no changes made.[/bold yellow]") # Changed message
+                rprint("[bold yellow]Crash fix attempt completed with issues.[/bold yellow]")
             rprint(f"[bold]Model used:[/bold] {model}")
             rprint(f"[bold]Total attempts:[/bold] {attempts}")
             rprint(f"[bold]Total cost:[/bold] ${cost:.2f}")
@@ -162,25 +161,20 @@ def crash_main(
                 if code_updated:
                     rprint(f"[bold]Fixed code saved to:[/bold] {output_code_path_str}")
                 else:
-                    rprint(f"[info]Code file {Path(code_file).name} was not modified. Output file {output_code_path_str} not written.[/info]")
-            
+                    rprint(f"[info]Code file '{Path(code_file).name}' was not modified (but output file was written).[/info]")
             if output_program_path_str:
                 if program_updated:
                     rprint(f"[bold]Fixed program saved to:[/bold] {output_program_path_str}")
                 else:
-                    rprint(f"[info]Program file {Path(program_file).name} was not modified. Output file {output_program_path_str} not written.[/info]")
+                    rprint(f"[info]Program file '{Path(program_file).name}' was not modified (but output file was written).[/info]")
 
         return success, final_code, final_program, attempts, cost, model
-    
+
     except FileNotFoundError as e:
         if not quiet:
-             # Provide a more specific error message for file not found
-             rprint(f"[bold red]Error:[/bold red] Input file not found: {e}")
+            rprint(f"[bold red]Error:[/bold red] Input file not found: {e}")
         sys.exit(1)
     except Exception as e:
         if not quiet:
             rprint(f"[bold red]An unexpected error occurred:[/bold red] {str(e)}")
-        # Consider logging the full traceback here for debugging
-        # import traceback
-        # traceback.print_exc()
         sys.exit(1)

pdd/data/llm_model.csv

@@ -6,7 +6,7 @@ OpenAI,deepseek/deepseek-chat,.27,1.1,1353,https://api.deepseek.com/beta,DEEPSEE
 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-sonnet-4-20250514,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
+Google,vertex_ai/gemini-2.5-pro,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

pdd/detect_change_main.py

@@ -39,7 +39,7 @@ def detect_change_main(
             "output": output
         }
 
-        input_strings, output_file_paths, _ = construct_paths(
+        resolved_config, input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),

pdd/fix_code_module_errors.py

@@ -81,6 +81,18 @@ def fix_code_module_errors(
         model_name = first_response.get('model_name', '')
         program_code_fix = first_response['result']
 
+        # Check if the LLM response is None or an error string
+        if program_code_fix is None:
+            error_msg = "LLM returned None result during error analysis"
+            if verbose:
+                print(f"[red]{error_msg}[/red]")
+            raise RuntimeError(error_msg)
+        elif isinstance(program_code_fix, str) and program_code_fix.startswith("ERROR:"):
+            error_msg = f"LLM failed to analyze errors: {program_code_fix}"
+            if verbose:
+                print(f"[red]{error_msg}[/red]")
+            raise RuntimeError(error_msg)
+
         if verbose:
             print("[green]Error analysis complete[/green]")
             print(Markdown(program_code_fix))

pdd/fix_main.py

@@ -91,7 +91,7 @@ def fix_main(
             "output_results": output_results
         }
 
-        input_strings, output_file_paths, _ = construct_paths(
+        resolved_config, input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
@@ -177,7 +177,7 @@ def fix_main(
                     try:
                         # Get JWT token for cloud authentication
                         jwt_token = asyncio.run(get_jwt_token(
-                            firebase_api_key=os.environ.get("REACT_APP_FIREBASE_API_KEY"),
+                            firebase_api_key=os.environ.get("NEXT_PUBLIC_FIREBASE_API_KEY"),
                             github_client_id=os.environ.get("GITHUB_CLIENT_ID"),
                             app_name="PDD Code Generator"
                         ))

pdd/fix_verification_errors.py

@@ -268,6 +268,13 @@ def fix_verification_errors(
                 fixed_program = fix_result_obj.fixed_program
                 fixed_code = fix_result_obj.fixed_code
                 fix_explanation = fix_result_obj.explanation
+                
+                # Unescape literal \n strings to actual newlines
+                if fixed_program:
+                    fixed_program = fixed_program.replace('\\n', '\n')
+                if fixed_code:
+                    fixed_code = fixed_code.replace('\\n', '\n')
+                
                 parsed_fix_successfully = True
                 if verbose:
                     rprint("[green]Successfully parsed structured output for fix.[/green]")
@@ -282,6 +289,12 @@ def fix_verification_errors(
                     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
 
+                    # Unescape literal \n strings to actual newlines
+                    if fixed_program_candidate:
+                        fixed_program_candidate = fixed_program_candidate.replace('\\n', '\n')
+                    if fixed_code_candidate:
+                        fixed_code_candidate = fixed_code_candidate.replace('\\n', '\n')
+
                     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]"

pdd/fix_verification_main.py

@@ -183,7 +183,7 @@ def fix_verification_main(
 
     try:
         # First try the official helper.
-        input_strings, output_file_paths, language = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths,
             force=force,
             quiet=quiet,
@@ -382,7 +382,7 @@ def fix_verification_main(
         if final_code is not None:
             rich_print(f"  len(final_code): {len(final_code)}")
 
-    if success and output_code_path and final_code is not None:
+    if output_code_path and final_code is not None:
         try:
             if verbose:
                 rich_print(f"[cyan bold DEBUG] In fix_verification_main, ATTEMPTING to write code to: {output_code_path!r}")
@@ -402,7 +402,7 @@ def fix_verification_main(
         if final_program is not None:
             rich_print(f"  len(final_program): {len(final_program)}")
 
-    if success and output_program_path and final_program is not None:
+    if output_program_path and final_program is not None:
         try:
             if verbose:
                 rich_print(f"[cyan bold DEBUG] In fix_verification_main, ATTEMPTING to write program to: {output_program_path!r}")