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

pdd/agentic_e2e_fix_orchestrator.py

@@ -0,0 +1,426 @@
+from __future__ import annotations
+
+import os
+import sys
+import time
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import List, Tuple, Dict, Any, Optional, Set
+
+from rich.console import Console
+
+from .agentic_common import (
+    run_agentic_task,
+    load_workflow_state,
+    save_workflow_state,
+    clear_workflow_state,
+)
+from .load_prompt_template import load_prompt_template
+
+# Constants
+STEP_NAMES = {
+    1: "unit_tests",
+    2: "e2e_tests",
+    3: "root_cause",
+    4: "fix_e2e_tests",
+    5: "identify_devunits",
+    6: "create_unit_tests",
+    7: "verify_tests",
+    8: "run_pdd_fix",
+    9: "verify_all",
+}
+
+STEP_DESCRIPTIONS = {
+    1: "Running unit tests from issue",
+    2: "Running e2e tests",
+    3: "Analyzing root cause",
+    4: "Fixing e2e tests",
+    5: "Identifying dev units",
+    6: "Creating unit tests",
+    7: "Verifying tests detect bugs",
+    8: "Running pdd fix",
+    9: "Final verification",
+}
+
+# Per-step timeouts for the 9-step agentic e2e fix workflow
+E2E_FIX_STEP_TIMEOUTS: Dict[int, float] = {
+    1: 340.0,   # Run unit tests from issue, pdd fix failures
+    2: 240.0,   # Run e2e tests, check completion (early exit)
+    3: 340.0,   # Root cause analysis (code vs test vs both)
+    4: 340.0,   # Fix e2e tests if needed
+    5: 340.0,   # Identify dev units involved in failures
+    6: 600.0,   # Create/append unit tests for dev units (Complex)
+    7: 600.0,   # Verify unit tests detect bugs (Complex)
+    8: 1000.0,  # Run pdd fix on failing dev units (Most Complex - multiple LLM calls)
+    9: 240.0,   # Final verification, loop control
+}
+
+console = Console()
+
+def _get_state_dir(cwd: Path) -> Path:
+    """Returns the state directory .pdd/e2e-fix-state/ relative to git root."""
+    # Simple heuristic: look for .git, otherwise use cwd
+    d = cwd.resolve()
+    root = d
+    while d != d.parent:
+        if (d / ".git").exists():
+            root = d
+            break
+        d = d.parent
+    
+    state_dir = root / ".pdd" / "e2e-fix-state"
+    state_dir.mkdir(parents=True, exist_ok=True)
+    return state_dir
+
+def _parse_changed_files(output: str) -> List[str]:
+    """Parses FILES_CREATED and FILES_MODIFIED from agent output."""
+    files = []
+    for line in output.splitlines():
+        if line.startswith("FILES_CREATED:") or line.startswith("FILES_MODIFIED:"):
+            # Extract content after colon
+            content = line.split(":", 1)[1].strip()
+            if content:
+                # Split by comma and strip
+                paths = [p.strip() for p in content.split(",") if p.strip()]
+                files.extend(paths)
+    return files
+
+def _parse_dev_units(output: str) -> str:
+    """Parses DEV_UNITS_IDENTIFIED from output."""
+    for line in output.splitlines():
+        if line.startswith("DEV_UNITS_IDENTIFIED:"):
+            return line.split(":", 1)[1].strip()
+    return ""
+
+def _update_dev_unit_states(output: str, current_states: Dict[str, Any], identified_units_str: str) -> Dict[str, Any]:
+    """Updates dev unit states based on Step 8 output."""
+    identified_units = [u.strip() for u in identified_units_str.split(",") if u.strip()]
+    
+    # Initialize if not present
+    for unit in identified_units:
+        if unit not in current_states:
+            current_states[unit] = {"fixed": False, "fix_attempts": 0}
+        current_states[unit]["fix_attempts"] += 1
+
+    # Parse results from output
+    # Heuristic: look for "unit_name: FIXED" or "unit_name: Failed"
+    # This depends on the LLM following instructions in Step 8 prompt.
+    for line in output.splitlines():
+        for unit in identified_units:
+            if unit in line:
+                if "FIXED" in line:
+                    current_states[unit]["fixed"] = True
+                elif "Failed" in line or "FAIL" in line:
+                    current_states[unit]["fixed"] = False
+    
+    return current_states
+
+def _check_staleness(state: Dict[str, Any], cwd: Path) -> None:
+    """Checks if files have changed since state was saved."""
+    last_saved_str = state.get("last_saved_at")
+    if not last_saved_str:
+        return
+
+    try:
+        last_saved = datetime.fromisoformat(last_saved_str)
+    except ValueError:
+        return
+
+    changed_files = state.get("changed_files", [])
+    stale = False
+    
+    for file_path in changed_files:
+        p = cwd / file_path
+        if not p.exists():
+            console.print(f"[yellow]Warning: File '{file_path}' from previous state is missing.[/yellow]")
+            continue
+        
+        # Check mtime
+        mtime = datetime.fromtimestamp(p.stat().st_mtime)
+        if mtime > last_saved:
+            stale = True
+            break
+    
+    if stale:
+        console.print("[yellow]Warning: Codebase may have changed since last run. Consider --no-resume for fresh start.[/yellow]")
+
+def run_agentic_e2e_fix_orchestrator(
+    issue_url: str,
+    issue_content: str,
+    repo_owner: str,
+    repo_name: str,
+    issue_number: int,
+    issue_author: str,
+    issue_title: str,
+    *,
+    cwd: Path,
+    timeout_adder: float = 0.0,
+    max_cycles: int = 5,
+    resume: bool = True,
+    verbose: bool = False,
+    quiet: bool = False,
+    use_github_state: bool = True
+) -> Tuple[bool, str, float, str, List[str]]:
+    """
+    Orchestrator for the 9-step agentic e2e fix workflow.
+    
+    Returns:
+        Tuple[bool, str, float, str, List[str]]: 
+        (success, final_message, total_cost, model_used, changed_files)
+    """
+    state_dir = _get_state_dir(cwd)
+    workflow_name = "e2e_fix"
+    
+    # Initialize state variables
+    current_cycle = 0
+    last_completed_step = 0
+    step_outputs: Dict[str, str] = {}
+    total_cost = 0.0
+    model_used = "unknown"
+    changed_files: List[str] = []
+    dev_unit_states: Dict[str, Any] = {}
+    github_comment_id: Optional[int] = None
+    
+    # Resume Logic
+    if resume:
+        loaded_state, gh_id = load_workflow_state(
+            cwd, issue_number, workflow_name, state_dir, repo_owner, repo_name, use_github_state
+        )
+        if loaded_state:
+            console.print(f"[blue]Resuming from cycle {loaded_state.get('current_cycle', 1)} step {loaded_state.get('last_completed_step', 0)}...[/blue]")
+            current_cycle = loaded_state.get("current_cycle", 0)
+            last_completed_step = loaded_state.get("last_completed_step", 0)
+            step_outputs = loaded_state.get("step_outputs", {})
+            total_cost = loaded_state.get("total_cost", 0.0)
+            model_used = loaded_state.get("model_used", "unknown")
+            changed_files = loaded_state.get("changed_files", [])
+            dev_unit_states = loaded_state.get("dev_unit_states", {})
+            github_comment_id = gh_id
+            
+            _check_staleness(loaded_state, cwd)
+            
+            # If we finished a cycle but didn't exit, prepare for next cycle
+            if last_completed_step >= 9:
+                current_cycle += 1
+                last_completed_step = 0
+                step_outputs = {} # Clear outputs for new cycle
+        else:
+            # No state found, start fresh
+            clear_workflow_state(cwd, issue_number, workflow_name, state_dir, repo_owner, repo_name, use_github_state)
+    else:
+        clear_workflow_state(cwd, issue_number, workflow_name, state_dir, repo_owner, repo_name, use_github_state)
+
+    console.print(f"Fixing e2e tests for issue #{issue_number}: \"{issue_title}\"")
+
+    success = False
+    final_message = ""
+
+    try:
+        # Outer Loop
+        if current_cycle == 0:
+            current_cycle = 1
+        
+        while current_cycle <= max_cycles:
+            console.print(f"\n[bold cyan][Cycle {current_cycle}/{max_cycles}] Starting fix cycle...[/bold cyan]")
+            
+            # Inner Loop (Steps 1-9)
+            for step_num in range(1, 10):
+                if step_num <= last_completed_step:
+                    continue # Skip already completed steps in this cycle
+
+                step_name = STEP_NAMES[step_num]
+                description = STEP_DESCRIPTIONS[step_num]
+                
+                console.print(f"[bold][Step {step_num}/9] {description}...[/bold]")
+                
+                # 1. Load Prompt
+                template_name = f"agentic_e2e_fix_step{step_num}_{step_name}_LLM"
+                prompt_template = load_prompt_template(template_name)
+                if not prompt_template:
+                    raise ValueError(f"Could not load prompt template: {template_name}")
+
+                # 2. Prepare Context
+                context = {
+                    "issue_url": issue_url,
+                    "repo_owner": repo_owner,
+                    "repo_name": repo_name,
+                    "issue_number": issue_number,
+                    "cycle_number": current_cycle,
+                    "max_cycles": max_cycles,
+                    "issue_content": issue_content,
+                }
+                
+                # Add previous step outputs
+                for prev_step in range(1, step_num):
+                    key = f"step{prev_step}_output"
+                    context[key] = step_outputs.get(str(prev_step), "")
+
+                # Derived variables for specific steps
+                if step_num >= 6:
+                    s5_out = step_outputs.get("5", "")
+                    context["dev_units_identified"] = _parse_dev_units(s5_out)
+                
+                if step_num == 8:
+                    s5_out = step_outputs.get("5", "")
+                    context["failing_dev_units"] = _parse_dev_units(s5_out)
+
+                if step_num == 9:
+                    context["next_cycle"] = current_cycle + 1
+
+                formatted_prompt = prompt_template.format(**context)
+
+                # 3. Run Task
+                base_timeout = E2E_FIX_STEP_TIMEOUTS.get(step_num, 340.0)
+                timeout = base_timeout + timeout_adder
+                
+                step_success, step_output, step_cost, step_model = run_agentic_task(
+                    instruction=formatted_prompt,
+                    cwd=cwd,
+                    verbose=verbose,
+                    quiet=quiet,
+                    timeout=timeout,
+                    label=f"cycle{current_cycle}_step{step_num}"
+                )
+
+                # 4. Store Output & Accumulate
+                step_outputs[str(step_num)] = step_output
+                total_cost += step_cost
+                model_used = step_model if step_model else model_used
+                
+                # Parse changed files
+                new_files = _parse_changed_files(step_output)
+                for f in new_files:
+                    if f not in changed_files:
+                        changed_files.append(f)
+
+                # Parse dev unit states (Step 8)
+                if step_num == 8:
+                    s5_out = step_outputs.get("5", "")
+                    dev_units_str = _parse_dev_units(s5_out)
+                    dev_unit_states = _update_dev_unit_states(step_output, dev_unit_states, dev_units_str)
+
+                # Print brief result
+                console.print(f"  -> Step {step_num} complete. Cost: ${step_cost:.4f}")
+
+                # 5. Save State
+                last_completed_step = step_num
+                state_data = {
+                    "workflow": workflow_name,
+                    "issue_url": issue_url,
+                    "issue_number": issue_number,
+                    "current_cycle": current_cycle,
+                    "last_completed_step": last_completed_step,
+                    "step_outputs": step_outputs,
+                    "dev_unit_states": dev_unit_states,
+                    "total_cost": total_cost,
+                    "model_used": model_used,
+                    "changed_files": changed_files,
+                    "last_saved_at": datetime.now().isoformat(),
+                    "github_comment_id": github_comment_id
+                }
+                
+                new_gh_id = save_workflow_state(
+                    cwd, issue_number, workflow_name, state_data, state_dir, repo_owner, repo_name, use_github_state, github_comment_id
+                )
+                if new_gh_id:
+                    github_comment_id = new_gh_id
+
+                # Check Early Exit (Step 2)
+                if step_num == 2 and "ALL_TESTS_PASS" in step_output:
+                    console.print("[green]ALL_TESTS_PASS detected in Step 2. Exiting loop.[/green]")
+                    success = True
+                    final_message = "All tests passed during e2e check."
+                    break
+
+                # Check Loop Control (Step 9)
+                if step_num == 9:
+                    if "ALL_TESTS_PASS" in step_output:
+                        console.print("[green]ALL_TESTS_PASS detected in Step 9.[/green]")
+                        success = True
+                        final_message = "All tests passed after fixes."
+                        break
+                    elif "MAX_CYCLES_REACHED" in step_output:
+                        console.print("[yellow]MAX_CYCLES_REACHED detected in Step 9.[/yellow]")
+                    elif "CONTINUE_CYCLE" not in step_output:
+                        console.print("[yellow]Warning: No loop control token found in Step 9. Defaulting to CONTINUE_CYCLE.[/yellow]")
+
+            if success:
+                break
+            
+            # Prepare for next cycle
+            current_cycle += 1
+            last_completed_step = 0
+            step_outputs = {} # Clear outputs for next cycle
+            
+            state_data["current_cycle"] = current_cycle
+            state_data["last_completed_step"] = 0
+            state_data["step_outputs"] = {}
+            state_data["last_saved_at"] = datetime.now().isoformat()
+            
+            if current_cycle <= max_cycles:
+                 save_workflow_state(
+                    cwd, issue_number, workflow_name, state_data, state_dir, repo_owner, repo_name, use_github_state, github_comment_id
+                )
+
+        if success:
+            clear_workflow_state(cwd, issue_number, workflow_name, state_dir, repo_owner, repo_name, use_github_state)
+            console.print("\n[bold green]E2E fix complete[/bold green]")
+            console.print(f"   Total cost: ${total_cost:.4f}")
+            console.print(f"   Cycles used: {current_cycle if current_cycle <= max_cycles else max_cycles}/{max_cycles}")
+            console.print(f"   Files changed: {', '.join(changed_files)}")
+            fixed_units = [u for u, s in dev_unit_states.items() if s.get("fixed")]
+            console.print(f"   Dev units fixed: {', '.join(fixed_units)}")
+            return True, final_message, total_cost, model_used, changed_files
+        else:
+            final_message = f"Max cycles ({max_cycles}) reached without all tests passing"
+            console.print("\n[bold red]E2E fix incomplete (max cycles reached)[/bold red]")
+            console.print(f"   Total cost: ${total_cost:.4f}")
+            remaining = [u for u, s in dev_unit_states.items() if not s.get("fixed")]
+            console.print(f"   Remaining failures: {', '.join(remaining)}")
+            return False, final_message, total_cost, model_used, changed_files
+
+    except KeyboardInterrupt:
+        console.print("\n[bold red]Interrupted by user. Saving state...[/bold red]")
+        state_data = {
+            "workflow": workflow_name,
+            "issue_url": issue_url,
+            "issue_number": issue_number,
+            "current_cycle": current_cycle,
+            "last_completed_step": last_completed_step,
+            "step_outputs": step_outputs,
+            "dev_unit_states": dev_unit_states,
+            "total_cost": total_cost,
+            "model_used": model_used,
+            "changed_files": changed_files,
+            "last_saved_at": datetime.now().isoformat(),
+            "github_comment_id": github_comment_id
+        }
+        save_workflow_state(
+            cwd, issue_number, workflow_name, state_data, state_dir, repo_owner, repo_name, use_github_state, github_comment_id
+        )
+        raise
+
+    except Exception as e:
+        console.print(f"\n[bold red]Fatal error: {e}[/bold red]")
+        try:
+            state_data = {
+                "workflow": workflow_name,
+                "issue_url": issue_url,
+                "issue_number": issue_number,
+                "current_cycle": current_cycle,
+                "last_completed_step": last_completed_step,
+                "step_outputs": step_outputs,
+                "dev_unit_states": dev_unit_states,
+                "total_cost": total_cost,
+                "model_used": model_used,
+                "changed_files": changed_files,
+                "last_saved_at": datetime.now().isoformat(),
+                "github_comment_id": github_comment_id
+            }
+            save_workflow_state(
+                cwd, issue_number, workflow_name, state_data, state_dir, repo_owner, repo_name, use_github_state, github_comment_id
+            )
+        except Exception:
+            pass
+        return False, f"Stopped at cycle {current_cycle} step {last_completed_step}: {str(e)}", total_cost, model_used, changed_files

