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

pdd/commands/generate.py

@@ -0,0 +1,257 @@
+"""
+Generate, test, and example commands.
+"""
+import click
+from typing import Dict, Optional, Tuple, List
+
+from ..code_generator_main import code_generator_main
+from ..context_generator_main import context_generator_main
+from ..cmd_test_main import cmd_test_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error, console
+
+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]
+
+
+@click.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),
+    default=None,
+    help="Specify where to save the generated code (file or directory).",
+)
+@click.option(
+    "--original-prompt",
+    "original_prompt_file_path",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to the original prompt file for incremental generation.",
+)
+@click.option(
+    "--incremental",
+    "incremental_flag",
+    is_flag=True,
+    default=False,
+    help="Force incremental patching even if changes are significant (requires existing output).",
+)
+@click.option(
+    "-e",
+    "--env",
+    "env_kv",
+    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.option(
+    "--unit-test",
+    "unit_test_file",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to a unit test file to include in the prompt.",
+)
+@click.option(
+    "--exclude-tests",
+    "exclude_tests",
+    is_flag=True,
+    default=False,
+    help="Do not automatically include test files found in the default tests directory.",
+)
+@click.pass_context
+@track_cost
+def generate(
+    ctx: click.Context,
+    prompt_file: Optional[str],
+    output: Optional[str],
+    original_prompt_file_path: Optional[str],
+    incremental_flag: bool,
+    env_kv: Tuple[str, ...],
+    template_name: Optional[str],
+    unit_test_file: Optional[str],
+    exclude_tests: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """
+    Generate code from a prompt file.
+
+       \b
+    Related commands:
+      test      Generate unit tests for a prompt.
+      example   Generate example code for a prompt.
+
+    \b
+    Note:
+      Global options (for example ``--force``, ``--temperature``, ``--time``)
+      can be placed either before or after the subcommand. For example:
+
+        pdd generate my.prompt --force --temperature 0.5
+    """
+    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
+        for item in env_kv or ():
+            if "=" in item:
+                key, value = item.split("=", 1)
+                key = key.strip()
+                if key:
+                    env_vars[key] = value
+            else:
+                key = item.strip()
+                if key:
+                    val = _os.environ.get(key)
+                    if val is not None:
+                        env_vars[key] = val
+                    else:
+                        if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                            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,  # resolved template path or user path
+            output=output,
+            original_prompt_file_path=original_prompt_file_path,
+            force_incremental_flag=incremental_flag,
+            env_vars=env_vars or None,
+            unit_test_file=unit_test_file,
+            exclude_tests=exclude_tests,
+        )
+        return generated_code, total_cost, model_name
+    except click.Abort:
+        # Let user cancellation (e.g., pressing 'no' on overwrite prompt) propagate
+        # to PDDCLI.invoke() for graceful handling (fix for issue #186)
+        raise
+    except Exception as exception:
+        handle_error(exception, "generate", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("example")
+@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.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the generated example code (file or directory).",
+)
+@click.pass_context
+@track_cost
+def example(
+    ctx: click.Context, 
+    prompt_file: str, 
+    code_file: str, 
+    output: Optional[str]
+) -> Optional[Tuple[str, float, str]]:
+    """Generate example code for a given prompt and implementation."""
+    try:
+        example_code, total_cost, model_name = context_generator_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            code_file=code_file,
+            output=output,
+        )
+        return example_code, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "example", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("test")
+@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.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the generated test file (file or directory).",
+)
+@click.option(
+    "--language", 
+    type=str, 
+    default=None, 
+    help="Specify the programming language."
+)
+@click.option(
+    "--coverage-report",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to the coverage report file for existing tests.",
+)
+@click.option(
+    "--existing-tests",
+    type=click.Path(exists=True, dir_okay=False),
+    multiple=True,
+    help="Path to existing unit test file(s). Can be specified multiple times.",
+)
+@click.option(
+    "--target-coverage",
+    type=click.FloatRange(0.0, 100.0),
+    default=None,  # Use None, default handled in cmd_test_main or env var
+    help="Desired code coverage percentage (default: 10.0 or PDD_TEST_COVERAGE_TARGET).",
+)
+@click.option(
+    "--merge",
+    is_flag=True,
+    default=False,
+    help="Merge new tests with existing test file instead of creating a separate file.",
+)
+@click.pass_context
+@track_cost
+def test(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    output: Optional[str],
+    language: Optional[str],
+    coverage_report: Optional[str],
+    existing_tests: Tuple[str, ...],
+    target_coverage: Optional[float],
+    merge: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """Generate unit tests for a given prompt and implementation."""
+    try:
+        # Convert empty tuple to None for cmd_test_main compatibility
+        existing_tests_list = list(existing_tests) if existing_tests else None
+        test_code, total_cost, model_name = cmd_test_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            code_file=code_file,
+            output=output,
+            language=language,
+            coverage_report=coverage_report,
+            existing_tests=existing_tests_list,
+            target_coverage=target_coverage,
+            merge=merge,
+        )
+        return test_code, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "test", ctx.obj.get("quiet", False))
+        return None

