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

pdd/agentic_verify.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+from .agentic_common import run_agentic_task
+from .load_prompt_template import load_prompt_template
+
+console = Console()
+
+
+def _get_file_mtimes(root: Path) -> dict[Path, float]:
+    """
+    Recursively scan the directory to record file modification times.
+    Excludes common ignored directories like .git, __pycache__, .venv, etc.
+    """
+    mtimes = {}
+    ignore_dirs = {".git", "__pycache__", ".venv", "venv", "node_modules", ".idea", ".vscode"}
+    
+    for path in root.rglob("*"):
+        # Skip ignored directories
+        if any(part in ignore_dirs for part in path.parts):
+            continue
+            
+        if path.is_file():
+            try:
+                mtimes[path] = path.stat().st_mtime
+            except OSError:
+                # Handle cases where file might disappear or be inaccessible during scan
+                continue
+    return mtimes
+
+
+def _extract_json_from_text(text: str) -> dict[str, Any] | None:
+    """
+    Attempts to extract a JSON object from a string.
+    Handles Markdown code blocks and raw JSON.
+    """
+    # Try to find JSON within markdown code blocks first
+    json_block_pattern = r"```(?:json)?\s*(\{.*?\})\s*```"
+    match = re.search(json_block_pattern, text, re.DOTALL)
+    
+    if match:
+        json_str = match.group(1)
+    else:
+        # Try to find the first opening brace and last closing brace
+        start = text.find("{")
+        end = text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            json_str = text[start : end + 1]
+        else:
+            return None
+
+    try:
+        return json.loads(json_str)
+    except json.JSONDecodeError:
+        return None
+
+
+def run_agentic_verify(
+    prompt_file: Path,
+    code_file: Path,
+    program_file: Path,
+    verification_log_file: Path,
+    *,
+    verbose: bool = False,
+    quiet: bool = False,
+) -> tuple[bool, str, float, str, list[str]]:
+    """
+    Runs an agentic verification fallback.
+    
+    This function delegates the verification fix to a CLI agent (explore mode).
+    It records file changes, parses the agent's JSON output, and returns the results.
+
+    Args:
+        prompt_file: Path to the prompt specification file.
+        code_file: Path to the generated code file.
+        program_file: Path to the program/driver file.
+        verification_log_file: Path to the log containing previous failures.
+        verbose: Enable verbose logging.
+        quiet: Suppress standard output.
+
+    Returns:
+        Tuple containing:
+        - success (bool): Whether the agent claims success.
+        - message (str): The explanation or output message.
+        - cost (float): Estimated cost of the operation.
+        - model (str): The model/provider used.
+        - changed_files (list[str]): List of files modified during execution.
+    """
+    project_root = Path.cwd()
+    
+    if not quiet:
+        console.print(f"[bold blue]Starting Agentic Verify (Explore Mode)[/bold blue]")
+        console.print(f"Context: {project_root}")
+
+    # 1. Load Prompt Template
+    template_name = "agentic_verify_explore_LLM"
+    template = load_prompt_template(template_name)
+    
+    if not template:
+        error_msg = f"Failed to load prompt template: {template_name}"
+        console.print(f"[bold red]{error_msg}[/bold red]")
+        return False, error_msg, 0.0, "unknown", []
+
+    # 2. Prepare Context
+    if verification_log_file.exists():
+        previous_attempts = verification_log_file.read_text(encoding="utf-8")
+    else:
+        previous_attempts = "No previous verification logs found."
+
+    # 3. Format Instruction
+    instruction = template.format(
+        prompt_path=prompt_file.resolve(),
+        code_path=code_file.resolve(),
+        program_path=program_file.resolve(),
+        project_root=project_root.resolve(),
+        previous_attempts=previous_attempts
+    )
+
+    # 4. Record State Before Execution
+    mtimes_before = _get_file_mtimes(project_root)
+
+    # 5. Run Agentic Task
+    # We use the project root as the CWD so the agent can explore freely
+    agent_success, agent_output, cost, provider = run_agentic_task(
+        instruction=instruction,
+        cwd=project_root,
+        verbose=verbose,
+        quiet=quiet,
+        label="verify-explore"
+    )
+
+    # 6. Record State After Execution & Detect Changes
+    mtimes_after = _get_file_mtimes(project_root)
+    changed_files = []
+    
+    for path, mtime in mtimes_after.items():
+        # Check if file is new or modified
+        if path not in mtimes_before or mtimes_before[path] != mtime:
+            # Store relative path for cleaner output
+            try:
+                rel_path = path.relative_to(project_root)
+                changed_files.append(str(rel_path))
+            except ValueError:
+                changed_files.append(str(path))
+
+    # 7. Parse Agent Output
+    # The agent is instructed to return JSON.
+    parsed_data = _extract_json_from_text(agent_output)
+    
+    final_success = False
+    final_message = agent_output
+    
+    if parsed_data:
+        # Trust the agent's self-reported success if JSON is valid
+        final_success = parsed_data.get("success", False)
+        final_message = parsed_data.get("message", agent_output)
+        
+        # We prefer our calculated changed_files, but if we found none and the agent
+        # claims to have changed some (and they exist), we could log that discrepancy.
+        # For now, we stick to the physical reality of mtimes.
+    else:
+        # Fallback if agent didn't output valid JSON but the CLI tool reported success
+        if verbose:
+            console.print("[yellow]Warning: Could not parse JSON from agent output. Using raw output.[/yellow]")
+        
+        # If the CLI tool failed (agent_success is False), we definitely failed.
+        # If the CLI tool succeeded, we still default to False because we couldn't verify the JSON contract.
+        final_success = False
+
+    if not quiet:
+        status_color = "green" if final_success else "red"
+        console.print(f"[{status_color}]Agentic Verify Finished. Success: {final_success}[/{status_color}]")
+        if changed_files:
+            console.print(f"Changed files: {', '.join(changed_files)}")
+
+    return final_success, final_message, cost, provider, changed_files

pdd/auto_deps_main.py

@@ -1,7 +1,7 @@
 """Main function for the auto-deps command."""
 import sys
 from pathlib import Path
-from typing import Tuple, Optional
+from typing import Callable, Tuple, Optional
 import click
 from rich import print as rprint
 
@@ -15,7 +15,8 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
     directory_path: str,
     auto_deps_csv_path: Optional[str],
     output: Optional[str],
-    force_scan: Optional[bool]
+    force_scan: Optional[bool],
+    progress_callback: Optional[Callable[[int, int], None]] = None
 ) -> Tuple[str, float, str]:
     """
     Main function to analyze and insert dependencies into a prompt file.
@@ -27,6 +28,7 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
         auto_deps_csv_path: Path to CSV file containing auto-dependency information.
         output: Optional path to save the modified prompt file.
         force_scan: Flag to force rescan of directory by deleting CSV file.
+        progress_callback: Callback for progress updates (current, total) for each file.
 
     Returns:
         Tuple containing:
@@ -49,7 +51,9 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="auto-deps",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context'),
+            confirm_callback=ctx.obj.get('confirm_callback')
         )
 
         # Get the CSV file path
@@ -74,10 +78,12 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
             input_prompt=input_strings["prompt_file"],
             directory_path=directory_path,
             csv_filename=csv_path,
+            prompt_filename=prompt_file,
             strength=strength,
             temperature=temperature,
             time=time_budget,
-            verbose=not ctx.obj.get('quiet', False)
+            verbose=not ctx.obj.get('quiet', False),
+            progress_callback=progress_callback
         )
 
         # Save the modified prompt to the output file
@@ -98,7 +104,11 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
 
         return modified_prompt, total_cost, model_name
 
+    except click.Abort:
+        # User cancelled - re-raise to stop the sync loop
+        raise
     except Exception as exc:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(exc)}")
-        sys.exit(1)
+        # Return error result instead of sys.exit(1) to allow orchestrator to handle gracefully
+        return "", 0.0, f"Error: {exc}"

pdd/auto_include.py

@@ -2,8 +2,9 @@
 This module provides the `auto_include` function to automatically find and
 insert dependencies into a prompt.
 """
+import re
 from io import StringIO
-from typing import Tuple, Optional
+from typing import Callable, Tuple, Optional
 
 import pandas as pd
 from pydantic import BaseModel, Field
@@ -61,11 +62,17 @@ def _load_prompts() -> tuple[str, str]:
     return auto_include_prompt, extract_prompt
 
 
-def _summarize(directory_path: str, csv_file: Optional[str], llm_kwargs: dict) -> tuple[str, float, str]:
+def _summarize(
+    directory_path: str,
+    csv_file: Optional[str],
+    llm_kwargs: dict,
+    progress_callback: Optional[Callable[[int, int], None]] = None
+) -> tuple[str, float, str]:
     """Summarize the directory."""
     return summarize_directory(
         directory_path=directory_path,
         csv_file=csv_file,
+        progress_callback=progress_callback,
         **llm_kwargs
     )
 
@@ -108,14 +115,57 @@ def _run_llm_and_extract(
     return dependencies, total_cost, model_name
 
 
+def _extract_module_name(prompt_filename: Optional[str]) -> Optional[str]:
+    """Extract module name from prompt filename.
+
+    Handles various language suffixes:
+    - 'prompts/agentic_fix_python.prompt' -> 'agentic_fix'
+    - 'prompts/some_module_LLM.prompt' -> 'some_module'
+    - 'prompts/cli_bash.prompt' -> 'cli'
+
+    Args:
+        prompt_filename: The prompt filename to extract the module name from.
+
+    Returns:
+        The module name, or None if it cannot be extracted.
+    """
+    if not prompt_filename:
+        return None
+    # Pattern: captures module name before the last underscore + language + .prompt
+    # e.g., "agentic_fix_python.prompt" captures "agentic_fix"
+    match = re.search(r'([^/]+)_[^_]+\.prompt$', prompt_filename)
+    if match:
+        return match.group(1)
+    return None
+
+
+def _filter_self_references(dependencies: str, module_name: Optional[str]) -> str:
+    """Remove includes that reference the module's own example file.
+
+    Args:
+        dependencies: The dependencies string containing include tags.
+        module_name: The module name to filter out self-references for.
+
+    Returns:
+        The dependencies string with self-referential includes removed.
+    """
+    if not module_name:
+        return dependencies
+    # Pattern matches: <...><include>context/{module_name}_example.py</include></...>
+    pattern = rf'<[^>]+><include>context/{re.escape(module_name)}_example\.py</include></[^>]+>\s*'
+    return re.sub(pattern, '', dependencies)
+
+
 def auto_include(
     input_prompt: str,
     directory_path: str,
     csv_file: Optional[str] = None,
+    prompt_filename: Optional[str] = None,
     strength: float = DEFAULT_STRENGTH,
     temperature: float = 0.0,
     time: float = DEFAULT_TIME,
-    verbose: bool = False
+    verbose: bool = False,
+    progress_callback: Optional[Callable[[int, int], None]] = None
 ) -> Tuple[str, str, float, str]:
     """
     Automatically find and insert proper dependencies into the prompt.
@@ -124,10 +174,14 @@ def auto_include(
         input_prompt (str): The prompt requiring includes
         directory_path (str): Directory path of dependencies
         csv_file (Optional[str]): Contents of existing CSV file
+        prompt_filename (Optional[str]): The prompt filename being processed,
+            used to filter out self-referential example files
         strength (float): Strength of LLM model (0-1)
         temperature (float): Temperature of LLM model (0-1)
         time (float): Time budget for LLM calls
         verbose (bool): Whether to print detailed information
+        progress_callback (Optional[Callable[[int, int], None]]): Callback for progress updates.
+            Called with (current, total) for each file processed.
 
     Returns:
         Tuple[str, str, float, str]: (dependencies, csv_output, total_cost, model_name)
@@ -152,7 +206,7 @@ def auto_include(
             console.print(Panel("Step 2: Running summarize_directory", style="blue"))
 
         csv_output, summary_cost, summary_model = _summarize(
-            directory_path, csv_file, llm_kwargs
+            directory_path, csv_file, llm_kwargs, progress_callback
         )
 
         available_includes = _get_available_includes_from_csv(csv_output)
@@ -167,7 +221,11 @@ def auto_include(
             available_includes=available_includes,
             llm_kwargs=llm_kwargs,
         )
-        
+
+        # Filter out self-referential includes (module's own example file)
+        module_name = _extract_module_name(prompt_filename)
+        dependencies = _filter_self_references(dependencies, module_name)
+
         total_cost = summary_cost + llm_cost
         model_name = llm_model_name or summary_model
 

pdd/bug_main.py

@@ -50,7 +50,8 @@ def bug_main(
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="bug",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
         
         # Use the language detected by construct_paths if none was explicitly provided
@@ -117,4 +118,4 @@ def bug_main(
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        sys.exit(1)

pdd/bug_to_unit_test.py

@@ -108,6 +108,7 @@ def bug_to_unit_test(  # pylint: disable=too-many-arguments, too-many-locals
             strength=0.89,
             temperature=temperature,
             time=time,
+            language=language,
             verbose=False,
         )
 
@@ -121,6 +122,7 @@ def bug_to_unit_test(  # pylint: disable=too-many-arguments, too-many-locals
                 strength=strength,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=True,
             )
             total_cost += continued_cost

pdd/change_main.py

@@ -17,11 +17,11 @@ from rich import print as rprint
 from rich.panel import Panel
 
 # Use relative imports for internal modules
+from .config_resolution import resolve_effective_config
 from .construct_paths import construct_paths
 from .change import change as change_func
 from .process_csv_change import process_csv_change
 from .get_extension import get_extension
-from . import DEFAULT_STRENGTH, DEFAULT_TIME
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -72,9 +72,8 @@ def change_main(
     # Retrieve global options from context
     force: bool = ctx.obj.get("force", False)
     quiet: bool = ctx.obj.get("quiet", False)
-    strength: float = ctx.obj.get("strength", DEFAULT_STRENGTH)
-    temperature: float = ctx.obj.get("temperature", 0.0)
-    time_budget: float = ctx.obj.get("time", DEFAULT_TIME)
+    # Note: strength/temperature/time will be resolved after construct_paths
+    # using resolve_effective_config for proper priority handling
     # --- Get language and extension from context ---
     # These are crucial for knowing the target code file types, especially in CSV mode
     target_language: str = ctx.obj.get("language", "")
@@ -203,6 +202,7 @@ def change_main(
                 quiet=quiet,
                 command="change",
                 command_options=command_options,
+                context_override=ctx.obj.get('context')
             )
             logger.debug("construct_paths returned:")
             logger.debug("  input_strings keys: %s", list(input_strings.keys()))
@@ -215,6 +215,13 @@ def change_main(
             logger.error(msg, exc_info=True)
             return msg, 0.0, ""
 
+        # Use centralized config resolution with proper priority:
+        # CLI > pddrc > defaults
+        effective_config = resolve_effective_config(ctx, resolved_config)
+        strength = effective_config["strength"]
+        temperature = effective_config["temperature"]
+        time_budget = effective_config["time"]
+
         # --- 3. Perform Prompt Modification ---
         if use_csv:
             logger.info("Running in CSV mode.")