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

pdd/sync_orchestration.py

@@ -38,6 +38,7 @@ from .sync_determine_operation import (
     read_run_report,
     calculate_sha256,
     calculate_current_hashes,
+    _safe_basename,
 )
 from .auto_deps_main import auto_deps_main
 from .code_generator_main import code_generator_main
@@ -53,6 +54,10 @@ from .pytest_output import extract_failing_files_from_output
 from . import DEFAULT_STRENGTH
 
 
+# --- Helper Functions ---
+# Note: _safe_basename is imported from sync_determine_operation
+
+
 # --- Atomic State Update (Issue #159 Fix) ---
 
 @dataclass
@@ -151,7 +156,7 @@ class AtomicStateUpdate:
 
 def load_sync_log(basename: str, language: str) -> List[Dict[str, Any]]:
     """Load sync log entries for a basename and language."""
-    log_file = META_DIR / f"{basename}_{language}_sync.log"
+    log_file = META_DIR / f"{_safe_basename(basename)}_{language}_sync.log"
     if not log_file.exists():
         return []
     try:
@@ -193,7 +198,7 @@ def update_sync_log_entry(entry: Dict[str, Any], result: Dict[str, Any], duratio
 
 def append_sync_log(basename: str, language: str, entry: Dict[str, Any]):
     """Append completed log entry to the sync log file."""
-    log_file = META_DIR / f"{basename}_{language}_sync.log"
+    log_file = META_DIR / f"{_safe_basename(basename)}_{language}_sync.log"
     META_DIR.mkdir(parents=True, exist_ok=True)
     with open(log_file, 'a') as f:
         f.write(json.dumps(entry) + '\n')
@@ -217,7 +222,7 @@ def save_run_report(report: Dict[str, Any], basename: str, language: str,
         language: The programming language.
         atomic_state: Optional AtomicStateUpdate for atomic writes (Issue #159 fix).
     """
-    report_file = META_DIR / f"{basename}_{language}_run.json"
+    report_file = META_DIR / f"{_safe_basename(basename)}_{language}_run.json"
     if atomic_state:
         # Buffer for atomic write
         atomic_state.set_run_report(report, report_file)
@@ -257,7 +262,7 @@ def _save_operation_fingerprint(basename: str, language: str, operation: str,
         test_files=current_hashes.get('test_files'),  # Bug #156
     )
 
-    fingerprint_file = META_DIR / f"{basename}_{language}.json"
+    fingerprint_file = META_DIR / f"{_safe_basename(basename)}_{language}.json"
     if atomic_state:
         # Buffer for atomic write
         atomic_state.set_fingerprint(asdict(fingerprint), fingerprint_file)
@@ -574,7 +579,7 @@ def _try_auto_fix_import_error(
 def _run_example_with_error_detection(
     cmd_parts: list[str],
     env: dict,
-    cwd: str,
+    cwd: Optional[str] = None,
     timeout: int = 60
 ) -> tuple[int, str, str]:
     """
@@ -635,24 +640,23 @@ def _run_example_with_error_detection(
     # Check for errors in output
     has_errors, error_summary = _detect_example_errors(combined)
 
-    # Determine result:
-    # - Errors in output → failure
+    # Determine result (check returncode first, then use error detection for signal-killed):
+    # - Zero exit code → success (trust the exit code)
     # - Positive exit code (process failed normally, e.g., sys.exit(1)) → failure
     # - Negative exit code (killed by signal, e.g., -9 for SIGKILL) → check output
-    # - Zero exit code → success
     #
     # IMPORTANT: When we kill the process after timeout, returncode is negative
     # (the signal number). This is NOT a failure if output has no errors.
-    if has_errors:
-        return 1, stdout, stderr  # Errors detected in output
+    if proc.returncode is not None and proc.returncode == 0:
+        return 0, stdout, stderr  # Clean exit = success (trust exit code)
     elif proc.returncode is not None and proc.returncode > 0:
         return proc.returncode, stdout, stderr  # Process exited with error
     else:
-        # Success cases:
-        # - returncode == 0 (clean exit)
-        # - returncode < 0 (killed by signal, but no errors in output)
-        # - returncode is None (shouldn't happen after wait, but safe fallback)
-        return 0, stdout, stderr
+        # Killed by signal (returncode < 0 or None) - use error detection
+        # Server-style examples may run until timeout, need to check output
+        if has_errors:
+            return 1, stdout, stderr  # Errors detected in output
+        return 0, stdout, stderr  # No errors, server was running fine
 
 
 def _execute_tests_and_create_run_report(
@@ -801,7 +805,7 @@ def _create_mock_context(**kwargs) -> click.Context:
 
 def _display_sync_log(basename: str, language: str, verbose: bool = False) -> Dict[str, Any]:
     """Displays the sync log for a given basename and language."""
-    log_file = META_DIR / f"{basename}_{language}_sync.log"
+    log_file = META_DIR / f"{_safe_basename(basename)}_{language}_sync.log"
     if not log_file.exists():
         print(f"No sync log found for '{basename}' in language '{language}'.")
         return {'success': False, 'errors': ['Log file not found.'], 'log_entries': []}
@@ -904,6 +908,14 @@ def sync_orchestration(
     """
     Orchestrates the complete PDD sync workflow with parallel animation.
     """
+    # Handle None values from CLI (Issue #194) - defense in depth
+    if target_coverage is None:
+        target_coverage = 90.0
+    if budget is None:
+        budget = 10.0
+    if max_attempts is None:
+        max_attempts = 3
+
     # Import get_extension at function scope
     from .sync_determine_operation import get_extension
     
@@ -967,6 +979,10 @@ def sync_orchestration(
         """Get the confirmation callback from the app if available.
 
         Once user confirms, we remember it so subsequent operations don't ask again.
+
+        Fix for Issue #277: In headless mode, we now return a wrapper callback
+        that uses click.confirm AND sets user_confirmed_overwrite[0] = True,
+        so subsequent calls auto-confirm instead of prompting repeatedly.
         """
         if user_confirmed_overwrite[0]:
             # User already confirmed, return a callback that always returns True
@@ -979,6 +995,26 @@ def sync_orchestration(
                     user_confirmed_overwrite[0] = True
                 return result
             return confirming_callback
+
+        # Fix #277: In headless mode (app_ref is None), create a wrapper callback
+        # that sets the flag after confirmation, preventing repeated prompts
+        if confirm_callback is None:
+            def headless_confirming_callback(msg: str, title: str) -> bool:
+                """Headless mode callback that remembers user confirmation."""
+                try:
+                    prompt = msg or "Overwrite existing files?"
+                    result = click.confirm(
+                        click.style(prompt, fg="yellow"),
+                        default=True,
+                        show_default=True
+                    )
+                except (click.Abort, EOFError):
+                    return False
+                if result:
+                    user_confirmed_overwrite[0] = True
+                return result
+            return headless_confirming_callback
+
         return confirm_callback  # Fall back to provided callback
 
     def sync_worker_logic():
@@ -1196,12 +1232,18 @@ def sync_orchestration(
                                         Path(temp_output).unlink()
                                         result = (new_content, 0.0, 'no-changes')
                             elif operation == 'generate':
-                                result = code_generator_main(ctx, prompt_file=str(pdd_files['prompt']), output=str(pdd_files['code']), original_prompt_file_path=None, force_incremental_flag=False)
+                                # Ensure code directory exists before generating
+                                pdd_files['code'].parent.mkdir(parents=True, exist_ok=True)
+                                # Use absolute paths to avoid path_resolution_mode mismatch between sync (cwd) and generate (config_base)
+                                result = code_generator_main(ctx, prompt_file=str(pdd_files['prompt'].resolve()), output=str(pdd_files['code'].resolve()), original_prompt_file_path=None, force_incremental_flag=False)
                                 # Clear stale run_report so crash/verify is required for newly generated code
-                                run_report_file = META_DIR / f"{basename}_{language}_run.json"
+                                run_report_file = META_DIR / f"{_safe_basename(basename)}_{language}_run.json"
                                 run_report_file.unlink(missing_ok=True)
                             elif operation == 'example':
-                                result = context_generator_main(ctx, prompt_file=str(pdd_files['prompt']), code_file=str(pdd_files['code']), output=str(pdd_files['example']))
+                                # Ensure example directory exists before generating
+                                pdd_files['example'].parent.mkdir(parents=True, exist_ok=True)
+                                # Use absolute paths to avoid path_resolution_mode mismatch between sync (cwd) and example (config_base)
+                                result = context_generator_main(ctx, prompt_file=str(pdd_files['prompt'].resolve()), code_file=str(pdd_files['code'].resolve()), output=str(pdd_files['example'].resolve()))
                             elif operation == 'crash':
                                 required_files = [pdd_files['code'], pdd_files['example']]
                                 missing_files = [f for f in required_files if not f.exists()]
@@ -1226,20 +1268,15 @@ def sync_orchestration(
                                     # Remove TUI-specific env vars that might contaminate subprocess
                                     for var in ['FORCE_COLOR', 'COLUMNS']:
                                         env.pop(var, None)
-                                    # Get language-appropriate run command from language_format.csv
-                                    example_path = str(pdd_files['example'])
-                                    run_cmd = get_run_command_for_file(example_path)
-                                    if run_cmd:
-                                        # Use the language-specific interpreter (e.g., node for .js)
-                                        cmd_parts = run_cmd.split()
-                                    else:
-                                        # Fallback to Python if no run command found
-                                        cmd_parts = ['python', example_path]
+                                    # Bug fix: Use sys.executable to match crash_main's Python interpreter
+                                    # and do NOT set cwd - inherit from pdd invocation directory
+                                    # to match crash_main behavior. Setting cwd to example's parent breaks imports.
+                                    example_path = str(pdd_files['example'].resolve())
+                                    cmd_parts = [sys.executable, example_path]
                                     # Use error-detection runner that handles server-style examples
                                     returncode, stdout, stderr = _run_example_with_error_detection(
                                         cmd_parts,
                                         env=env,
-                                        cwd=str(pdd_files['example'].parent),
                                         timeout=60
                                     )
 
@@ -1285,7 +1322,6 @@ def sync_orchestration(
                                         retry_returncode, retry_stdout, retry_stderr = _run_example_with_error_detection(
                                             cmd_parts,
                                             env=env,
-                                            cwd=str(pdd_files['example'].parent),
                                             timeout=60
                                         )
                                         if retry_returncode == 0:
@@ -1314,7 +1350,10 @@ def sync_orchestration(
 
                                     Path("crash.log").write_text(crash_log_content)
                                     try:
-                                        result = crash_main(ctx, prompt_file=str(pdd_files['prompt']), code_file=str(pdd_files['code']), program_file=str(pdd_files['example']), error_file="crash.log", output=str(pdd_files['code']), output_program=str(pdd_files['example']), loop=True, max_attempts=max_attempts, budget=budget - current_cost_ref[0], strength=strength, temperature=temperature)
+                                        # For non-Python languages, set max_attempts=0 to skip iterative loop
+                                        # and go directly to agentic fallback
+                                        effective_max_attempts = 0 if language.lower() != 'python' else max_attempts
+                                        result = crash_main(ctx, prompt_file=str(pdd_files['prompt']), code_file=str(pdd_files['code']), program_file=str(pdd_files['example']), error_file="crash.log", output=str(pdd_files['code']), output_program=str(pdd_files['example']), loop=True, max_attempts=effective_max_attempts, budget=budget - current_cost_ref[0], strength=strength, temperature=temperature)
                                     except Exception as e:
                                         print(f"Crash fix failed: {e}")
                                         skipped_operations.append('crash')
@@ -1324,7 +1363,10 @@ def sync_orchestration(
                                 if not pdd_files['example'].exists():
                                     skipped_operations.append('verify')
                                     continue
-                                result = fix_verification_main(ctx, prompt_file=str(pdd_files['prompt']), code_file=str(pdd_files['code']), program_file=str(pdd_files['example']), output_results=f"{basename}_verify_results.log", output_code=str(pdd_files['code']), output_program=str(pdd_files['example']), loop=True, verification_program=str(pdd_files['example']), max_attempts=max_attempts, budget=budget - current_cost_ref[0], strength=strength, temperature=temperature)
+                                # For non-Python languages, set max_attempts=0 to skip iterative loop
+                                # and go directly to agentic fallback
+                                effective_max_attempts = 0 if language.lower() != 'python' else max_attempts
+                                result = fix_verification_main(ctx, prompt_file=str(pdd_files['prompt']), code_file=str(pdd_files['code']), program_file=str(pdd_files['example']), output_results=f"{basename}_verify_results.log", output_code=str(pdd_files['code']), output_program=str(pdd_files['example']), loop=True, verification_program=str(pdd_files['example']), max_attempts=effective_max_attempts, budget=budget - current_cost_ref[0], strength=strength, temperature=temperature)
                             elif operation == 'test':
                                 pdd_files['test'].parent.mkdir(parents=True, exist_ok=True)
                                 # Use merge=True when test file exists to preserve fixes and append new tests
@@ -1402,11 +1444,13 @@ def sync_orchestration(
                                             # Bug #156: Run pytest on ALL matching test files
                                             test_files = pdd_files.get('test_files', [pdd_files['test']])
                                             pytest_args = [python_executable, '-m', 'pytest'] + [str(f) for f in test_files] + ['-v', '--tb=short']
+                                            # Bug fix: Run from project root (no cwd), matching _run_tests_and_report pattern
+                                            # Using cwd=test.parent with paths like 'backend/tests/test_foo.py' causes
+                                            # pytest to look for 'backend/tests/backend/tests/test_foo.py' (not found)
                                             test_result = subprocess.run(
                                                 pytest_args,
                                                 capture_output=True, text=True, timeout=300,
-                                                stdin=subprocess.DEVNULL, env=clean_env, start_new_session=True,
-                                                cwd=str(pdd_files['test'].parent)
+                                                stdin=subprocess.DEVNULL, env=clean_env, start_new_session=True
                                             )
                                         else:
                                             # Use shell command for non-Python
@@ -1460,7 +1504,10 @@ def sync_orchestration(
                                                     unit_test_file_for_fix = str(ff_path.resolve())
                                                     break
 
-                                result = fix_main(ctx, prompt_file=str(pdd_files['prompt']), code_file=str(pdd_files['code']), unit_test_file=unit_test_file_for_fix, error_file=str(error_file_path), output_test=str(pdd_files['test']), output_code=str(pdd_files['code']), output_results=f"{basename}_fix_results.log", loop=True, verification_program=str(pdd_files['example']), max_attempts=max_attempts, budget=budget - current_cost_ref[0], auto_submit=True, strength=strength, temperature=temperature)
+                                # For non-Python languages, set max_attempts=0 to skip iterative loop
+                                # and go directly to agentic fallback
+                                effective_max_attempts = 0 if language.lower() != 'python' else max_attempts
+                                result = fix_main(ctx, prompt_file=str(pdd_files['prompt']), code_file=str(pdd_files['code']), unit_test_file=unit_test_file_for_fix, error_file=str(error_file_path), output_test=str(pdd_files['test']), output_code=str(pdd_files['code']), output_results=f"{basename}_fix_results.log", loop=True, verification_program=str(pdd_files['example']), max_attempts=effective_max_attempts, budget=budget - current_cost_ref[0], auto_submit=True, strength=strength, temperature=temperature)
                             elif operation == 'update':
                                 result = update_main(ctx, input_prompt_file=str(pdd_files['prompt']), modified_code_file=str(pdd_files['code']), input_code_file=None, output=str(pdd_files['prompt']), use_git=True, strength=strength, temperature=temperature)
                             else:
@@ -1509,18 +1556,18 @@ def sync_orchestration(
                                  clean_env = os.environ.copy()
                                  for var in ['FORCE_COLOR', 'COLUMNS']:
                                      clean_env.pop(var, None)
-                                 # Get language-appropriate run command
-                                 example_path = str(pdd_files['example'])
-                                 run_cmd = get_run_command_for_file(example_path)
-                                 if run_cmd:
-                                     cmd_parts = run_cmd.split()
-                                 else:
-                                     cmd_parts = ['python', example_path]
+                                 # Bug fix: Use sys.executable to ensure same Python interpreter as
+                                 # crash_main (fix_code_loop.py:477). When both venv and conda are
+                                 # active, PATH lookup for 'python' may resolve to a different
+                                 # interpreter, causing infinite crash loops.
+                                 # Bug fix: Do NOT set cwd - inherit from pdd invocation directory
+                                 # to match crash_main behavior. Setting cwd to example's parent breaks imports.
+                                 example_path = str(pdd_files['example'].resolve())
+                                 cmd_parts = [sys.executable, example_path]
                                  # Use error-detection runner that handles server-style examples
                                  returncode, stdout, stderr = _run_example_with_error_detection(
                                      cmd_parts,
                                      env=clean_env,
-                                     cwd=str(pdd_files['example'].parent),
                                      timeout=60
                                  )
                                  # Include test_hash for staleness detection
@@ -1574,48 +1621,62 @@ def sync_orchestration(
             'model_name': last_model_name,
         }
 
-    # Instantiate and run Textual App
-    app = SyncApp(
-        basename=basename,
-        budget=budget,
-        worker_func=sync_worker_logic,
-        function_name_ref=current_function_name_ref,
-        cost_ref=current_cost_ref,
-        prompt_path_ref=prompt_path_ref,
-        code_path_ref=code_path_ref,
-        example_path_ref=example_path_ref,
-        tests_path_ref=tests_path_ref,
-        prompt_color_ref=prompt_box_color_ref,
-        code_color_ref=code_box_color_ref,
-        example_color_ref=example_box_color_ref,
-        tests_color_ref=tests_box_color_ref,
-        stop_event=stop_event,
-        progress_callback_ref=progress_callback_ref
-    )
+    # Detect headless mode (no TTY, CI environment, or quiet mode)
+    headless = quiet or not sys.stdout.isatty() or os.environ.get('CI')
+
+    if headless:
+        # Set PDD_FORCE to also skip API key prompts in headless mode
+        os.environ['PDD_FORCE'] = '1'
+        # Run worker logic directly without TUI in headless mode
+        if not quiet:
+            print(f"Running sync in headless mode (CI/non-TTY environment)...")
+        result = sync_worker_logic()
+        # No TUI app, so no worker_exception to check
+        worker_exception = None
+    else:
+        # Instantiate and run Textual App
+        app = SyncApp(
+            basename=basename,
+            budget=budget,
+            worker_func=sync_worker_logic,
+            function_name_ref=current_function_name_ref,
+            cost_ref=current_cost_ref,
+            prompt_path_ref=prompt_path_ref,
+            code_path_ref=code_path_ref,
+            example_path_ref=example_path_ref,
+            tests_path_ref=tests_path_ref,
+            prompt_color_ref=prompt_box_color_ref,
+            code_color_ref=code_box_color_ref,
+            example_color_ref=example_box_color_ref,
+            tests_color_ref=tests_box_color_ref,
+            stop_event=stop_event,
+            progress_callback_ref=progress_callback_ref
+        )
 
-    # Store app reference so worker can access request_confirmation
-    app_ref[0] = app
+        # Store app reference so worker can access request_confirmation
+        app_ref[0] = app
 
-    result = app.run()
-    
-    # Show exit animation if not quiet
-    if not quiet:
+        result = app.run()
+
+        # Show exit animation if not quiet
         from .sync_tui import show_exit_animation
         show_exit_animation()
-    
-    # Check for worker exception that might have caused a crash
-    if app.worker_exception:
-        print(f"\n[Error] Worker thread crashed with exception: {app.worker_exception}", file=sys.stderr)
-        
+
+        worker_exception = app.worker_exception
+
+    # Check for worker exception that might have caused a crash (TUI mode only)
+    if not headless and worker_exception:
+        print(f"\n[Error] Worker thread crashed with exception: {worker_exception}", file=sys.stderr)
+
         if hasattr(app, 'captured_logs') and app.captured_logs:
              print("\n[Captured Logs (last 20 lines)]", file=sys.stderr)
              for line in app.captured_logs[-20:]: # Print last 20 lines
                  print(f"  {line}", file=sys.stderr)
-        
+
         import traceback
         # Use trace module to print the stored exception's traceback if available
-        if hasattr(app.worker_exception, '__traceback__'):
-            traceback.print_exception(type(app.worker_exception), app.worker_exception, app.worker_exception.__traceback__, file=sys.stderr)
+        if hasattr(worker_exception, '__traceback__'):
+            traceback.print_exception(type(worker_exception), worker_exception, worker_exception.__traceback__, file=sys.stderr)
 
     if result is None:
         return {

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):