pdd-cli 0.0.45__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,18 +22,26 @@ 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
-    project_path = os.getenv('PDD_PATH')
-    if not project_path:
-        print_formatted("[red]PDD_PATH environment variable is not set[/red]")
-        return None
+    resolver = get_default_resolver()
+    prompt_path = resolver.resolve_prompt_template(prompt_name)
+
+    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)
 
-    # Construct the full path to the prompt file
-    prompt_path = Path(project_path) / 'prompts' / f"{prompt_name}.prompt"
+        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")
 
-    # Step 2: Load and return the prompt template
-    if not prompt_path.exists():
-        print_formatted(f"[red]Prompt file not found: {prompt_path}[/red]")
+        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]"
+        )
         return None
 
     try:

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/pdd_completion.fish

@@ -10,6 +10,8 @@ complete -c pdd -n "__fish_use_subcommand" -l quiet -d "Decrease output verbosit
 complete -c pdd -n "__fish_use_subcommand" -l output-cost -r -d "Enable cost tracking and output CSV file"
 complete -c pdd -n "__fish_use_subcommand" -l review-examples -d "Review few-shot examples before execution"
 complete -c pdd -n "__fish_use_subcommand" -l local -d "Run commands locally"
+complete -c pdd -n "__fish_use_subcommand" -l context -r -d "Override .pddrc context"
+complete -c pdd -n "__fish_use_subcommand" -l list-contexts -d ".pddrc contexts and exit"
 complete -c pdd -n "__fish_use_subcommand" -l help -d "Show help message"
 complete -c pdd -n "__fish_use_subcommand" -l version -d "Show version information"
 
@@ -27,13 +29,18 @@ complete -c pdd -n "__fish_use_subcommand" -a conflicts -d "Analyze conflicts be
 complete -c pdd -n "__fish_use_subcommand" -a crash -d "Fix code causing program crash"
 complete -c pdd -n "__fish_use_subcommand" -a trace -d "Trace code line to prompt"
 complete -c pdd -n "__fish_use_subcommand" -a bug -d "Generate unit test from bug report"
-complete -c pdd -n "__fish_use_subcommand" -a auto-deps -d "Analyze and insert dependencies"
+complete -c pdd -n "__fish_use_subcommand" -a auto-deps -d "Analyze and insert dependencies from directory or glob"
 complete -c pdd -n "__fish_use_subcommand" -a verify -d "Verify functional correctness using LLM judgment"
+complete -c pdd -n "__fish_use_subcommand" -a sync -d "Synchronize prompt, code, examples, tests"
+complete -c pdd -n "__fish_use_subcommand" -a setup -d "Interactive setup and completion install"
+complete -c pdd -n "__fish_use_subcommand" -a install_completion -d "Install shell completion"
+complete -c pdd -n "__fish_use_subcommand" -a pytest-output -d "Run pytest and capture structured output"
 
 # Command-specific completions
 complete -c pdd -n "__fish_seen_subcommand_from generate" -l output -r -d "Output location for generated code"
 complete -c pdd -n "__fish_seen_subcommand_from generate" -l original-prompt -r -d "Original prompt file for incremental generation"
 complete -c pdd -n "__fish_seen_subcommand_from generate" -l incremental -d "Force incremental patching"
+complete -c pdd -n "__fish_seen_subcommand_from generate" -s e -l env -xa "(env | cut -d= -f1 | sed 's/.*/&=/' | sort -u)" -d "Set template variable (KEY=VALUE) or read KEY from env"
 complete -c pdd -n "__fish_seen_subcommand_from generate" -a "(__fish_complete_suffix .prompt)"
 
 complete -c pdd -n "__fish_seen_subcommand_from example" -l output -r -d "Output location for example code"
@@ -125,10 +132,26 @@ complete -c pdd -n "__fish_seen_subcommand_from verify" -l budget -x -d "Max bud
 complete -c pdd -n "__fish_seen_subcommand_from verify" -a "(__fish_complete_suffix .prompt)"
 complete -c pdd -n "__fish_seen_subcommand_from verify" -a "(__fish_complete_suffix .py .js .java .cpp .rb .go)" # For CODE_FILE and PROGRAM_FILE
 
