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

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,

pdd/agentic_update.py

@@ -16,8 +16,9 @@ import os
 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.
@@ -107,17 +108,23 @@ def _detect_changed_files(
     return sorted({p.resolve() for p in changed})
 
 
-def _discover_test_files(code_path: Path) -> List[Path]:
+def _discover_test_files(
+    code_path: Path,
+    tests_dir: Optional[Path] = None,
+) -> List[Path]:
     """
     Discover test files associated with a given code file.
 
     Uses pattern: ``test_{code_stem}*{code_suffix}`` and searches in:
-      1. ``tests/`` relative to the code file directory
-      2. The same directory as the code file
-      3. Project root ``tests/``
+      1. Configured tests_dir from .pddrc (if provided)
+      2. ``tests/`` relative to the code file directory
+      3. The same directory as the code file
+      4. Sibling ``tests/`` directory (../tests/)
+      5. Project root ``tests/``
 
     Args:
         code_path: Path to the main code file.
+        tests_dir: Optional path to tests directory from .pddrc config.
 
     Returns:
         Ordered list of discovered test file paths (deduplicated).
@@ -127,11 +134,15 @@ def _discover_test_files(code_path: Path) -> List[Path]:
     suffix = code_path.suffix
     pattern = f"test_{stem}*{suffix}"
 
-    search_dirs: List[Path] = [
+    search_dirs: List[Path] = []
+    if tests_dir is not None:
+        search_dirs.append(Path(tests_dir).resolve())
+    search_dirs.extend([
         code_path.parent / "tests",
         code_path.parent,
+        code_path.parent.parent / "tests",  # Sibling tests dir (../tests/)
         PROJECT_ROOT / "tests",
-    ]
+    ])
 
     seen: set[Path] = set()
     discovered: List[Path] = []
@@ -183,6 +194,7 @@ def run_agentic_update(
     code_file: str,
     test_files: Optional[List[Path]] = None,
     *,
+    tests_dir: Optional[Path] = None,
     verbose: bool = False,
     quiet: bool = False,
 ) -> Tuple[bool, str, float, str, List[str]]:
@@ -205,6 +217,8 @@ def run_agentic_update(
             test files are auto-discovered using the pattern
             ``test_{code_stem}*{code_suffix}`` in the configured search
             locations.
+        tests_dir: Optional path to tests directory from .pddrc config.
+            Used for auto-discovery when test_files is None.
         verbose: If True, enable verbose logging for the underlying agent task.
         quiet: If True, suppress informational logging from this function.
             (Passed through to the agent as well; ``quiet`` takes precedence
@@ -268,7 +282,7 @@ def run_agentic_update(
             return False, error, 0.0, "", []
         selected_tests = normalized_tests or []
     else:
-        selected_tests = _discover_test_files(code_path)
+        selected_tests = _discover_test_files(code_path, tests_dir=tests_dir)
 
     # Paths to track *before* running the agent (for mtime comparison)
     before_paths: set[Path] = {prompt_path.resolve(), code_path.resolve()}
@@ -323,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}"
@@ -361,7 +376,10 @@ def run_agentic_update(
 
     if not quiet:
         if success:
-            console.print(f"[green]{base_msg}[/green]")
+            console.print("[green]Prompt file updated successfully.[/green]")
+            if output_message:
+                console.print("\n[bold]Agent output:[/bold]")
+                console.print(Markdown(output_message))
         else:
             console.print(f"[yellow]{base_msg}[/yellow]")
 

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