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

pdd/postprocess.py

@@ -1,136 +1,158 @@
-from typing import Tuple
-from rich import print
-from pydantic import BaseModel, Field
+from __future__ import annotations
+
+import re
+from typing import Tuple, Optional
+
+from rich.console import Console
+from pydantic import BaseModel, Field, ValidationError
+
+from . import DEFAULT_STRENGTH, DEFAULT_TIME
 from .load_prompt_template import load_prompt_template
 from .llm_invoke import llm_invoke
-from . import DEFAULT_TIME, DEFAULT_STRENGTH
+
+
+console = Console()
+
 
 class ExtractedCode(BaseModel):
-    """Pydantic model for the extracted code."""
-    focus: str = Field(default="", description="The focus of the generation")
-    explanation: str = Field(default="", description="Explanation of the extraction")
-    extracted_code: str = Field(description="The extracted code from the LLM output")
+    focus: str = Field("", description="Focus of the code")
+    explanation: str = Field("", description="Explanation of the code")
+    extracted_code: str = Field(..., description="Extracted code")
+
+
+def postprocess_0(llm_output: str, language: str) -> str:
+    """Simple extraction of code blocks."""
+    if language == "prompt":
+        # Strip <prompt> tags
+        llm_output = re.sub(r"<prompt>\s*(.*?)\s*</prompt>", r"\1", llm_output, flags=re.DOTALL)
+        llm_output = llm_output.strip()
+
+        # Also strip triple backticks if present
+        lines = llm_output.splitlines()
+        if lines and lines[0].startswith("```"):
+            # Remove first line with opening backticks
+            lines = lines[1:]
+            # If there's a last line with closing backticks, remove it
+            if lines and lines[-1].startswith("```"):
+                lines = lines[:-1]
+        llm_output = "\n".join(lines)
+
+        return llm_output.strip()
+
+    # First try to find complete code blocks with closing backticks
+    code_blocks = re.findall(r"```(?:[a-zA-Z]+)?\n(.*?)\n```", llm_output, re.DOTALL)
+    if code_blocks:
+        return "\n".join(block.strip() for block in code_blocks)
+
+    # If no complete blocks found, try to find incomplete blocks (opening backticks without closing)
+    # But ensure there's actual content after the opening backticks
+    incomplete_match = re.search(r"```(?:[a-zA-Z]+)?\n(.+?)(?:\n```)?$", llm_output, re.DOTALL)
+    if incomplete_match:
+        content = incomplete_match.group(1).strip()
+        # Don't return if content is just closing backticks
+        if content and content != "```":
+            return content
+
+    return ""
 
-def postprocess_0(text: str) -> str:
-    """
-    Simple code extraction for strength = 0.
-    Extracts code between triple backticks.
-    """
-    lines = text.split('\n')
-    code_lines = []
-    in_code_block = False
-    
-    for line in lines:
-        if '```' in line: # MODIFIED: Was line.startswith('```')
-            if not in_code_block:
-                # Skip the language identifier line / content on opening delimiter line
-                in_code_block = True
-                continue
-            else:
-                # Content on closing delimiter line is skipped
-                in_code_block = False
-                continue
-        if in_code_block:
-            code_lines.append(line)
-    
-    return '\n'.join(code_lines)
 
 def postprocess(
     llm_output: str,
     language: str,
     strength: float = DEFAULT_STRENGTH,
-    temperature: float = 0,
+    temperature: float = 0.0,
     time: float = DEFAULT_TIME,
-    verbose: bool = False
+    verbose: bool = False,
 ) -> Tuple[str, float, str]:
     """
-    Extract code from LLM output string.
-    
+    Extracts code from a string output of an LLM.
+
     Args:
-        llm_output (str): The string output from the LLM containing code sections
-        language (str): The programming language of the code to extract
-        strength (float): The strength of the LLM model to use (0-1)
-        temperature (float): The temperature parameter for the LLM (0-1)
-        time (float): The thinking effort for the LLM model (0-1)
-        verbose (bool): Whether to print detailed processing information
-    
+        llm_output: A string containing a mix of text and code sections.
+        language: A string specifying the programming language of the code to be extracted.
+        strength: A float between 0 and 1 that represents the strength of the LLM model to use.
+        temperature: A float between 0 and 1 that represents the temperature parameter for the LLM model.
+        time: A float between 0 and 1 that controls the thinking effort for the LLM model.
+        verbose: A boolean that indicates whether to print detailed processing information.
+
     Returns:
-        Tuple[str, float, str]: (extracted_code, total_cost, model_name)
+        A tuple containing the extracted code string, total cost float and model name string.
     """
-    try:
-        # Input validation
-        if not llm_output or not isinstance(llm_output, str):
-            raise ValueError("llm_output must be a non-empty string")
-        if not language or not isinstance(language, str):
-            raise ValueError("language must be a non-empty string")
-        if not 0 <= strength <= 1:
-            raise ValueError("strength must be between 0 and 1")
-        if not 0 <= temperature <= 1:
-            raise ValueError("temperature must be between 0 and 1")
-
-        # Step 1: If strength is 0, use simple extraction
-        if strength == 0:
-            if verbose:
-                print("[blue]Using simple code extraction (strength = 0)[/blue]")
-            return (postprocess_0(llm_output), 0.0, "simple_extraction")
-
-        # Step 2: Load the prompt template
-        prompt_template = load_prompt_template("extract_code_LLM")
-        if not prompt_template:
-            raise ValueError("Failed to load prompt template")
+    if not isinstance(llm_output, str) or not llm_output:
+        raise ValueError("llm_output must be a non-empty string")
+    if not isinstance(language, str) or not language:
+        raise ValueError("language must be a non-empty string")
+    if not isinstance(strength, (int, float)):
+        raise TypeError("strength must be a number")
+    if not 0 <= strength <= 1:
+        raise ValueError("strength must be between 0 and 1")
+    if not isinstance(temperature, (int, float)):
+        raise TypeError("temperature must be a number")
+    if not 0 <= temperature <= 1:
+        raise ValueError("temperature must be between 0 and 1")
 
+    if language == "prompt":
+        extracted_code = postprocess_0(llm_output, language)
+        return extracted_code, 0.0, "simple_extraction"
+    
+    if strength == 0:
+        extracted_code = postprocess_0(llm_output, language)
         if verbose:
-            print("[blue]Loaded prompt template for code extraction[/blue]")
+            console.print("[blue]Using simple code extraction (strength = 0)[/blue]")
+        return extracted_code, 0.0, "simple_extraction"
+
+    prompt_name = "extract_code_LLM"
+    prompt = load_prompt_template(prompt_name)
 
-        # Step 3: Process using llm_invoke
-        input_json = {
-            "llm_output": llm_output,
-            "language": language
-        }
+    if not prompt:
+        error_msg = "Failed to load prompt template"
+        console.print(f"[red]Error:[/red] {error_msg}")
+        raise ValueError(error_msg)
 
-        response = llm_invoke(
-            prompt=prompt_template,
+    input_json = {"llm_output": llm_output, "language": language}
+
+    if verbose:
+        console.print("[blue]Loaded prompt template for code extraction[/blue]")
+
+    try:
+        result = llm_invoke(
+            prompt=prompt,
             input_json=input_json,
             strength=strength,
             temperature=temperature,
             time=time,
-            verbose=verbose,
             output_pydantic=ExtractedCode,
-            language=language,
+            verbose=verbose,
         )
 
-        if not response or 'result' not in response:
-            raise ValueError("Failed to get valid response from LLM")
-
-        result_obj = response['result']
-        if not isinstance(result_obj, ExtractedCode):
-            # If we got a string (likely an error message from llm_invoke), fallback to simple extraction
-            if verbose:
-                print(f"[yellow]Structured extraction failed ({result_obj}). Falling back to simple extraction.[/yellow]")
-            return (postprocess_0(llm_output), response.get('cost', 0.0), response.get('model_name', 'fallback'))
+        if not result or "result" not in result:
+            error_msg = "Failed to get valid response from LLM"
+            console.print(f"[red]Error during LLM invocation:[/red] {error_msg}")
+            raise ValueError(error_msg)
 
-        extracted_code_obj: ExtractedCode = result_obj
-        code_text = extracted_code_obj.extracted_code
+        extracted_code = result["result"].extracted_code
 
-        # Step 3c: Remove triple backticks and language identifier if present
-        lines = code_text.split('\n')
-        if lines and lines[0].startswith('```'):
+        # Clean up triple backticks
+        lines = extracted_code.splitlines()
+        if lines and lines[0].startswith("```"):
+            # Remove first line with opening backticks
             lines = lines[1:]
-        if lines and lines[-1].startswith('```'): # Check if lines is not empty again after potentially removing first line
-            lines = lines[:-1]
-        
-        final_code = '\n'.join(lines)
+            # If there's a last line with closing backticks, remove it
+            if lines and lines[-1].startswith("```"):
+                lines = lines[:-1]
+        extracted_code = "\n".join(lines)
+
+        total_cost = result["cost"]
+        model_name = result["model_name"]
 
         if verbose:
-            print("[green]Successfully extracted code[/green]")
+            console.print("[green]Successfully extracted code[/green]")
 
-        # Step 4: Return the results
-        return (
-            final_code,
-            response['cost'],
-            response['model_name']
-        )
+        return extracted_code, total_cost, model_name
 
+    except KeyError as e:
+        console.print(f"[red]Error in postprocess: {e}[/red]")
+        raise ValueError(f"Failed to get valid response from LLM: missing key {e}")
     except Exception as e:
-        print(f"[red]Error in postprocess: {str(e)}[/red]")
+        console.print(f"[red]Error in postprocess: {e}[/red]")
         raise

pdd/prompts/agentic_change_step12_create_pr_LLM.prompt

@@ -13,6 +13,8 @@ You are working on step 12 of 12 in an agentic change workflow. This is the fina
 - Worktree Path: {worktree_path}
 - Branch Name: change/issue-{issue_number}
 - Files Changed: {files_to_stage}
+- Sync Order Script: {sync_order_script}
+- Sync Order Commands: {sync_order_list}
 
 % Issue Content
 <issue_content>
@@ -91,7 +93,14 @@ Closes #{issue_number}
 
 ## Next Steps After Merge
 
-1. Run `pdd sync <module>` to regenerate code from modified prompts
+1. Regenerate code from modified prompts in dependency order:
+   ```bash
+   ./sync_order.sh
+   ```
+   Or manually:
+   ```
+   {sync_order_list}
+   ```
 2. Run tests to verify functionality
 3. Deploy if applicable
 
@@ -115,7 +124,7 @@ Closes #{issue_number}
 
 ### What's Next
 1. Review the PR
-2. Run `pdd sync` on affected modules after merge
+2. Run `./sync_order.sh` after merge to regenerate code in dependency order
 3. Run tests to verify
 
 ---

pdd/prompts/generate_test_LLM.prompt

@@ -41,7 +41,6 @@
     - Prefer function-scoped test resources over shared/module-scoped ones to ensure isolation
 
 <include>context/test.prompt</include>
-<include>context/pytest_isolation_example.py</include>
 
 <instructions>
     1. FIRST: Carefully analyze the ACTUAL code provided in code_under_test:

pdd/prompts/generate_test_from_example_LLM.prompt

@@ -98,6 +98,257 @@
     - Prefer function-scoped fixtures over module or session scope
     - Use yield in fixtures to ensure cleanup runs even on test failure
 
+% 7. MODULE-LEVEL SYS.MODULES FOR IMPORT-TIME DEPENDENCIES:
+    - Sometimes you must mock modules BEFORE importing the code under test
+      (e.g., when decorators or top-level imports need mocking)
+    - ALWAYS save original values, apply mocks, load module, then RESTORE immediately
+    - BAD:  sys.modules.update(mocks); exec_module(...)  # No cleanup - pollutes all tests!
+    - GOOD: See PATTERN 7 in pytest_isolation_example.py for the full save/restore pattern
+
+<isolation_example>
+"""
+Example code patterns demonstrating proper test isolation to prevent test pollution.
+
+This file provides reference implementations of CORRECT patterns that should be used
+in generated tests. These patterns prevent test pollution and ensure tests are independent.
+
+IMPORTANT: This is a context file for the LLM, not a runnable test file.
+"""
+
+import os
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# =============================================================================
+# PATTERN 1: Environment Variable Handling with monkeypatch
+# =============================================================================
+
+def test_set_env_var_with_monkeypatch(monkeypatch):
+    """GOOD: Use monkeypatch.setenv() for setting env vars.
+
+    monkeypatch automatically restores the original value after the test,
+    preventing pollution of subsequent tests.
+    """
+    monkeypatch.setenv("TEST_API_KEY", "test_key_123")
+    assert os.environ["TEST_API_KEY"] == "test_key_123"
+    # Automatically cleaned up after test
+
+
+def test_delete_env_var_with_monkeypatch(monkeypatch):
+    """GOOD: Use monkeypatch.delenv() for removing env vars."""
+    monkeypatch.setenv("TEMP_VAR_TO_DELETE", "value")
+    monkeypatch.delenv("TEMP_VAR_TO_DELETE")
+    assert "TEMP_VAR_TO_DELETE" not in os.environ
+
+
+def test_multiple_env_vars(monkeypatch):
+    """GOOD: Set multiple env vars safely with monkeypatch."""
+    monkeypatch.setenv("VAR_ONE", "value1")
+    monkeypatch.setenv("VAR_TWO", "value2")
+    monkeypatch.setenv("VAR_THREE", "value3")
+    # All automatically cleaned up
+
+
+# =============================================================================
+# PATTERN 2: Mocking with monkeypatch and context managers
+# =============================================================================
+
+def test_mock_function_with_monkeypatch(monkeypatch):
+    """GOOD: Use monkeypatch.setattr() for mocking functions."""
+    def mock_getcwd():
+        return "/mock/path"
+
+    monkeypatch.setattr(os, "getcwd", mock_getcwd)
+    assert os.getcwd() == "/mock/path"
+    # Original function automatically restored after test
+
+
+def test_mock_with_context_manager():
+    """GOOD: Use patch as context manager for scoped mocking."""
+    with patch("os.path.exists") as mock_exists:
+        mock_exists.return_value = True
+        assert os.path.exists("/fake/nonexistent/path") is True
+    # Mock is automatically removed when context exits
+
+
+# =============================================================================
+# PATTERN 3: File System Operations with tmp_path
+# =============================================================================
+
+def test_create_temp_file(tmp_path):
+    """GOOD: Use tmp_path fixture for temporary files."""
+    test_file = tmp_path / "test_output.txt"
+    test_file.write_text("test content")
+    assert test_file.exists()
+    assert test_file.read_text() == "test content"
+    # tmp_path is automatically cleaned up by pytest
+
+
+def test_create_temp_directory_structure(tmp_path):
+    """GOOD: Create directory structures in tmp_path."""
+    subdir = tmp_path / "subdir" / "nested"
+    subdir.mkdir(parents=True)
+    config_file = subdir / "config.json"
+    config_file.write_text('{{"key": "value"}}')
+    assert config_file.exists()
+
+
+# =============================================================================
+# PATTERN 4: Fixtures with Proper Cleanup
+# =============================================================================
+
+@pytest.fixture
+def resource_with_cleanup():
+    """GOOD: Fixture with proper cleanup using yield.
+
+    The cleanup code after yield always runs, even if the test fails.
+    """
+    # Setup
+    resource = {{"initialized": True, "data": []}}
+    yield resource
+    # Cleanup - always runs
+    resource["initialized"] = False
+    resource["data"].clear()
+
+
+@pytest.fixture
+def mock_module_with_cleanup():
+    """GOOD: Fixture for sys.modules with save/restore.
+
+    This pattern ensures sys.modules is always restored to its original
+    state after the test, preventing pollution.
+    """
+    module_name = "test_mock_module"
+    saved = sys.modules.get(module_name)
+
+    mock_module = MagicMock()
+    sys.modules[module_name] = mock_module
+
+    yield mock_module
+
+    # Cleanup - restore original state
+    if saved is not None:
+        sys.modules[module_name] = saved
+    elif module_name in sys.modules:
+        del sys.modules[module_name]
+
+
+def test_with_resource_cleanup(resource_with_cleanup):
+    """Test using fixture with automatic cleanup."""
+    assert resource_with_cleanup["initialized"] is True
+    resource_with_cleanup["data"].append("test_item")
+
+
+def test_with_mock_module_cleanup(mock_module_with_cleanup):
+    """Test using sys.modules fixture with cleanup."""
+    assert "test_mock_module" in sys.modules
+
+
+# =============================================================================
+# PATTERN 5: Exception Testing with Context Manager
+# =============================================================================
+
+def test_exception_with_context_manager():
+    """GOOD: Use pytest.raises() as context manager."""
+    with pytest.raises(ValueError) as exc_info:
+        raise ValueError("expected error message")
+    assert "expected error message" in str(exc_info.value)
+
+
+def test_exception_with_match():
+    """GOOD: Use match parameter for regex matching."""
+    with pytest.raises(ValueError, match=r"invalid.*value"):
+        raise ValueError("invalid input value provided")
+
+
+# =============================================================================
+# PATTERN 6: Combining Multiple Isolation Techniques
+# =============================================================================
+
+def test_combined_env_and_file(monkeypatch, tmp_path):
+    """GOOD: Combine monkeypatch and tmp_path for full isolation."""
+    config_path = tmp_path / "config"
+    config_path.mkdir()
+    monkeypatch.setenv("CONFIG_DIR", str(config_path))
+
+    config_file = config_path / "settings.json"
+    config_file.write_text('{{"debug": true}}')
+
+    assert os.environ["CONFIG_DIR"] == str(config_path)
+    assert config_file.exists()
+    # Both automatically cleaned up
+
+
+def test_combined_mock_and_env(monkeypatch):
+    """GOOD: Combine function mocking with environment variables."""
+    monkeypatch.setattr(os.path, "isfile", lambda x: True)
+    monkeypatch.setenv("TEST_MODE", "true")
+
+    assert os.path.isfile("/any/path") is True
+    assert os.environ["TEST_MODE"] == "true"
+    # Both automatically cleaned up
+
+
+# =============================================================================
+# PATTERN 7: Module-Level sys.modules for Import-Time Dependencies
+# =============================================================================
+#
+# When you need to mock modules BEFORE importing code under test
+# (e.g., for decorators or top-level imports), use this pattern.
+#
+# This is necessary when the code under test has decorators or module-level
+# imports that you need to mock. Unlike fixture-based mocking, this happens
+# at test file load time, before any test functions run.
+#
+# CRITICAL: You MUST restore original modules after loading, or you will
+# pollute sys.modules for all other test files during collection!
+#
+# Example usage (place at module level, outside any test function):
+#
+# import importlib.util
+# from unittest.mock import MagicMock
+#
+# # Step 1: Define mocks for dependencies that need mocking at import time
+# _mock_decorator = lambda f: f  # Pass-through decorator
+# _mock_dependency = MagicMock(some_decorator=_mock_decorator)
+# _module_mocks = {{
+#     "some.dependency": _mock_dependency,
+# }}
+#
+# # Step 2: Save originals BEFORE patching
+# _original_modules = {{key: sys.modules.get(key) for key in _module_mocks}}
+#
+# # Step 3: Apply mocks to sys.modules
+# sys.modules.update(_module_mocks)
+#
+# # Step 4: Load the module under test using importlib
+# _module_path = os.path.join(os.path.dirname(__file__), "..", "src", "module.py")
+# _module_path = os.path.abspath(_module_path)
+# _spec = importlib.util.spec_from_file_location("my_module", _module_path)
+# _module = importlib.util.module_from_spec(_spec)
+# sys.modules["my_module"] = _module
+# _spec.loader.exec_module(_module)
+# function_to_test = _module.function_to_test
+#
+# # Step 5: RESTORE originals immediately after load
+# # This is CRITICAL to avoid polluting other test files!
+# for key, original in _original_modules.items():
+#     if original is None:
+#         sys.modules.pop(key, None)
+#     else:
+#         sys.modules[key] = original
+#
+# # Now you can write normal test functions using function_to_test
+# def test_something():
+#     result = function_to_test()
+#     assert result == expected
+
+</isolation_example>
+
 
 <instructions>
     1. FIRST: Carefully analyze the EXAMPLE to understand:

pdd/prompts/prompt_code_diff_LLM.prompt

@@ -48,17 +48,21 @@ Respond with a JSON object:
    - 50-69: Significant gaps, regeneration would likely fail some tests
    - 0-49: Major knowledge missing, regeneration would definitely fail
 
-2. "canRegenerate": boolean - Conservative assessment: could this prompt produce working code?
+2. "promptToCodeScore": integer 0-100 - How well the code implements the prompt requirements
 
-3. "regenerationRisk": "low", "medium", "high", or "critical"
+3. "codeToPromptScore": integer 0-100 - How well the prompt documents/describes the code
+
+4. "canRegenerate": boolean - Conservative assessment: could this prompt produce working code?
+
+5. "regenerationRisk": "low", "medium", "high", or "critical"
    - "low": Prompt captures all essential details
    - "medium": Some implementation details missing but core logic documented
    - "high": Significant undocumented behavior that would differ on regeneration
    - "critical": Code has major features/logic not in prompt at all
 
-4. "summary": 1-2 sentences on regeneration viability, be direct about risks
+6. "summary": 1-2 sentences on regeneration viability, be direct about risks
 
-5. "sections": array of PROMPT requirement sections, each with:
+7. "sections": array of PROMPT requirement sections, each with:
    - "id": unique string like "req_1", "req_2"
    - "promptRange": {{"startLine": int, "endLine": int, "text": "excerpt"}}
    - "codeRanges": array of {{"startLine": int, "endLine": int, "text": "excerpt"}} (empty if missing)
@@ -67,7 +71,7 @@ Respond with a JSON object:
    - "semanticLabel": descriptive label like "Error Handling", "Input Validation"
    - "notes": REQUIRED explanation - be specific about what's missing or at risk
 
-6. "codeSections": array of CODE sections NOT adequately documented in prompt:
+8. "codeSections": array of CODE sections NOT adequately documented in prompt:
    - "id": unique string like "code_1", "code_2"
    - "promptRange": {{"startLine": int, "endLine": int, "text": "excerpt"}} (empty if undocumented)
    - "codeRanges": array of {{"startLine": int, "endLine": int, "text": "excerpt"}}
@@ -78,34 +82,34 @@ Respond with a JSON object:
      * For "extra": "REGENERATION RISK: [specific feature/value/logic] is not in prompt and would be lost or different"
      * For "partial": "INCOMPLETE: Prompt mentions [X] but doesn't specify [critical detail Y]"
 
-7. "hiddenKnowledge": array of objects describing undocumented code knowledge:
+9. "hiddenKnowledge": array of objects describing undocumented code knowledge:
    - "type": "magic_value" | "algorithm_choice" | "edge_case" | "error_handling" | "api_contract" | "optimization" | "business_logic" | "assumption"
    - "location": {{"startLine": int, "endLine": int}}
    - "description": what the code knows that the prompt doesn't say
    - "regenerationImpact": "would_differ" | "would_fail" | "might_work"
    - "suggestedPromptAddition": what to add to the prompt to capture this
 
-8. "lineMappings": array of line-level mappings:
-   - "promptLine": int
-   - "codeLines": array of ints
-   - "matchType": "exact", "semantic", "partial", "none"
-
-9. "stats": {{
-   "totalRequirements": int,
-   "matchedRequirements": int,
-   "missingRequirements": int,
-   "totalCodeFeatures": int,
-   "documentedFeatures": int,
-   "undocumentedFeatures": int,
-   "promptToCodeCoverage": float,
-   "codeToPromptCoverage": float,
-   "hiddenKnowledgeCount": int,
-   "criticalGaps": int
+10. "lineMappings": array of line-level mappings:
+    - "promptLine": int
+    - "codeLines": array of ints
+    - "matchType": "exact", "semantic", "partial", "none"
+
+11. "stats": {{
+    "totalRequirements": int,
+    "matchedRequirements": int,
+    "missingRequirements": int,
+    "totalCodeFeatures": int,
+    "documentedFeatures": int,
+    "undocumentedFeatures": int,
+    "promptToCodeCoverage": float,
+    "codeToPromptCoverage": float,
+    "hiddenKnowledgeCount": int,
+    "criticalGaps": int
 }}
 
-10. "missing": array of strings - requirements in prompt not implemented
-11. "extra": array of strings - CRITICAL: code features that would be LOST on regeneration
-12. "suggestions": array of specific additions to make to the prompt to enable regeneration
+12. "missing": array of strings - requirements in prompt not implemented
+13. "extra": array of strings - CRITICAL: code features that would be LOST on regeneration
+14. "suggestions": array of specific additions to make to the prompt to enable regeneration
 
 ## Strictness Guidelines