pdd/commands/maintenance.py

@@ -0,0 +1,175 @@
+"""
+Maintenance commands (sync, auto_deps, setup).
+"""
+import click
+from typing import Optional, Tuple
+from pathlib import Path
+
+from ..sync_main import sync_main
+from ..auto_deps_main import auto_deps_main
+from ..track_cost import track_cost
+from ..core.errors import handle_error
+from ..core.utils import _run_setup_utility
+
+@click.command("sync")
+@click.argument("basename", required=True)
+@click.option(
+    "--max-attempts",
+    type=int,
+    default=None,
+    help="Maximum number of fix attempts. Default: 3 or .pddrc value.",
+)
+@click.option(
+    "--budget",
+    type=float,
+    default=None,
+    help="Maximum total cost for the sync process. Default: 20.0 or .pddrc value.",
+)
+@click.option(
+    "--skip-verify",
+    is_flag=True,
+    default=False,
+    help="Skip the functional verification step.",
+)
+@click.option(
+    "--skip-tests",
+    is_flag=True,
+    default=False,
+    help="Skip unit test generation and fixing.",
+)
+@click.option(
+    "--target-coverage",
+    type=float,
+    default=None,
+    help="Desired code coverage percentage. Default: 90.0 or .pddrc value.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Analyze sync state without executing operations. Shows what sync would do.",
+)
+@click.option(
+    "--log",
+    is_flag=True,
+    default=False,
+    hidden=True,
+    help="Deprecated: Use --dry-run instead.",
+)
+@click.pass_context
+@track_cost
+def sync(
+    ctx: click.Context,
+    basename: str,
+    max_attempts: Optional[int],
+    budget: Optional[float],
+    skip_verify: bool,
+    skip_tests: bool,
+    target_coverage: Optional[float],
+    dry_run: bool,
+    log: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """
+    Synchronize prompts with code and tests.
+
+    BASENAME is the base name of the prompt file (e.g., 'my_module' for 'prompts/my_module_python.prompt').
+    """
+    # Handle deprecated --log flag
+    if log:
+        click.echo(
+            click.style(
+                "Warning: --log is deprecated, use --dry-run instead.",
+                fg="yellow"
+            ),
+            err=True
+        )
+        dry_run = True
+
+    try:
+        result, total_cost, model_name = sync_main(
+            ctx=ctx,
+            basename=basename,
+            max_attempts=max_attempts,
+            budget=budget,
+            skip_verify=skip_verify,
+            skip_tests=skip_tests,
+            target_coverage=target_coverage,
+            dry_run=dry_run,
+        )
+        return str(result), total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "sync", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("auto-deps")
+@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
+# exists=False to allow manual handling of quoted paths or paths with globs that shell didn't expand
+@click.argument("directory_path", type=click.Path(exists=False, file_okay=False))
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the modified prompt (file or directory).",
+)
+@click.option(
+    "--csv",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify the CSV file that contains or will contain dependency information.",
+)
+@click.option(
+    "--force-scan",
+    is_flag=True,
+    default=False,
+    help="Force rescanning of all potential dependency files even if they exist in the CSV file.",
+)
+@click.pass_context
+@track_cost
+def auto_deps(
+    ctx: click.Context,
+    prompt_file: str,
+    directory_path: str,
+    output: Optional[str],
+    csv: Optional[str],
+    force_scan: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """Analyze project dependencies and update the prompt file."""
+    try:
+        # Strip quotes from directory_path if present (e.g. passed incorrectly)
+        if directory_path:
+            directory_path = directory_path.strip('"').strip("'")
+
+        # auto_deps_main signature: (ctx, prompt_file, directory_path, auto_deps_csv_path, output, force_scan)
+        result, total_cost, model_name = auto_deps_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            directory_path=directory_path,
+            auto_deps_csv_path=csv,
+            output=output,
+            force_scan=force_scan
+        )
+        return result, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "auto-deps", ctx.obj.get("quiet", False))
+        return None
+
+
+@click.command("setup")
+@click.pass_context
+def setup(ctx: click.Context):
+    """Run the interactive setup utility."""
+    try:
+        # Import here to allow proper mocking
+        from .. import cli as cli_module
+        quiet = ctx.obj.get("quiet", False) if ctx.obj else False
+        # First install completion
+        cli_module.install_completion(quiet=quiet)
+        # Then run setup utility
+        _run_setup_utility()
+    except Exception as e:
+        handle_error(e, "setup", False)

pdd/commands/misc.py

@@ -0,0 +1,87 @@
+"""
+Miscellaneous commands (preprocess).
+"""
+import click
+from typing import Optional, Tuple
+
+from ..preprocess_main import preprocess_main
+from ..core.errors import handle_error
+
+@click.command("preprocess")
+@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output",
+    type=click.Path(writable=True),
+    default=None,
+    help="Specify where to save the preprocessed prompt file (file or directory).",
+)
+@click.option(
+    "--xml",
+    is_flag=True,
+    default=False,
+    help="Insert XML delimiters for structure (minimal preprocessing).",
+)
+@click.option(
+    "--recursive",
+    is_flag=True,
+    default=False,
+    help="Recursively preprocess includes.",
+)
+@click.option(
+    "--double",
+    is_flag=True,
+    default=False,
+    help="Double curly brackets.",
+)
+@click.option(
+    "--exclude",
+    multiple=True,
+    default=None,
+    help="List of keys to exclude from curly bracket doubling.",
+)
+@click.option(
+    "--pdd-tags",
+    is_flag=True,
+    default=False,
+    help="Inject PDD metadata tags (<pdd-reason>, <pdd-interface>, <pdd-dependency>) from architecture.json.",
+)
+@click.pass_context
+# No @track_cost as preprocessing is local, but return dummy tuple for callback
+def preprocess(
+    ctx: click.Context,
+    prompt_file: str,
+    output: Optional[str],
+    xml: bool,
+    recursive: bool,
+    double: bool,
+    exclude: Optional[Tuple[str, ...]],
+    pdd_tags: bool,
+) -> Optional[Tuple[str, float, str]]:
+    """Preprocess a prompt file to prepare it for LLM use."""
+    try:
+        # Since preprocess is a local operation, we don't track cost
+        # But we need to return a tuple in the expected format for result callback
+        result = preprocess_main(
+            ctx=ctx,
+            prompt_file=prompt_file,
+            output=output,
+            xml=xml,
+            recursive=recursive,
+            double=double,
+            exclude=list(exclude) if exclude else [],
+            pdd_tags=pdd_tags,
+        )
+        
+        # Handle the result from preprocess_main
+        if result is None:
+            # If preprocess_main returns None, still return a dummy tuple for the callback
+            return "", 0.0, "local"
+        else:
+            # Unpack the return value from preprocess_main
+            processed_prompt, total_cost, model_name = result
+            return processed_prompt, total_cost, model_name
+    except click.Abort:
+        raise
+    except Exception as exception:
+        handle_error(exception, "preprocess", ctx.obj.get("quiet", False))
+        return None