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

pdd/sync_determine_operation.py

@@ -11,6 +11,7 @@ import sys
 import json
 import hashlib
 import subprocess
+import fnmatch
 from pathlib import Path
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Any
@@ -31,10 +32,17 @@ except ImportError:
     HAS_MSVCRT = False
 
 # Import PDD internal modules
-from pdd.construct_paths import construct_paths
+from pdd.construct_paths import (
+    _detect_context,
+    _find_pddrc_file,
+    _get_relative_basename,
+    _load_pddrc_config,
+    construct_paths,
+)
 from pdd.load_prompt_template import load_prompt_template
 from pdd.llm_invoke import llm_invoke
 from pdd.get_language import get_language
+from pdd.template_expander import expand_template
 
 # Constants - Use functions for dynamic path resolution
 def get_pdd_dir():
@@ -55,11 +63,41 @@ META_DIR = get_meta_dir()
 LOCKS_DIR = get_locks_dir()
 
 # Export constants for other modules
-__all__ = ['PDD_DIR', 'META_DIR', 'LOCKS_DIR', 'Fingerprint', 'RunReport', 'SyncDecision', 
+__all__ = ['PDD_DIR', 'META_DIR', 'LOCKS_DIR', 'Fingerprint', 'RunReport', 'SyncDecision',
            'sync_determine_operation', 'analyze_conflict_with_llm', 'read_run_report', 'get_pdd_file_paths',
            '_check_example_success_history']
 
 
+def _safe_basename(basename: str) -> str:
+    """Sanitize basename for use in metadata filenames.
+
+    Replaces '/' with '_' to prevent path interpretation when the basename
+    contains subdirectory components (e.g., 'core/cloud' -> 'core_cloud').
+    """
+    return basename.replace('/', '_')
+
+
+def _extract_name_part(basename: str) -> tuple:
+    """Extract directory and name parts from a subdirectory basename.
+
+    For subdirectory basenames like 'core/cloud', separates the directory
+    prefix from the actual name so that filename patterns can be applied
+    correctly.
+
+    Args:
+        basename: The full basename, possibly containing subdirectory path.
+
+    Returns:
+        Tuple of (dir_prefix, name_part):
+        - 'core/cloud' -> ('core/', 'cloud')
+        - 'calculator' -> ('', 'calculator')
+    """
+    if '/' in basename:
+        dir_part, name_part = basename.rsplit('/', 1)
+        return dir_part + '/', name_part
+    return '', basename
+
+
 @dataclass
 class Fingerprint:
     """Represents the last known good state of a PDD unit."""
@@ -102,7 +140,7 @@ class SyncLock:
     def __init__(self, basename: str, language: str):
         self.basename = basename
         self.language = language
-        self.lock_file = get_locks_dir() / f"{basename}_{language}.lock"
+        self.lock_file = get_locks_dir() / f"{_safe_basename(basename)}_{language}.lock"
         self.fd = None
         self.current_pid = os.getpid()
     
@@ -212,6 +250,142 @@ def get_extension(language: str) -> str:
     return extensions.get(language.lower(), language.lower())
 
 
+def _resolve_prompts_root(prompts_dir: str) -> Path:
+    """Resolve prompts root relative to the .pddrc location when available."""
+    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
+
+    parts = prompts_root.parts
+    if "prompts" in parts:
+        prompt_index = parts.index("prompts")
+        prompts_root = Path(*parts[: prompt_index + 1])
+
+    return prompts_root
+
+
+def _relative_basename_for_context(basename: str, context_name: Optional[str]) -> str:
+    """Strip context-specific prefixes from basename when possible."""
+    if not context_name:
+        return basename
+
+    pddrc_path = _find_pddrc_file()
+    if not pddrc_path:
+        return basename
+
+    try:
+        config = _load_pddrc_config(pddrc_path)
+    except ValueError:
+        return basename
+
+    contexts = config.get("contexts", {})
+    context_config = contexts.get(context_name, {})
+    defaults = context_config.get("defaults", {})
+
+    matches = []
+
+    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))
+
+    for pattern in context_config.get("paths", []):
+        pattern_base = pattern.rstrip("/**").rstrip("/*")
+        if fnmatch.fnmatch(basename, pattern) or \
+           basename.startswith(pattern_base + "/") or \
+           basename == pattern_base:
+            relative = _get_relative_basename(basename, pattern)
+            matches.append((len(pattern_base), relative))
+
+    if not matches:
+        return basename
+
+    matches.sort(key=lambda item: item[0], reverse=True)
+    return matches[0][1]
+
+
+def _generate_paths_from_templates(
+    basename: str,
+    language: str,
+    extension: str,
+    outputs_config: Dict[str, Any],
+    prompt_path: str
+) -> Dict[str, Path]:
+    """
+    Generate file paths from template configuration.
+
+    This function is used by Issue #237 to support extensible output path patterns
+    for different project layouts (Next.js, Vue, Python backend, etc.).
+
+    Args:
+        basename: The relative basename (e.g., 'marketplace/AssetCard' or 'credit_helpers')
+        language: The full language name (e.g., 'python', 'typescript')
+        extension: The file extension (e.g., 'py', 'tsx')
+        outputs_config: The 'outputs' section from .pddrc context config
+        prompt_path: The prompt file path to use as fallback
+
+    Returns:
+        Dictionary mapping file types ('prompt', 'code', 'test', etc.) to Path objects
+    """
+    import logging
+    logger = logging.getLogger(__name__)
+
+    # Extract name parts for template context
+    parts = basename.split('/')
+    name = parts[-1] if parts else basename
+    category = '/'.join(parts[:-1]) if len(parts) > 1 else ''
+
+    # Build dir_prefix (for legacy template compatibility)
+    dir_prefix = '/'.join(parts[:-1]) + '/' if len(parts) > 1 else ''
+
+    # Build template context
+    template_context = {
+        'name': name,
+        'category': category,
+        'dir_prefix': dir_prefix,
+        'ext': extension,
+        'language': language,
+    }
+
+    logger.debug(f"Template context: {template_context}")
+
+    result = {}
+
+    # Expand templates for each output type
+    for output_type, config in outputs_config.items():
+        if isinstance(config, dict) and 'path' in config:
+            template = config['path']
+            expanded = expand_template(template, template_context)
+            result[output_type] = Path(expanded)
+            logger.debug(f"Template {output_type}: {template} -> {expanded}")
+
+    # Ensure prompt is always present (fallback to provided prompt_path)
+    if 'prompt' not in result:
+        result['prompt'] = Path(prompt_path)
+
+    # Handle test_files for Bug #156 compatibility
+    if 'test' in result:
+        test_path = result['test']
+        test_dir_path = test_path.parent
+        test_stem = f"test_{name}"
+        if test_dir_path.exists():
+            matching_test_files = sorted(test_dir_path.glob(f"{test_stem}*.{extension}"))
+        else:
+            matching_test_files = [test_path] if test_path.exists() else []
+        result['test_files'] = matching_test_files or [test_path]
+
+    return result
+
+
 def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts", context_override: Optional[str] = None) -> Dict[str, Path]:
     """Returns a dictionary mapping file types to their expected Path objects."""
     import logging
@@ -220,8 +394,27 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
     
     try:
         # Use construct_paths to get configuration-aware paths
+        prompts_root = _resolve_prompts_root(prompts_dir)
         prompt_filename = f"{basename}_{language}.prompt"
-        prompt_path = str(Path(prompts_dir) / prompt_filename)
+        prompt_path = str(prompts_root / prompt_filename)
+        pddrc_path = _find_pddrc_file()
+        if pddrc_path:
+            try:
+                config = _load_pddrc_config(pddrc_path)
+                context_name = context_override or _detect_context(Path.cwd(), config, None)
+                context_config = config.get('contexts', {}).get(context_name or '', {})
+                prompts_dir_config = context_config.get('defaults', {}).get('prompts_dir', '')
+                if prompts_dir_config:
+                    normalized = prompts_dir_config.rstrip('/')
+                    prefix = normalized
+                    if normalized == 'prompts':
+                        prefix = ''
+                    elif normalized.startswith('prompts/'):
+                        prefix = normalized[len('prompts/'):]
+                    if prefix and not (basename == prefix or basename.startswith(prefix + '/')):
+                        prompt_path = str(prompts_root / prefix / prompt_filename)
+            except ValueError:
+                pass
         logger.info(f"Checking prompt_path={prompt_path}, exists={Path(prompt_path).exists()}")
         
         # Check if prompt file exists - if not, we still need configuration-aware paths
@@ -237,22 +430,40 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
                     quiet=True,
                     command="sync",
                     command_options={"basename": basename, "language": language},
-                    context_override=context_override
+                    context_override=context_override,
+                    path_resolution_mode="cwd"
                 )
-                
+
                 import logging
                 logger = logging.getLogger(__name__)
                 logger.info(f"resolved_config: {resolved_config}")
                 logger.info(f"output_paths: {output_paths}")
-                
+
+                # Issue #237: Check for 'outputs' config for template-based path generation
+                outputs_config = resolved_config.get('outputs')
+                if outputs_config:
+                    logger.info(f"Using template-based paths from outputs config")
+                    context_name = context_override or resolved_config.get('_matched_context')
+                    basename_for_templates = _relative_basename_for_context(basename, context_name)
+                    result = _generate_paths_from_templates(
+                        basename=basename_for_templates,
+                        language=language,
+                        extension=extension,
+                        outputs_config=outputs_config,
+                        prompt_path=prompt_path
+                    )
+                    logger.debug(f"get_pdd_file_paths returning (template-based): {result}")
+                    return result
+
+                # Legacy path construction (backwards compatibility)
                 # Extract directory configuration from resolved_config
                 # Note: construct_paths sets tests_dir, examples_dir, code_dir keys
                 test_dir = resolved_config.get('tests_dir', 'tests/')
                 example_dir = resolved_config.get('examples_dir', 'examples/')
                 code_dir = resolved_config.get('code_dir', './')
-                
+
                 logger.info(f"Extracted dirs - test: {test_dir}, example: {example_dir}, code: {code_dir}")
-                
+
                 # Ensure directories end with /
                 if test_dir and not test_dir.endswith('/'):
                     test_dir = test_dir + '/'
@@ -260,14 +471,45 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
                     example_dir = example_dir + '/'
                 if code_dir and not code_dir.endswith('/'):
                     code_dir = code_dir + '/'
-                
-                # Construct the full paths
-                test_path = f"{test_dir}test_{basename}.{extension}"
-                example_path = f"{example_dir}{basename}_example.{extension}"
-                code_path = f"{code_dir}{basename}.{extension}"
-                
+
+                # Extract directory and name parts for subdirectory basename support
+                dir_prefix, name_part = _extract_name_part(basename)
+
+                # Get explicit config paths (these are the SOURCE OF TRUTH when configured)
+                # These should be used directly, NOT combined with dir_prefix
+                generate_output_path = resolved_config.get('generate_output_path', '')
+                example_output_path = resolved_config.get('example_output_path', '')
+                test_output_path = resolved_config.get('test_output_path', '')
+
+                # Construct paths: use explicit config paths directly when configured,
+                # otherwise fall back to old behavior with dir_prefix for backwards compat
+
+                # Code path
+                if generate_output_path and generate_output_path.endswith('/'):
+                    # Explicit complete directory - use directly with just filename
+                    code_path = f"{generate_output_path}{name_part}.{extension}"
+                else:
+                    # Old behavior - use code_dir + dir_prefix
+                    code_path = f"{code_dir}{dir_prefix}{name_part}.{extension}"
+
+                # Example path
+                if example_output_path and example_output_path.endswith('/'):
+                    # Explicit complete directory - use directly with just filename
+                    example_path = f"{example_output_path}{name_part}_example.{extension}"
+                else:
+                    # Old behavior - use example_dir + dir_prefix
+                    example_path = f"{example_dir}{dir_prefix}{name_part}_example.{extension}"
+
+                # Test path
+                if test_output_path and test_output_path.endswith('/'):
+                    # Explicit complete directory - use directly with just filename
+                    test_path = f"{test_output_path}test_{name_part}.{extension}"
+                else:
+                    # Old behavior - use test_dir + dir_prefix
+                    test_path = f"{test_dir}{dir_prefix}test_{name_part}.{extension}"
+
                 logger.debug(f"Final paths: test={test_path}, example={example_path}, code={code_path}")
-                
+
                 # Convert to Path objects
                 test_path = Path(test_path)
                 example_path = Path(example_path)
@@ -275,7 +517,7 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
 
                 # Bug #156: Find all matching test files
                 test_dir_path = test_path.parent
-                test_stem = f"test_{basename}"
+                test_stem = f"test_{name_part}"
                 if test_dir_path.exists():
                     matching_test_files = sorted(test_dir_path.glob(f"{test_stem}*.{extension}"))
                 else:
@@ -296,16 +538,17 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
                 import logging
                 logger = logging.getLogger(__name__)
                 logger.debug(f"construct_paths failed for non-existent prompt, using defaults: {e}")
-                fallback_test_path = Path(f"test_{basename}.{extension}")
+                dir_prefix, name_part = _extract_name_part(basename)
+                fallback_test_path = Path(f"{dir_prefix}test_{name_part}.{extension}")
                 # Bug #156: Find matching test files even in fallback
                 if Path('.').exists():
-                    fallback_matching = sorted(Path('.').glob(f"test_{basename}*.{extension}"))
+                    fallback_matching = sorted(Path('.').glob(f"{dir_prefix}test_{name_part}*.{extension}"))
                 else:
                     fallback_matching = [fallback_test_path] if fallback_test_path.exists() else []
                 return {
                     'prompt': Path(prompt_path),
-                    'code': Path(f"{basename}.{extension}"),
-                    'example': Path(f"{basename}_example.{extension}"),
+                    'code': Path(f"{dir_prefix}{name_part}.{extension}"),
+                    'example': Path(f"{dir_prefix}{name_part}_example.{extension}"),
                     'test': fallback_test_path,
                     'test_files': fallback_matching or [fallback_test_path]  # Bug #156
                 }
@@ -321,9 +564,28 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
             quiet=True,
             command="sync",  # Use sync command to get more tolerant path handling
             command_options={"basename": basename, "language": language},
-            context_override=context_override
+            context_override=context_override,
+            path_resolution_mode="cwd"
         )
-        
+
+        # Issue #237: Check for 'outputs' config for template-based path generation
+        # This must be checked even when prompt EXISTS (not just when it doesn't exist)
+        outputs_config = resolved_config.get('outputs')
+        if outputs_config:
+            extension = get_extension(language)
+            logger.info(f"Using template-based paths from outputs config (prompt exists)")
+            context_name = context_override or resolved_config.get('_matched_context')
+            basename_for_templates = _relative_basename_for_context(basename, context_name)
+            result = _generate_paths_from_templates(
+                basename=basename_for_templates,
+                language=language,
+                extension=extension,
+                outputs_config=outputs_config,
+                prompt_path=prompt_path
+            )
+            logger.debug(f"get_pdd_file_paths returning (template-based, prompt exists): {result}")
+            return result
+
         # For sync command, output_file_paths contains the configured paths
         # Extract the code path from output_file_paths
         code_path = output_file_paths.get('generate_output_path', '')
@@ -333,10 +595,18 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
         if not code_path:
             # Fallback to constructing from basename with configuration
             extension = get_extension(language)
-            code_dir = resolved_config.get('generate_output_path', './')
-            if code_dir and not code_dir.endswith('/'):
-                code_dir = code_dir + '/'
-            code_path = f"{code_dir}{basename}.{extension}"
+            generate_output_path = resolved_config.get('generate_output_path', '')
+            dir_prefix, name_part = _extract_name_part(basename)
+
+            # Use explicit config path directly when configured (ending with /)
+            if generate_output_path and generate_output_path.endswith('/'):
+                code_path = f"{generate_output_path}{name_part}.{extension}"
+            else:
+                # Old behavior - use path + dir_prefix
+                code_dir = generate_output_path or './'
+                if not code_dir.endswith('/'):
+                    code_dir = code_dir + '/'
+                code_path = f"{code_dir}{dir_prefix}{name_part}.{extension}"
         
         # Get configured paths for example and test files using construct_paths
         # Note: construct_paths requires files to exist, so we need to handle the case
@@ -353,26 +623,31 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
             try:
                 # Get example path using example command
                 # Pass path_resolution_mode="cwd" so paths resolve relative to CWD (not project root)
+                # Pass basename in command_options to preserve subdirectory structure
                 _, _, example_output_paths, _ = construct_paths(
                     input_file_paths={"prompt_file": prompt_path, "code_file": code_path},
-                    force=True, quiet=True, command="example", command_options={},
+                    force=True, quiet=True, command="example",
+                    command_options={"basename": basename},
                     context_override=context_override,
                     path_resolution_mode="cwd"
                 )
-                example_path = Path(example_output_paths.get('output', f"{basename}_example.{get_extension(language)}"))
+                dir_prefix, name_part = _extract_name_part(basename)
+                example_path = Path(example_output_paths.get('output', f"{dir_prefix}{name_part}_example.{get_extension(language)}"))
 
                 # Get test path using test command - handle case where test file doesn't exist yet
+                # Pass basename in command_options to preserve subdirectory structure
                 try:
                     _, _, test_output_paths, _ = construct_paths(
                         input_file_paths={"prompt_file": prompt_path, "code_file": code_path},
-                        force=True, quiet=True, command="test", command_options={},
+                        force=True, quiet=True, command="test",
+                        command_options={"basename": basename},
                         context_override=context_override,
                         path_resolution_mode="cwd"
                     )
-                    test_path = Path(test_output_paths.get('output', f"test_{basename}.{get_extension(language)}"))
+                    test_path = Path(test_output_paths.get('output', f"{dir_prefix}test_{name_part}.{get_extension(language)}"))
                 except FileNotFoundError:
                     # Test file doesn't exist yet - create default path
-                    test_path = Path(f"test_{basename}.{get_extension(language)}")
+                    test_path = Path(f"{dir_prefix}test_{name_part}.{get_extension(language)}")
                 
             finally:
                 # Clean up temporary file if we created it
@@ -391,25 +666,29 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
             try:
                 # Get configured directories by using construct_paths with just the prompt file
                 # Pass path_resolution_mode="cwd" so paths resolve relative to CWD (not project root)
+                # Pass basename in command_options to preserve subdirectory structure
                 _, _, example_output_paths, _ = construct_paths(
                     input_file_paths={"prompt_file": prompt_path},
-                    force=True, quiet=True, command="example", command_options={},
+                    force=True, quiet=True, command="example",
+                    command_options={"basename": basename},
                     context_override=context_override,
                     path_resolution_mode="cwd"
                 )
-                example_path = Path(example_output_paths.get('output', f"{basename}_example.{get_extension(language)}"))
+                dir_prefix, name_part = _extract_name_part(basename)
+                example_path = Path(example_output_paths.get('output', f"{dir_prefix}{name_part}_example.{get_extension(language)}"))
 
                 try:
                     _, _, test_output_paths, _ = construct_paths(
                         input_file_paths={"prompt_file": prompt_path},
-                        force=True, quiet=True, command="test", command_options={},
+                        force=True, quiet=True, command="test",
+                        command_options={"basename": basename},
                         context_override=context_override,
                         path_resolution_mode="cwd"
                     )
-                    test_path = Path(test_output_paths.get('output', f"test_{basename}.{get_extension(language)}"))
+                    test_path = Path(test_output_paths.get('output', f"{dir_prefix}test_{name_part}.{get_extension(language)}"))
                 except Exception:
                     # If test path construction fails, use default naming
-                    test_path = Path(f"test_{basename}.{get_extension(language)}")
+                    test_path = Path(f"{dir_prefix}test_{name_part}.{get_extension(language)}")
                 
             except Exception:
                 # Final fallback to deriving from code path if all else fails
@@ -429,7 +708,8 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
 
         # Bug #156: Find all matching test files
         test_dir = test_path.parent
-        test_stem = f"test_{basename}"
+        _, name_part_for_glob = _extract_name_part(basename)
+        test_stem = f"test_{name_part_for_glob}"
         extension = get_extension(language)
         if test_dir.exists():
             matching_test_files = sorted(test_dir.glob(f"{test_stem}*.{extension}"))
@@ -443,22 +723,24 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
             'test': test_path,
             'test_files': matching_test_files or [test_path]  # Bug #156: All matching test files
         }
-        
+
     except Exception as e:
         # Fallback to simple naming if construct_paths fails
         extension = get_extension(language)
-        test_path = Path(f"test_{basename}.{extension}")
+        dir_prefix, name_part = _extract_name_part(basename)
+        test_path = Path(f"{dir_prefix}test_{name_part}.{extension}")
         # Bug #156: Try to find matching test files even in fallback
         test_dir = Path('.')
-        test_stem = f"test_{basename}"
+        test_stem = f"{dir_prefix}test_{name_part}"
         if test_dir.exists():
             matching_test_files = sorted(test_dir.glob(f"{test_stem}*.{extension}"))
         else:
             matching_test_files = [test_path] if test_path.exists() else []
+        prompts_root = _resolve_prompts_root(prompts_dir)
         return {
-            'prompt': Path(prompts_dir) / f"{basename}_{language}.prompt",
-            'code': Path(f"{basename}.{extension}"),
-            'example': Path(f"{basename}_example.{extension}"),
+            'prompt': prompts_root / f"{basename}_{language}.prompt",
+            'code': Path(f"{dir_prefix}{name_part}.{extension}"),
+            'example': Path(f"{dir_prefix}{name_part}_example.{extension}"),
             'test': test_path,
             'test_files': matching_test_files or [test_path]  # Bug #156: All matching test files
         }
@@ -483,7 +765,7 @@ def read_fingerprint(basename: str, language: str) -> Optional[Fingerprint]:
     """Reads and validates the JSON fingerprint file."""
     meta_dir = get_meta_dir()
     meta_dir.mkdir(parents=True, exist_ok=True)
-    fingerprint_file = meta_dir / f"{basename}_{language}.json"
+    fingerprint_file = meta_dir / f"{_safe_basename(basename)}_{language}.json"
     
     if not fingerprint_file.exists():
         return None
@@ -510,7 +792,7 @@ def read_run_report(basename: str, language: str) -> Optional[RunReport]:
     """Reads and validates the JSON run report file."""
     meta_dir = get_meta_dir()
     meta_dir.mkdir(parents=True, exist_ok=True)
-    run_report_file = meta_dir / f"{basename}_{language}_run.json"
+    run_report_file = meta_dir / f"{_safe_basename(basename)}_{language}_run.json"
     
     if not run_report_file.exists():
         return None
@@ -888,7 +1170,7 @@ def _check_example_success_history(basename: str, language: str) -> bool:
     
     # Strategy 2b: Look for historical run reports with exit_code == 0
     # Check all run report files in the meta directory that match the pattern
-    run_report_pattern = f"{basename}_{language}_run"
+    run_report_pattern = f"{_safe_basename(basename)}_{language}_run"
     for file in meta_dir.glob(f"{run_report_pattern}*.json"):
         try:
             with open(file, 'r') as f: