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

pdd/commands/templates.py

@@ -0,0 +1,215 @@
+"""
+Templates command group.
+"""
+import click
+from rich import box
+from rich.table import Table
+from rich.text import Text
+from rich.markup import escape
+from typing import Optional, List, Tuple, Any
+
+from .. import template_registry
+from ..core.errors import handle_error, console
+
+@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:
+                # Print the template name on its own line to avoid Rich wrapping
+                name_line = Text(f"- {it['name']}", style="bold", no_wrap=True)
+                console.print(name_line)
+                # Print details on the next line(s) with a small indent; wrapping is fine here
+                version = it.get("version", "")
+                description = it.get("description", "")
+                tags = ", ".join(it.get("tags", []))
+                details_parts = []
+                if version:
+                    details_parts.append(f"({version})")
+                if description:
+                    details_parts.append(description)
+                if tags:
+                    details_parts.append(f"[{tags}]")
+                if details_parts:
+                    console.print("  " + " — ".join(details_parts))
+    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", {})
+
+        def _render_key_value_table(title: Optional[str], items: List[Tuple[str, Any]], *, highlight_path: bool = False):
+            """Render a 2-column Rich table for key/value pairs."""
+
+            table = Table(show_header=False, box=box.SIMPLE, expand=True)
+            table.add_column("Field", style="info", no_wrap=True)
+            table.add_column("Value", overflow="fold")
+
+            added_rows = False
+            for label, value in items:
+                if value in (None, "", [], {}):
+                    continue
+                if isinstance(value, (list, tuple)):
+                    value_str = ", ".join(str(v) for v in value)
+                else:
+                    value_str = str(value)
+
+                if highlight_path and label.lower() == "path":
+                    value_markup = f"[path]{escape(value_str)}[/path]"
+                else:
+                    value_markup = escape(value_str)
+
+                table.add_row(label, value_markup)
+                added_rows = True
+
+            if added_rows:
+                if title:
+                    console.print(f"[info]{title}[/info]")
+                console.print(table)
+
+        summary_items = [
+            ("Name", summary.get("name")),
+            ("Description", summary.get("description")),
+            ("Version", summary.get("version")),
+            ("Tags", summary.get("tags", [])),
+            ("Language", summary.get("language")),
+            ("Output", summary.get("output")),
+            ("Path", summary.get("path")),
+        ]
+        _render_key_value_table("Template Summary:", summary_items, highlight_path=True)
+
+        if data.get("variables"):
+            console.print("\n[info]Variables:[/info]")
+            variables_table = Table(box=box.SIMPLE_HEAD, show_lines=False, expand=True)
+            variables_table.add_column("Name", style="bold", no_wrap=True)
+            variables_table.add_column("Required", style="info", no_wrap=True)
+            variables_table.add_column("Type", no_wrap=True)
+            variables_table.add_column("Description", overflow="fold")
+            variables_table.add_column("Default/Examples", overflow="fold")
+
+            for var_name, var_meta in data["variables"].items():
+                required = var_meta.get("required")
+                if required is True:
+                    required_str = "Yes"
+                elif required is False:
+                    required_str = "No"
+                else:
+                    required_str = "-"
+
+                var_type = escape(str(var_meta.get("type", "-")))
+                description = escape(str(var_meta.get("description", "")))
+
+                default_parts: List[str] = []
+                default_value = var_meta.get("default")
+                if default_value not in (None, ""):
+                    default_parts.append(f"default: {default_value}")
+
+                examples_value = var_meta.get("examples")
+                if examples_value:
+                    if isinstance(examples_value, (list, tuple)):
+                        examples_str = ", ".join(str(example) for example in examples_value)
+                    else:
+                        examples_str = str(examples_value)
+                    default_parts.append(f"examples: {examples_str}")
+
+                example_paths_value = var_meta.get("example_paths")
+                if example_paths_value:
+                    if isinstance(example_paths_value, (list, tuple)):
+                        example_paths_str = ", ".join(str(example) for example in example_paths_value)
+                    else:
+                        example_paths_str = str(example_paths_value)
+                    default_parts.append(f"paths: {example_paths_str}")
+
+                default_examples = "\n".join(default_parts) if default_parts else "-"
+
+                variables_table.add_row(
+                    escape(str(var_name)),
+                    required_str,
+                    var_type,
+                    description,
+                    escape(default_examples),
+                )
+
+            console.print(variables_table)
+
+        if data.get("usage"):
+            console.print("\n[info]Usage:[/info]")
+            usage = data["usage"]
+            if isinstance(usage, dict):
+                for group_name, entries in usage.items():
+                    console.print(f"[bold]{escape(str(group_name))}[/bold]")
+                    usage_table = Table(box=box.SIMPLE, show_lines=False, expand=True)
+                    usage_table.add_column("Name", style="bold", no_wrap=True)
+                    usage_table.add_column("Command", overflow="fold")
+
+                    if isinstance(entries, (list, tuple)):
+                        iterable_entries = entries
+                    else:
+                        iterable_entries = [entries]
+
+                    for entry in iterable_entries:
+                        if isinstance(entry, dict):
+                            name_value = escape(str(entry.get("name", "")))
+                            command_value = escape(str(entry.get("command", "")))
+                        else:
+                            name_value = "-"
+                            command_value = escape(str(entry))
+                        usage_table.add_row(name_value, f"[command]{command_value}[/command]")
+
+                    if usage_table.row_count:
+                        console.print(usage_table)
+            else:
+                console.print(usage)
+
+        if data.get("discover"):
+            console.print("\n[info]Discover:[/info]")
+            discover = data["discover"]
+            if isinstance(discover, dict):
+                discover_items = [(str(key), value) for key, value in discover.items()]
+                _render_key_value_table(None, discover_items)
+            else:
+                console.print(discover)
+        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)

pdd/commands/utility.py

@@ -0,0 +1,110 @@
+"""
+Utility commands (install_completion, verify/fix-verification).
+"""
+import click
+from typing import Optional, Tuple
+
+from ..fix_verification_main import fix_verification_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+
+@click.command("install_completion")
+@click.pass_context
+def install_completion_cmd(ctx: click.Context):
+    """Install shell completion for the PDD CLI."""
+    try:
+        from .. import cli as cli_module  # Import parent module for proper patching
+        quiet = ctx.obj.get("quiet", False)
+        # Call through cli_module so patches to pdd.cli.install_completion work
+        cli_module.install_completion(quiet=quiet)
+    except Exception as e:
+        handle_error(e, "install_completion", ctx.obj.get("quiet", False))
+
+
+@click.command("verify")
+@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("code_file", type=click.Path(exists=True, dir_okay=False))
+@click.argument("verification_program", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output-code",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the verified code file (file or directory).",
+)
+@click.option(
+    "--output-program",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the verified program file (file or directory).",
+)
+@click.option(
+    "--output-results",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the results log (file or directory).",
+)
+@click.option(
+    "--max-attempts",
+    type=int,
+    default=3,
+    show_default=True,
+    help="Maximum number of verification attempts.",
+)
+@click.option(
+    "--budget",
+    type=float,
+    default=5.0,
+    show_default=True,
+    help="Maximum cost allowed for the verification process.",
+)
+@click.option(
+    "--agentic-fallback/--no-agentic-fallback",
+    is_flag=True,
+    default=True,
+    help="Enable agentic fallback if the primary fix mechanism fails.",
+)
+@click.pass_context
+@track_cost
+def verify(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    verification_program: str,
+    output_code: Optional[str],
+    output_program: Optional[str],
+    output_results: Optional[str],
+    max_attempts: int,
+    budget: float,
+    agentic_fallback: bool,
+) -> Optional[Tuple]:
+    """Verify code using a verification program."""
+    try:
+        # verify command implies a loop if max_attempts > 1, but let's enable loop by default
+        # as it's the more powerful mode and matches the CLI args provided (max_attempts).
+        # verification_program positional arg acts as both program_file (to run) and verification_program (reference)
+        success, prog_code,  code_content, attempts, total_cost, model_name = fix_verification_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            code_file=code_file,
+            program_file=verification_program,
+            output_code=output_code,
+            output_program=output_program,
+            output_results=output_results,
+            loop=True,
+            verification_program=verification_program,
+            max_attempts=max_attempts,
+            budget=budget,
+            agentic_fallback=agentic_fallback,
+        )
+        result = {
+            "success": success,
+            "program_code": prog_code,
+            "code_content": code_content,
+            "attempts": attempts,
+        }
+        return result, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "verify", ctx.obj.get("quiet", False))
+        return None

pdd/config_resolution.py

@@ -0,0 +1,58 @@
+"""
+Centralized config resolution for all commands.
+
+Single source of truth for resolving strength, temperature, and other config values.
+This module ensures consistent priority ordering across all commands:
+    1. CLI global options (--strength, --temperature) - highest priority
+    2. pddrc context defaults - medium priority
+    3. Hardcoded defaults - lowest priority
+"""
+from typing import Dict, Any, Optional
+import click
+
+from . import DEFAULT_STRENGTH, DEFAULT_TEMPERATURE, DEFAULT_TIME
+
+
+def resolve_effective_config(
+    ctx: click.Context,
+    resolved_config: Dict[str, Any],
+    param_overrides: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Resolve effective config values with proper priority.
+
+    Priority (highest to lowest):
+        1. Command parameter overrides (e.g., strength kwarg)
+        2. CLI global options (--strength stored in ctx.obj)
+        3. pddrc context defaults (from resolved_config)
+        4. Hardcoded defaults
+
+    Args:
+        ctx: Click context with CLI options in ctx.obj
+        resolved_config: Config returned by construct_paths (contains pddrc values)
+        param_overrides: Optional command-specific parameter overrides
+
+    Returns:
+        Dict with resolved values for strength, temperature, time
+    """
+    ctx_obj = ctx.obj if ctx.obj else {}
+    param_overrides = param_overrides or {}
+
+    def resolve_value(key: str, default: Any) -> Any:
+        # Priority 1: Command parameter override
+        if key in param_overrides and param_overrides[key] is not None:
+            return param_overrides[key]
+        # Priority 2: CLI global option (only if key IS in ctx.obj - meaning CLI passed it)
+        if key in ctx_obj:
+            return ctx_obj[key]
+        # Priority 3: pddrc context default
+        if key in resolved_config and resolved_config[key] is not None:
+            return resolved_config[key]
+        # Priority 4: Hardcoded default
+        return default
+
+    return {
+        "strength": resolve_value("strength", DEFAULT_STRENGTH),
+        "temperature": resolve_value("temperature", DEFAULT_TEMPERATURE),
+        "time": resolve_value("time", DEFAULT_TIME),
+    }

pdd/conflicts_main.py

@@ -8,7 +8,7 @@ from .construct_paths import construct_paths
 from .conflicts_in_prompts import conflicts_in_prompts
 from . import DEFAULT_TIME, DEFAULT_STRENGTH
 
-def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optional[str], verbose: bool = False) -> Tuple[List[Dict], float, str]:
+def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optional[str], verbose: bool = False, language: Optional[str] = None) -> Tuple[List[Dict], float, str]:
     """
     Main function to analyze conflicts between two prompts.
 
@@ -17,6 +17,7 @@ def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optio
     :param prompt2: Path to the second prompt file.
     :param output: Optional path to save the output CSV file.
     :param verbose: Optional parameter to control verbosity (default: False).
+    :param language: Optional language hint for file processing.
     :return: A tuple containing the list of conflicts, total cost, and model name used.
     """
     try:
@@ -28,12 +29,16 @@ def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optio
         command_options = {
             "output": output
         }
+        if language:
+            command_options["language"] = language
+
         resolved_config, input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="conflicts",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
 
         # Load input files
@@ -91,4 +96,4 @@ def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optio
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        sys.exit(1)