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

pdd/construct_paths.py

@@ -73,6 +73,146 @@ def list_available_contexts(start_path: Optional[Path] = None) -> list[str]:
     names = sorted(contexts.keys()) if isinstance(contexts, dict) else []
     return names or ["default"]
 
+def _match_path_to_contexts(
+    path_str: str,
+    contexts: Dict[str, Any],
+    use_specificity: bool = False,
+    is_absolute: bool = False
+) -> Optional[str]:
+    """
+    Core pattern matching logic - matches a path against context patterns.
+
+    Args:
+        path_str: Path to match (can be relative or absolute)
+        contexts: The contexts dict from .pddrc config
+        use_specificity: If True, return most specific match; else first match
+        is_absolute: If True, use absolute path matching with "*/" prefix
+
+    Returns:
+        Context name or None
+    """
+    matches = []
+    for context_name, context_config in contexts.items():
+        if context_name == 'default':
+            continue
+        for path_pattern in context_config.get('paths', []):
+            pattern_base = path_pattern.rstrip('/**').rstrip('/*')
+
+            # Check for match - handle both absolute and relative paths
+            matched = False
+            if is_absolute:
+                # For absolute paths (CWD-based detection), use existing logic
+                if fnmatch.fnmatch(path_str, f"*/{path_pattern}") or \
+                   fnmatch.fnmatch(path_str, path_pattern) or \
+                   path_str.endswith(f"/{pattern_base}"):
+                    matched = True
+            else:
+                # For relative paths (file-based detection)
+                if fnmatch.fnmatch(path_str, path_pattern) or \
+                   path_str.startswith(pattern_base + '/') or \
+                   path_str.startswith(pattern_base):
+                    matched = True
+
+            if matched:
+                if not use_specificity:
+                    return context_name  # First match wins
+                matches.append((context_name, len(pattern_base)))
+
+    if matches:
+        matches.sort(key=lambda x: x[1], reverse=True)
+        return matches[0][0]
+
+    return 'default' if 'default' in contexts else None
+
+
+def _detect_context_from_basename(basename: str, config: Dict[str, Any]) -> Optional[str]:
+    """Detect context by matching a sync basename against prompts_dir prefixes or paths patterns."""
+    if not basename:
+        return None
+
+    contexts = config.get('contexts', {})
+    matches = []
+
+    for context_name, context_config in contexts.items():
+        if context_name == 'default':
+            continue
+
+        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 + '/')):
+                matches.append((context_name, len(prefix)))
+                continue
+
+        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:
+                matches.append((context_name, len(pattern_base)))
+
+    if not matches:
+        return None
+
+    matches.sort(key=lambda item: item[1], reverse=True)
+    return matches[0][0]
+
+
+def _get_relative_basename(input_path: str, pattern: str) -> str:
+    """
+    Compute basename relative to the matched pattern base.
+
+    This is critical for Issue #237: when a context pattern like
+    'frontend/components/**' matches 'frontend/components/marketplace/AssetCard',
+    we need to return 'marketplace/AssetCard' (relative to pattern base),
+    not the full path which would cause double-pathing in output.
+
+    Args:
+        input_path: The full input path (e.g., 'frontend/components/marketplace/AssetCard')
+        pattern: The matching pattern (e.g., 'frontend/components/**')
+
+    Returns:
+        Path relative to the pattern base (e.g., 'marketplace/AssetCard')
+
+    Examples:
+        >>> _get_relative_basename('frontend/components/marketplace/AssetCard', 'frontend/components/**')
+        'marketplace/AssetCard'
+        >>> _get_relative_basename('backend/utils/credit_helpers', 'backend/utils/**')
+        'credit_helpers'
+        >>> _get_relative_basename('unknown/path', 'other/**')
+        'unknown/path'  # No match, return as-is
+    """
+    # Strip glob patterns to get the base directory
+    pattern_base = pattern.rstrip('/**').rstrip('/*').rstrip('*')
+
+    # Remove trailing slash from pattern base if present
+    pattern_base = pattern_base.rstrip('/')
+
+    # Check if input path starts with pattern base
+    if input_path.startswith(pattern_base + '/'):
+        # Return the portion after pattern_base/
+        return input_path[len(pattern_base) + 1:]
+    elif input_path.startswith(pattern_base) and len(input_path) > len(pattern_base):
+        # Handle case where pattern_base has no trailing content
+        remainder = input_path[len(pattern_base):]
+        if remainder.startswith('/'):
+            return remainder[1:]
+        return remainder
+    elif input_path == pattern_base:
+        # Exact match - return just the last component
+        return input_path.split('/')[-1] if '/' in input_path else input_path
+
+    # No match - return as-is (fallback for default context)
+    return input_path
+
+
 def _detect_context(current_dir: Path, config: Dict[str, Any], context_override: Optional[str] = None) -> Optional[str]:
     """Detect the appropriate context based on current directory path."""
     if context_override:
@@ -82,28 +222,82 @@ def _detect_context(current_dir: Path, config: Dict[str, Any], context_override:
             available = list(contexts.keys())
             raise ValueError(f"Unknown context '{context_override}'. Available contexts: {available}")
         return context_override
-    
+
     contexts = config.get('contexts', {})
-    current_path_str = str(current_dir)
-    
-    # Try to match against each context's paths
+    return _match_path_to_contexts(str(current_dir), contexts, use_specificity=False, is_absolute=True)
+
+
+def detect_context_for_file(file_path: str, repo_root: Optional[str] = None) -> Tuple[Optional[str], Dict[str, Any]]:
+    """
+    Detect the appropriate context for a file path based on .pddrc configuration.
+
+    This function finds the most specific matching context by comparing pattern lengths.
+    For example, 'backend/functions/utils/**' is more specific than 'backend/**'.
+
+    Args:
+        file_path: Path to the file (can be absolute or relative)
+        repo_root: Optional repository root path. If not provided, will be detected.
+
+    Returns:
+        Tuple of (context_name, context_config_defaults) or (None, {}) if no match.
+    """
+    # Find repo root if not provided
+    if repo_root is None:
+        pddrc_path = _find_pddrc_file(Path(file_path).parent)
+        if pddrc_path:
+            repo_root = str(pddrc_path.parent)
+        else:
+            try:
+                import git
+                repo = git.Repo(file_path, search_parent_directories=True)
+                repo_root = repo.working_tree_dir
+            except:
+                repo_root = os.getcwd()
+
+    # Make file_path relative to repo_root for matching
+    file_path_abs = os.path.abspath(file_path)
+    repo_root_abs = os.path.abspath(repo_root)
+
+    if file_path_abs.startswith(repo_root_abs):
+        relative_path = os.path.relpath(file_path_abs, repo_root_abs)
+    else:
+        relative_path = file_path
+
+    # Find and load .pddrc
+    pddrc_path = _find_pddrc_file(Path(repo_root))
+    if not pddrc_path:
+        return None, {}
+
+    try:
+        config = _load_pddrc_config(pddrc_path)
+    except ValueError:
+        return None, {}
+
+    contexts = config.get('contexts', {})
+
+    # First, try to match against prompts_dir for each context
+    # This allows prompt files to be detected even when paths pattern only matches code files
+    prompts_dir_matches = []
     for context_name, context_config in contexts.items():
         if context_name == 'default':
-            continue  # Handle default as fallback
-        
-        paths = context_config.get('paths', [])
-        for path_pattern in paths:
-            # Convert glob pattern to match current directory
-            if fnmatch.fnmatch(current_path_str, f"*/{path_pattern}") or \
-               fnmatch.fnmatch(current_path_str, path_pattern) or \
-               current_path_str.endswith(f"/{path_pattern.rstrip('/**')}"):
-                return context_name
-    
-    # Return default context if available
-    if 'default' in contexts:
-        return 'default'
-    
-    return None
+            continue
+        prompts_dir = context_config.get('defaults', {}).get('prompts_dir', '')
+        if prompts_dir:
+            prompts_dir_normalized = prompts_dir.rstrip('/')
+            if relative_path.startswith(prompts_dir_normalized + '/') or relative_path == prompts_dir_normalized:
+                # Track match with specificity (length of prompts_dir)
+                prompts_dir_matches.append((context_name, len(prompts_dir_normalized)))
+
+    # Return most specific prompts_dir match if any
+    if prompts_dir_matches:
+        prompts_dir_matches.sort(key=lambda x: x[1], reverse=True)
+        matched_context = prompts_dir_matches[0][0]
+        return matched_context, _get_context_config(config, matched_context)
+
+    # Fall back to existing paths pattern matching
+    context_name = _match_path_to_contexts(relative_path, contexts, use_specificity=True, is_absolute=False)
+    return context_name, _get_context_config(config, context_name)
+
 
 def _get_context_config(config: Dict[str, Any], context_name: Optional[str]) -> Dict[str, Any]:
     """Get configuration settings for the specified context."""
@@ -121,7 +315,7 @@ def _resolve_config_hierarchy(
 ) -> Dict[str, Any]:
     """Apply configuration hierarchy: CLI > context > environment > defaults."""
     resolved = {}
-    
+
     # Configuration keys to resolve
     config_keys = {
         'generate_output_path': 'PDD_GENERATE_OUTPUT_PATH',
@@ -135,7 +329,7 @@ def _resolve_config_hierarchy(
         'budget': None,
         'max_attempts': None,
     }
-    
+
     for config_key, env_var in config_keys.items():
         # 1. CLI options (highest priority)
         if config_key in cli_options and cli_options[config_key] is not None:
@@ -147,10 +341,56 @@ def _resolve_config_hierarchy(
         elif env_var and env_var in env_vars:
             resolved[config_key] = env_vars[env_var]
         # 4. Defaults are handled elsewhere
-    
+
+    # Issue #237: Pass through 'outputs' config for template-based path generation
+    # This enables extensible project layouts (Next.js, Vue, Python, Go, etc.)
+    if 'outputs' in context_config:
+        resolved['outputs'] = context_config['outputs']
+
     return resolved
 
 
+def get_tests_dir_from_config(start_path: Optional[Path] = None) -> Optional[Path]:
+    """
+    Get the tests directory from .pddrc configuration.
+
+    Searches for .pddrc, detects the appropriate context, and returns the
+    configured test_output_path as a Path object.
+
+    Args:
+        start_path: Starting directory for .pddrc search. Defaults to CWD.
+
+    Returns:
+        Path to tests directory if configured, None otherwise.
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+
+    # Find and load .pddrc
+    pddrc_path = _find_pddrc_file(start_path)
+    if not pddrc_path:
+        return None
+
+    try:
+        config = _load_pddrc_config(pddrc_path)
+    except ValueError:
+        return None
+
+    # Detect context and get its config
+    context_name = _detect_context(start_path, config)
+    context_config = _get_context_config(config, context_name)
+
+    # Check context config first, then env var
+    test_output_path = context_config.get('test_output_path')
+    if not test_output_path:
+        test_output_path = os.environ.get('PDD_TEST_OUTPUT_PATH')
+
+    if test_output_path:
+        return Path(test_output_path)
+
+    return None
+
+
 def _read_file(path: Path) -> str:
     """Read a text file safely and return its contents."""
     try:
@@ -463,9 +703,30 @@ def construct_paths(
             pddrc_config = _load_pddrc_config(pddrc_path)
             
             # Detect appropriate context
-            current_dir = Path.cwd()
-            context = _detect_context(current_dir, pddrc_config, context_override)
-            
+            # Priority: context_override > file-based detection > CWD-based detection
+            if context_override:
+                # Delegate validation to _detect_context to avoid duplicate validation logic
+                context = _detect_context(Path.cwd(), pddrc_config, context_override)
+            else:
+                # Try file-based detection when prompt file is provided
+                prompt_file_str = input_file_paths.get('prompt_file') if input_file_paths else None
+                if prompt_file_str and Path(prompt_file_str).exists():
+                    detected_context, _ = detect_context_for_file(prompt_file_str)
+                    if detected_context:
+                        context = detected_context
+                    else:
+                        context = _detect_context(Path.cwd(), pddrc_config, None)
+                else:
+                    basename_hint = command_options.get("basename")
+                    if basename_hint:
+                        detected_context = _detect_context_from_basename(basename_hint, pddrc_config)
+                        if detected_context:
+                            context = detected_context
+                        else:
+                            context = _detect_context(Path.cwd(), pddrc_config, None)
+                    else:
+                        context = _detect_context(Path.cwd(), pddrc_config, None)
+
             # Get context-specific configuration
             context_config = _get_context_config(pddrc_config, context)
             original_context_config = context_config.copy()  # Store original before modifications
@@ -476,9 +737,15 @@ def construct_paths(
         # Apply configuration hierarchy
         env_vars = dict(os.environ)
         resolved_config = _resolve_config_hierarchy(command_options, context_config, env_vars)
-        
+
+        # Issue #237: Track matched context for debugging
+        resolved_config['_matched_context'] = context or 'default'
+
         # Update command_options with resolved configuration for internal use
+        # Exclude internal metadata keys (prefixed with _) from command_options
         for key, value in resolved_config.items():
+            if key.startswith('_'):
+                continue  # Skip internal metadata like _matched_context
             if key not in command_options or command_options[key] is None:
                 command_options[key] = value
         
@@ -531,7 +798,10 @@ def construct_paths(
             else:
                 # Fall back to context-aware logic
                 # Use original_context_config to avoid checking augmented config with env vars
-                if original_context_config and any(key.endswith('_output_path') for key in original_context_config):
+                if original_context_config and (
+                    'prompts_dir' in original_context_config or
+                    any(key.endswith('_output_path') for key in original_context_config)
+                ):
                     # For configured contexts, use prompts_dir from config if provided,
                     # otherwise default to "prompts" at the same level as output dirs
                     resolved_config["prompts_dir"] = original_context_config.get("prompts_dir", "prompts")
@@ -543,9 +813,22 @@ def construct_paths(
                     resolved_config["code_dir"] = str(gen_path.parent)
             
             resolved_config["tests_dir"] = str(Path(output_paths_str.get("test_output_path", "tests")).parent)
-            # example_output_path can be a directory (e.g., "context/") or a file path (e.g., "examples/foo.py")
+
+            # Determine examples_dir for auto-deps scanning
+            # NOTE: outputs.example.path is for OUTPUT only (where to write examples),
+            # NOT for determining scan scope. Using it caused CSV row deletion issues.
+            # Check RAW context config for example_output_path, or default to "context".
+            # Do NOT use output_paths_str since generate_output_paths always returns absolute paths.
+            example_path_str = None
+            if original_context_config:
+                example_path_str = original_context_config.get("example_output_path")
+
+            # Final fallback to "context" (sensible default for this project)
+            if not example_path_str:
+                example_path_str = "context"
+
+            # example_path_str can be a directory (e.g., "context/") or a file path (e.g., "examples/foo.py")
             # If it ends with / or has no file extension, treat as directory; otherwise use parent
-            example_path_str = output_paths_str.get("example_output_path", "examples")
             example_path = Path(example_path_str)
             if example_path_str.endswith('/') or '.' not in example_path.name:
                 resolved_config["examples_dir"] = example_path_str.rstrip('/')
@@ -633,7 +916,13 @@ def construct_paths(
 
     # ------------- Step 2: basename --------------------------
     try:
-        basename = _extract_basename(command, input_paths)
+        # For sync, example, and test commands, prefer the basename from command_options if provided.
+        # This preserves subdirectory paths like 'core/cloud' which would otherwise
+        # be lost when extracting from the prompt file path.
+        if command in ("sync", "example", "test") and command_options.get("basename"):
+            basename = command_options["basename"]
+        else:
+            basename = _extract_basename(command, input_paths)
     except ValueError as exc:
          # Check if it's the specific error from the initial check (now done at start)
          # This try/except might not be needed if initial check is robust
@@ -854,9 +1143,22 @@ def construct_paths(
     resolved_config["prompts_dir"] = str(next(iter(input_paths.values())).parent)
     resolved_config["code_dir"] = str(gen_path.parent)
     resolved_config["tests_dir"] = str(Path(resolved_config.get("test_output_path", "tests")).parent)
-    # example_output_path can be a directory (e.g., "context/") or a file path (e.g., "examples/foo.py")
+
+    # Determine examples_dir for auto-deps scanning
+    # NOTE: outputs.example.path is for OUTPUT only (where to write examples),
+    # NOT for determining scan scope. Using it caused CSV row deletion issues.
+    # Check RAW context config for example_output_path, or default to "context".
+    # Do NOT use resolved_config since generate_output_paths sets it to absolute paths.
+    example_path_str = None
+    if original_context_config:
+        example_path_str = original_context_config.get("example_output_path")
+
+    # Final fallback to "context" (sensible default for this project)
+    if not example_path_str:
+        example_path_str = "context"
+
+    # example_path_str can be a directory (e.g., "context/") or a file path (e.g., "examples/foo.py")
     # If it ends with / or has no file extension, treat as directory; otherwise use parent
-    example_path_str = resolved_config.get("example_output_path", "examples")
     example_path = Path(example_path_str)
     if example_path_str.endswith('/') or '.' not in example_path.name:
         resolved_config["examples_dir"] = example_path_str.rstrip('/')