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

pdd/sync_main.py

@@ -1,3 +1,4 @@
+import fnmatch
 import re
 import time
 from pathlib import Path
@@ -12,17 +13,26 @@ from rich import print as rprint
 # Relative imports from the pdd package
 from . import DEFAULT_STRENGTH, DEFAULT_TIME
 from .construct_paths import (
-    _is_known_language, 
+    _is_known_language,
     construct_paths,
     _find_pddrc_file,
+    _get_relative_basename,
     _load_pddrc_config,
     _detect_context,
-    _get_context_config
+    _get_context_config,
+    get_extension
 )
 from .sync_orchestration import sync_orchestration
+from .template_expander import expand_template
 
-# A simple regex for basename validation to prevent path traversal or other injection
-VALID_BASENAME_CHARS = re.compile(r"^[a-zA-Z0-9_-]+$")
+# Regex for basename validation supporting subdirectory paths (e.g., 'core/cloud')
+# Allows: alphanumeric, underscore, hyphen, and forward slash for subdirectory paths
+# Structure inherently prevents:
+#   - Path traversal (..) - dot not in character class
+#   - Leading slash (/abs) - must start with [a-zA-Z0-9_-]+
+#   - Trailing slash (path/) - must end with [a-zA-Z0-9_-]+
+#   - Double slash (a//b) - requires characters between slashes
+VALID_BASENAME_CHARS = re.compile(r"^[a-zA-Z0-9_-]+(/[a-zA-Z0-9_-]+)*$")
 
 
 def _validate_basename(basename: str) -> None:
@@ -32,27 +42,231 @@ def _validate_basename(basename: str) -> None:
     if not VALID_BASENAME_CHARS.match(basename):
         raise click.UsageError(
             f"Basename '{basename}' contains invalid characters. "
-            "Only alphanumeric, underscore, and hyphen are allowed."
+            "Only alphanumeric, underscore, hyphen, and forward slash (for subdirectories) are allowed."
         )
 
 
+def _get_extension_safe(language: str) -> str:
+    """Get file extension with fallback for when PDD_PATH is not set."""
+    try:
+        return get_extension(language)
+    except (ValueError, FileNotFoundError):
+        # Fallback to built-in mapping
+        builtin_ext_map = {
+            'python': 'py', 'javascript': 'js', 'typescript': 'ts', 'java': 'java',
+            'typescriptreact': 'tsx', 'javascriptreact': 'jsx',
+            'cpp': 'cpp', 'c': 'c', 'go': 'go', 'ruby': 'rb', 'rust': 'rs',
+        }
+        return builtin_ext_map.get(language.lower(), '')
+
+
+def _relative_basename_for_context(basename: str, context_config: Dict[str, Any]) -> str:
+    """Return basename relative to a context's most specific path or prompt prefix."""
+    matches = []
+
+    for path_pattern in context_config.get('paths', []):
+        pattern_base = path_pattern.rstrip('/**').rstrip('/*')
+        if fnmatch.fnmatch(basename, path_pattern) or \
+           basename.startswith(pattern_base + '/') or \
+           basename == pattern_base:
+            relative = _get_relative_basename(basename, path_pattern)
+            matches.append((len(pattern_base), relative))
+
+    defaults = context_config.get('defaults', {})
+    prompts_dir = defaults.get('prompts_dir', '')
+    if prompts_dir:
+        normalized = prompts_dir.rstrip('/')
+        prefix = normalized
+        if normalized == 'prompts':
+            prefix = ''
+        elif normalized.startswith('prompts/'):
+            prefix = normalized[len('prompts/'):]
+
+        if prefix and (basename == prefix or basename.startswith(prefix + '/')):
+            relative = basename[len(prefix) + 1 :] if basename != prefix else basename.split('/')[-1]
+            matches.append((len(prefix), relative))
+
+    if not matches:
+        return basename
+
+    matches.sort(key=lambda item: item[0], reverse=True)
+    return matches[0][1]
+
+
+def _normalize_prompts_root(prompts_dir: Path) -> Path:
+    """
+    Resolve prompts_dir to an absolute path relative to the project root.
+
+    This function takes a potentially relative prompts_dir path (e.g., "prompts/backend")
+    and resolves it to an absolute path using the .pddrc location as the project root.
+
+    Note: This function previously stripped subdirectories after "prompts" which was
+    incorrect for context-specific prompts_dir values. Fixed in Issue #253.
+    """
+    prompts_root = Path(prompts_dir)
+    pddrc_path = _find_pddrc_file()
+    if pddrc_path and not prompts_root.is_absolute():
+        prompts_root = pddrc_path.parent / prompts_root
+
+    return prompts_root
+
+
+def _find_prompt_in_contexts(basename: str) -> Optional[Tuple[str, Path, str]]:
+    """
+    Search for a prompt file across all contexts using outputs.prompt.path templates.
+
+    This enables finding prompts when the basename alone doesn't match context path patterns.
+    For example, 'credit_helpers' can find 'prompts/backend/utils/credit_helpers_python.prompt'
+    if the backend-utils context has outputs.prompt.path configured.
+
+    Args:
+        basename: The base name for the prompt file (e.g., 'credit_helpers')
+
+    Returns:
+        Tuple of (context_name, prompt_path, language) if found, None otherwise
+    """
+    pddrc_path = _find_pddrc_file()
+    if not pddrc_path:
+        return None
+
+    try:
+        config = _load_pddrc_config(pddrc_path)
+    except Exception:
+        return None
+
+    # Resolve paths relative to .pddrc location, not CWD
+    pddrc_parent = pddrc_path.parent
+
+    contexts = config.get('contexts', {})
+
+    # Common languages to try
+    languages_to_try = ['python', 'typescript', 'javascript', 'typescriptreact', 'go', 'rust', 'java']
+
+    for context_name, context_config in contexts.items():
+        if context_name == 'default':
+            continue
+
+        defaults = context_config.get('defaults', {})
+        outputs = defaults.get('outputs', {})
+        prompt_config = outputs.get('prompt', {})
+        prompt_template = prompt_config.get('path')
+
+        if not prompt_template:
+            continue
+
+        context_basename = _relative_basename_for_context(basename, context_config)
+        parts = context_basename.split('/') if context_basename else ['']
+        name_part = parts[-1]
+        category = '/'.join(parts[:-1]) if len(parts) > 1 else ''
+        dir_prefix = f"{category}/" if category else ''
+
+        # Try each language
+        for lang in languages_to_try:
+            ext = _get_extension_safe(lang)
+            template_context = {
+                'name': name_part,
+                'category': category,
+                'dir_prefix': dir_prefix,
+                'ext': ext,
+                'language': lang,
+            }
+
+            expanded_path = expand_template(prompt_template, template_context)
+            # Resolve relative to .pddrc location, not CWD
+            prompt_path = pddrc_parent / expanded_path
+
+            if prompt_path.exists():
+                return (context_name, prompt_path, lang)
+
+    return None
+
+
+def _detect_languages_with_context(basename: str, prompts_dir: Path, context_name: Optional[str] = None) -> List[str]:
+    """
+    Detects all available languages for a given basename, optionally using context config.
+
+    If context_name is provided and has outputs.prompt.path configured, uses template-based
+    discovery. Otherwise falls back to directory scanning.
+    """
+    if context_name:
+        pddrc_path = _find_pddrc_file()
+        if pddrc_path:
+            try:
+                config = _load_pddrc_config(pddrc_path)
+                # Resolve paths relative to .pddrc location, not CWD
+                pddrc_parent = pddrc_path.parent
+                contexts = config.get('contexts', {})
+                context_config = contexts.get(context_name, {})
+                defaults = context_config.get('defaults', {})
+                outputs = defaults.get('outputs', {})
+                prompt_config = outputs.get('prompt', {})
+                prompt_template = prompt_config.get('path')
+
+                if prompt_template:
+                    context_basename = _relative_basename_for_context(basename, context_config)
+                    parts = context_basename.split('/') if context_basename else ['']
+                    name_part = parts[-1]
+                    category = '/'.join(parts[:-1]) if len(parts) > 1 else ''
+                    dir_prefix = f"{category}/" if category else ''
+
+                    # Try all known languages
+                    languages_to_try = ['python', 'typescript', 'javascript', 'typescriptreact', 'go', 'rust', 'java']
+                    found_languages = []
+
+                    for lang in languages_to_try:
+                        ext = _get_extension_safe(lang)
+                        template_context = {
+                            'name': name_part,
+                            'category': category,
+                            'dir_prefix': dir_prefix,
+                            'ext': ext,
+                            'language': lang,
+                        }
+                        expanded_path = expand_template(prompt_template, template_context)
+                        # Resolve relative to .pddrc location, not CWD
+                        if (pddrc_parent / expanded_path).exists():
+                            found_languages.append(lang)
+
+                    if found_languages:
+                        # Return with Python first if present
+                        if 'python' in found_languages:
+                            other = sorted([l for l in found_languages if l != 'python'])
+                            return ['python'] + other
+                        return sorted(found_languages)
+            except Exception:
+                pass
+
+    # Fallback to original directory scanning
+    return _detect_languages(basename, prompts_dir)
+
+
 def _detect_languages(basename: str, prompts_dir: Path) -> List[str]:
     """
     Detects all available languages for a given basename by finding
     matching prompt files in the prompts directory.
     Excludes runtime languages (LLM) as they cannot form valid development units.
+
+    Supports subdirectory basenames like 'core/cloud':
+    - For basename 'core/cloud', searches in prompts/core/ for cloud_*.prompt files
+    - The stem comparison only uses the filename part ('cloud'), not the path ('core/cloud')
     """
     development_languages = []
     if not prompts_dir.is_dir():
         return []
 
+    # For subdirectory basenames, extract just the name part for stem comparison
+    if '/' in basename:
+        name_part = basename.rsplit('/', 1)[1]  # 'cloud' from 'core/cloud'
+    else:
+        name_part = basename
+
     pattern = f"{basename}_*.prompt"
     for prompt_file in prompts_dir.glob(pattern):
-        # stem is 'basename_language'
+        # stem is the filename without extension (e.g., 'cloud_python')
         stem = prompt_file.stem
-        # Ensure the file starts with the exact basename followed by an underscore
-        if stem.startswith(f"{basename}_"):
-            potential_language = stem[len(basename) + 1 :]
+        # Ensure the file starts with the exact name part followed by an underscore
+        if stem.startswith(f"{name_part}_"):
+            potential_language = stem[len(name_part) + 1 :]
             try:
                 if _is_known_language(potential_language):
                     # Exclude runtime languages (LLM) as they cannot form valid development units
@@ -118,9 +332,10 @@ def sync_main(
     local = ctx.obj.get("local", False)
     context_override = ctx.obj.get("context", None)
 
-    # Default values for max_attempts and budget when not specified via CLI or .pddrc
+    # Default values for max_attempts, budget, target_coverage when not specified via CLI or .pddrc
     DEFAULT_MAX_ATTEMPTS = 3
     DEFAULT_BUDGET = 20.0
+    DEFAULT_TARGET_COVERAGE = 90.0
 
     # 2. Validate inputs (basename only - budget/max_attempts validated after config resolution)
     _validate_basename(basename)
@@ -132,23 +347,47 @@ def sync_main(
     if max_attempts is not None and max_attempts < 0:
         raise click.BadParameter("Max attempts must be a non-negative integer.", param_hint="--max-attempts")
 
-    # 3. Use construct_paths in 'discovery' mode to find the prompts directory.
-    try:
-        initial_config, _, _, _ = construct_paths(
-            input_file_paths={},
-            force=False,
-            quiet=True,
-            command="sync",
-            command_options={"basename": basename},
-            context_override=context_override,
-        )
-        prompts_dir = Path(initial_config.get("prompts_dir", "prompts"))
-    except Exception as e:
-        rprint(f"[bold red]Error initializing PDD paths:[/bold red] {e}")
-        raise click.Abort()
+    # 3. Try template-based prompt discovery first (uses outputs.prompt.path from .pddrc)
+    template_result = _find_prompt_in_contexts(basename)
+    discovered_context = None
+
+    if template_result:
+        discovered_context, discovered_prompt_path, first_lang = template_result
+        prompts_dir_raw = discovered_prompt_path.parent
+        pddrc_path = _find_pddrc_file()
+        if pddrc_path and not prompts_dir_raw.is_absolute():
+            prompts_dir = pddrc_path.parent / prompts_dir_raw
+        else:
+            prompts_dir = prompts_dir_raw
+        # Use context override if not already set
+        if not context_override:
+            context_override = discovered_context
+        if not quiet:
+            rprint(f"[dim]Found prompt via template in context: {discovered_context}[/dim]")
+
+    # 4. Fallback: Use construct_paths in 'discovery' mode to find the prompts directory.
+    if not template_result:
+        try:
+            initial_config, _, _, _ = construct_paths(
+                input_file_paths={},
+                force=False,
+                quiet=True,
+                command="sync",
+                command_options={"basename": basename},
+                context_override=context_override,
+            )
+            prompts_dir_raw = initial_config.get("prompts_dir", "prompts")
+            pddrc_path = _find_pddrc_file()
+            if pddrc_path and not Path(prompts_dir_raw).is_absolute():
+                prompts_dir = pddrc_path.parent / prompts_dir_raw
+            else:
+                prompts_dir = Path(prompts_dir_raw)
+        except Exception as e:
+            rprint(f"[bold red]Error initializing PDD paths:[/bold red] {e}")
+            raise click.Abort()
 
-    # 4. Detect all languages for the given basename
-    languages = _detect_languages(basename, prompts_dir)
+    # 5. Detect all languages for the given basename
+    languages = _detect_languages_with_context(basename, prompts_dir, context_name=discovered_context)
     if not languages:
         raise click.UsageError(
             f"No prompt files found for basename '{basename}' in directory '{prompts_dir}'.\n"
@@ -274,10 +513,15 @@ def sync_main(
             # Priority: CLI value > .pddrc value > hardcoded default
             final_strength = resolved_config.get("strength", strength)
             final_temp = resolved_config.get("temperature", temperature)
-            final_target_coverage = resolved_config.get("target_coverage", target_coverage)
 
-            # For max_attempts and budget: CLI > .pddrc > hardcoded default
+            # For target_coverage, max_attempts and budget: CLI > .pddrc > hardcoded default
             # If CLI value is provided (not None), use it. Otherwise, use .pddrc or default.
+            # Issue #194: target_coverage was not being handled consistently with the others
+            if target_coverage is not None:
+                final_target_coverage = target_coverage
+            else:
+                final_target_coverage = resolved_config.get("target_coverage") or DEFAULT_TARGET_COVERAGE
+
             if max_attempts is not None:
                 final_max_attempts = max_attempts
             else: