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

pdd/__init__.py

@@ -2,7 +2,7 @@
 
 import os
 
-__version__ = "0.0.118"
+__version__ = "0.0.121"
 
 # Strength parameter used for LLM extraction across the codebase
 # Used in postprocessing, XML tagging, code generation, and other extraction

pdd/agentic_bug_orchestrator.py

@@ -12,7 +12,8 @@ from .agentic_common import (
     run_agentic_task,
     load_workflow_state,
     save_workflow_state,
-    clear_workflow_state
+    clear_workflow_state,
+    DEFAULT_MAX_RETRIES
 )
 from .load_prompt_template import load_prompt_template
 
@@ -357,6 +358,7 @@ def run_agentic_bug_orchestrator(
             quiet=quiet,
             label=f"step{step_num}",
             timeout=BUG_STEP_TIMEOUTS.get(step_num, 340.0) + timeout_adder,
+            max_retries=DEFAULT_MAX_RETRIES,
         )
 
         # Update tracking
@@ -441,17 +443,24 @@ def run_agentic_bug_orchestrator(
             console.print(f"  → Step {step_num} complete.")
 
         # Save state after each step (for resume support)
-        step_outputs[str(step_num)] = output
-        
+        # Only mark step completed if it succeeded; failed steps get "FAILED:" prefix
+        # and last_completed_step stays at previous step (ensures resume re-runs failed step)
+        if success:
+            step_outputs[str(step_num)] = output
+            last_completed_step_to_save = step_num
+        else:
+            step_outputs[str(step_num)] = f"FAILED: {output}"
+            last_completed_step_to_save = step_num - 1
+
         new_state = {
             "workflow": "bug",
             "issue_number": issue_number,
             "issue_url": issue_url,
-            "last_completed_step": step_num,
-            "step_outputs": step_outputs,
+            "last_completed_step": last_completed_step_to_save,
+            "step_outputs": step_outputs.copy(),  # Copy to avoid shared reference
             "total_cost": total_cost,
             "model_used": last_model_used,
-            "changed_files": changed_files,
+            "changed_files": changed_files.copy(),  # Copy to avoid shared reference
             "worktree_path": str(worktree_path) if worktree_path else None,
             "github_comment_id": github_comment_id
         }

pdd/agentic_change_orchestrator.py

@@ -20,6 +20,7 @@ from pdd.agentic_common import (
     load_workflow_state,
     save_workflow_state,
     clear_workflow_state,
+    DEFAULT_MAX_RETRIES,
 )
 from pdd.load_prompt_template import load_prompt_template
 
@@ -325,7 +326,8 @@ def run_agentic_change_orchestrator(
             verbose=verbose,
             quiet=quiet,
             timeout=timeout,
-            label=f"step{step_num}"
+            label=f"step{step_num}",
+            max_retries=DEFAULT_MAX_RETRIES,
         )
 
         # Update tracking
@@ -370,10 +372,16 @@ def run_agentic_change_orchestrator(
                 return False, "Stopped at step 9: Implementation produced no file changes", total_cost, model_used, []
 
         # Update Context & State
+        # Only mark step completed if it succeeded; failed steps get "FAILED:" prefix
+        # and last_completed_step stays at previous step (ensures resume re-runs failed step)
         context[f"step{step_num}_output"] = step_output
-        state["step_outputs"][str(step_num)] = step_output
-        state["last_completed_step"] = step_num
-        
+        if step_success:
+            state["step_outputs"][str(step_num)] = step_output
+            state["last_completed_step"] = step_num
+        else:
+            state["step_outputs"][str(step_num)] = f"FAILED: {step_output}"
+            # Don't update last_completed_step - keep it at previous value
+
         # Save State
         save_result = save_workflow_state(cwd, issue_number, "change", state, state_dir, repo_owner, repo_name, use_github_state, github_comment_id)
         if save_result:
@@ -423,7 +431,8 @@ def run_agentic_change_orchestrator(
                 verbose=verbose,
                 quiet=quiet,
                 timeout=timeout10,
-                label=f"step10_iter{review_iteration}"
+                label=f"step10_iter{review_iteration}",
+                max_retries=DEFAULT_MAX_RETRIES,
             )
             
             total_cost += s10_cost
@@ -454,7 +463,8 @@ def run_agentic_change_orchestrator(
                 verbose=verbose,
                 quiet=quiet,
                 timeout=timeout11,
-                label=f"step11_iter{review_iteration}"
+                label=f"step11_iter{review_iteration}",
+                max_retries=DEFAULT_MAX_RETRIES,
             )
             
             total_cost += s11_cost
@@ -488,7 +498,8 @@ def run_agentic_change_orchestrator(
             verbose=verbose,
             quiet=quiet,
             timeout=timeout12,
-            label="step12"
+            label="step12",
+            max_retries=DEFAULT_MAX_RETRIES,
         )
         
         total_cost += s12_cost

pdd/agentic_common.py

@@ -6,6 +6,7 @@ import json
 import shutil
 import subprocess
 import tempfile
+import time
 import uuid
 import re
 from pathlib import Path
@@ -24,6 +25,8 @@ except ImportError:
 AGENT_PROVIDER_PREFERENCE: List[str] = ["anthropic", "google", "openai"]
 DEFAULT_TIMEOUT_SECONDS: float = 240.0
 MIN_VALID_OUTPUT_LENGTH: int = 50
+DEFAULT_MAX_RETRIES: int = 3
+DEFAULT_RETRY_DELAY: float = 5.0
 
 # GitHub State Markers
 GITHUB_STATE_MARKER_START = "<!-- PDD_WORKFLOW_STATE:"
@@ -122,25 +125,37 @@ def _calculate_codex_cost(usage: Dict[str, Any]) -> float:
     return input_cost + cached_cost + output_cost
 
 def run_agentic_task(
-    instruction: str, 
-    cwd: Path, 
-    *, 
-    verbose: bool = False, 
-    quiet: bool = False, 
-    label: str = "", 
-    timeout: Optional[float] = None
+    instruction: str,
+    cwd: Path,
+    *,
+    verbose: bool = False,
+    quiet: bool = False,
+    label: str = "",
+    timeout: Optional[float] = None,
+    max_retries: int = 1,
+    retry_delay: float = DEFAULT_RETRY_DELAY
 ) -> Tuple[bool, str, float, str]:
     """
     Runs an agentic task using available providers in preference order.
-    
+
+    Args:
+        instruction: The task instruction
+        cwd: Working directory
+        verbose: Show detailed output
+        quiet: Suppress all non-error output
+        label: Task label for logging
+        timeout: Optional timeout override
+        max_retries: Number of attempts per provider before fallback (default: 1 = no retries)
+        retry_delay: Base delay in seconds for exponential backoff (default: DEFAULT_RETRY_DELAY)
+
     Returns:
         (success, output_text, cost_usd, provider_used)
     """
     agents = get_available_agents()
-    
+
     # Filter agents based on preference order
     candidates = [p for p in AGENT_PROVIDER_PREFERENCE if p in agents]
-    
+
     if not candidates:
         msg = "No agent providers are available (check CLI installation and API keys)"
         if not quiet:
@@ -148,11 +163,11 @@ def run_agentic_task(
         return False, msg, 0.0, ""
 
     effective_timeout = timeout if timeout is not None else DEFAULT_TIMEOUT_SECONDS
-    
+
     # Create a unique temp file for the prompt
     prompt_filename = f".agentic_prompt_{uuid.uuid4().hex[:8]}.txt"
     prompt_path = cwd / prompt_filename
-    
+
     full_instruction = (
         f"{instruction}\n\n"
         f"Read the file {prompt_filename} for instructions. "
@@ -168,34 +183,47 @@ def run_agentic_task(
             if verbose:
                 console.print(f"[dim]Attempting provider: {provider} for task '{label}'[/dim]")
 
-            success, output, cost = _run_with_provider(
-                provider, prompt_path, cwd, effective_timeout, verbose, quiet
-            )
-
-            # False Positive Detection
-            if success:
-                is_false_positive = (cost == 0.0 and len(output.strip()) < MIN_VALID_OUTPUT_LENGTH)
-                
-                if is_false_positive:
-                    if not quiet:
-                        console.print(f"[bold red]Provider '{provider}' returned success but appears to be a false positive (Cost: {cost}, Len: {len(output)})[/bold red]")
-                    # Treat as failure, try next provider
-                    continue
-                
-                # Check for suspicious files (C, E, T)
-                suspicious = []
-                for name in ["C", "E", "T"]:
-                    if (cwd / name).exists():
-                        suspicious.append(name)
-                
-                if suspicious:
-                    console.print(f"[bold red]SUSPICIOUS FILES DETECTED: {', '.join(['- ' + s for s in suspicious])}[/bold red]")
-
-                # Real success
-                return True, output, cost, provider
-            else:
-                if verbose:
-                    console.print(f"[yellow]Provider {provider} failed: {output}[/yellow]")
+            last_output = ""
+            for attempt in range(1, max_retries + 1):
+                if verbose and attempt > 1:
+                    console.print(f"[dim]Retry {attempt}/{max_retries} for {provider} (task: {label})[/dim]")
+
+                success, output, cost = _run_with_provider(
+                    provider, prompt_path, cwd, effective_timeout, verbose, quiet
+                )
+                last_output = output
+
+                # False Positive Detection
+                if success:
+                    is_false_positive = (cost == 0.0 and len(output.strip()) < MIN_VALID_OUTPUT_LENGTH)
+
+                    if is_false_positive:
+                        if not quiet:
+                            console.print(f"[yellow]Provider '{provider}' returned false positive (attempt {attempt})[/yellow]")
+                        # Treat as failure, retry
+                    else:
+                        # Check for suspicious files (C, E, T)
+                        suspicious = []
+                        for name in ["C", "E", "T"]:
+                            if (cwd / name).exists():
+                                suspicious.append(name)
+
+                        if suspicious:
+                            console.print(f"[bold red]SUSPICIOUS FILES DETECTED: {', '.join(['- ' + s for s in suspicious])}[/bold red]")
+
+                        # Real success
+                        return True, output, cost, provider
+
+                # Failed - retry with backoff if attempts remain
+                if attempt < max_retries:
+                    backoff = retry_delay * attempt
+                    if verbose:
+                        console.print(f"[dim]Waiting {backoff}s before retry...[/dim]")
+                    time.sleep(backoff)
+
+            # All retries exhausted for this provider
+            if verbose:
+                console.print(f"[yellow]Provider {provider} failed after {max_retries} attempts: {last_output}[/yellow]")
 
         return False, "All agent providers failed", 0.0, ""
 

pdd/agentic_crash.py

@@ -8,7 +8,7 @@ from typing import Any, Iterable, Mapping
 
 from rich.console import Console
 
-from .agentic_common import get_available_agents, run_agentic_task
+from .agentic_common import get_available_agents, run_agentic_task, DEFAULT_MAX_RETRIES
 from .get_run_command import get_run_command_for_file
 from .load_prompt_template import load_prompt_template
 
@@ -458,6 +458,7 @@ def run_agentic_crash(
             verbose=verbose,
             quiet=quiet,
             label="agentic_crash_explore",
+            max_retries=DEFAULT_MAX_RETRIES,
         )
     except Exception as exc:  # noqa: BLE001
         msg = f"Agentic CLI invocation failed: {exc}"

pdd/agentic_e2e_fix_orchestrator.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import hashlib
 import os
+import subprocess
 import sys
 import time
 import json
@@ -15,6 +17,7 @@ from .agentic_common import (
     load_workflow_state,
     save_workflow_state,
     clear_workflow_state,
+    DEFAULT_MAX_RETRIES,
 )
 from .load_prompt_template import load_prompt_template
 
@@ -145,6 +148,131 @@ def _check_staleness(state: Dict[str, Any], cwd: Path) -> None:
     if stale:
         console.print("[yellow]Warning: Codebase may have changed since last run. Consider --no-resume for fresh start.[/yellow]")
 
+
+def _get_modified_and_untracked(cwd: Path) -> Set[str]:
+    """Returns set of modified tracked files plus untracked files."""
+    files: Set[str] = set()
+
+    # Get modified tracked files
+    result = subprocess.run(
+        ["git", "diff", "--name-only", "HEAD"],
+        cwd=cwd,
+        capture_output=True,
+        text=True
+    )
+    if result.returncode == 0:
+        files.update(f for f in result.stdout.strip().split("\n") if f)
+
+    # Get untracked files
+    result = subprocess.run(
+        ["git", "ls-files", "--others", "--exclude-standard"],
+        cwd=cwd,
+        capture_output=True,
+        text=True
+    )
+    if result.returncode == 0:
+        files.update(f for f in result.stdout.strip().split("\n") if f)
+
+    return files
+
+
+def _get_file_hashes(cwd: Path) -> Dict[str, Optional[str]]:
+    """
+    Returns {filepath: md5_hash} for all modified and untracked files.
+
+    If a file is deleted or unreadable, stores None for that file.
+    """
+    hashes: Dict[str, Optional[str]] = {}
+    for filepath in _get_modified_and_untracked(cwd):
+        path = cwd / filepath
+        if path.exists() and path.is_file():
+            try:
+                hashes[filepath] = hashlib.md5(path.read_bytes()).hexdigest()
+            except (IOError, OSError):
+                hashes[filepath] = None
+        else:
+            hashes[filepath] = None  # Deleted or not a file
+    return hashes
+
+
+def _commit_and_push(
+    cwd: Path,
+    issue_number: int,
+    issue_title: str,
+    initial_file_hashes: Dict[str, Optional[str]],
+    quiet: bool = False
+) -> Tuple[bool, str]:
+    """
+    Commits only files that changed during the workflow and pushes.
+
+    Uses hash comparison to detect actual content changes, avoiding
+    staging pre-existing modified/untracked files.
+
+    The PR was already created by `pdd bug`, so pushing
+    automatically updates it.
+
+    Args:
+        cwd: Working directory
+        issue_number: GitHub issue number
+        issue_title: Issue title for commit message
+        initial_file_hashes: File hashes from before workflow started
+        quiet: Suppress output
+
+    Returns:
+        (success, message)
+    """
+    # Get current file hashes
+    current_hashes = _get_file_hashes(cwd)
+
+    # Find files that changed during workflow
+    files_to_commit: List[str] = []
+    for filepath, current_hash in current_hashes.items():
+        if filepath not in initial_file_hashes:
+            # New file created during workflow
+            files_to_commit.append(filepath)
+        elif initial_file_hashes[filepath] != current_hash:
+            # Content changed during workflow
+            files_to_commit.append(filepath)
+
+    if not files_to_commit:
+        return True, "No changes to commit"
+
+    # Stage only workflow-changed files
+    for filepath in files_to_commit:
+        stage_result = subprocess.run(
+            ["git", "add", filepath],
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        if stage_result.returncode != 0:
+            return False, f"Failed to stage {filepath}: {stage_result.stderr}"
+
+    # Commit with message referencing issue
+    commit_msg = f"fix: {issue_title}\n\nFixes #{issue_number}"
+    commit_result = subprocess.run(
+        ["git", "commit", "-m", commit_msg],
+        cwd=cwd,
+        capture_output=True,
+        text=True
+    )
+    if commit_result.returncode != 0:
+        return False, f"Failed to commit: {commit_result.stderr}"
+
+    # Push to remote (branch already exists from pdd bug)
+    push_result = subprocess.run(
+        ["git", "push"],
+        cwd=cwd,
+        capture_output=True,
+        text=True
+    )
+
+    if push_result.returncode == 0:
+        return True, f"Committed and pushed {len(files_to_commit)} file(s)"
+    else:
+        return False, f"Push failed: {push_result.stderr}"
+
+
 def run_agentic_e2e_fix_orchestrator(
     issue_url: str,
     issue_content: str,
@@ -213,6 +341,9 @@ def run_agentic_e2e_fix_orchestrator(
 
     console.print(f"Fixing e2e tests for issue #{issue_number}: \"{issue_title}\"")
 
+    # Snapshot file state before workflow (for hash-based commit detection)
+    initial_file_hashes = _get_file_hashes(cwd)
+
     success = False
     final_message = ""
 
@@ -273,21 +404,30 @@ def run_agentic_e2e_fix_orchestrator(
                 # 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}"
+                    label=f"cycle{current_cycle}_step{step_num}",
+                    max_retries=DEFAULT_MAX_RETRIES,
                 )
 
                 # 4. Store Output & Accumulate
-                step_outputs[str(step_num)] = step_output
+                # Only mark step completed if it succeeded; failed steps get "FAILED:" prefix
+                # and last_completed_step stays at previous step (ensures resume re-runs failed step)
+                if step_success:
+                    step_outputs[str(step_num)] = step_output
+                    last_completed_step = step_num
+                else:
+                    step_outputs[str(step_num)] = f"FAILED: {step_output}"
+                    # Don't update last_completed_step - keep it at previous value
+
                 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:
@@ -301,21 +441,23 @@ def run_agentic_e2e_fix_orchestrator(
                     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}")
+                if step_success:
+                    console.print(f"  -> Step {step_num} complete. Cost: ${step_cost:.4f}")
+                else:
+                    console.print(f"  -> Step {step_num} [red]failed[/red]. 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,
+                    "step_outputs": step_outputs.copy(),  # Copy to avoid shared reference
+                    "dev_unit_states": dev_unit_states.copy(),  # Copy to avoid shared reference
                     "total_cost": total_cost,
                     "model_used": model_used,
-                    "changed_files": changed_files,
+                    "changed_files": changed_files.copy(),  # Copy to avoid shared reference
                     "last_saved_at": datetime.now().isoformat(),
                     "github_comment_id": github_comment_id
                 }
@@ -371,6 +513,20 @@ def run_agentic_e2e_fix_orchestrator(
             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)}")
+
+            # Commit and push changes to update the existing PR
+            commit_success, commit_message = _commit_and_push(
+                cwd=cwd,
+                issue_number=issue_number,
+                issue_title=issue_title,
+                initial_file_hashes=initial_file_hashes,
+                quiet=quiet
+            )
+            if commit_success:
+                console.print(f"   [green]{commit_message}[/green]")
+            else:
+                console.print(f"   [yellow]Warning: {commit_message}[/yellow]")
+
             return True, final_message, total_cost, model_used, changed_files
         else:
             final_message = f"Max cycles ({max_cycles}) reached without all tests passing"

pdd/agentic_update.py

@@ -18,7 +18,7 @@ import traceback
 from rich.console import Console
 from rich.markdown import Markdown
 
-from .agentic_common import get_available_agents, run_agentic_task
+from .agentic_common import get_available_agents, run_agentic_task, DEFAULT_MAX_RETRIES
 from .load_prompt_template import load_prompt_template
 
 # Optional globals from package root; ignore if not present.
@@ -337,6 +337,7 @@ def run_agentic_update(
             verbose=bool(verbose and not quiet),
             quiet=quiet,
             label=f"agentic_update:{code_path.stem}",
+            max_retries=DEFAULT_MAX_RETRIES,
         )
     except Exception as exc:
         message = f"Agentic task failed with an exception: {exc}"

pdd/agentic_verify.py

@@ -8,7 +8,7 @@ from typing import Any
 
 from rich.console import Console
 
-from .agentic_common import run_agentic_task
+from .agentic_common import run_agentic_task, DEFAULT_MAX_RETRIES
 from .load_prompt_template import load_prompt_template
 
 console = Console()
@@ -133,7 +133,8 @@ def run_agentic_verify(
         cwd=project_root,
         verbose=verbose,
         quiet=quiet,
-        label="verify-explore"
+        label="verify-explore",
+        max_retries=DEFAULT_MAX_RETRIES,
     )
 
     # 6. Record State After Execution & Detect Changes

pdd/auto_include.py

@@ -321,6 +321,54 @@ def _filter_circular_dependencies(dependencies: str, cycles: List[List[str]]) ->
     return result
 
 
+def _extract_includes(content: str) -> Set[str]:
+    """Extract all paths from <include> tags in the content.
+
+    Args:
+        content: The string content to search.
+
+    Returns:
+        A set of paths found in <include> tags.
+    """
+    pattern = r'<include>(.*?)</include>'
+    matches = re.findall(pattern, content, re.DOTALL)
+    return {m.strip() for m in matches}
+
+
+def _filter_existing_includes(input_prompt: str, dependencies: str) -> str:
+    """Remove includes from dependencies that already exist in the input prompt.
+
+    If the input prompt already has <include>path/to/file</include>, and the
+    generated dependencies also have <wrapper><include>path/to/file</include></wrapper>,
+    the duplicate in dependencies should be removed.
+
+    Args:
+        input_prompt: The original input prompt.
+        dependencies: The generated dependencies string.
+
+    Returns:
+        The dependencies string with duplicates removed.
+    """
+    existing_includes = _extract_includes(input_prompt)
+    if not existing_includes:
+        return dependencies
+
+    result = dependencies
+    for include_path in existing_includes:
+        # Remove any include block that contains this path
+        # Pattern matches: <wrapper><include>path</include></wrapper>
+        # We use re.escape for the path to handle special chars
+        pattern = rf'<[^>]+><include>{re.escape(include_path)}</include></[^>]+>\s*'
+        result = re.sub(pattern, '', result)
+        
+        # Also try to remove bare includes if they exist in the dependencies string
+        # Pattern matches: <include>path</include> surrounded by whitespace
+        pattern_bare = rf'\s*<include>{re.escape(include_path)}</include>\s*'
+        result = re.sub(pattern_bare, '', result)
+
+    return result
+
+
 def auto_include(
     input_prompt: str,
     directory_path: str,
@@ -408,6 +456,9 @@ def auto_include(
                         f"{' -> '.join(cycle)}[/yellow]"
                     )
 
+        # Filter out includes that already exist in the input prompt
+        dependencies = _filter_existing_includes(input_prompt, dependencies)
+
         total_cost = summary_cost + llm_cost
         model_name = llm_model_name or summary_model