Merge pull request #275 from beknobloch/prompt_path_18

feat(config): resolve prompt_path via env and .pddrc (implements #18)

Author: gltanaka

README.md

@@ -2559,6 +2559,7 @@ PDD automatically detects the appropriate context based on:
 3. **Fallback**: Uses `default` context if no path matches
 
 **Available Context Settings**:
+- `prompts_dir`: Directory where prompt files are located (default: "prompts")
 - `generate_output_path`: Where generated code files are saved
 - `test_output_path`: Where test files are saved
 - `example_output_path`: Where example files are saved
@@ -2603,6 +2604,7 @@ PDD uses several environment variables to customize its behavior:
 
 **Note**: When using `.pddrc` configuration, context-specific settings take precedence over these global environment variables.
 
+- **`PDD_PROMPTS_DIR`**: Default directory where prompt files are located (default: "prompts").
 - **`PDD_GENERATE_OUTPUT_PATH`**: Default path for the `generate` command.
 - **`PDD_EXAMPLE_OUTPUT_PATH`**: Default path for the `example` command.
 - **`PDD_TEST_OUTPUT_PATH`**: Default path for the unit test file.

pdd/construct_paths.py

@@ -889,31 +889,33 @@ def construct_paths(
             # 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 (
-                    'prompts_dir' in original_context_config or
-                    any(key.endswith('_output_path') for key in original_context_config)
-                ):
-                    # For configured contexts, use prompts_dir from config if provided,
-                    # otherwise default to "prompts" at the same level as output dirs
-                    resolved_config["prompts_dir"] = original_context_config.get("prompts_dir", "prompts")
-                    resolved_config["code_dir"] = str(gen_path.parent)
+            # Only infer prompts_dir if it wasn't provided via CLI/.pddrc/env
+            if not resolved_config.get("prompts_dir"):
+                # 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:
-                    # 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)
+                    # Fall back to context-aware logic
+                    # Use original_context_config to avoid checking augmented config with env vars
+                    if original_context_config and (
+                        'prompts_dir' in original_context_config or
+                        any(key.endswith('_output_path') for key in original_context_config)
+                    ):
+                        # For configured contexts, use prompts_dir from config if provided,
+                        # otherwise default to "prompts" at the same level as output dirs
+                        resolved_config["prompts_dir"] = original_context_config.get("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)
 
@@ -1247,9 +1249,10 @@ def construct_paths(
 
     # Add resolved paths to the config that gets returned
     resolved_config.update(output_file_paths_str_return)
-    # Also add inferred directory paths
+    # Only infer prompts_dir if it wasn't provided via CLI/.pddrc/env.
     gen_path = Path(resolved_config.get("generate_output_path", "src"))
-    resolved_config["prompts_dir"] = str(next(iter(input_paths.values())).parent)
+    if not resolved_config.get("prompts_dir"):
+        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)
 

tests/test_construct_paths.py

@@ -3,9 +3,7 @@
 import pytest
 import click
 from pathlib import Path
-from unittest import mock
-from unittest.mock import patch, MagicMock, ANY
-import sys
+from unittest.mock import patch, ANY
 import os
 
 # Mock generate_output_paths before importing construct_paths if it's needed globally
@@ -18,6 +16,7 @@
 def resolve_path(relative_path_str, base_dir):
     return str(Path(base_dir) / relative_path_str)
 
+
 def test_construct_paths_load_input_files(tmpdir):
     """
     Test that construct_paths properly loads input files into input_strings,
@@ -2906,4 +2905,133 @@ def test_construct_paths_sync_basename_paths_pattern_context(self, tmp_path, mon
 
         assert resolved_config["_matched_context"] == "frontend-components"
         assert resolved_config["prompts_dir"] == "prompts"
-        assert Path(resolved_config["code_dir"]).as_posix().endswith("frontend/src/components")
+        assert Path(resolved_config["code_dir"]).as_posix().endswith("frontend/src/components")
+
+
+def test_resolve_config_hierarchy_env_prompts_dir(monkeypatch):
+    """PDD_PROMPTS_DIR environment variable should be respected."""
+    monkeypatch.setenv("PDD_PROMPTS_DIR", "/tmp/custom_prompts")
+
+    resolved = _resolve_config_hierarchy(
+        cli_options={},
+        context_config={},
+        env_vars={
+            "PDD_PROMPTS_DIR": os.environ.get("PDD_PROMPTS_DIR"),
+        },
+    )
+
+    assert "prompts_dir" in resolved
+    assert resolved["prompts_dir"] == "/tmp/custom_prompts"
+
+
+def test_resolve_config_hierarchy_pddrc_prompts_dir(monkeypatch):
+    """The .pddrc key `prompts_dir` should be respected."""
+    monkeypatch.delenv("PDD_PROMPTS_DIR", raising=False)
+
+    context_config = {
+        "prompts_dir": "my_prompts",
+    }
+
+    resolved = _resolve_config_hierarchy(
+        cli_options={},
+        context_config=context_config,
+        env_vars={},
+    )
+
+    assert "prompts_dir" in resolved
+    assert resolved["prompts_dir"] == "my_prompts"
+
+
+def test_resolve_config_hierarchy_cli_prompts_dir_wins(monkeypatch):
+    """CLI prompts_dir should take precedence over .pddrc and env vars."""
+    monkeypatch.setenv("PDD_PROMPTS_DIR", "/tmp/env_prompts")
+
+    resolved = _resolve_config_hierarchy(
+        cli_options={
+            "prompts_dir": "cli_prompts",
+        },
+        context_config={
+            "prompts_dir": "pddrc_prompts",
+        },
+        env_vars={
+            "PDD_PROMPTS_DIR": os.environ.get("PDD_PROMPTS_DIR"),
+        },
+    )
+
+    assert "prompts_dir" in resolved
+    assert resolved["prompts_dir"] == "cli_prompts"
+
+
+def test_construct_paths_regular_mode_respects_env_prompts_dir(tmp_path, monkeypatch):
+    """
+    Integration test: PDD_PROMPTS_DIR should be respected in regular mode (e.g., pdd generate).
+    
+    This verifies the environment variable works through the full construct_paths flow,
+    not just in _resolve_config_hierarchy isolation.
+    """
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("PDD_PROMPTS_DIR", "/custom/prompts")
+    
+    # Create minimal test files
+    prompts_dir = tmp_path / "custom_prompts_location"
+    prompts_dir.mkdir()
+    prompt_file = prompts_dir / "test_python.prompt"
+    prompt_file.write_text("% Test prompt", encoding="utf-8")
+    
+    input_file_paths = {"prompt_file": str(prompt_file)}
+    command_options = {"output": "test.py"}
+    
+    resolved_config, _, output_paths, _ = construct_paths(
+        input_file_paths=input_file_paths,
+        force=True,
+        quiet=True,
+        command="generate",
+        command_options=command_options,
+    )
+    
+    # The environment variable should be in resolved_config
+    assert "prompts_dir" in resolved_config
+    assert resolved_config["prompts_dir"] == "/custom/prompts", \
+        f"Expected prompts_dir='/custom/prompts' from PDD_PROMPTS_DIR, got '{resolved_config['prompts_dir']}'"
+
+
+def test_construct_paths_sync_mode_respects_env_prompts_dir(tmp_path, monkeypatch):
+    """
+    Integration test: PDD_PROMPTS_DIR should be respected in sync discovery mode.
+    
+    Verifies the fix for the bug where sync mode would unconditionally overwrite
+    prompts_dir (lines 794, 807, 812) even when PDD_PROMPTS_DIR was set.
+    """
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("PDD_PROMPTS_DIR", "/custom/sync/prompts")
+    
+    # Create minimal structure for sync mode
+    (tmp_path / "src").mkdir()
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "context").mkdir()
+    
+    command_options = {"basename": "calculator"}
+    
+    # Mock generate_output_paths to return predictable paths
+    mock_output_paths = {
+        "generate_output_path": str(tmp_path / "src" / "calculator.py"),
+        "test_output_path": str(tmp_path / "tests" / "test_calculator.py"),
+        "example_output_path": str(tmp_path / "context" / "calculator_example.py"),
+    }
+    
+    with patch('pdd.construct_paths.generate_output_paths', return_value=mock_output_paths), \
+         patch('pdd.construct_paths._get_context_config', return_value={}):
+        
+        resolved_config, _, _, _ = construct_paths(
+            input_file_paths={},
+            force=True,
+            quiet=True,
+            command="sync",
+            command_options=command_options,
+        )
+    
+    # The environment variable should take precedence over sync discovery inference
+    assert "prompts_dir" in resolved_config
+    assert resolved_config["prompts_dir"] == "/custom/sync/prompts", \
+        f"Expected prompts_dir='/custom/sync/prompts' from PDD_PROMPTS_DIR in sync mode, got '{resolved_config['prompts_dir']}'"
+