+# sync command
+complete -c pdd -n "__fish_seen_subcommand_from sync" -l max-attempts -x -d "Max attempts for loops"
+complete -c pdd -n "__fish_seen_subcommand_from sync" -l budget -x -d "Total budget for sync"
+complete -c pdd -n "__fish_seen_subcommand_from sync" -l skip-verify -d "Skip functional verification"
+complete -c pdd -n "__fish_seen_subcommand_from sync" -l skip-tests -d "Skip unit test generation"
+complete -c pdd -n "__fish_seen_subcommand_from sync" -l target-coverage -x -d "Desired coverage percentage"
+complete -c pdd -n "__fish_seen_subcommand_from sync" -l log -d "Show analysis instead of running"
+
+# setup and install_completion have no options
+complete -c pdd -n "__fish_seen_subcommand_from setup" -d "Run interactive setup"
+complete -c pdd -n "__fish_seen_subcommand_from install_completion" -d "Install shell completion"
+
+# pytest-output command
+complete -c pdd -n "__fish_seen_subcommand_from pytest-output" -l json-only -d "Print only JSON"
+complete -c pdd -n "__fish_seen_subcommand_from pytest-output" -a "(__fish_complete_suffix .py)"
+
 # File completion for all commands
 complete -c pdd -n "__fish_seen_subcommand_from generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify" -a "(__fish_complete_suffix .prompt)"
 complete -c pdd -n "__fish_seen_subcommand_from generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify" -a "(__fish_complete_suffix .py .js .java .cpp .rb .go)"
 complete -c pdd -n "__fish_seen_subcommand_from generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify" -a "(__fish_complete_suffix .log .txt .csv)"
 
 # Help completion
-complete -c pdd -n "__fish_seen_subcommand_from help" -a "generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify" -d "Show help for specific command"
+complete -c pdd -n "__fish_seen_subcommand_from help" -a "generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify sync setup install_completion pytest-output" -d "Show help for specific command"

pdd/pdd_completion.sh

@@ -15,13 +15,13 @@ _pdd() {
     cword=$COMP_CWORD
 
     # Global options
-    local global_opts="--force --strength --time --temperature --verbose --quiet --output-cost --review-examples --local --help --version"
+    local global_opts="--force --strength --time --temperature --verbose --quiet --output-cost --review-examples --local --context --list-contexts --help --version"
 
     # Commands
-    local commands="generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify"
+    local commands="generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify sync setup install_completion pytest-output"
 
     # Command-specific options
-    local generate_opts="--output --original-prompt --incremental"
+    local generate_opts="--output --original-prompt --incremental --env -e"
     local example_opts="--output"
     local test_opts="--output --language --coverage-report --existing-tests --target-coverage --merge"
     local preprocess_opts="--output --xml --recursive --double --exclude"
@@ -36,6 +36,8 @@ _pdd() {
     local bug_opts="--output --language"
     local auto_deps_opts="--output --csv --force-scan"
     local verify_opts="--output-results --output-code --output-program --max-attempts --budget"
+    local sync_opts="--max-attempts --budget --skip-verify --skip-tests --target-coverage --log"
+    local pytest_output_opts="--json-only"
 
     # Complete global options before command
     if [[ $cword -eq 1 ]]; then
@@ -46,6 +48,16 @@ _pdd() {
     # Complete command-specific options
     case ${words[1]} in
         generate)
+            # If completing the value for -e/--env, suggest environment variable names (with and without '=')
+            if [[ $prev == "-e" || $prev == "--env" ]]; then
+                local vars
+                vars=$(env | cut -d= -f1 | sort -u)
+                # Offer both KEY and KEY=
+                local vars_with_eq
+                vars_with_eq=$(printf '%s=\n' $vars)
+                COMPREPLY=($(compgen -W "$vars $vars_with_eq" -- "$cur"))
+                return
+            fi
             _complete_files ".prompt"
             COMPREPLY+=($(compgen -W "$generate_opts" -- "$cur"))
             ;;
@@ -131,6 +143,20 @@ _pdd() {
             _complete_files
             COMPREPLY+=($(compgen -W "$verify_opts" -- "$cur"))
             ;;
+        sync)
+            # BASENAME (not a file), offer options
+            COMPREPLY+=($(compgen -W "$sync_opts" -- "$cur"))
+            ;;
+        setup)
+            # no command-specific options
+            ;;
+        install_completion)
+            # no command-specific options
+            ;;
+        pytest-output)
+            _complete_files
+            COMPREPLY+=($(compgen -W "$pytest_output_opts" -- "$cur"))
+            ;;
         *)
             COMPREPLY=($(compgen -W "$global_opts" -- "$cur"))
             ;;
@@ -157,4 +183,4 @@ _complete_files() {
     fi
 }
 
-complete -F _pdd pdd
+complete -F _pdd pdd

pdd/pdd_completion.zsh

@@ -57,6 +57,8 @@ _pdd_global_opts=(
   '--output-cost[Enable cost tracking and output a CSV file with usage details.]:filename:_files'
   '--review-examples[Review and optionally exclude few-shot examples before command execution.]'
   '--local[Run commands locally instead of in the cloud.]'
+  '--context[Override automatic .pddrc context]:context-name:_guard'
+  '--list-contexts[List available .pddrc contexts and exit]'
   '--help[Show help message and exit.]'
   '--version[Show version and exit.]'
 )
@@ -65,6 +67,14 @@ _pdd_global_opts=(
 # Per-subcommand completion functions
 ##
 
+# Helper: suggest environment variables (KEY and KEY=)
+_pdd_env_vars() {
+  local -a envs envs_eq
+  envs=(${(f)"$(env | cut -d= -f1 | sort -u)"})
+  envs_eq=(${envs/%/=})
+  _describe -t envvars 'environment variables' envs_eq envs
+}
+
 # generate
 # Usage: pdd [GLOBAL OPTIONS] generate [OPTIONS] PROMPT_FILE
 # Options:
@@ -77,6 +87,7 @@ _pdd_generate() {
     '--output=[Specify where to save the generated code.]:filename:_files' \
     '--original-prompt=[The original prompt file used to generate existing code.]:filename:_files' \
     '--incremental[Force incremental patching even if changes are significant.]' \
+    '(-e --env)'{-e,--env}'[Set template variable (KEY=VALUE) or read KEY from env]:template variable:_pdd_env_vars' \
     '1:prompt-file:_files' \
     '*:filename:_files'
 }
@@ -349,7 +360,7 @@ _pdd_bug() {
 #   --force-scan
 # Args:
 #   1: PROMPT_FILE
-#   2: DIRECTORY_PATH
+#   2: DIRECTORY_PATH (directory or glob pattern)
 _pdd_auto_deps() {
   _arguments -s \
     $_pdd_global_opts \
@@ -357,7 +368,7 @@ _pdd_auto_deps() {
     '--csv=[CSV file for dependency info (default: project_dependencies.csv).]:filename:_files' \
     '--force-scan[Force rescanning of all potential dependency files.]' \
     '1:prompt-file:_files' \
-    '2:directory:_files -/' \
+    '2:directory-or-glob:_files -/' \
     '*:filename:_files'
 }
 
@@ -387,6 +398,54 @@ _pdd_verify() {
     '*:filename:_files'
 }
 
+# sync
+# Usage: pdd [GLOBAL OPTIONS] sync [OPTIONS] BASENAME
+# Options:
+#   --max-attempts [INT]
+#   --budget [FLOAT]
+#   --skip-verify
+#   --skip-tests
+#   --target-coverage [FLOAT]
+#   --log
+# Arg:
+#   1: BASENAME
+_pdd_sync() {
+  _arguments -s \
+    $_pdd_global_opts \
+    '--max-attempts=[Maximum attempts for iterative loops (default 3)]:int' \
+    '--budget=[Maximum total cost for sync (default 10.0)]:float' \
+    '--skip-verify[Skip the functional verification step]' \
+    '--skip-tests[Skip unit test generation and fixing]' \
+    '--target-coverage=[Desired code coverage percentage]:float' \
+    '--log[Show analysis instead of executing operations]' \
+    '1:basename: ' \
+    '*: :'
+}
+
+# setup (no options)
+_pdd_setup() {
+  _arguments -s $_pdd_global_opts
+}
+
+# install_completion (no options)
+_pdd_install_completion() {
+  _arguments -s $_pdd_global_opts
+}
+
+# pytest-output
+# Usage: pdd [GLOBAL OPTIONS] pytest-output [OPTIONS] TEST_FILE
+# Options:
+#   --json-only
+# Arg:
+#   1: TEST_FILE
+_pdd_pytest_output() {
+  _arguments -s \
+    $_pdd_global_opts \
+    '--json-only[Print only JSON to stdout]' \
+    '1:test-file:_files' \
+    '*:filename:_files'
+}
+
 ##
 # Main PDD completion dispatcher
 ##
@@ -410,8 +469,12 @@ _pdd() {
     'crash:Fix errors in a code module and its calling program'
     'trace:Find the prompt file line number associated with a code line'
     'bug:Generate a unit test based on incorrect vs desired outputs'
-    'auto-deps:Analyze a prompt file and directory for needed dependencies'
+    'auto-deps:Analyze a prompt and include deps from a directory or glob'
     'verify:Verify functional correctness using LLM judgment and iteratively fix'
+    'sync:Synchronize prompt, code, examples, tests with analysis'
+    'setup:Interactive setup and completion install'
+    'install_completion:Install shell completion for current shell'
+    'pytest-output:Run pytest and capture structured output'
   )
 
   # If there's no subcommand yet (i.e., user typed only "pdd " or "pdd -<Tab>"), offer global opts or subcommands.
@@ -471,6 +534,18 @@ _pdd() {
     verify)
       _pdd_verify
       ;;
+    sync)
+      _pdd_sync
+      ;;
+    setup)
+      _pdd_setup
+      ;;
+    install_completion)
+      _pdd_install_completion
+      ;;
+    pytest-output)
+      _pdd_pytest_output
+      ;;
     # If the subcommand is unknown or not typed yet, fall back to showing the list of subcommands.
     *)
       _describe -t subcommands 'pdd subcommand' _pdd_subcommands
@@ -487,4 +562,4 @@ else
   echo >&2 "Warning: Could not register pdd completion. Make sure ZSH completion system is working."
 fi
 
-# End of pdd_completion.zsh
+# End of pdd_completion.zsh

pdd/postprocess.py

@@ -3,10 +3,12 @@ from rich import print
 from pydantic import BaseModel, Field
 from .load_prompt_template import load_prompt_template
 from .llm_invoke import llm_invoke
-from . import DEFAULT_TIME
+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:
@@ -36,7 +38,7 @@ def postprocess_0(text: str) -> str:
 def postprocess(
     llm_output: str,
     language: str,
-    strength: float = 0.9,
+    strength: float = DEFAULT_STRENGTH,
     temperature: float = 0,
     time: float = DEFAULT_TIME,
     verbose: bool = False
@@ -93,13 +95,21 @@ def postprocess(
             temperature=temperature,
             time=time,
             verbose=verbose,
-            output_pydantic=ExtractedCode
+            output_pydantic=ExtractedCode,
+            language=language,
         )
 
         if not response or 'result' not in response:
             raise ValueError("Failed to get valid response from LLM")
 
-        extracted_code_obj: ExtractedCode = response['result'] # Renamed for clarity
+        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'))
+
+        extracted_code_obj: ExtractedCode = result_obj
         code_text = extracted_code_obj.extracted_code
 
         # Step 3c: Remove triple backticks and language identifier if present