pdd-cli 0.0.41__py3-none-any.whl → 0.0.43__py3-none-any.whl

pdd/__init__.py

@@ -1,6 +1,6 @@
 """PDD - Prompt Driven Development"""
 
-__version__ = "0.0.41"
+__version__ = "0.0.43"
 
 # Strength parameter used for LLM extraction across the codebase
 # Used in postprocessing, XML tagging, code generation, and other extraction

pdd/auto_deps_main.py

@@ -44,7 +44,7 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
             "csv": auto_deps_csv_path
         }
 
-        input_strings, output_file_paths, _ = construct_paths(
+        resolved_config, input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),

pdd/bug_main.py

@@ -45,7 +45,7 @@ def bug_main(
             "output": output,
             "language": language
         }
-        input_strings, output_file_paths, detected_language = construct_paths(
+        resolved_config, input_strings, output_file_paths, detected_language = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),

pdd/change_main.py

@@ -197,7 +197,7 @@ def change_main(
         logger.debug("Calling construct_paths with inputs: %s and options: %s",
                      input_file_paths, command_options)
         try:
-            input_strings, output_file_paths, language = construct_paths(
+            resolved_config, input_strings, output_file_paths, language = construct_paths(
                 input_file_paths=input_file_paths,
                 force=force,
                 quiet=quiet,

pdd/cli.py

@@ -35,6 +35,7 @@ from .fix_verification_main import fix_verification_main
 from .install_completion import install_completion, get_local_pdd_path
 from .preprocess_main import preprocess_main
 from .split_main import split_main
+from .sync_main import sync_main
 from .trace_main import trace_main
 from .track_cost import track_cost
 from .update_main import update_main
@@ -695,7 +696,7 @@ def change(
     "--output",
     type=click.Path(writable=True),
     default=None,
-    help="Specify where to save the updated prompt file (file or directory).",
+    help="Specify where to save the updated prompt file. If not specified, overwrites the original prompt file to maintain it as the source of truth.",
 )
 @click.option(
     "--git",
@@ -870,8 +871,8 @@ def crash(
         result_data = {
             "success": success,
             "attempts": attempts,
-            "fixed_code_path": output,
-            "fixed_program_path": output_program,
+            "fixed_code": fixed_code,
+            "fixed_program": fixed_program,
         }
         return result_data, cost, model
     except Exception as e:
@@ -1098,6 +1099,83 @@ def verify(
         return None # Return None on failure
 
 
+@cli.command("sync")
+@click.argument("basename", type=str)
+@click.option(
+    "--max-attempts",
+    type=int,
+    default=3,
+    show_default=True,
+    help="Maximum number of sync attempts.",
+)
+@click.option(
+    "--budget",
+    type=float,
+    default=10.0,
+    show_default=True,
+    help="Maximum total cost allowed for the entire sync process.",
+)
+@click.option(
+    "--skip-verify",
+    is_flag=True,
+    default=False,
+    help="Skip verification step during sync.",
+)
+@click.option(
+    "--skip-tests",
+    is_flag=True,
+    default=False,
+    help="Skip test generation during sync.",
+)
+@click.option(
+    "--target-coverage",
+    type=click.FloatRange(0.0, 100.0),
+    default=90.0,
+    show_default=True,
+    help="Target code coverage percentage for generated tests.",
+)
+@click.option(
+    "--log",
+    is_flag=True,
+    default=False,
+    help="Enable detailed logging during sync.",
+)
+@click.pass_context
+@track_cost
+def sync(
+    ctx: click.Context,
+    basename: str,
+    max_attempts: int,
+    budget: float,
+    skip_verify: bool,
+    skip_tests: bool,
+    target_coverage: float,
+    log: bool,
+) -> Optional[Tuple[Dict[str, Any], float, str]]:
+    """Automatically execute the complete PDD workflow loop for a given basename. 
+    
+    This command implements the entire synchronized cycle, intelligently determining 
+    what steps are needed and executing them in the correct order. It detects 
+    programming languages by scanning for prompt files matching the pattern 
+    {basename}_{language}.prompt in the prompts directory.
+    """
+    try:
+        results, total_cost, model = sync_main(
+            ctx=ctx,
+            basename=basename,
+            max_attempts=max_attempts,
+            budget=budget,
+            skip_verify=skip_verify,
+            skip_tests=skip_tests,
+            target_coverage=target_coverage,
+            log=log,
+        )
+        return results, total_cost, model
+    except Exception as exception:
+        handle_error(exception, "sync", ctx.obj.get("quiet", False))
+        return None
+
+
 @cli.command("install_completion")
 @click.pass_context
 # No @track_cost

pdd/cmd_test_main.py

@@ -81,7 +81,7 @@ def cmd_test_main(
             "target_coverage": target_coverage,
         }
 
-        input_strings, output_file_paths, language = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj["force"],
             quiet=ctx.obj["quiet"],
@@ -146,8 +146,8 @@ def cmd_test_main(
             ctx.exit(1)
             return "", 0.0, ""
 
-    # Handle output
-    output_file = output_file_paths["output"]
+    # Handle output - prioritize orchestration output path over construct_paths result
+    output_file = output or output_file_paths["output"]
     if merge and existing_tests:
         output_file = existing_tests
 

pdd/code_generator_main.py

@@ -157,7 +157,7 @@ def code_generator_main(
     command_options: Dict[str, Any] = {"output": output}
 
     try:
-        input_strings, output_file_paths, language = construct_paths(
+        resolved_config, input_strings, output_file_paths, language = construct_paths(
             input_file_paths=input_file_paths_dict,
             force=force_overwrite,
             quiet=quiet,
@@ -165,7 +165,8 @@ def code_generator_main(
             command_options=command_options,
         )
         prompt_content = input_strings["prompt_file"]
-        output_path = output_file_paths.get("output")
+        # Prioritize orchestration output path over construct_paths result
+        output_path = output or output_file_paths.get("output")
 
     except FileNotFoundError as e:
         console.print(f"[red]Error: Input file not found: {e.filename}[/red]")

pdd/conflicts_main.py

@@ -28,7 +28,7 @@ def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optio
         command_options = {
             "output": output
         }
-        input_strings, output_file_paths, _ = construct_paths(
+        resolved_config, input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),

pdd/construct_paths.py

@@ -4,9 +4,12 @@ from __future__ import annotations
 import sys
 import os
 from pathlib import Path
-from typing import Dict, Tuple, Any, Optional # Added Optional
+from typing import Dict, Tuple, Any, Optional, List
+import fnmatch
+import logging
 
 import click
+import yaml
 from rich.console import Console
 from rich.theme import Theme
 
@@ -21,6 +24,114 @@ import csv
 
 console = Console(theme=Theme({"info": "cyan", "warning": "yellow", "error": "bold red"}))
 
+# Configuration loading functions
+def _find_pddrc_file(start_path: Optional[Path] = None) -> Optional[Path]:
+    """Find .pddrc file by searching upward from the given path."""
+    if start_path is None:
+        start_path = Path.cwd()
+    
+    # Search upward through parent directories
+    for path in [start_path] + list(start_path.parents):
+        pddrc_file = path / ".pddrc"
+        if pddrc_file.is_file():
+            return pddrc_file
+    return None
+
+def _load_pddrc_config(pddrc_path: Path) -> Dict[str, Any]:
+    """Load and parse .pddrc configuration file."""
+    try:
+        with open(pddrc_path, 'r', encoding='utf-8') as f:
+            config = yaml.safe_load(f)
+        
+        if not isinstance(config, dict):
+            raise ValueError(f"Invalid .pddrc format: expected dictionary at root level")
+        
+        # Validate basic structure
+        if 'contexts' not in config:
+            raise ValueError(f"Invalid .pddrc format: missing 'contexts' section")
+        
+        return config
+    except yaml.YAMLError as e:
+        raise ValueError(f"YAML syntax error in .pddrc: {e}")
+    except Exception as e:
+        raise ValueError(f"Error loading .pddrc: {e}")
+
+def _detect_context(current_dir: Path, config: Dict[str, Any], context_override: Optional[str] = None) -> Optional[str]:
+    """Detect the appropriate context based on current directory path."""
+    if context_override:
+        # Validate that the override context exists
+        contexts = config.get('contexts', {})
+        if context_override not in contexts:
+            available = list(contexts.keys())
+            raise ValueError(f"Unknown context '{context_override}'. Available contexts: {available}")
+        return context_override
+    
+    contexts = config.get('contexts', {})
+    current_path_str = str(current_dir)
+    
+    # Try to match against each context's paths
+    for context_name, context_config in contexts.items():
+        if context_name == 'default':
+            continue  # Handle default as fallback
+        
+        paths = context_config.get('paths', [])
+        for path_pattern in paths:
+            # Convert glob pattern to match current directory
+            if fnmatch.fnmatch(current_path_str, f"*/{path_pattern}") or \
+               fnmatch.fnmatch(current_path_str, path_pattern) or \
+               current_path_str.endswith(f"/{path_pattern.rstrip('/**')}"):
+                return context_name
+    
+    # Return default context if available
+    if 'default' in contexts:
+        return 'default'
+    
+    return None
+
+def _get_context_config(config: Dict[str, Any], context_name: Optional[str]) -> Dict[str, Any]:
+    """Get configuration settings for the specified context."""
+    if not context_name:
+        return {}
+    
+    contexts = config.get('contexts', {})
+    context_config = contexts.get(context_name, {})
+    return context_config.get('defaults', {})
+
+def _resolve_config_hierarchy(
+    cli_options: Dict[str, Any],
+    context_config: Dict[str, Any],
+    env_vars: Dict[str, str]
+) -> Dict[str, Any]:
+    """Apply configuration hierarchy: CLI > context > environment > defaults."""
+    resolved = {}
+    
+    # Configuration keys to resolve
+    config_keys = {
+        'generate_output_path': 'PDD_GENERATE_OUTPUT_PATH',
+        'test_output_path': 'PDD_TEST_OUTPUT_PATH', 
+        'example_output_path': 'PDD_EXAMPLE_OUTPUT_PATH',
+        'default_language': 'PDD_DEFAULT_LANGUAGE',
+        'target_coverage': 'PDD_TEST_COVERAGE_TARGET',
+        'strength': None,
+        'temperature': None,
+        'budget': None,
+        'max_attempts': None,
+    }
+    
+    for config_key, env_var in config_keys.items():
+        # 1. CLI options (highest priority)
+        if config_key in cli_options and cli_options[config_key] is not None:
+            resolved[config_key] = cli_options[config_key]
+        # 2. Context configuration
+        elif config_key in context_config:
+            resolved[config_key] = context_config[config_key]
+        # 3. Environment variables
+        elif env_var and env_var in env_vars:
+            resolved[config_key] = env_vars[env_var]
+        # 4. Defaults are handled elsewhere
+    
+    return resolved
+
 
 def _read_file(path: Path) -> str:
     """Read a text file safely and return its contents."""
@@ -126,29 +237,24 @@ def _is_known_language(language_name: str) -> bool:
 
 def _strip_language_suffix(path_like: os.PathLike[str]) -> str:
     """
-    Remove trailing '_<language>.prompt' or '_<language>' from a filename stem
-    if it matches a known language.
+    Remove trailing '_<language>' from a filename stem if it matches a known language.
     """
     p = Path(path_like)
-    stem = p.stem # removes last extension (e.g. '.prompt', '.py')
+    stem = p.stem  # removes last extension (e.g., '.prompt', '.py')
 
-    if "_" not in stem: # No underscore, nothing to strip
+    if "_" not in stem:
         return stem
 
     parts = stem.split("_")
-    # Avoid splitting single-word stems like "Makefile_" if that's possible
-    if len(parts) < 2:
-        return stem
-
     candidate_lang = parts[-1]
 
-    # Check if the last part is a known language
     if _is_known_language(candidate_lang):
-        # If the last part is a language, strip it
+        # Do not strip '_prompt' from a non-.prompt file (e.g., 'test_prompt.txt')
+        if candidate_lang == 'prompt' and p.suffix != '.prompt':
+            return stem
         return "_".join(parts[:-1])
-    else:
-        # Last part is not a language, return original stem
-        return stem
+    
+    return stem
 
 
 def _extract_basename(
@@ -267,20 +373,125 @@ def construct_paths(
     command: str,
     command_options: Optional[Dict[str, Any]], # Allow None
     create_error_file: bool = True,  # Added parameter to control error file creation
-) -> Tuple[Dict[str, str], Dict[str, str], str]:
+    context_override: Optional[str] = None,  # Added parameter for context override
+) -> Tuple[Dict[str, Any], Dict[str, str], Dict[str, str], str]:
     """
     High‑level orchestrator that loads inputs, determines basename/language,
     computes output locations, and verifies overwrite rules.
+    
+    Supports .pddrc configuration with context-aware settings and configuration hierarchy:
+    CLI options > .pddrc context > environment variables > defaults
 
     Returns
     -------
-    (input_strings, output_file_paths, language)
+    (resolved_config, input_strings, output_file_paths, language)
     """
     command_options = command_options or {} # Ensure command_options is a dict
 
+    # ------------- Load .pddrc configuration -----------------
+    pddrc_config = {}
+    context = None
+    context_config = {}
+    original_context_config = {}  # Keep track of original context config for sync discovery
+    
+    try:
+        # Find and load .pddrc file
+        pddrc_path = _find_pddrc_file()
+        if pddrc_path:
+            pddrc_config = _load_pddrc_config(pddrc_path)
+            
+            # Detect appropriate context
+            current_dir = Path.cwd()
+            context = _detect_context(current_dir, pddrc_config, context_override)
+            
+            # Get context-specific configuration
+            context_config = _get_context_config(pddrc_config, context)
+            original_context_config = context_config.copy()  # Store original before modifications
+            
+            if not quiet and context:
+                console.print(f"[info]Using .pddrc context:[/info] {context}")
+        
+        # Apply configuration hierarchy
+        env_vars = dict(os.environ)
+        resolved_config = _resolve_config_hierarchy(command_options, context_config, env_vars)
+        
+        # Update command_options with resolved configuration for internal use
+        for key, value in resolved_config.items():
+            if key not in command_options or command_options[key] is None:
+                command_options[key] = value
+        
+        # Also update context_config with resolved environment variables for generate_output_paths
+        # This ensures environment variables are available when context config doesn't override them
+        for key, value in resolved_config.items():
+            if key.endswith('_output_path') and key not in context_config:
+                context_config[key] = value
+                
+    except Exception as e:
+        error_msg = f"Configuration error: {e}"
+        console.print(f"[error]{error_msg}[/error]", style="error")
+        if not quiet:
+            console.print("[warning]Continuing with default configuration...[/warning]", style="warning")
+        # Initialize resolved_config on error to avoid downstream issues
+        resolved_config = command_options.copy()
+
+
+    # ------------- Handle sync discovery mode ----------------
+    if command == "sync" and not input_file_paths:
+        basename = command_options.get("basename")
+        if not basename:
+            raise ValueError("Basename must be provided in command_options for sync discovery mode.")
+        
+        # For discovery, we only need directory paths. Call generate_output_paths with dummy values.
+        try:
+            output_paths_str = generate_output_paths(
+                command="sync",
+                output_locations={},
+                basename=basename,
+                language="python", # Dummy language
+                file_extension=".py", # Dummy extension
+                context_config=context_config,
+            )
+            # Infer base directories from a sample output path
+            gen_path = Path(output_paths_str.get("generate_output_path", "src"))
+            
+            # First, check current working directory for prompt files matching the basename pattern
+            current_dir = Path.cwd()
+            prompt_pattern = f"{basename}_*.prompt"
+            if list(current_dir.glob(prompt_pattern)):
+                # Found prompt files in current working directory
+                resolved_config["prompts_dir"] = str(current_dir)
+                resolved_config["code_dir"] = str(current_dir)
+                if not quiet:
+                    console.print(f"[info]Found prompt files in current directory:[/info] {current_dir}")
+            else:
+                # Fall back to context-aware logic
+                # Use original_context_config to avoid checking augmented config with env vars
+                if original_context_config and any(key.endswith('_output_path') for key in original_context_config):
+                    # For configured contexts, prompts are typically at the same level as output dirs
+                    # e.g., if code goes to "pdd/", prompts should be at "prompts/" (siblings)
+                    resolved_config["prompts_dir"] = "prompts"
+                    resolved_config["code_dir"] = str(gen_path.parent)
+                else:
+                    # For default contexts, maintain relative relationship 
+                    # e.g., if code goes to "pi.py", prompts should be at "prompts/" (siblings)
+                    resolved_config["prompts_dir"] = str(gen_path.parent / "prompts")
+                    resolved_config["code_dir"] = str(gen_path.parent)
+            
+            resolved_config["tests_dir"] = str(Path(output_paths_str.get("test_output_path", "tests")).parent)
+            resolved_config["examples_dir"] = str(Path(output_paths_str.get("example_output_path", "examples")).parent)
+
+        except Exception as e:
+            console.print(f"[error]Failed to determine initial paths for sync: {e}", style="error")
+            raise
+        
+        # Return early for discovery mode
+        return resolved_config, {}, {}, ""
+
+
     if not input_file_paths:
         raise ValueError("No input files provided")
 
+
     # ------------- normalise & resolve Paths -----------------
     input_paths: Dict[str, Path] = {}
     for key, path_str in input_file_paths.items():
@@ -407,6 +618,7 @@ def construct_paths(
             basename=basename,
             language=language,
             file_extension=file_extension,
+            context_config=context_config,
         )
         # Convert to Path objects for internal use
         output_paths_resolved: Dict[str, Path] = {k: Path(v) for k, v in output_paths_str.items()}
@@ -440,8 +652,12 @@ def construct_paths(
                 click.secho("Operation cancelled.", fg="red", err=True)
                 sys.exit(1) # Exit if user chooses not to overwrite
         except Exception as e: # Catch potential errors during confirm (like EOFError in non-interactive)
-             click.secho(f"Confirmation failed: {e}. Aborting.", fg="red", err=True)
-             sys.exit(1)
+            if 'EOF' in str(e) or 'end-of-file' in str(e).lower():
+                # Non-interactive environment, default to not overwriting
+                click.secho("Non-interactive environment detected. Use --force to overwrite existing files.", fg="yellow", err=True)
+            else:
+                click.secho(f"Confirmation failed: {e}. Aborting.", fg="red", err=True)
+            sys.exit(1)
 
 
     # ------------- Final reporting ---------------------------
@@ -462,4 +678,14 @@ def construct_paths(
     # Since we converted to Path, convert back now.
     output_file_paths_str_return = {k: str(v) for k, v in output_paths_resolved.items()}
 
-    return input_strings, output_file_paths_str_return, language
+    # Add resolved paths to the config that gets returned
+    resolved_config.update(output_file_paths_str_return)
+    # Also add inferred directory paths
+    gen_path = Path(resolved_config.get("generate_output_path", "src"))
+    resolved_config["prompts_dir"] = str(next(iter(input_paths.values())).parent)
+    resolved_config["code_dir"] = str(gen_path.parent)
+    resolved_config["tests_dir"] = str(Path(resolved_config.get("test_output_path", "tests")).parent)
+    resolved_config["examples_dir"] = str(Path(resolved_config.get("example_output_path", "examples")).parent)
+
+
+    return resolved_config, input_strings, output_file_paths_str_return, language

pdd/context_generator_main.py

@@ -25,7 +25,7 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
         command_options = {
             "output": output
         }
-        input_strings, output_file_paths, language = construct_paths(
+        resolved_config, 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),
@@ -51,22 +51,37 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
             verbose=ctx.obj.get('verbose', False)
         )
 
-        # Save results
-        if output_file_paths["output"]:
-            with open(output_file_paths["output"], 'w') as f:
+        # Save results - prioritize orchestration output path over construct_paths result
+        final_output_path = output or output_file_paths["output"]
+        print(f"DEBUG: output param = {output}")
+        print(f"DEBUG: output_file_paths['output'] = {output_file_paths['output']}")
+        print(f"DEBUG: final_output_path = {final_output_path}")
+        if final_output_path and example_code is not None:
+            with open(final_output_path, 'w') as f:
                 f.write(example_code)
+        elif final_output_path and example_code is None:
+            # Log the error but don't crash
+            if not ctx.obj.get('quiet', False):
+                rprint("[bold red]Warning:[/bold red] Example generation failed, skipping file write")
 
         # Provide user feedback
         if not ctx.obj.get('quiet', False):
-            rprint("[bold green]Example code generated 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]Example code saved to:[/bold] {output_file_paths['output']}")
+            if example_code is not None:
+                rprint("[bold green]Example code generated successfully.[/bold green]")
+                rprint(f"[bold]Model used:[/bold] {model_name}")
+                rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+                if final_output_path and example_code is not None:
+                    rprint(f"[bold]Example code saved to:[/bold] {final_output_path}")
+            else:
+                rprint("[bold red]Example code generation failed.[/bold red]")
+                rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
 
-        # Always print example code, even in quiet mode
-        rprint("[bold]Generated Example Code:[/bold]")
-        rprint(example_code)
+        # Always print example code, even in quiet mode (if it exists)
+        if example_code is not None:
+            rprint("[bold]Generated Example Code:[/bold]")
+            rprint(example_code)
+        else:
+            rprint("[bold red]No example code generated due to errors.[/bold red]")
 
         return example_code, total_cost, model_name