pdd-cli 0.0.56__py3-none-any.whl → 0.0.58__py3-none-any.whl

pdd/__init__.py

@@ -1,6 +1,6 @@
 """PDD - Prompt Driven Development"""
 
-__version__ = "0.0.56"
+__version__ = "0.0.58"
 
 # Strength parameter used for LLM extraction across the codebase
 # Used in postprocessing, XML tagging, code generation, and other extraction

pdd/cli.py

@@ -8,6 +8,8 @@ generating code, tests, fixing issues, and managing prompts.
 from __future__ import annotations
 
 import os
+import subprocess
+import sys
 from typing import Any, Dict, List, Optional, Tuple
 from pathlib import Path # Import Path
 
@@ -32,7 +34,12 @@ from .crash_main import crash_main
 from .detect_change_main import detect_change_main
 from .fix_main import fix_main
 from .fix_verification_main import fix_verification_main
-from .install_completion import install_completion, get_local_pdd_path
+from .install_completion import (
+    install_completion,
+    get_local_pdd_path,
+    get_current_shell,
+    get_shell_rc_path,
+)
 from .preprocess_main import preprocess_main
 from .pytest_output import run_pytest_and_capture_output
 from .split_main import split_main
@@ -40,6 +47,7 @@ from .sync_main import sync_main
 from .trace_main import trace_main
 from .track_cost import track_cost
 from .update_main import update_main
+from . import template_registry
 
 
 # --- Initialize Rich Console ---
@@ -75,8 +83,89 @@ def handle_error(exception: Exception, command_name: str, quiet: bool):
     # Do NOT re-raise e here. Let the command function return None.
 
 
+def _first_pending_command(ctx: click.Context) -> Optional[str]:
+    """Return the first subcommand scheduled for this invocation."""
+    for arg in ctx.protected_args:
+        if not arg.startswith("-"):
+            return arg
+    return None
+
+
+def _api_env_exists() -> bool:
+    """Check whether the ~/.pdd/api-env file exists."""
+    return (Path.home() / ".pdd" / "api-env").exists()
+
+
+def _completion_installed() -> bool:
+    """Check if the shell RC file already sources the PDD completion script."""
+    shell = get_current_shell()
+    rc_path = get_shell_rc_path(shell) if shell else None
+    if not rc_path:
+        return False
+
+    try:
+        content = Path(rc_path).read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return False
+
+    return "PDD CLI completion" in content or "pdd_completion" in content
+
+
+def _project_has_local_configuration() -> bool:
+    """Detect project-level env configuration that should suppress reminders."""
+    cwd = Path.cwd()
+
+    env_file = cwd / ".env"
+    if env_file.exists():
+        try:
+            env_content = env_file.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            env_content = ""
+        if any(token in env_content for token in ("OPENAI_API_KEY=", "GOOGLE_API_KEY=", "ANTHROPIC_API_KEY=")):
+            return True
+
+    project_pdd_dir = cwd / ".pdd"
+    if project_pdd_dir.exists():
+        return True
+
+    return False
+
+
+def _should_show_onboarding_reminder(ctx: click.Context) -> bool:
+    """Determine whether to display the onboarding reminder banner."""
+    suppress = os.getenv("PDD_SUPPRESS_SETUP_REMINDER", "").lower()
+    if suppress in {"1", "true", "yes"}:
+        return False
+
+    first_command = _first_pending_command(ctx)
+    if first_command == "setup":
+        return False
+
+    if _api_env_exists():
+        return False
+
+    if _project_has_local_configuration():
+        return False
+
+    if _completion_installed():
+        return False
+
+    return True
+
+
+def _run_setup_utility() -> None:
+    """Execute the interactive setup utility script."""
+    setup_script = Path(__file__).resolve().parent.parent / "utils" / "pdd-setup.py"
+    if not setup_script.exists():
+        raise FileNotFoundError(f"Setup utility not found at {setup_script}")
+
+    result = subprocess.run([sys.executable, str(setup_script)])
+    if result.returncode not in (0, None):
+        raise RuntimeError(f"Setup utility exited with status {result.returncode}")
+
+
 # --- Main CLI Group ---
-@click.group(chain=True, invoke_without_command=True, help="PDD (Prompt-Driven Development) Command Line Interface.")
+@click.group(invoke_without_command=True, help="PDD (Prompt-Driven Development) Command Line Interface.")
 @click.option(
     "--force",
     is_flag=True,
@@ -166,7 +255,6 @@ def cli(
 ):
     """
     Main entry point for the PDD CLI. Handles global options and initializes context.
-    Supports multi-command chaining.
     """
     # Ensure PDD_PATH is set before any commands run
     get_local_pdd_path()
@@ -189,6 +277,13 @@ def cli(
     if quiet:
         ctx.obj["verbose"] = False
 
+    # Warn users who have not completed interactive setup unless they are running it now
+    if _should_show_onboarding_reminder(ctx):
+        console.print(
+            "[warning]Complete onboarding with `pdd setup` to install tab completion and configure API keys.[/warning]"
+        )
+        ctx.obj["reminder_shown"] = True
+
     # If --list-contexts is provided, print and exit before any other actions
     if list_contexts:
         try:
@@ -227,17 +322,23 @@ def cli(
                     style="warning"
                 )
 
-# --- Result Callback for Chained Commands ---
+    # If no subcommands were provided, show help and exit gracefully
+    if ctx.invoked_subcommand is None and not ctx.protected_args:
+        if not quiet:
+            console.print("[info]Run `pdd --help` for usage or `pdd setup` to finish onboarding.[/info]")
+        click.echo(ctx.get_help())
+        ctx.exit(0)
+
+# --- Result Callback for Command Execution Summary ---
 @cli.result_callback()
 @click.pass_context
 def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float, str]]], **kwargs):
     """
-    Processes the results from chained commands.
-
+    Processes results returned by executed commands and prints a summary.
     Receives a list of tuples, typically (result, cost, model_name),
     or None from each command function.
     """
-    total_chain_cost = 0.0
+    total_cost = 0.0
     # Get Click's invoked subcommands attribute first
     invoked_subcommands = getattr(ctx, 'invoked_subcommands', [])
     # If Click didn't provide it (common in real runs), fall back to the list
@@ -251,11 +352,12 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
                     invoked_subcommands = ctx.obj.get('invoked_subcommands', []) or []
             except Exception:
                 invoked_subcommands = []
+    results = results or []
     num_commands = len(invoked_subcommands)
     num_results = len(results) # Number of results actually received
 
     if not ctx.obj.get("quiet"):
-        console.print("\n[info]--- Command Chain Execution Summary ---[/info]")
+        console.print("\n[info]--- Command Execution Summary ---[/info]")
 
     for i, result_tuple in enumerate(results):
         # Use the retrieved subcommand name (might be "Unknown Command X" in tests)
@@ -279,7 +381,7 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
         # Check if the result is the expected tuple structure from @track_cost or preprocess success
         elif isinstance(result_tuple, tuple) and len(result_tuple) == 3:
             _result_data, cost, model_name = result_tuple
-            total_chain_cost += cost
+            total_cost += cost
             if not ctx.obj.get("quiet"):
                 # Special handling for preprocess success message (check actual command name)
                 actual_command_name = invoked_subcommands[i] if i < num_commands else None # Get actual name if possible
@@ -298,17 +400,107 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
     if not ctx.obj.get("quiet"):
         # Only print total cost if at least one command potentially contributed cost
         if any(res is not None and isinstance(res, tuple) and len(res) == 3 for res in results):
-            console.print(f"[info]Total Estimated Cost for Chain:[/info] ${total_chain_cost:.6f}")
+            console.print(f"[info]Total Estimated Cost:[/info] ${total_cost:.6f}")
         # Indicate if the chain might have been incomplete due to errors
         if num_results < num_commands and not all(res is None for res in results): # Avoid printing if all failed
             console.print("[warning]Note: Chain may have terminated early due to errors.[/warning]")
         console.print("[info]-------------------------------------[/info]")
 
 
+# --- Templates Command Group ---
+@click.group(name="templates")
+def templates_group():
+    """Manage packaged and project templates."""
+    pass
+
+
+@templates_group.command("list")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.option("--filter", "filter_tag", type=str, default=None, help="Filter by tag")
+def templates_list(as_json: bool, filter_tag: Optional[str]):
+    try:
+        items = template_registry.list_templates(filter_tag)
+        if as_json:
+            import json as _json
+            click.echo(_json.dumps(items, indent=2))
+        else:
+            if not items:
+                console.print("[info]No templates found.[/info]")
+                return
+            console.print("[info]Available Templates:[/info]")
+            for it in items:
+                tags = ", ".join(it.get("tags", []))
+                console.print(f"- [bold]{it['name']}[/bold] ({it.get('version','')}) — {it.get('description','')} [dim]{tags}[/dim]")
+    except Exception as e:
+        handle_error(e, "templates list", False)
+
+
+@templates_group.command("show")
+@click.argument("name", type=str)
+def templates_show(name: str):
+    try:
+        data = template_registry.show_template(name)
+        summary = data.get("summary", {})
+        console.print(f"[bold]{summary.get('name','')}[/bold] — {summary.get('description','')}")
+        console.print(f"Version: {summary.get('version','')}  Tags: {', '.join(summary.get('tags',[]))}")
+        console.print(f"Language: {summary.get('language','')}  Output: {summary.get('output','')}")
+        console.print(f"Path: {summary.get('path','')}")
+        if data.get("variables"):
+            console.print("\n[info]Variables:[/info]")
+            for k, v in data["variables"].items():
+                console.print(f"- {k}: {v}")
+        if data.get("usage"):
+            console.print("\n[info]Usage:[/info]")
+            console.print(data["usage"])  # raw; CLI may format later
+        if data.get("discover"):
+            console.print("\n[info]Discover:[/info]")
+            console.print(data["discover"])  # raw dict
+        if data.get("output_schema"):
+            console.print("\n[info]Output Schema:[/info]")
+            try:
+                import json as _json
+                console.print(_json.dumps(data["output_schema"], indent=2))
+            except Exception:
+                console.print(str(data["output_schema"]))
+        if data.get("notes"):
+            console.print("\n[info]Notes:[/info]")
+            console.print(data["notes"])  # plain text
+    except Exception as e:
+        handle_error(e, "templates show", False)
+
+
+@templates_group.command("copy")
+@click.argument("name", type=str)
+@click.option("--to", "dest_dir", type=click.Path(file_okay=False), required=True)
+def templates_copy(name: str, dest_dir: str):
+    try:
+        dest = template_registry.copy_template(name, dest_dir)
+        console.print(f"[success]Copied to:[/success] {dest}")
+    except Exception as e:
+        handle_error(e, "templates copy", False)
+
+
+# Register the templates group with the main CLI.
+# Click disallows attaching a MultiCommand to a chained group via add_command,
+# so insert directly into the commands mapping after cli is defined.
+cli.commands["templates"] = templates_group
+
+
+# --- Custom Click Command Classes ---
+
+
+class GenerateCommand(click.Command):
+    """Ensure help shows PROMPT_FILE as required even when validated at runtime."""
+
+    def collect_usage_pieces(self, ctx: click.Context) -> List[str]:
+        pieces = super().collect_usage_pieces(ctx)
+        return ["PROMPT_FILE" if piece == "[PROMPT_FILE]" else piece for piece in pieces]
+
+
 # --- Command Definitions ---
 
-@cli.command("generate")
-@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
+@cli.command("generate", cls=GenerateCommand)
+@click.argument("prompt_file", required=False, type=click.Path(exists=True, dir_okay=False))
 @click.option(
     "--output",
     type=click.Path(writable=True),
@@ -336,18 +528,40 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
     multiple=True,
     help="Set template variable (KEY=VALUE) or read KEY from env",
 )
+@click.option(
+    "--template",
+    "template_name",
+    type=str,
+    default=None,
+    help="Use a packaged/project template by name (e.g., architecture/architecture_json)",
+)
 @click.pass_context
 @track_cost
 def generate(
     ctx: click.Context,
-    prompt_file: str,
+    prompt_file: Optional[str],
     output: Optional[str],
     original_prompt_file_path: Optional[str],
     incremental_flag: bool,
     env_kv: Tuple[str, ...],
+    template_name: Optional[str],
 ) -> Optional[Tuple[str, float, str]]:
     """Generate code from a prompt file."""
     try:
+        # Resolve template to a prompt path when requested
+        if template_name and prompt_file:
+            raise click.UsageError("Provide either --template or a PROMPT_FILE path, not both.")
+        if template_name:
+            try:
+                from . import template_registry as _tpl
+                meta = _tpl.load_template(template_name)
+                prompt_file = meta.get("path")
+                if not prompt_file:
+                    raise click.UsageError(f"Template '{template_name}' did not return a valid path")
+            except Exception as e:
+                raise click.UsageError(f"Failed to load template '{template_name}': {e}")
+        if not template_name and not prompt_file:
+            raise click.UsageError("Missing PROMPT_FILE. To use a template, pass --template NAME instead.")
         # Parse -e/--env arguments into a dict
         env_vars: Dict[str, str] = {}
         import os as _os
@@ -368,7 +582,7 @@ def generate(
                             console.print(f"[warning]-e {key} not found in environment; skipping[/warning]")
         generated_code, incremental, total_cost, model_name = code_generator_main(
             ctx=ctx,
-            prompt_file=prompt_file,
+            prompt_file=prompt_file,  # resolved template path or user path
             output=output,
             original_prompt_file_path=original_prompt_file_path,
             force_incremental_flag=incremental_flag,
@@ -1330,6 +1544,22 @@ def install_completion_cmd(ctx: click.Context) -> None: # Return type remains No
         # Do not return anything, as the callback expects None or a tuple
 
 
+@cli.command("setup")
+@click.pass_context
+def setup_cmd(ctx: click.Context) -> None:
+    """Run the interactive setup utility and install shell completion."""
+    command_name = "setup"
+    quiet_mode = ctx.obj.get("quiet", False)
+
+    try:
+        install_completion(quiet=quiet_mode)
+        _run_setup_utility()
+        if not quiet_mode:
+            console.print("[success]Setup completed. Restart your shell or source your RC file to apply changes.[/success]")
+    except Exception as exc:
+        handle_error(exc, command_name, quiet_mode)
+
+
 # --- Entry Point ---
 if __name__ == "__main__":
     cli()

pdd/code_generator_main.py

@@ -79,6 +79,27 @@ def _expand_vars(text: str, vars_map: Optional[Dict[str, str]]) -> str:
     return text
 
 
+def _parse_front_matter(text: str) -> Tuple[Optional[Dict[str, Any]], str]:
+    """Parse YAML front matter at the start of a prompt and return (meta, body)."""
+    try:
+        if not text.startswith("---\n"):
+            return None, text
+        end_idx = text.find("\n---", 4)
+        if end_idx == -1:
+            return None, text
+        fm_body = text[4:end_idx]
+        rest = text[end_idx + len("\n---"):]
+        if rest.startswith("\n"):
+            rest = rest[1:]
+        import yaml as _yaml
+        meta = _yaml.safe_load(fm_body) or {}
+        if not isinstance(meta, dict):
+            meta = {}
+        return meta, rest
+    except Exception:
+        return None, text
+
+
 def get_git_content_at_ref(file_path: str, git_ref: str = "HEAD") -> Optional[str]:
     """Gets the content of the file as it was at the specified git_ref."""
     abs_file_path = pathlib.Path(file_path).resolve()
@@ -187,6 +208,10 @@ def code_generator_main(
             context_override=ctx.obj.get('context')
         )
         prompt_content = input_strings["prompt_file"]
+        # Phase-2 templates: parse front matter metadata
+        fm_meta, body = _parse_front_matter(prompt_content)
+        if fm_meta:
+            prompt_content = body
         # Determine final output path: if user passed a directory, use resolved file path
         resolved_output = output_file_paths.get("output")
         if output is None:
@@ -212,10 +237,108 @@ def code_generator_main(
     existing_code_content: Optional[str] = None
     original_prompt_content_for_incremental: Optional[str] = None
 
+    # Merge -e vars with front-matter defaults; validate required
+    if env_vars is None:
+        env_vars = {}
+    if fm_meta and isinstance(fm_meta.get("variables"), dict):
+        for k, spec in (fm_meta["variables"].items()):
+            if isinstance(spec, dict):
+                if k not in env_vars and "default" in spec:
+                    env_vars[k] = str(spec["default"])
+            # if scalar default allowed, ignore for now
+        missing = [k for k, spec in fm_meta["variables"].items() if isinstance(spec, dict) and spec.get("required") and k not in env_vars]
+        if missing:
+            console.print(f"[error]Missing required variables: {', '.join(missing)}")
+            return "", False, 0.0, "error"
+
+    # Execute optional discovery from front matter to populate env_vars without overriding explicit -e values
+    def _run_discovery(discover_cfg: Dict[str, Any]) -> Dict[str, str]:
+        results: Dict[str, str] = {}
+        try:
+            if not discover_cfg:
+                return results
+            enabled = discover_cfg.get("enabled", False)
+            if not enabled:
+                return results
+            root = discover_cfg.get("root", ".")
+            patterns = discover_cfg.get("patterns", []) or []
+            exclude = discover_cfg.get("exclude", []) or []
+            max_per = int(discover_cfg.get("max_per_pattern", 0) or 0)
+            max_total = int(discover_cfg.get("max_total", 0) or 0)
+            root_path = pathlib.Path(root).resolve()
+            seen: List[str] = []
+            def _match_one(patterns_list: List[str]) -> List[str]:
+                matches: List[str] = []
+                for pat in patterns_list:
+                    globbed = list(root_path.rglob(pat))
+                    for p in globbed:
+                        if any(p.match(ex) for ex in exclude):
+                            continue
+                        sp = str(p.resolve())
+                        if sp not in matches:
+                            matches.append(sp)
+                    if max_per and len(matches) >= max_per:
+                        matches = matches[:max_per]
+                        break
+                return matches
+            # If a mapping 'set' is provided, compute per-variable results
+            set_map = discover_cfg.get("set") or {}
+            if isinstance(set_map, dict) and set_map:
+                for var_name, spec in set_map.items():
+                    if var_name in env_vars:
+                        continue  # don't override explicit -e
+                    v_patterns = spec.get("patterns", []) if isinstance(spec, dict) else []
+                    v_exclude = spec.get("exclude", []) if isinstance(spec, dict) else []
+                    save_exclude = exclude
+                    try:
+                        if v_exclude:
+                            exclude = v_exclude
+                        matches = _match_one(v_patterns or patterns)
+                    finally:
+                        exclude = save_exclude
+                    if matches:
+                        results[var_name] = ",".join(matches)
+                        seen.extend(matches)
+            # Fallback: populate SCAN_FILES and SCAN metadata
+            if not results:
+                files = _match_one(patterns)
+                if max_total and len(files) > max_total:
+                    files = files[:max_total]
+                if files:
+                    results["SCAN_FILES"] = ",".join(files)
+            # Always set root/patterns helpers
+            if root:
+                results.setdefault("SCAN_ROOT", str(root_path))
+            if patterns:
+                results.setdefault("SCAN_PATTERNS", ",".join(patterns))
+        except Exception as e:
+            if verbose and not quiet:
+                console.print(f"[yellow]Discovery skipped due to error: {e}[/yellow]")
+        return results
+
+    if fm_meta and isinstance(fm_meta.get("discover"), dict):
+        discovered = _run_discovery(fm_meta.get("discover") or {})
+        for k, v in discovered.items():
+            if k not in env_vars:
+                env_vars[k] = v
+
     # Expand variables in output path if provided
     if output_path:
         output_path = _expand_vars(output_path, env_vars)
 
+    # Honor front-matter output when CLI did not pass --output
+    if output is None and fm_meta and isinstance(fm_meta.get("output"), str):
+        try:
+            meta_out = _expand_vars(fm_meta["output"], env_vars)
+            if meta_out:
+                output_path = str(pathlib.Path(meta_out).resolve())
+        except Exception:
+            pass
+
+    # Honor front-matter language if provided (overrides detection for both local and cloud)
+    if fm_meta and isinstance(fm_meta.get("language"), str) and fm_meta.get("language"):
+        language = fm_meta.get("language")
+
     if output_path and pathlib.Path(output_path).exists():
         try:
             existing_code_content = pathlib.Path(output_path).read_text(encoding="utf-8")
@@ -462,9 +585,11 @@ def code_generator_main(
                 local_prompt = pdd_preprocess(prompt_content, recursive=True, double_curly_brackets=False, exclude_keys=[])
                 local_prompt = _expand_vars(local_prompt, env_vars)
                 local_prompt = pdd_preprocess(local_prompt, recursive=False, double_curly_brackets=True, exclude_keys=[])
+                # Language already resolved (front matter overrides detection if present)
+                gen_language = language
                 generated_code_content, total_cost, model_name = local_code_generator_func(
                     prompt=local_prompt,
-                    language=language,
+                    language=gen_language,
                     strength=strength,
                     temperature=temperature,
                     time=time_budget,
@@ -476,14 +601,37 @@ def code_generator_main(
                     console.print(Panel(f"Full generation successful. Model: {model_name}, Cost: ${total_cost:.6f}", title="[green]Local Success[/green]", expand=False))
         
         if generated_code_content is not None:
+            # Optional output_schema JSON validation before writing
+            try:
+                if fm_meta and isinstance(fm_meta.get("output_schema"), dict):
+                    is_json_output = False
+                    if isinstance(language, str) and str(language).lower().strip() == "json":
+                        is_json_output = True
+                    elif output_path and str(output_path).lower().endswith(".json"):
+                        is_json_output = True
+                    if is_json_output:
+                        parsed = json.loads(generated_code_content)
+                        try:
+                            import jsonschema  # type: ignore
+                            jsonschema.validate(instance=parsed, schema=fm_meta.get("output_schema"))
+                        except ModuleNotFoundError:
+                            if verbose and not quiet:
+                                console.print("[yellow]jsonschema not installed; skipping schema validation.[/yellow]")
+                        except Exception as ve:
+                            raise click.UsageError(f"Generated JSON does not match output_schema: {ve}")
+            except json.JSONDecodeError as jde:
+                raise click.UsageError(f"Generated output is not valid JSON: {jde}")
+
             if output_path:
                 p_output = pathlib.Path(output_path)
                 p_output.parent.mkdir(parents=True, exist_ok=True)
                 p_output.write_text(generated_code_content, encoding="utf-8")
                 if verbose or not quiet:
                     console.print(f"Generated code saved to: [green]{p_output.resolve()}[/green]")
-            elif not quiet: # No output path, print to console if not quiet
-                console.print(Panel(Text(generated_code_content, overflow="fold"), title="[cyan]Generated Code[/cyan]", expand=True))
+            elif not quiet:
+                # No destination resolved; surface the generated code directly to the console.
+                console.print(Panel(Text(generated_code_content, overflow="fold"), title="[cyan]Generated Code[/cyan]", expand=False))
+                console.print("[yellow]No output path resolved; skipping file write and stdout print.[/yellow]")
         else:
             console.print("[red]Error: Code generation failed. No code was produced.[/red]")
             return "", was_incremental_operation, total_cost, model_name or "error"

pdd/construct_paths.py

@@ -210,7 +210,9 @@ def _is_known_language(language_name: str) -> bool:
     builtin_languages = {
         'python', 'javascript', 'typescript', 'java', 'cpp', 'c', 'go', 'ruby', 'rust',
         'kotlin', 'swift', 'csharp', 'php', 'scala', 'r', 'lua', 'perl', 'bash', 'shell',
-        'powershell', 'sql', 'prompt', 'html', 'css', 'makefile'
+        'powershell', 'sql', 'prompt', 'html', 'css', 'makefile',
+        # Common data and config formats for architecture prompts and configs
+        'json', 'jsonl', 'yaml', 'yml', 'toml', 'ini'
     }
 
     pdd_path_str = os.getenv('PDD_PATH')
@@ -636,7 +638,9 @@ def construct_paths(
             'kotlin': '.kt', 'swift': '.swift', 'csharp': '.cs', 'php': '.php',
             'scala': '.scala', 'r': '.r', 'lua': '.lua', 'perl': '.pl', 'bash': '.sh',
             'shell': '.sh', 'powershell': '.ps1', 'sql': '.sql', 'html': '.html', 'css': '.css',
-            'prompt': '.prompt', 'makefile': ''
+            'prompt': '.prompt', 'makefile': '',
+            # Common data/config formats
+            'json': '.json', 'jsonl': '.jsonl', 'yaml': '.yaml', 'yml': '.yml', 'toml': '.toml', 'ini': '.ini'
         }
         file_extension = builtin_ext_map.get(language.lower(), f".{language.lower()}" if language else '')
 

pdd/data/language_format.csv

@@ -30,6 +30,7 @@ Groovy,//,.groovy
 Dart,//,.dart
 F#,//,.fs
 YAML,#,.yml
+YAML,#,.yaml
 JSON,del,.json
 JSONL,del,.jsonl
 XML,"<!-- -->",.xml
@@ -62,3 +63,4 @@ TOML,#,.toml
 Log,del,.log
 reStructuredText,del,.rst
 Text,del,.txt
+INI,;,.ini