pdd-cli 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl

pdd/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.30"
+__version__ = "0.0.31"
 
 # 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.
@@ -6,9 +6,17 @@ EXTRACTION_STRENGTH = 0.9
 
 DEFAULT_STRENGTH = 0.9
 
+DEFAULT_TEMPERATURE = 0.0
+
+DEFAULT_TIME = 0.25
+
 """PDD - Prompt Driven Development"""
 
 # Define constants used across the package
 DEFAULT_LLM_MODEL = "gpt-4.1-nano"
+# When going to production, set the following constants:
+# REACT_APP_FIREBASE_API_KEY
+# GITHUB_CLIENT_ID
+
+# You can add other package-level initializations or imports here
 
-# You can add other package-level initializations or imports here

pdd/cli.py

@@ -239,17 +239,39 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
     default=None,
     help="Specify where to save the generated code (file or directory).",
 )
+@click.option(
+    "--original-prompt",
+    "original_prompt_file_path",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to the original prompt file for incremental generation.",
+)
+@click.option(
+    "--force-incremental",
+    "force_incremental_flag",
+    is_flag=True,
+    default=False,
+    help="Force incremental generation even if full regeneration is suggested.",
+)
 @click.pass_context
 @track_cost
-def generate(ctx: click.Context, prompt_file: str, output: Optional[str]) -> Optional[Tuple[str, float, str]]: # Modified return type
+def generate(
+    ctx: click.Context,
+    prompt_file: str,
+    output: Optional[str],
+    original_prompt_file_path: Optional[str],
+    force_incremental_flag: bool,
+) -> Optional[Tuple[str, float, str]]: # Modified return type
     """Create runnable code from a prompt file."""
     quiet = ctx.obj.get("quiet", False)
     command_name = "generate"
     try:
-        generated_code, total_cost, model_name = code_generator_main(
+        generated_code, incremental, total_cost, model_name = code_generator_main(
             ctx=ctx,
             prompt_file=prompt_file,
             output=output,
+            original_prompt_file_path=original_prompt_file_path,
+            force_incremental_flag=force_incremental_flag,
         )
         return generated_code, total_cost, model_name
     except Exception as e:
@@ -1009,7 +1031,7 @@ def verify(
     quiet = ctx.obj.get("quiet", False)
     command_name = "verify"
     try:
-        success, final_program, final_code, attempts, cost, model = fix_verification_main(
+        success, final_program, final_code, attempts, total_cost_value, model_name_value = fix_verification_main(
             ctx=ctx,
             prompt_file=prompt_file,
             code_file=code_file,
@@ -1029,7 +1051,7 @@ def verify(
             "verified_program_path": output_program,
             "results_log_path": output_results,
         }
-        return result_data, cost, model
+        return result_data, total_cost_value, model_name_value
     except Exception as e:
         handle_error(e, command_name, quiet)
         return None # Return None on failure

pdd/code_generator_main.py

@@ -1,124 +1,354 @@
-import sys
-from typing import Tuple, Optional
-import click
-from rich import print as rprint
+import os
+import asyncio
+import json
+import pathlib
+import shlex
+import subprocess
+import requests
+from typing import Optional, Tuple, Dict, Any, List
 
-import requests   # <── Added at top level so the tests can patch pdd.code_generator_main.requests
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
 
+# Relative imports for PDD package structure
+from . import DEFAULT_STRENGTH, DEFAULT_TIME, EXTRACTION_STRENGTH # Assuming these are in __init__.py
 from .construct_paths import construct_paths
-from .code_generator import code_generator
-from .get_jwt_token import get_jwt_token
-from .preprocess import preprocess
+from .preprocess import preprocess as pdd_preprocess
+from .code_generator import code_generator as local_code_generator_func
+from .incremental_code_generator import incremental_code_generator as incremental_code_generator_func
+from .get_jwt_token import get_jwt_token, AuthError, NetworkError, TokenError, UserCancelledError, RateLimitError
+
+# Environment variable names for Firebase/GitHub auth
+FIREBASE_API_KEY_ENV_VAR = "NEXT_PUBLIC_FIREBASE_API_KEY" 
+GITHUB_CLIENT_ID_ENV_VAR = "GITHUB_CLIENT_ID"
+PDD_APP_NAME = "PDD Code Generator"
+
+# Cloud function URL
+CLOUD_GENERATE_URL = "https://us-central1-prompt-driven-development.cloudfunctions.net/generateCode"
+CLOUD_REQUEST_TIMEOUT = 200  # seconds
+
+console = Console()
+
+# --- Git Helper Functions ---
+def _run_git_command(command: List[str], cwd: Optional[str] = None) -> Tuple[int, str, str]:
+    """Runs a git command and returns (return_code, stdout, stderr)."""
+    try:
+        process = subprocess.run(command, capture_output=True, text=True, check=False, cwd=cwd, encoding='utf-8')
+        return process.returncode, process.stdout.strip(), process.stderr.strip()
+    except FileNotFoundError:
+        return -1, "", "Git command not found. Ensure git is installed and in your PATH."
+    except Exception as e:
+        return -2, "", f"Error running git command {' '.join(command)}: {e}"
+
+def is_git_repository(path: Optional[str] = None) -> bool:
+    """Checks if the given path (or current dir) is a git repository."""
+    start_path = pathlib.Path(path).resolve() if path else pathlib.Path.cwd()
+    # Check for .git in current or any parent directory
+    current_path = start_path
+    while True:
+        if (current_path / ".git").is_dir():
+            # Verify it's the root of the work tree or inside it
+            returncode, stdout, _ = _run_git_command(["git", "rev-parse", "--is-inside-work-tree"], cwd=str(start_path))
+            return returncode == 0 and stdout == "true"
+        parent = current_path.parent
+        if parent == current_path: # Reached root directory
+            break
+        current_path = parent
+    return False
 
-def code_generator_main(ctx: click.Context, prompt_file: str, output: Optional[str]) -> Tuple[str, float, str]:
-    """
-    Main function to generate code from a prompt file.
 
-    :param ctx: Click context containing command-line parameters.
-    :param prompt_file: Path to the prompt file used to generate the code.
-    :param output: Optional path to save the generated code.
-    :return: A tuple containing the generated code, total cost, and model name used.
+def get_git_committed_content(file_path: str) -> Optional[str]:
+    """Gets the content of the file as it was in the last commit (HEAD)."""
+    abs_file_path = pathlib.Path(file_path).resolve()
+    if not is_git_repository(str(abs_file_path.parent)):
+        return None
+    
+    returncode_rev, git_root_str, stderr_rev = _run_git_command(["git", "rev-parse", "--show-toplevel"], cwd=str(abs_file_path.parent))
+    if returncode_rev != 0:
+        # console.print(f"[yellow]Git (rev-parse) warning for {file_path}: {stderr_rev}[/yellow]")
+        return None
+    
+    git_root = pathlib.Path(git_root_str)
+    try:
+        relative_path = abs_file_path.relative_to(git_root)
+    except ValueError:
+        # console.print(f"[yellow]File {file_path} is not under git root {git_root}.[/yellow]")
+        return None
+
+    returncode, stdout, stderr = _run_git_command(["git", "show", f"HEAD:{relative_path.as_posix()}"], cwd=str(git_root))
+    if returncode == 0:
+        return stdout
+    else:
+        # File might be new, or other git error. Not necessarily an error for this function's purpose.
+        # if "does not exist" not in stderr and "exists on disk, but not in 'HEAD'" not in stderr and console.is_terminal:
+        #     console.print(f"[yellow]Git (show) warning for {file_path}: {stderr}[/yellow]")
+        return None
+
+def get_file_git_status(file_path: str) -> str:
+    """Gets the git status of a single file (e.g., ' M', '??', 'A '). Empty if clean."""
+    abs_file_path = pathlib.Path(file_path).resolve()
+    if not is_git_repository(str(abs_file_path.parent)) or not abs_file_path.exists():
+        return ""
+    returncode, stdout, _ = _run_git_command(["git", "status", "--porcelain", str(abs_file_path)], cwd=str(abs_file_path.parent))
+    if returncode == 0:
+        # stdout might be " M path/to/file" or "?? path/to/file"
+        # We only want the status codes part
+        status_part = stdout.split(str(abs_file_path.name))[0].strip() if str(abs_file_path.name) in stdout else stdout.strip()
+        return status_part
+    return ""
+
+def git_add_files(file_paths: List[str], verbose: bool = False) -> bool:
+    """Stages the given files using 'git add'."""
+    if not file_paths:
+        return True
+    
+    # Resolve paths and ensure they are absolute for git command
+    abs_paths = [str(pathlib.Path(fp).resolve()) for fp in file_paths]
+    
+    # Determine common parent directory to run git command from, or git root
+    # For simplicity, assume they are in the same repo and run from one of their parents
+    if not is_git_repository(str(pathlib.Path(abs_paths[0]).parent)):
+        if verbose:
+            console.print(f"[yellow]Cannot stage files: {abs_paths[0]} is not in a git repository.[/yellow]")
+        return False
+        
+    returncode, _, stderr = _run_git_command(["git", "add"] + abs_paths, cwd=str(pathlib.Path(abs_paths[0]).parent))
+    if returncode == 0:
+        if verbose:
+            console.print(f"Successfully staged: [cyan]{', '.join(abs_paths)}[/cyan]")
+        return True
+    else:
+        console.print(f"[red]Error staging files with git:[/red] {stderr}")
+        return False
+# --- End Git Helper Functions ---
+
+
+def code_generator_main(
+    ctx: click.Context,
+    prompt_file: str,
+    output: Optional[str],
+    original_prompt_file_path: Optional[str],
+    force_incremental_flag: bool,
+) -> Tuple[str, bool, float, str]:
+    """
+    CLI wrapper for generating code from prompts. Handles full and incremental generation,
+    local vs. cloud execution, and output.
     """
+    cli_params = ctx.obj or {}
+    is_local_execution_preferred = cli_params.get('local', False)
+    strength = cli_params.get('strength', DEFAULT_STRENGTH)
+    temperature = cli_params.get('temperature', 0.0)
+    time_budget = cli_params.get('time', DEFAULT_TIME)
+    verbose = cli_params.get('verbose', False)
+    force_overwrite = cli_params.get('force', False)
+    quiet = cli_params.get('quiet', False)
+
+    generated_code_content: Optional[str] = None
+    was_incremental_operation = False
+    total_cost = 0.0
+    model_name = "unknown"
+
+    input_file_paths_dict: Dict[str, str] = {"prompt_file": prompt_file}
+    if original_prompt_file_path:
+        input_file_paths_dict["original_prompt_file"] = original_prompt_file_path
+    
+    command_options: Dict[str, Any] = {"output": output}
+
     try:
-        # Construct file paths
-        input_file_paths = {
-            "prompt_file": prompt_file
-        }
-        command_options = {
-            "output": output
-        }
         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),
+            input_file_paths=input_file_paths_dict,
+            force=force_overwrite,
+            quiet=quiet,
             command="generate",
-            command_options=command_options
+            command_options=command_options,
         )
-
-        # Load input file
         prompt_content = input_strings["prompt_file"]
+        output_path = output_file_paths.get("output")
+
+    except FileNotFoundError as e:
+        console.print(f"[red]Error: Input file not found: {e.filename}[/red]")
+        return "", False, 0.0, "error"
+    except Exception as e:
+        console.print(f"[red]Error during path construction: {e}[/red]")
+        return "", False, 0.0, "error"
+
+    can_attempt_incremental = False
+    existing_code_content: Optional[str] = None
+    original_prompt_content_for_incremental: Optional[str] = None
+
+    if output_path and pathlib.Path(output_path).exists():
+        try:
+            existing_code_content = pathlib.Path(output_path).read_text(encoding="utf-8")
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not read existing output file {output_path}: {e}[/yellow]")
+            existing_code_content = None
+
+        if existing_code_content is not None:
+            if "original_prompt_file" in input_strings:
+                original_prompt_content_for_incremental = input_strings["original_prompt_file"]
+                can_attempt_incremental = True
+                if verbose:
+                    console.print(f"Using specified original prompt: [cyan]{original_prompt_file_path}[/cyan]")
+            elif is_git_repository(str(pathlib.Path(prompt_file).parent)):
+                original_prompt_git_content = get_git_committed_content(prompt_file)
+                if original_prompt_git_content is not None:
+                    original_prompt_content_for_incremental = original_prompt_git_content
+                    can_attempt_incremental = True
+                    if verbose:
+                        console.print(f"Using last committed version of [cyan]{prompt_file}[/cyan] as original prompt.")
+                elif verbose:
+                    console.print(f"[yellow]Warning: Could not find committed version of {prompt_file} in git for incremental generation.[/yellow]")
+            
+            if force_incremental_flag and existing_code_content:
+                if not (original_prompt_content_for_incremental or "original_prompt_file" in input_strings): # Check if original prompt is actually available
+                     console.print(
+                        "[yellow]Warning: --incremental flag used, but original prompt could not be determined. "
+                        "Falling back to full generation.[/yellow]"
+                    )
+                else:
+                    can_attempt_incremental = True 
+    
+    if force_incremental_flag and (not output_path or not pathlib.Path(output_path).exists()):
+        console.print(
+            "[yellow]Warning: --incremental flag used, but output file does not exist or path not specified. "
+            "Performing full generation.[/yellow]"
+        )
+        can_attempt_incremental = False
+
+    try:
+        if can_attempt_incremental and existing_code_content is not None and original_prompt_content_for_incremental is not None:
+            if verbose:
+                console.print(Panel("Attempting incremental code generation...", title="[blue]Mode[/blue]", expand=False))
 
-        # Generate code
-        strength = ctx.obj.get('strength', 0.5)
-        temperature = ctx.obj.get('temperature', 0.0)
-        verbose = not ctx.obj.get('quiet', False)
-        local = ctx.obj.get('local', False)
-
-        if local:
-            print("Running in local mode")
-            # Local execution
-            generated_code, total_cost, model_name = code_generator(
-                prompt_content,
-                language,
-                strength,
-                temperature,
-                verbose=verbose
+            if is_git_repository(str(pathlib.Path(prompt_file).parent)):
+                files_to_stage_for_rollback: List[str] = []
+                paths_to_check = [pathlib.Path(prompt_file).resolve()]
+                if output_path and pathlib.Path(output_path).exists():
+                    paths_to_check.append(pathlib.Path(output_path).resolve())
+
+                for p_to_check in paths_to_check:
+                    if not p_to_check.exists(): continue
+                    
+                    is_untracked = get_file_git_status(str(p_to_check)).startswith("??")
+                    # Check if different from HEAD or untracked
+                    is_different_from_head_rc = 1 if is_untracked else _run_git_command(["git", "diff", "--quiet", "HEAD", "--", str(p_to_check)], cwd=str(p_to_check.parent))[0]
+                    
+                    if is_different_from_head_rc != 0: # Different from HEAD or untracked
+                        files_to_stage_for_rollback.append(str(p_to_check))
+                
+                if files_to_stage_for_rollback:
+                    git_add_files(files_to_stage_for_rollback, verbose=verbose)
+            
+            generated_code_content, was_incremental_operation, total_cost, model_name = incremental_code_generator_func(
+                original_prompt=original_prompt_content_for_incremental,
+                new_prompt=prompt_content,
+                existing_code=existing_code_content,
+                language=language,
+                strength=strength,
+                temperature=temperature,
+                time=time_budget,
+                force_incremental=force_incremental_flag,
+                verbose=verbose,
+                preprocess_prompt=True
             )
-        else:
-            # Cloud execution
-            try:
-                import asyncio
-                import os
-                # Get JWT token for cloud authentication
-                jwt_token = asyncio.run(get_jwt_token(
-                    firebase_api_key=os.environ.get("REACT_APP_FIREBASE_API_KEY"),
-                    github_client_id=os.environ.get("GITHUB_CLIENT_ID"),
-                    app_name="PDD Code Generator"
-                ))
-                # Call cloud code generator
-                headers = {
-                    "Authorization": f"Bearer {jwt_token}",
-                    "Content-Type": "application/json"
-                }
-                # Preprocess the prompt
-                processed_prompt = preprocess(prompt_content, recursive=False, double_curly_brackets=True)
+
+            if not was_incremental_operation:
                 if verbose:
-                    print(f"Processed prompt: {processed_prompt}")
-                data = {
-                    "promptContent": processed_prompt,
-                    "language": language,
-                    "strength": strength,
-                    "temperature": temperature,
-                    "verbose": verbose
-                }
-                response = requests.post(
-                    "https://us-central1-prompt-driven-development.cloudfunctions.net/generateCode",
-                    headers=headers,
-                    json=data
-                )
-                response.raise_for_status()
-                result = response.json()
-                generated_code = result["generatedCode"]
-                total_cost = result["totalCost"]
-                model_name = result["modelName"]
-
-            except Exception as e:
-                if not ctx.obj.get('quiet', False):
-                    rprint("[bold red]Cloud execution failed, falling back to local mode[/bold red]")
-                generated_code, total_cost, model_name = code_generator(
-                    prompt_content,
-                    language,
-                    strength,
-                    temperature,
-                    verbose=verbose
-                )
+                    console.print(Panel("Incremental generator suggested full regeneration. Falling back.", title="[yellow]Fallback[/yellow]", expand=False))
+            elif verbose:
+                console.print(Panel(f"Incremental update successful. Model: {model_name}, Cost: ${total_cost:.6f}", title="[green]Incremental Success[/green]", expand=False))
 
-        # Save results
-        if output_file_paths["output"]:
-            with open(output_file_paths["output"], 'w') as f:
-                f.write(generated_code)
+        if not was_incremental_operation: # Full generation path
+            if verbose:
+                console.print(Panel("Performing full code generation...", title="[blue]Mode[/blue]", expand=False))
+            
+            current_execution_is_local = is_local_execution_preferred
+            
+            if not current_execution_is_local:
+                if verbose: console.print("Attempting cloud code generation...")
+                
+                processed_prompt_for_cloud = pdd_preprocess(prompt_content, recursive=True, double_curly_brackets=True, exclude_keys=[])
+                if verbose: console.print(Panel(Text(processed_prompt_for_cloud, overflow="fold"), title="[cyan]Preprocessed Prompt for Cloud[/cyan]", expand=False))
+                
+                jwt_token: Optional[str] = None
+                try:
+                    firebase_api_key_val = os.environ.get(FIREBASE_API_KEY_ENV_VAR)
+                    github_client_id_val = os.environ.get(GITHUB_CLIENT_ID_ENV_VAR)
 
-        # Provide user feedback
-        if not ctx.obj.get('quiet', False):
-            rprint("[bold green]Code generation completed 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]Code saved to:[/bold] {output_file_paths['output']}")
+                    if not firebase_api_key_val: raise AuthError(f"{FIREBASE_API_KEY_ENV_VAR} not set.")
+                    if not github_client_id_val: raise AuthError(f"{GITHUB_CLIENT_ID_ENV_VAR} not set.")
 
-        return generated_code, total_cost, model_name
+                    jwt_token = asyncio.run(get_jwt_token(
+                        firebase_api_key=firebase_api_key_val,
+                        github_client_id=github_client_id_val,
+                        app_name=PDD_APP_NAME
+                    ))
+                except (AuthError, NetworkError, TokenError, UserCancelledError, RateLimitError) as e:
+                    console.print(f"[yellow]Cloud authentication/token error: {e}. Falling back to local execution.[/yellow]")
+                    current_execution_is_local = True
+                except Exception as e:
+                    console.print(f"[yellow]Unexpected error during cloud authentication: {e}. Falling back to local execution.[/yellow]")
+                    current_execution_is_local = True
+
+                if jwt_token and not current_execution_is_local:
+                    payload = {"promptContent": processed_prompt_for_cloud, "language": language, "strength": strength, "temperature": temperature, "verbose": verbose}
+                    headers = {"Authorization": f"Bearer {jwt_token}", "Content-Type": "application/json"}
+                    try:
+                        response = requests.post(CLOUD_GENERATE_URL, json=payload, headers=headers, timeout=CLOUD_REQUEST_TIMEOUT)
+                        response.raise_for_status()
+                        
+                        response_data = response.json()
+                        generated_code_content = response_data.get("generatedCode")
+                        total_cost = float(response_data.get("totalCost", 0.0))
+                        model_name = response_data.get("modelName", "cloud_model")
+
+                        if generated_code_content is None:
+                            console.print("[yellow]Cloud execution returned no code. Falling back to local.[/yellow]")
+                            current_execution_is_local = True
+                        elif verbose:
+                             console.print(Panel(f"Cloud generation successful. Model: {model_name}, Cost: ${total_cost:.6f}", title="[green]Cloud Success[/green]", expand=False))
+                    except requests.exceptions.Timeout:
+                        console.print(f"[yellow]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s). Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+                    except requests.exceptions.HTTPError as e:
+                        err_content = e.response.text[:200] if e.response else "No response content"
+                        console.print(f"[yellow]Cloud HTTP error ({e.response.status_code}): {err_content}. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+                    except requests.exceptions.RequestException as e:
+                        console.print(f"[yellow]Cloud network error: {e}. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+                    except json.JSONDecodeError:
+                        console.print("[yellow]Cloud returned invalid JSON. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+            
+            if current_execution_is_local:
+                if verbose: console.print("Executing code generator locally...")
+                generated_code_content, total_cost, model_name = local_code_generator_func(
+                    prompt=prompt_content, language=language, strength=strength,
+                    temperature=temperature, verbose=verbose
+                )
+                if verbose:
+                    console.print(Panel(f"Local generation successful. Model: {model_name}, Cost: ${total_cost:.6f}", title="[green]Local Success[/green]", expand=False))
+        
+        if generated_code_content is not None:
+            if output_path:
+                p_output = pathlib.Path(output_path)
+                p_output.parent.mkdir(parents=True, exist_ok=True)
+                p_output.write_text(generated_code_content, encoding="utf-8")
+                if verbose or not quiet:
+                    console.print(f"Generated code saved to: [green]{p_output.resolve()}[/green]")
+            elif not quiet: # No output path, print to console if not quiet
+                console.print(Panel(Text(generated_code_content, overflow="fold"), title="[cyan]Generated Code[/cyan]", expand=True))
+        else:
+            console.print("[red]Error: Code generation failed. No code was produced.[/red]")
+            return "", was_incremental_operation, total_cost, model_name or "error"
 
     except Exception as e:
-        if not ctx.obj.get('quiet', False):
-            rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        console.print(f"[red]An unexpected error occurred: {e}[/red]")
+        import traceback
+        if verbose: console.print(traceback.format_exc())
+        return "", was_incremental_operation, total_cost, "error"
+        
+    return generated_code_content or "", was_incremental_operation, total_cost, model_name

pdd/fix_verification_errors_loop.py

@@ -507,44 +507,70 @@ def fix_verification_errors_loop(
         # FIX: Restructured logic for success check and secondary verification
         secondary_verification_passed = True # Assume pass unless changes made and verification fails
         changes_applied_this_iteration = False
+        verify_ret_code = 0 # Default for skipped verification
+        verify_output = "Secondary verification not run." # Default for skipped
 
-        # Run secondary verification ONLY if code was updated
         if code_updated:
             if verbose:
-                console.print("Code change suggested, running secondary verification...")
-            try:
-                # Temporarily write the proposed code change
-                code_path.write_text(fixed_code, encoding="utf-8")
+                console.print("Code change suggested, attempting secondary verification...")
+            
+            if verification_program is not None and verification_program_path.is_file():
+                try:
+                    # Temporarily write the proposed code change
+                    code_path.write_text(fixed_code, encoding="utf-8")
 
-                # Run verification program
-                verify_ret_code, verify_output = _run_program(verification_program_path)
+                    # Run verification program
+                    # Consider if verification_program_path needs arguments or specific env vars
+                    # For now, assuming it can run directly or uses env vars set externally
+                    current_verify_ret_code, current_verify_output = _run_program(verification_program_path)
 
-                # Determine pass/fail (simple: exit code 0 = pass)
-                secondary_verification_passed = (verify_ret_code == 0)
+                    # Determine pass/fail (simple: exit code 0 = pass)
+                    secondary_verification_passed = (current_verify_ret_code == 0)
+                    verify_ret_code = current_verify_ret_code
+                    verify_output = current_verify_output
 
+                    if verbose:
+                        console.print(f"Secondary verification ran. Exit code: {verify_ret_code}")
+                        console.print(f"Secondary verification passed: {secondary_verification_passed}")
+                        # console.print(f"Secondary verification output:\\n{verify_output}")
+
+                    if not secondary_verification_passed:
+                        console.print("[yellow]Secondary verification failed. Restoring code file from memory.[/yellow]")
+                        code_path.write_text(code_contents, encoding="utf-8") # Restore from memory state before this attempt
+                
+                except IOError as e:
+                    console.print(f"[bold red]Error during secondary verification I/O: {e}[/bold red]")
+                    verify_output = f"Error during secondary verification I/O: {str(e)}"
+                    secondary_verification_passed = False # Treat I/O error as failure
+                    verify_ret_code = -1 # Indicate error
+                    try:
+                        code_path.write_text(code_contents, encoding="utf-8")
+                    except IOError:
+                        console.print(f"[bold red]Failed to restore code file after I/O error.[/bold red]")
+            else:
+                # No valid verification program provided, or it's not a file
+                secondary_verification_passed = True # Effectively skipped, so it doesn't block progress
+                verify_ret_code = 0
+                if verification_program is None:
+                    verify_output = "Secondary verification skipped: No verification program provided."
+                else:
+                    verify_output = f"Secondary verification skipped: Verification program '{verification_program}' not found or is not a file at '{verification_program_path}'."
                 if verbose:
-                    console.print(f"Secondary verification exit code: {verify_ret_code}")
-                    console.print(f"Secondary verification passed: {secondary_verification_passed}")
-                    # console.print(f"Secondary verification output:\n{verify_output}")
-
-                passed_str = str(secondary_verification_passed).lower()
-                iteration_log_xml += f'  <SecondaryVerification passed="{passed_str}">\n'
-                iteration_log_xml += f'    <ExitCode>{verify_ret_code}</ExitCode>\n'
-                iteration_log_xml += f'    <Output>{escape(verify_output)}</Output>\n'
-                iteration_log_xml += f'  </SecondaryVerification>\n'
-
-                if not secondary_verification_passed:
-                    console.print("[yellow]Secondary verification failed. Restoring code file.[/yellow]")
-                    code_path.write_text(code_contents, encoding="utf-8") # Restore from memory state before this attempt
-
-            except IOError as e:
-                console.print(f"[bold red]Error during secondary verification I/O: {e}[/bold red]")
-                iteration_log_xml += f'  <Status>Error during secondary verification I/O: {escape(str(e))}</Status>\n'
-                secondary_verification_passed = False # Treat I/O error as failure
-                try:
-                    code_path.write_text(code_contents, encoding="utf-8")
-                except IOError:
-                    console.print(f"[bold red]Failed to restore code file after I/O error.[/bold red]")
+                    console.print(f"[dim]{verify_output}[/dim]")
+        else:
+            # Code was not updated by the fixer, so secondary verification is not strictly needed
+            secondary_verification_passed = True # No changes to verify
+            verify_ret_code = 0
+            verify_output = "Secondary verification not needed: Code was not modified by the fixer."
+            if verbose:
+                console.print(f"[dim]{verify_output}[/dim]")
+
+        # Always log the SecondaryVerification block
+        passed_str = str(secondary_verification_passed).lower()
+        iteration_log_xml += f'  <SecondaryVerification passed="{passed_str}">\n'
+        iteration_log_xml += f'    <ExitCode>{verify_ret_code}</ExitCode>\n'
+        iteration_log_xml += f'    <Output>{escape(verify_output)}</Output>\n'
+        iteration_log_xml += f'  </SecondaryVerification>\n'
 
         # Now, decide outcome based on issue count and verification status
         if secondary_verification_passed: