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

pdd/sync_order.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+import os
+import re
+import stat
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Set, Optional, Dict, List, Tuple, Deque
+from collections import deque, defaultdict
+
+from rich.console import Console
+
+# Initialize rich console
+console = Console()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+logger = logging.getLogger(__name__)
+
+def extract_includes_from_file(file_path: Path) -> Set[str]:
+    """
+    Parses <include> tags from a prompt file.
+
+    Args:
+        file_path: Path to the prompt file.
+
+    Returns:
+        Set of included paths found in the file. Returns empty set if file
+        cannot be read.
+    """
+    if not file_path.exists() or not file_path.is_file():
+        logger.warning(f"File not found or not a file: {file_path}")
+        return set()
+
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        # Regex pattern matching <include>...</include> tags
+        pattern = r'<include>(.*?)</include>'
+        matches = re.findall(pattern, content, re.DOTALL)
+        
+        # Clean up matches (strip whitespace)
+        includes = {m.strip() for m in matches if m.strip()}
+        return includes
+    except Exception as e:
+        logger.error(f"Error reading file {file_path}: {e}")
+        return set()
+
+
+def extract_module_from_include(include_path: str) -> Optional[str]:
+    """
+    Maps include paths to module names by stripping suffixes.
+
+    Args:
+        include_path: The path string found inside an include tag.
+
+    Returns:
+        The extracted module name, or None if it's not a module include.
+    """
+    path_obj = Path(include_path)
+    filename = path_obj.name
+    stem = path_obj.stem
+
+    # Logic:
+    # 1. If it's a context example file (e.g., context/llm_invoke_example.py)
+    # 2. If it's a prompt file with language suffix (e.g., prompts/cli_python.prompt)
+
+    # Check if it looks like a module file:
+    # - Example files contain "_example" in the stem
+    # - Prompt files must have a language suffix (_python, _typescript, _LLM)
+    is_example = "_example" in stem
+    has_language_suffix = bool(re.search(r'(_python|_typescript|_LLM)$', stem, re.IGNORECASE))
+    is_module_prompt = filename.endswith(".prompt") and has_language_suffix
+
+    if not (is_example or is_module_prompt):
+        return None
+
+    # Remove suffixes
+    # Order matters: remove language specific suffixes first, then _example
+    clean_name = stem
+
+    # Remove language suffixes
+    clean_name = re.sub(r'(_python|_typescript|_LLM)$', '', clean_name, flags=re.IGNORECASE)
+
+    # Remove example suffix
+    clean_name = re.sub(r'_example$', '', clean_name, flags=re.IGNORECASE)
+
+    if not clean_name:
+        return None
+
+    return clean_name
+
+
+def build_dependency_graph(prompts_dir: Path) -> Dict[str, List[str]]:
+    """
+    Scans prompt files and builds a dependency graph based on includes.
+
+    Args:
+        prompts_dir: Directory containing .prompt files.
+
+    Returns:
+        Dictionary mapping module_name -> list of dependencies (modules it depends on).
+    """
+    if not prompts_dir.exists() or not prompts_dir.is_dir():
+        logger.error(f"Prompts directory not found: {prompts_dir}")
+        return {}
+
+    dependency_graph: Dict[str, Set[str]] = defaultdict(set)
+    
+    # Scan for relevant prompt files
+    patterns = ["*_python.prompt", "*_typescript.prompt", "*_LLM.prompt"]
+    prompt_files: List[Path] = []
+    for pattern in patterns:
+        prompt_files.extend(prompts_dir.glob(pattern))
+
+    for p_file in prompt_files:
+        # Determine current module name from filename
+        # e.g., "foo_python.prompt" -> "foo"
+        current_module = extract_module_from_include(p_file.name)
+        
+        if not current_module:
+            continue
+
+        # Ensure module exists in graph even if it has no dependencies
+        if current_module not in dependency_graph:
+            dependency_graph[current_module] = set()
+
+        # Parse includes
+        includes = extract_includes_from_file(p_file)
+        
+        for inc in includes:
+            dep_module = extract_module_from_include(inc)
+            
+            # Add dependency if valid and not self-reference
+            if dep_module and dep_module != current_module:
+                dependency_graph[current_module].add(dep_module)
+
+    # Convert sets to lists for return type consistency
+    return {k: list(v) for k, v in dependency_graph.items()}
+
+
+def topological_sort(graph: Dict[str, List[str]]) -> Tuple[List[str], List[List[str]]]:
+    """
+    Performs topological sort using Kahn's algorithm.
+
+    Args:
+        graph: Adjacency list (module -> dependencies).
+
+    Returns:
+        Tuple containing:
+        1. List of modules in topological order (dependencies first).
+        2. List of cycles detected (if any).
+    """
+    # Calculate in-degrees (number of modules depending on key)
+    # Note: The input graph is "Module -> Depends On".
+    # For Kahn's algo to output [Dependency, ..., Dependent], we need to process
+    # nodes with 0 dependencies first.
+    
+    # Normalize graph to ensure all nodes are keys
+    all_nodes = set(graph.keys())
+    for deps in graph.values():
+        all_nodes.update(deps)
+    
+    adj_list = {node: graph.get(node, []) for node in all_nodes}
+    
+    # In Kahn's, usually we track edges: Dependency -> Dependent.
+    # Our input is Dependent -> [Dependencies].
+    # So, in-degree here represents "number of unsatisfied dependencies".
+    in_degree = {node: 0 for node in all_nodes}
+    
+    # Reverse graph: Dependency -> [Dependents] (needed to update neighbors)
+    reverse_graph: Dict[str, List[str]] = defaultdict(list)
+    
+    for node, deps in adj_list.items():
+        in_degree[node] = len(deps)
+        for dep in deps:
+            reverse_graph[dep].append(node)
+
+    # Queue for nodes with 0 dependencies
+    queue: Deque[str] = deque([node for node, deg in in_degree.items() if deg == 0])
+    
+    sorted_list: List[str] = []
+    processed_count = 0
+    
+    while queue:
+        u = queue.popleft()
+        sorted_list.append(u)
+        processed_count += 1
+        
+        # For every module 'v' that depends on 'u'
+        for v in reverse_graph[u]:
+            in_degree[v] -= 1
+            if in_degree[v] == 0:
+                queue.append(v)
+
+    cycles: List[List[str]] = []
+    
+    if processed_count != len(all_nodes):
+        # Cycle detected. Identify nodes involved in cycles.
+        remaining_nodes = [n for n, deg in in_degree.items() if deg > 0]
+        if remaining_nodes:
+            cycles.append(remaining_nodes)
+            logger.warning(f"Cyclic dependencies detected involving: {remaining_nodes}")
+
+    return sorted_list, cycles
+
+
+def get_affected_modules(sorted_modules: List[str], modified: Set[str], graph: Dict[str, List[str]]) -> List[str]:
+    """
+    Identifies modules that need syncing based on modified modules and dependencies.
+
+    Args:
+        sorted_modules: Full list of modules in topological order.
+        modified: Set of module names that have changed.
+        graph: Dependency graph (module -> dependencies).
+
+    Returns:
+        List of modules to sync, preserving topological order.
+    """
+    if not modified:
+        return []
+
+    # Build reverse graph: Dependency -> [Dependents]
+    # This allows us to traverse "up" the chain from a modified dependency to things that use it
+    reverse_graph: Dict[str, Set[str]] = defaultdict(set)
+    for node, deps in graph.items():
+        for dep in deps:
+            reverse_graph[dep].add(node)
+
+    affected = set()
+    queue = deque(modified)
+    
+    # BFS to find all transitive dependents
+    while queue:
+        current = queue.popleft()
+        if current in affected:
+            continue
+            
+        affected.add(current)
+        
+        # Add all modules that depend on current
+        for dependent in reverse_graph.get(current, []):
+            if dependent not in affected:
+                queue.append(dependent)
+
+    # Filter sorted_modules to keep only affected ones, preserving order
+    result = [m for m in sorted_modules if m in affected]
+    
+    return result
+
+
+def generate_sync_order_script(modules: List[str], output_path: Path, worktree_path: Optional[Path] = None) -> str:
+    """
+    Generates a shell script to execute pdd sync commands in order.
+
+    Args:
+        modules: Ordered list of module names to sync.
+        output_path: Path where the script should be written.
+        worktree_path: Optional path to cd into before running commands.
+
+    Returns:
+        The content of the generated script.
+    """
+    if not modules:
+        logger.info("No modules to sync. Skipping script generation.")
+        return ""
+
+    lines = [
+        "#!/bin/bash",
+        "#",
+        "# PDD Sync Order Script",
+        f"# Generated: {datetime.now().isoformat()}",
+        f"# Total Modules: {len(modules)}",
+        "#",
+        "",
+        "set -e  # Exit immediately if a command exits with a non-zero status",
+        ""
+    ]
+
+    if worktree_path:
+        lines.append(f"cd {worktree_path}")
+        lines.append("")
+
+    total = len(modules)
+    for i, module in enumerate(modules, 1):
+        lines.append(f'echo "[{i}/{total}] Syncing {module}..."')
+        lines.append(f"pdd sync {module}")
+        lines.append("")
+
+    script_content = "\n".join(lines)
+
+    try:
+        output_path.write_text(script_content, encoding="utf-8")
+        
+        # Make executable (chmod +x)
+        st = os.stat(output_path)
+        os.chmod(output_path, st.st_mode | stat.S_IEXEC)
+        
+        console.print(f"[green]Successfully generated sync script at: {output_path}[/green]")
+    except Exception as e:
+        console.print(f"[red]Failed to write sync script: {e}[/red]")
+        raise
+
+    return script_content

pdd/template_expander.py

@@ -0,0 +1,161 @@
+# pdd/template_expander.py
+"""
+Template expansion utility for output path configuration.
+
+This module provides a function to expand path templates with placeholders
+like {name}, {category}, {ext}, etc. It enables extensible project layouts
+for different languages and frameworks (Python, TypeScript, Vue, Go, etc.).
+
+Supported placeholders:
+    {name}        - Base name (last segment of input path)
+    {category}    - Parent path segments (empty if none)
+    {dir_prefix}  - Full input directory prefix with trailing /
+    {ext}         - File extension from language (e.g., "py", "tsx")
+    {language}    - Full language name (e.g., "python", "typescript")
+    {name_snake}  - snake_case version of name
+    {name_pascal} - PascalCase version of name
+    {name_kebab}  - kebab-case version of name
+
+Example:
+    >>> expand_template(
+    ...     "frontend/src/components/{category}/{name}/{name}.tsx",
+    ...     {"name": "AssetCard", "category": "marketplace"}
+    ... )
+    'frontend/src/components/marketplace/AssetCard/AssetCard.tsx'
+"""
+
+import re
+import os
+from typing import Dict, Any
+
+
+def _to_snake_case(s: str) -> str:
+    """
+    Convert string to snake_case.
+
+    Handles PascalCase, camelCase, and existing snake_case.
+
+    Examples:
+        AssetCard -> asset_card
+        assetCard -> asset_card
+        already_snake -> already_snake
+    """
+    if not s:
+        return s
+    # Insert underscore before uppercase letters (except at start)
+    result = re.sub(r'(?<!^)(?=[A-Z])', '_', s)
+    return result.lower()
+
+
+def _to_pascal_case(s: str) -> str:
+    """
+    Convert string to PascalCase.
+
+    Handles snake_case, kebab-case, and existing PascalCase.
+
+    Examples:
+        asset_card -> AssetCard
+        asset-card -> AssetCard
+        AssetCard -> Assetcard (note: re-capitalizes)
+    """
+    if not s:
+        return s
+    # Split on underscores, hyphens, or other common delimiters
+    parts = re.split(r'[_\-\s]+', s)
+    return ''.join(part.title() for part in parts if part)
+
+
+def _to_kebab_case(s: str) -> str:
+    """
+    Convert string to kebab-case.
+
+    Handles PascalCase, camelCase, and existing kebab-case.
+
+    Examples:
+        AssetCard -> asset-card
+        assetCard -> asset-card
+        already-kebab -> already-kebab
+    """
+    if not s:
+        return s
+    # Insert hyphen before uppercase letters (except at start)
+    result = re.sub(r'(?<!^)(?=[A-Z])', '-', s)
+    return result.lower()
+
+
+def _normalize_path(path: str) -> str:
+    """
+    Normalize a path to remove double slashes and resolve . and ..
+
+    This handles edge cases like empty {category} producing paths like:
+    "src/components//Button" -> "src/components/Button"
+
+    Unlike os.path.normpath, this preserves relative paths without
+    converting them to absolute paths.
+    """
+    if not path:
+        return path
+
+    # Split path and filter empty segments (which cause double slashes)
+    parts = path.split('/')
+    normalized_parts = [p for p in parts if p]
+
+    # Rejoin with single slashes
+    result = '/'.join(normalized_parts)
+
+    # Use os.path.normpath for additional cleanup (handles . and ..)
+    # but it converts to OS-specific separators, so convert back
+    result = os.path.normpath(result)
+
+    # On Windows, normpath uses backslashes; convert back to forward slashes
+    result = result.replace('\\', '/')
+
+    return result
+
+
+def expand_template(template: str, context: Dict[str, Any]) -> str:
+    """
+    Expand a path template with placeholder values.
+
+    Args:
+        template: Path template with {placeholder} syntax
+        context: Dictionary of values to substitute
+
+    Returns:
+        Expanded path with normalized slashes
+
+    Example:
+        >>> expand_template(
+        ...     "frontend/src/components/{category}/{name}/{name}.tsx",
+        ...     {"name": "AssetCard", "category": "marketplace"}
+        ... )
+        'frontend/src/components/marketplace/AssetCard/AssetCard.tsx'
+    """
+    # Get base values from context (with empty string defaults)
+    name = context.get('name', '')
+    category = context.get('category', '')
+    dir_prefix = context.get('dir_prefix', '')
+    ext = context.get('ext', '')
+    language = context.get('language', '')
+
+    # Build the full set of available placeholders
+    placeholders = {
+        'name': name,
+        'category': category,
+        'dir_prefix': dir_prefix,
+        'ext': ext,
+        'language': language,
+        'name_snake': _to_snake_case(name),
+        'name_pascal': _to_pascal_case(name),
+        'name_kebab': _to_kebab_case(name),
+    }
+
+    # Perform substitution
+    result = template
+    for key, value in placeholders.items():
+        result = result.replace(f'{{{key}}}', str(value))
+
+    # Normalize the path to handle empty segments (double slashes)
+    result = _normalize_path(result)
+
+    return result

pdd/templates/architecture/architecture_json.prompt

@@ -140,56 +140,51 @@ INSTRUCTIONS:
   - When interface.type is "page", each entry in `dataSources` must be an object with at least `kind` and `source` (e.g., URL or identifier). The `kind` field MUST be exactly one of: `"api"`, `"query"`, `"stream"`, `"file"`, `"cache"`, `"message"`, `"job"`, or `"other"`. Do not invent new values like `"api/mutation"`; instead, use `"api"` (for any HTTP/REST/GraphQL endpoint) or `"other"` and describe details such as queries vs. mutations in `description` or `notes`. Provide `method`, `description`, and any other useful metadata when known.
 - Valid JSON only. No comments or trailing commas.
 
-OUTPUT FORMAT (authoritative):
+OUTPUT FORMAT - CRITICAL: Return a raw JSON array, NOT an object with "items" or "data" wrapper:
 ```json
-{
-  "type": "array",
-  "items": {
-    "type": "object",
-    "required": ["reason", "description", "dependencies", "priority", "filename", "filepath"],
-    "properties": {
-      "reason": {"type": "string"},
-      "description": {"type": "string"},
-      "dependencies": {"type": "array", "items": {"type": "string"}},
-      "priority": {"type": "integer", "minimum": 1},
-      "filename": {"type": "string"},
-      "filepath": {"type": "string"},
-      "tags": {"type": "array", "items": {"type": "string"}},
-      "interface": {
-        "type": "object",
-        "properties": {
-          "type": {"type": "string", "enum": ["component", "page", "module", "api", "graphql", "cli", "job", "message", "config"]},
-          "component": {"type": "object"},
-          "page": {
-            "type": "object",
-            "properties": {
-              "route": {"type": "string"},
-              "params": {
-                "type": "array",
-                "items": {
-                  "type": "object",
-                  "required": ["name", "type"],
-                  "properties": {
-                    "name": {"type": "string"},
-                    "type": {"type": "string"},
-                    "description": {"type": "string"}
-                  }
-                }
-              }
-            }
-          },
-          "module": {"type": "object"},
-          "api": {"type": "object"},
-          "graphql": {"type": "object"},
-          "cli": {"type": "object"},
-          "job": {"type": "object"},
-          "message": {"type": "object"},
-          "config": {"type": "object"}
-        }
+[
+  {
+    "reason": "Core data models needed by all other modules",
+    "description": "Defines Order, User, and Item data models with validation",
+    "dependencies": [],
+    "priority": 1,
+    "filename": "models_Python.prompt",
+    "filepath": "src/models.py",
+    "tags": ["backend", "data"],
+    "interface": {
+      "type": "module",
+      "module": {
+        "functions": [
+          {"name": "Order", "signature": "class Order(BaseModel)", "returns": "Order instance"}
+        ]
+      }
+    }
+  },
+  {
+    "reason": "API endpoints for order management",
+    "description": "REST API for creating, reading, updating orders",
+    "dependencies": ["models_Python.prompt"],
+    "priority": 2,
+    "filename": "orders_api_Python.prompt",
+    "filepath": "src/api/orders.py",
+    "tags": ["backend", "api"],
+    "interface": {
+      "type": "api",
+      "api": {
+        "endpoints": [
+          {"method": "POST", "path": "/orders", "auth": "jwt"},
+          {"method": "GET", "path": "/orders/{id}", "auth": "jwt"}
+        ]
       }
     }
   }
-}
+]
+```
+WRONG (do NOT do this):
+```json
+{"items": [...]}  // WRONG - no wrapper objects!
+{"data": [...]}   // WRONG - no wrapper objects!
+{"type": "array", "items": [...]}  // WRONG - this is schema, not output!
 ```
 
 INTERFACE TYPES (emit only applicable):

pdd/trace.py

@@ -222,7 +222,7 @@ def trace(
                 for start_idx in range(1, len(prompt_lines) - window_size + 2):
                     window_lines = prompt_lines[start_idx - 1 : start_idx - 1 + window_size]
                     window_text = " ".join(window_lines)
-                    normalized_window = normalize_text(window_text).casefold()
+                    normalized_window = _normalize_text(window_text).casefold()
                     seg_len = len(normalized_window)
                     if seg_len == 0:
                         continue

pdd/track_cost.py

@@ -57,9 +57,7 @@ def track_cost(func):
                             # (it might have been created/deleted during command execution)
                             if os.path.exists(abs_path) or '.' in os.path.basename(f):
                                 files_set.add(abs_path)
-                                print(f"Debug: Added to core_dump_files: {abs_path} (exists: {os.path.exists(abs_path)})")
                     ctx.obj['core_dump_files'] = files_set
-                    print(f"Debug: Total files in core_dump_files: {len(files_set)}")
 
                 # Check if we need to write cost tracking (only on success)
                 if exception_raised is None:
@@ -92,10 +90,6 @@ def track_cost(func):
                                 writer.writeheader()
                             writer.writerow(row)
 
-                        print(f"Debug: Writing row to CSV: {row}")
-                        print(f"Debug: Input files: {input_files}")
-                        print(f"Debug: Output files: {output_files}")
-
             except Exception as e:
                 rprint(f"[red]Error tracking cost: {e}[/red]")
 
@@ -116,11 +110,6 @@ def collect_files(args, kwargs):
     input_files = []
     output_files = []
 
-    print(f"Debug: collect_files called")
-    print(f"Debug: args = {args}")
-    print(f"Debug: kwargs keys = {list(kwargs.keys())}")
-    print(f"Debug: kwargs = {kwargs}")
-
     # Known input parameter names that typically contain file paths
     input_param_names = {
         'prompt_file', 'prompt', 'input', 'input_file', 'source', 'source_file',
@@ -187,6 +176,4 @@ def collect_files(args, kwargs):
                 if isinstance(item, str) and item and looks_like_file(item):
                     input_files.append(item)
 
-    print(f"Debug: Collected input files: {input_files}")
-    print(f"Debug: Collected output files: {output_files}")
     return input_files, output_files

pdd/unfinished_prompt.py

@@ -114,7 +114,8 @@ def unfinished_prompt(
             temperature=temperature,
             time=time,
             verbose=verbose,
-            output_pydantic=PromptAnalysis
+            output_pydantic=PromptAnalysis,
+            language=language,
         )
 
         # Step 3: Extract and return results