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

pdd/load_prompt_template.py

@@ -1,8 +1,7 @@
 from pathlib import Path
-import os
 from typing import Optional
-import sys
 from rich import print
+from pdd.path_resolution import get_default_resolver
 
 def print_formatted(message: str) -> None:
     """Print message with raw formatting tags for testing compatibility."""
@@ -23,40 +22,22 @@ def load_prompt_template(prompt_name: str) -> Optional[str]:
         print_formatted("[red]Unexpected error loading prompt template[/red]")
         return None
 
-    # Step 1: Get project path from environment variable (preferred),
-    # else fall back to auto-detect based on this module's location or CWD.
-    project_path_env = os.getenv('PDD_PATH')
-    candidate_paths = []
-    if project_path_env:
-        candidate_paths.append(Path(project_path_env))
+    resolver = get_default_resolver()
+    prompt_path = resolver.resolve_prompt_template(prompt_name)
 
-    # Fallback 1: repository root inferred from this module (pdd/ => repo root)
-    try:
-        module_root = Path(__file__).resolve().parent  # pdd/
-        repo_root = module_root.parent                 # repo root
-        candidate_paths.append(repo_root)
-    except Exception:
-        pass
-
-    # Fallback 2: current working directory
-    candidate_paths.append(Path.cwd())
-
-    # Build candidate prompt paths to try in order
-    prompt_candidates = []
-    for cp in candidate_paths:
-        # Check both <path>/prompts/ and <path>/pdd/prompts/
-        # The latter handles installed package case where prompts are in pdd/prompts/
-        prompt_candidates.append(cp / 'prompts' / f"{prompt_name}.prompt")
-        prompt_candidates.append(cp / 'pdd' / 'prompts' / f"{prompt_name}.prompt")
+    if prompt_path is None:
+        candidate_roots = []
+        if resolver.pdd_path_env is not None:
+            candidate_roots.append(resolver.pdd_path_env)
+        if resolver.repo_root is not None:
+            candidate_roots.append(resolver.repo_root)
+        candidate_roots.append(resolver.cwd)
 
-    # Step 2: Load and return the prompt template
-    prompt_path: Optional[Path] = None
-    for candidate in prompt_candidates:
-        if candidate.exists():
-            prompt_path = candidate
-            break
+        prompt_candidates = []
+        for root in candidate_roots:
+            prompt_candidates.append(root / 'prompts' / f"{prompt_name}.prompt")
+            prompt_candidates.append(root / 'pdd' / 'prompts' / f"{prompt_name}.prompt")
 
-    if prompt_path is None:
         tried = "\n".join(str(c) for c in prompt_candidates)
         print_formatted(
             f"[red]Prompt file not found in any candidate locations for '{prompt_name}'. Tried:\n{tried}[/red]"
@@ -82,4 +63,4 @@ if __name__ == "__main__":
     prompt = load_prompt_template("example_prompt")
     if prompt:
         print_formatted("[blue]Loaded prompt template:[/blue]")
-        print_formatted(prompt)
+        print_formatted(prompt)

pdd/path_resolution.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from pathlib import Path
+from typing import Literal, Optional
+
+IncludeProfile = Literal["cwd_then_package_then_repo"]
+PromptProfile = Literal["pdd_path_then_repo_then_cwd"]
+DataProfile = Literal["pdd_path_only"]
+ProjectRootProfile = Literal["pdd_path_then_marker_then_cwd"]
+
+
+@dataclass(frozen=True)
+class PathResolver:
+    cwd: Path
+    pdd_path_env: Optional[Path]
+    package_root: Path
+    repo_root: Optional[Path]
+
+    def resolve_include(self, rel: str, profile: IncludeProfile = "cwd_then_package_then_repo") -> Path:
+        if profile != "cwd_then_package_then_repo":
+            raise ValueError(f"Unsupported include profile: {profile}")
+
+        cwd_path = self.cwd / rel
+        if cwd_path.exists():
+            return cwd_path
+
+        pkg_path = self.package_root / rel
+        if pkg_path.exists():
+            return pkg_path
+
+        if self.repo_root is not None:
+            repo_path = self.repo_root / rel
+            if repo_path.exists():
+                return repo_path
+
+        return cwd_path
+
+    def resolve_prompt_template(
+        self,
+        name: str,
+        profile: PromptProfile = "pdd_path_then_repo_then_cwd",
+    ) -> Optional[Path]:
+        if profile != "pdd_path_then_repo_then_cwd":
+            raise ValueError(f"Unsupported prompt profile: {profile}")
+
+        roots = []
+        if self.pdd_path_env is not None:
+            roots.append(self.pdd_path_env)
+        if self.repo_root is not None:
+            roots.append(self.repo_root)
+        roots.append(self.cwd)
+
+        prompt_file = f"{name}.prompt"
+        for root in roots:
+            candidate = root / "prompts" / prompt_file
+            if candidate.exists():
+                return candidate
+            candidate = root / "pdd" / "prompts" / prompt_file
+            if candidate.exists():
+                return candidate
+
+        return None
+
+    def resolve_data_file(self, rel: str, profile: DataProfile = "pdd_path_only") -> Path:
+        if profile != "pdd_path_only":
+            raise ValueError(f"Unsupported data profile: {profile}")
+        if self.pdd_path_env is None:
+            raise ValueError("PDD_PATH environment variable is not set.")
+        return self.pdd_path_env / rel
+
+    def resolve_project_root(
+        self,
+        profile: ProjectRootProfile = "pdd_path_then_marker_then_cwd",
+        max_levels: int = 5,
+    ) -> Path:
+        if profile != "pdd_path_then_marker_then_cwd":
+            raise ValueError(f"Unsupported project root profile: {profile}")
+
+        if (
+            self.pdd_path_env is not None
+            and self.pdd_path_env.is_dir()
+            and not _is_within(self.pdd_path_env, self.package_root)
+        ):
+            return self.pdd_path_env
+
+        current = self.cwd
+        for _ in range(max_levels):
+            if _has_project_marker(current):
+                return current
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+
+        return self.cwd
+
+
+def get_default_resolver() -> PathResolver:
+    cwd = Path.cwd().resolve()
+
+    pdd_path_env = None
+    env_value = os.getenv("PDD_PATH")
+    if env_value:
+        pdd_path_env = Path(env_value).expanduser().resolve()
+
+    package_root = Path(__file__).resolve().parent
+    repo_root = package_root.parent
+
+    return PathResolver(
+        cwd=cwd,
+        pdd_path_env=pdd_path_env,
+        package_root=package_root,
+        repo_root=repo_root,
+    )
+
+
+def _has_project_marker(path: Path) -> bool:
+    return (
+        (path / ".git").exists()
+        or (path / "pyproject.toml").exists()
+        or (path / "data").is_dir()
+        or (path / ".env").exists()
+    )
+
+
+def _is_within(path: Path, parent: Path) -> bool:
+    try:
+        resolved_path = path.resolve()
+        resolved_parent = parent.resolve()
+    except Exception:
+        return False
+
+    if resolved_path == resolved_parent:
+        return True
+    parent_str = str(resolved_parent)
+    if not parent_str.endswith(os.sep):
+        parent_str = parent_str + os.sep
+    return str(resolved_path).startswith(parent_str)

pdd/postprocess.py

@@ -7,6 +7,8 @@ from . import DEFAULT_TIME, DEFAULT_STRENGTH
 
 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")
 
 def postprocess_0(text: str) -> str:
@@ -93,7 +95,8 @@ def postprocess(
             temperature=temperature,
             time=time,
             verbose=verbose,
-            output_pydantic=ExtractedCode
+            output_pydantic=ExtractedCode,
+            language=language,
         )
 
         if not response or 'result' not in response:

pdd/preprocess.py

@@ -4,10 +4,12 @@ import base64
 import subprocess
 from typing import List, Optional, Tuple
 import traceback
+from pathlib import Path
 from rich.console import Console
 from rich.panel import Panel
 from rich.markup import escape
 from rich.traceback import install
+from pdd.path_resolution import get_default_resolver
 
 install()
 console = Console()
@@ -37,24 +39,51 @@ def _write_debug_report() -> None:
         console.print("[dim]Debug mode enabled but PDD_PREPROCESS_DEBUG_FILE not set (output shown in console only)[/dim]")
 
 def _extract_fence_spans(text: str) -> List[Tuple[int, int]]:
-    """Return list of (start, end) spans for fenced code blocks ```...```.
+    """Return list of (start, end) spans for fenced code blocks (``` or ~~~).
 
     The spans are [start, end) indices in the original text.
     """
     spans: List[Tuple[int, int]] = []
     try:
-        for m in re.finditer(r"```[\w\s]*\n[\s\S]*?```", text):
+        fence_re = re.compile(
+            r"(?m)^[ \t]*([`~]{3,})[^\n]*\n[\s\S]*?\n[ \t]*\1[ \t]*(?:\n|$)"
+        )
+        for m in fence_re.finditer(text):
             spans.append((m.start(), m.end()))
     except Exception:
         pass
     return spans
 
+
+def _extract_inline_code_spans(text: str) -> List[Tuple[int, int]]:
+    """Return list of (start, end) spans for inline code (backticks)."""
+    spans: List[Tuple[int, int]] = []
+    try:
+        for m in re.finditer(r"(?<!`)(`+)([^\n]*?)\1", text):
+            spans.append((m.start(), m.end()))
+    except Exception:
+        pass
+    return spans
+
+
+def _extract_code_spans(text: str) -> List[Tuple[int, int]]:
+    spans = _extract_fence_spans(text)
+    spans.extend(_extract_inline_code_spans(text))
+    return sorted(spans, key=lambda s: s[0])
+
 def _is_inside_any_span(idx: int, spans: List[Tuple[int, int]]) -> bool:
     for s, e in spans:
         if s <= idx < e:
             return True
     return False
 
+
+def _intersects_any_span(start: int, end: int, spans: List[Tuple[int, int]]) -> bool:
+    for s, e in spans:
+        if start < e and end > s:
+            return True
+    return False
+
 def _scan_risky_placeholders(text: str) -> Tuple[List[Tuple[int, str]], List[Tuple[int, str]]]:
     """Scan for risky placeholders outside code fences.
 
@@ -119,8 +148,11 @@ def preprocess(prompt: str, recursive: bool = False, double_curly_brackets: bool
         return prompt
 
 def get_file_path(file_name: str) -> str:
-    base_path = './'
-    return os.path.join(base_path, file_name)
+    resolver = get_default_resolver()
+    resolved = resolver.resolve_include(file_name)
+    if not Path(file_name).is_absolute() and resolved == resolver.cwd / file_name:
+        return os.path.join("./", file_name)
+    return str(resolved)
 
 def process_backtick_includes(text: str, recursive: bool) -> str:
     # More specific pattern that doesn't match nested > characters
@@ -229,7 +261,12 @@ def process_include_tags(text: str, recursive: bool) -> str:
     current_text = text
     while prev_text != current_text:
         prev_text = current_text
-        current_text = re.sub(pattern, replace_include, current_text, flags=re.DOTALL)
+        code_spans = _extract_code_spans(current_text)
+        def replace_include_with_spans(match):
+            if _intersects_any_span(match.start(), match.end(), code_spans):
+                return match.group(0)
+            return replace_include(match)
+        current_text = re.sub(pattern, replace_include_with_spans, current_text, flags=re.DOTALL)
     return current_text
 
 def process_pdd_tags(text: str) -> str:
@@ -262,7 +299,12 @@ def process_shell_tags(text: str, recursive: bool) -> str:
             console.print(f"[bold red]Error executing shell command:[/bold red] {str(e)}")
             _dbg(f"Shell execution exception: {e}")
             return f"[Shell execution error: {str(e)}]"
-    return re.sub(pattern, replace_shell, text, flags=re.DOTALL)
+    code_spans = _extract_code_spans(text)
+    def replace_shell_with_spans(match):
+        if _intersects_any_span(match.start(), match.end(), code_spans):
+            return match.group(0)
+        return replace_shell(match)
+    return re.sub(pattern, replace_shell_with_spans, text, flags=re.DOTALL)
 
 def process_web_tags(text: str, recursive: bool) -> str:
     pattern = r'<web>(.*?)</web>'
@@ -275,7 +317,7 @@ def process_web_tags(text: str, recursive: bool) -> str:
         _dbg(f"Web tag URL: {url}")
         try:
             try:
-                from firecrawl import FirecrawlApp
+                from firecrawl import Firecrawl
             except ImportError:
                 _dbg("firecrawl import failed; package not installed")
                 return f"[Error: firecrawl-py package not installed. Cannot scrape {url}]"
@@ -284,9 +326,13 @@ def process_web_tags(text: str, recursive: bool) -> str:
                 console.print("[bold yellow]Warning:[/bold yellow] FIRECRAWL_API_KEY not found in environment")
                 _dbg("FIRECRAWL_API_KEY not set")
                 return f"[Error: FIRECRAWL_API_KEY not set. Cannot scrape {url}]"
-            app = FirecrawlApp(api_key=api_key)
-            response = app.scrape_url(url, formats=['markdown'])
-            if hasattr(response, 'markdown'):
+            app = Firecrawl(api_key=api_key)
+            response = app.scrape(url, formats=['markdown'])
+            # Handle both dict response (new API) and object response (legacy)
+            if isinstance(response, dict) and 'markdown' in response:
+                _dbg(f"Web scrape returned markdown (len={len(response['markdown'])})")
+                return response['markdown']
+            elif hasattr(response, 'markdown'):
                 _dbg(f"Web scrape returned markdown (len={len(response.markdown)})")
                 return response.markdown
             else:
@@ -297,7 +343,12 @@ def process_web_tags(text: str, recursive: bool) -> str:
             console.print(f"[bold red]Error scraping web content:[/bold red] {str(e)}")
             _dbg(f"Web scraping exception: {e}")
             return f"[Web scraping error: {str(e)}]"
-    return re.sub(pattern, replace_web, text, flags=re.DOTALL)
+    code_spans = _extract_code_spans(text)
+    def replace_web_with_spans(match):
+        if _intersects_any_span(match.start(), match.end(), code_spans):
+            return match.group(0)
+        return replace_web(match)
+    return re.sub(pattern, replace_web_with_spans, text, flags=re.DOTALL)
 
 def process_include_many_tags(text: str, recursive: bool) -> str:
     """Process <include-many> blocks whose inner content is a comma- or newline-separated
@@ -328,7 +379,12 @@ def process_include_many_tags(text: str, recursive: bool) -> str:
                 _dbg(f"Error processing include-many {p}: {e}")
                 contents.append(f"[Error processing include: {p}]")
         return "\n".join(contents)
-    return re.sub(pattern, replace_many, text, flags=re.DOTALL)
+    code_spans = _extract_code_spans(text)
+    def replace_many_with_spans(match):
+        if _intersects_any_span(match.start(), match.end(), code_spans):
+            return match.group(0)
+        return replace_many(match)
+    return re.sub(pattern, replace_many_with_spans, text, flags=re.DOTALL)
 
 def double_curly(text: str, exclude_keys: Optional[List[str]] = None) -> str:
     if exclude_keys is None:

pdd/preprocess_main.py

@@ -1,5 +1,6 @@
 import csv
 import sys
+from pathlib import Path
 from typing import Tuple, Optional
 import click
 from rich import print as rprint
@@ -8,8 +9,15 @@ from .config_resolution import resolve_effective_config
 from .construct_paths import construct_paths
 from .preprocess import preprocess
 from .xml_tagger import xml_tagger
+from .architecture_sync import (
+    get_architecture_entry_for_prompt,
+    generate_tags_from_architecture,
+    has_pdd_tags,
+)
+
+
 def preprocess_main(
-    ctx: click.Context, prompt_file: str, output: Optional[str], xml: bool, recursive: bool, double: bool, exclude: list
+    ctx: click.Context, prompt_file: str, output: Optional[str], xml: bool, recursive: bool, double: bool, exclude: list, pdd_tags: bool = False
 ) -> Tuple[str, float, str]:
     """
     CLI wrapper for preprocessing prompts.
@@ -22,6 +30,7 @@ def preprocess_main(
     :param double: If True, curly brackets will be doubled.
     :param exclude: List of keys to exclude from curly bracket doubling.
     :return: Tuple containing the preprocessed prompt, total cost, and model name used.
+    :param pdd_tags: If True, inject PDD metadata tags from architecture.json.
     """
     try:
         # Construct file paths
@@ -39,6 +48,27 @@ def preprocess_main(
         # Load prompt file
         prompt = input_strings["prompt_file"]
 
+        # Inject PDD metadata tags from architecture.json if requested
+        pdd_tags_injected = False
+        if pdd_tags:
+            prompt_filename = Path(prompt_file).name
+            arch_entry = get_architecture_entry_for_prompt(prompt_filename)
+
+            if arch_entry:
+                if has_pdd_tags(prompt):
+                    if not ctx.obj.get("quiet", False):
+                        rprint(f"[yellow]Prompt already has PDD tags, skipping injection.[/yellow]")
+                else:
+                    generated_tags = generate_tags_from_architecture(arch_entry)
+                    if generated_tags:
+                        prompt = generated_tags + '\n\n' + prompt
+                        pdd_tags_injected = True
+                        if not ctx.obj.get("quiet", False):
+                            rprint(f"[green]Injected PDD tags from architecture.json[/green]")
+            else:
+                if not ctx.obj.get("quiet", False):
+                    rprint(f"[yellow]No architecture entry found for '{prompt_filename}', skipping PDD tags.[/yellow]")
+
         if xml:
             # Use xml_tagger to add XML delimiters
             # Use centralized config resolution with proper priority: CLI > pddrc > defaults
@@ -67,6 +97,8 @@ def preprocess_main(
         # Provide user feedback
         if not ctx.obj.get("quiet", False):
             rprint("[bold green]Prompt preprocessing completed successfully.[/bold green]")
+            if pdd_tags_injected:
+                rprint("[bold]PDD metadata tags: injected from architecture.json[/bold]")
             if xml:
                 rprint(f"[bold]XML Tagging used: {model_name}[/bold]")
             else:

pdd/prompts/agentic_bug_step10_pr_LLM.prompt

@@ -0,0 +1,182 @@
+% You are an expert software engineer investigating a bug report. Your task is to create a draft pull request with the failing tests and link it to the issue.
+
+% Context
+
+You are working on step 10 of 10 (final step) in an agentic bug investigation workflow. Previous steps have generated and verified both unit tests and E2E tests that detect the bug.
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Previous Steps Output
+<step1_output>
+{step1_output}
+</step1_output>
+
+<step2_output>
+{step2_output}
+</step2_output>
+
+<step3_output>
+{step3_output}
+</step3_output>
+
+<step4_output>
+{step4_output}
+</step4_output>
+
+<step5_output>
+{step5_output}
+</step5_output>
+
+<step6_output>
+{step6_output}
+</step6_output>
+
+<step7_output>
+{step7_output}
+</step7_output>
+
+<step8_output>
+{step8_output}
+</step8_output>
+
+<step9_output>
+{step9_output}
+</step9_output>
+
+% Worktree Information
+
+You are operating in an isolated git worktree at: {worktree_path}
+This worktree is already checked out to branch `fix/issue-{issue_number}`.
+Do NOT create a new branch - just stage, commit, and push.
+
+% Files to Stage
+
+**IMPORTANT: Only stage these specific files:**
+{files_to_stage}
+
+% Your Task
+
+1. **Prepare the commit**
+   - You are already on branch `fix/issue-{issue_number}` in an isolated worktree
+   - **CRITICAL: Stage ONLY the test file(s) created in Steps 7 and 9**
+   - Get the exact file paths from:
+     - Step 7's `FILES_CREATED:` or `FILES_MODIFIED:` output (unit tests)
+     - Step 9's `E2E_FILES_CREATED:` or `E2E_FILES_MODIFIED:` output (E2E tests)
+   - Stage each file individually: `git add <exact_file_path>`
+   - **DO NOT use `git add .` or `git add -A`** - these will stage unrelated files and pollute the PR
+   - Verify only the intended files are staged: `git status --short` (should show only the test file(s))
+   - Commit with a descriptive message referencing the issue
+
+2. **Create the draft PR**
+   - Push the branch to origin
+   - Create a draft pull request using `gh pr create --draft`
+   - Link to the issue using "Fixes #{issue_number}" in the PR body
+
+3. **Post final summary**
+   - Comment on the issue with PR link and next steps for the fix
+
+4. **Include PDD fix command**
+   - Extract code file path from Step 5's `**Location:**` field (strip the `:line_number` suffix)
+   - Use test file path from Step 7's `FILES_CREATED:` or test file section
+   - Search repo for matching prompt file: `find . -name "*.prompt" -type f`
+   - Derive module name from code file (e.g., `pdd/foo.py` -> `foo`)
+   - Use verification program: `context/{{module_name}}_example.py`
+   - Use error log path: `fix-issue-{issue_number}.log` for the fix command output
+   - Include a ready-to-run `pdd fix` command in your GitHub comment
+   - If no prompt file or verification program exists, include a note that they must be created first
+
+% PR Creation Command
+
+```bash
+gh pr create --draft --title "Add failing tests for #{issue_number}" --body "$(cat <<'EOF'
+## Summary
+Adds failing tests that detect the bug reported in #{issue_number}.
+
+## Test Files
+- Unit test: `{{unit_test_file_path}}`
+- E2E test: `{{e2e_test_file_path}}` (if applicable)
+
+## What This PR Contains
+- Failing unit test that reproduces the reported bug
+- Failing E2E test that verifies the bug at integration level (if applicable)
+- Tests are verified to fail on current code and will pass once the bug is fixed
+
+## Root Cause
+{{root_cause_summary}}
+
+## Next Steps
+1. [ ] Implement the fix at the identified location
+2. [ ] Verify the unit test passes
+3. [ ] Verify the E2E test passes
+4. [ ] Run full test suite
+5. [ ] Mark PR as ready for review
+
+Fixes #{issue_number}
+
+---
+*Generated by PDD agentic bug workflow*
+EOF
+)"
+```
+
+% Output
+
+After creating the PR, use `gh issue comment` to post your final report to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+```markdown
+## Step 10: Draft PR Created
+
+### Pull Request
+**PR #{{pr_number}}:** [{{pr_title}}]({{pr_url}})
+
+### Branch
+`fix/issue-{issue_number}`
+
+### What's Included
+- Failing unit test at `{{unit_test_file_path}}`
+- Failing E2E test at `{{e2e_test_file_path}}` (if applicable)
+- Commits: {{commit_count}}
+
+### Next Steps for Maintainers
+1. Review the failing tests to understand the expected behavior
+2. Implement the fix at the identified location
+3. Verify both unit and E2E tests pass with your fix
+4. Run full test suite to check for regressions
+5. Mark the PR as ready for review
+
+### PDD Fix Command
+
+To auto-fix this bug using PDD:
+
+```bash
+cd {{worktree_path}}
+pdd --force fix --loop --max-attempts 5 --verification-program context/{{module_name}}_example.py {{prompt_file}} {{code_file_path}} {{test_file_path}} fix-issue-{{issue_number}}.log
+```
+
+---
+*Investigation complete. A draft PR with failing tests has been created and linked to this issue.*
+```
+
+% Important
+
+- Create a DRAFT PR (not ready for review) since it only contains the failing tests
+- The PR should clearly state that a fix is still needed
+- Use "Fixes #{issue_number}" to auto-link the PR to the issue
+- Do NOT create a new branch - you are already on the correct branch in the worktree
+- Include both unit test files (Step 7) and E2E test files (Step 9) if both exist
+- Always post your findings as a GitHub comment before completing