pdd/agentic_fix.py

@@ -4,6 +4,7 @@ import os
 import re
 import shutil
 import subprocess
+import sys
 import difflib
 import tempfile
 from pathlib import Path
@@ -56,6 +57,68 @@ def _verbose(msg: str) -> None:
     if _IS_VERBOSE:
         console.print(msg)
 
+
+def _detect_suspicious_files(cwd: Path, context: str = "") -> List[Path]:
+    """
+    Detect suspicious single-character files (like C, E, T) in a directory.
+
+    This is a diagnostic function to help identify when/where these files are created.
+    Issue #186: Empty files named C, E, T (first letters of Code, Example, Test)
+    have been appearing during agentic operations.
+
+    Args:
+        cwd: Directory to scan
+        context: Description of what operation just ran (for logging)
+
+    Returns:
+        List of suspicious file paths found
+    """
+    suspicious: List[Path] = []
+    try:
+        for f in cwd.iterdir():
+            if f.is_file() and len(f.name) <= 2 and not f.name.startswith('.'):
+                suspicious.append(f)
+
+        if suspicious:
+            import datetime
+            timestamp = datetime.datetime.now().isoformat()
+            _always(f"[bold red]⚠️  SUSPICIOUS FILES DETECTED (Issue #186)[/bold red]")
+            _always(f"[red]Timestamp: {timestamp}[/red]")
+            _always(f"[red]Context: {context}[/red]")
+            _always(f"[red]Directory: {cwd}[/red]")
+            for sf in suspicious:
+                try:
+                    size = sf.stat().st_size
+                    _always(f"[red]  - {sf.name} (size: {size} bytes)[/red]")
+                except Exception:
+                    _always(f"[red]  - {sf.name} (could not stat)[/red]")
+
+            # Also log to a file for persistence
+            log_file = Path.home() / ".pdd" / "suspicious_files.log"
+            log_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(log_file, "a") as lf:
+                lf.write(f"\n{'='*60}\n")
+                lf.write(f"Timestamp: {timestamp}\n")
+                lf.write(f"Context: {context}\n")
+                lf.write(f"Directory: {cwd}\n")
+                lf.write(f"CWD at detection: {Path.cwd()}\n")
+                for sf in suspicious:
+                    try:
+                        size = sf.stat().st_size
+                        lf.write(f"  - {sf.name} (size: {size} bytes)\n")
+                    except Exception as e:
+                        lf.write(f"  - {sf.name} (error: {e})\n")
+                # Log stack trace to help identify caller
+                import traceback
+                lf.write("Stack trace:\n")
+                lf.write(traceback.format_stack()[-10:][0] if traceback.format_stack() else "N/A")
+                lf.write("\n")
+    except Exception as e:
+        _verbose(f"[yellow]Could not scan for suspicious files: {e}[/yellow]")
+
+    return suspicious
+
+
 def _begin_marker(path: Path) -> str:
     """Marker that must wrap the BEGIN of a corrected file block emitted by the agent."""
     return f"<<<BEGIN_FILE:{path}>>>"
@@ -130,10 +193,41 @@ _MULTI_FILE_BLOCK_RE = re.compile(
     re.DOTALL,
 )
 
+
+def _is_suspicious_path(path: str) -> bool:
+    """
+    Reject paths that look like LLM artifacts or template variables.
+
+    This defends against:
+    - Single/double character filenames (e.g., 'C', 'E', 'T' from agent misbehavior)
+    - Template variables like {path}, {code_abs} captured by regex
+    - Other LLM-generated garbage patterns
+
+    Returns True if the path should be rejected.
+    """
+    if not path:
+        return True
+    # Get the basename for validation
+    base_name = Path(path).name
+    # Reject single or double character filenames (too short to be legitimate)
+    if len(base_name) <= 2:
+        return True
+    # Reject template variable patterns like {path}, {code_abs}
+    if '{' in base_name or '}' in base_name:
+        return True
+    # Reject paths that are just dots like "..", "..."
+    if base_name.strip('.') == '':
+        return True
+    return False
+
+
 def _extract_files_from_output(*blobs: str) -> Dict[str, str]:
     """
     Parse stdout/stderr blobs and collect all emitted file blocks into {path: content}.
     Returns an empty dict if none found.
+
+    Note: Suspicious paths (single-char, template variables) are rejected to prevent
+    LLM artifacts from being written to disk.
     """
     out: Dict[str, str] = {}
     for blob in blobs:
@@ -143,6 +237,9 @@ def _extract_files_from_output(*blobs: str) -> Dict[str, str]:
             path = (m.group(1) or "").strip()
             body = m.group(2) or ""
             if path and body != "":
+                if _is_suspicious_path(path):
+                    _info(f"[yellow]Skipping suspicious path from LLM output: {path!r}[/yellow]")
+                    continue
                 out[path] = body
     return out
 
@@ -401,6 +498,12 @@ def _run_anthropic_variants(prompt_text: str, cwd: Path, total_timeout: int, lab
         return last
     finally:
         prompt_file.unlink(missing_ok=True)
+        # Issue #186: Scan for suspicious files after Anthropic agent runs
+        _detect_suspicious_files(cwd, f"After _run_anthropic_variants ({label})")
+        # Also scan project root in case agent created files there
+        project_root = Path.cwd()
+        if project_root != cwd:
+            _detect_suspicious_files(project_root, f"After _run_anthropic_variants ({label}) - project root")
 
 def _run_cli_args_google(args: List[str], cwd: Path, timeout: int) -> subprocess.CompletedProcess:
     """Subprocess runner for Google commands with common sanitized env."""
@@ -460,6 +563,12 @@ def _run_google_variants(prompt_text: str, cwd: Path, total_timeout: int, label:
         return last
     finally:
         prompt_file.unlink(missing_ok=True)
+        # Issue #186: Scan for suspicious files after Google agent runs
+        _detect_suspicious_files(cwd, f"After _run_google_variants ({label})")
+        # Also scan project root in case agent created files there
+        project_root = Path.cwd()
+        if project_root != cwd:
+            _detect_suspicious_files(project_root, f"After _run_google_variants ({label}) - project root")
 
 def _run_testcmd(cmd: str, cwd: Path) -> bool:
     """
@@ -498,7 +607,7 @@ def _verify_and_log(unit_test_file: str, cwd: Path, *, verify_cmd: Optional[str]
         return _run_testcmd(run_cmd, cwd)
     # Fallback: try running with Python if no run command found
     verify = subprocess.run(
-        [os.sys.executable, str(Path(unit_test_file).resolve())],
+        [sys.executable, str(Path(unit_test_file).resolve())],
         capture_output=True,
         text=True,
         check=False,
@@ -549,10 +658,16 @@ def _normalize_target_path(
 ) -> Optional[Path]:
     """
     Resolve an emitted path to a safe file path we should write:
+    - reject suspicious paths (single-char, template variables)
     - make path absolute under project root
     - allow direct match, primary-file match (with/without _fixed), or basename search
     - create new files only if allow_new is True
     """
+    # Early rejection of suspicious paths (defense against LLM artifacts)
+    if _is_suspicious_path(emitted_path):
+        _info(f"[yellow]Skipping suspicious path: {emitted_path!r}[/yellow]")
+        return None
+
     p = Path(emitted_path)
     if not p.is_absolute():
         p = (project_root / emitted_path).resolve()
@@ -760,7 +875,7 @@ def _try_harvest_then_verify(
                 newest = code_path.read_text(encoding="utf-8")
                 _print_diff(code_snapshot, newest, code_path)
                 ok = _post_apply_verify_or_testcmd(
-                    provider, unit_test_file, working_dir,
+                    provider, unit_test_file, cwd,
                     verify_cmd=verify_cmd, verify_enabled=verify_enabled,
                     stdout=res.stdout or "", stderr=res.stderr or ""
                 )
@@ -952,7 +1067,7 @@ def run_agentic_fix(
                     else:
                         # Fallback: run directly with Python interpreter
                         pre = subprocess.run(
-                            [os.sys.executable, str(Path(unit_test_file).resolve())],
+                            [sys.executable, str(Path(unit_test_file).resolve())],
                             capture_output=True,
                             text=True,
                             check=False,