pdd-cli 0.0.2__py3-none-any.whl

pdd/auto_deps_main.py

@@ -0,0 +1,98 @@
+import sys
+from pathlib import Path
+from typing import Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .insert_includes import insert_includes
+
+def auto_deps_main(
+    ctx: click.Context,
+    prompt_file: str,
+    directory_path: str,
+    auto_deps_csv_path: Optional[str],
+    output: Optional[str],
+    force_scan: Optional[bool]
+) -> Tuple[str, float, str]:
+    """
+    Main function to analyze and insert dependencies into a prompt file.
+
+    Args:
+        ctx: Click context containing command-line parameters.
+        prompt_file: Path to the input prompt file.
+        directory_path: Path to directory containing potential dependency files.
+        auto_deps_csv_path: Path to CSV file containing auto-dependency information.
+        output: Optional path to save the modified prompt file.
+        force_scan: Flag to force rescan of directory by deleting CSV file.
+
+    Returns:
+        Tuple containing:
+        - str: Modified prompt with auto-dependencies added
+        - float: Total cost of the operation
+        - str: Name of the model used
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "prompt_file": prompt_file
+        }
+        command_options = {
+            "output": output,
+            "csv": auto_deps_csv_path
+        }
+
+        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="auto-deps",
+            command_options=command_options
+        )
+
+        # Get the CSV file path
+        csv_path = output_file_paths.get("csv", "project_dependencies.csv")
+
+        # Handle force_scan option
+        if force_scan and Path(csv_path).exists():
+            if not ctx.obj.get('quiet', False):
+                rprint(f"[yellow]Removing existing CSV file due to --force-scan option: {csv_path}[/yellow]")
+            Path(csv_path).unlink()
+
+        # Get strength and temperature from context
+        strength = ctx.obj.get('strength', 0.9)
+        temperature = ctx.obj.get('temperature', 0)
+
+        # Call insert_includes with the prompt content and directory path
+        modified_prompt, csv_output, total_cost, model_name = insert_includes(
+            input_prompt=input_strings["prompt_file"],
+            directory_path=directory_path,
+            csv_filename=csv_path,
+            strength=strength,
+            temperature=temperature,
+            verbose=not ctx.obj.get('quiet', False)
+        )
+
+        # Save the modified prompt to the output file
+        output_path = output_file_paths["output"]
+        Path(output_path).write_text(modified_prompt)
+
+        # Save the CSV output if it was generated
+        if csv_output:
+            Path(csv_path).write_text(csv_output)
+
+        # Provide user feedback
+        if not ctx.obj.get('quiet', False):
+            rprint("[bold green]Successfully analyzed and inserted dependencies![/bold green]")
+            rprint(f"[bold]Model used:[/bold] {model_name}")
+            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+            rprint(f"[bold]Modified prompt saved to:[/bold] {output_path}")
+            rprint(f"[bold]Dependency information saved to:[/bold] {csv_path}")
+
+        return modified_prompt, total_cost, model_name
+
+    except Exception as e:
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+        sys.exit(1)
+        # Removed the "raise" line so that we only exit, satisfying the test.

pdd/auto_include.py

@@ -0,0 +1,175 @@
+from typing import Tuple, Optional
+from pydantic import BaseModel, Field
+from rich import print
+from rich.console import Console
+from rich.panel import Panel
+from .load_prompt_template import load_prompt_template
+from .llm_invoke import llm_invoke
+from .summarize_directory import summarize_directory
+import pandas as pd
+from io import StringIO
+
+console = Console()
+
+class AutoIncludeOutput(BaseModel):
+    string_of_includes: str = Field(description="The string of includes to be added to the prompt")
+
+def auto_include(
+    input_prompt: str,
+    directory_path: str,
+    csv_file: Optional[str] = None,
+    strength: float = 0.7,
+    temperature: float = 0.0,
+    verbose: bool = False
+) -> Tuple[str, str, float, str]:
+    """
+    Automatically find and insert proper dependencies into the prompt.
+
+    Args:
+        input_prompt (str): The prompt requiring includes
+        directory_path (str): Directory path of dependencies
+        csv_file (Optional[str]): Contents of existing CSV file
+        strength (float): Strength of LLM model (0-1)
+        temperature (float): Temperature of LLM model (0-1)
+        verbose (bool): Whether to print detailed information
+
+    Returns:
+        Tuple[str, str, float, str]: (dependencies, csv_output, total_cost, model_name)
+    """
+    try:
+        # Input validation
+        if not input_prompt:
+            raise ValueError("Input prompt cannot be empty")
+        if not directory_path:
+            raise ValueError("Invalid 'directory_path'.")
+        if not 0 <= strength <= 1:
+            raise ValueError("Strength must be between 0 and 1")
+        if not 0 <= temperature <= 1:
+            raise ValueError("Temperature must be between 0 and 1")
+
+        total_cost = 0.0
+        model_name = ""
+
+        if verbose:
+            console.print(Panel("Step 1: Loading prompt templates", style="blue"))
+
+        # Load prompt templates
+        auto_include_prompt = load_prompt_template("auto_include_LLM")
+        extract_prompt = load_prompt_template("extract_auto_include_LLM")
+
+        if not auto_include_prompt or not extract_prompt:
+            raise ValueError("Failed to load prompt templates")
+
+        if verbose:
+            console.print(Panel("Step 2: Running summarize_directory", style="blue"))
+
+        # Run summarize_directory
+        csv_output, summary_cost, summary_model = summarize_directory(
+            directory_path=directory_path,
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose,
+            csv_file=csv_file
+        )
+        total_cost += summary_cost
+        model_name = summary_model
+
+        # Parse CSV to get available includes
+        if not csv_output:
+            available_includes = []
+        else:
+            try:
+                df = pd.read_csv(StringIO(csv_output))
+                available_includes = df.apply(
+                    lambda row: f"File: {row['full_path']}\nSummary: {row['file_summary']}",
+                    axis=1
+                ).tolist()
+            except Exception as e:
+                console.print(f"[red]Error parsing CSV: {str(e)}[/red]")
+                available_includes = []
+
+        if verbose:
+            console.print(Panel("Step 3: Running auto_include_LLM prompt", style="blue"))
+
+        # Run auto_include_LLM prompt
+        auto_include_response = llm_invoke(
+            prompt=auto_include_prompt,
+            input_json={
+                "input_prompt": input_prompt,
+                "available_includes": "\n".join(available_includes)
+            },
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+        total_cost += auto_include_response["cost"]
+        model_name = auto_include_response["model_name"]
+
+        if verbose:
+            console.print(Panel("Step 4: Running extract_auto_include_LLM prompt", style="blue"))
+
+        # Run extract_auto_include_LLM prompt
+        try:
+            extract_response = llm_invoke(
+                prompt=extract_prompt,
+                input_json={"llm_output": auto_include_response["result"]},
+                strength=strength,
+                temperature=temperature,
+                verbose=verbose,
+                output_pydantic=AutoIncludeOutput
+            )
+            total_cost += extract_response["cost"]
+            model_name = extract_response["model_name"]
+
+            if verbose:
+                console.print(Panel("Step 5: Extracting dependencies", style="blue"))
+
+            # Extract dependencies
+            dependencies = extract_response["result"].string_of_includes
+        except Exception as e:
+            console.print(f"[red]Error extracting dependencies: {str(e)}[/red]")
+            dependencies = ""
+
+        if verbose:
+            console.print(Panel(f"""
+Results:
+Dependencies: {dependencies}
+CSV Output: {csv_output}
+Total Cost: ${total_cost:.6f}
+Model Used: {model_name}
+            """, style="green"))
+
+        return dependencies, csv_output, total_cost, model_name
+
+    except Exception as e:
+        console.print(f"[red]Error in auto_include: {str(e)}[/red]")
+        raise
+
+def main():
+    """Example usage of auto_include function"""
+    try:
+        # Example inputs
+        input_prompt = "Write a function to process image data"
+        directory_path = "context/c*.py"
+        csv_file = """full_path,file_summary,date
+context/image_utils.py,"Image processing utilities",2023-01-01T10:00:00"""
+
+        dependencies, csv_output, total_cost, model_name = auto_include(
+            input_prompt=input_prompt,
+            directory_path=directory_path,
+            csv_file=csv_file,
+            strength=0.7,
+            temperature=0.0,
+            verbose=True
+        )
+
+        console.print("\n[blue]Final Results:[/blue]")
+        console.print(f"Dependencies: {dependencies}")
+        console.print(f"Total Cost: ${total_cost:.6f}")
+        console.print(f"Model Used: {model_name}")
+
+    except Exception as e:
+        console.print(f"[red]Error in main: {str(e)}[/red]")
+
+if __name__ == "__main__":
+    main()

pdd/auto_update.py

@@ -0,0 +1,73 @@
+import pkg_resources
+import requests
+import semver
+import subprocess
+import sys
+
+def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> None:
+    """
+    Check if there's a new version of the package available and prompt for upgrade.
+    
+    Args:
+        latest_version (str): Known latest version (default: None)
+        package_name (str): Name of the package to check (default: "pdd")
+    """
+    try:
+        # Get current installed version
+        current_version = pkg_resources.get_distribution(package_name).version
+
+        # If latest_version is not provided, fetch from PyPI
+        if latest_version is None:
+            try:
+                pypi_url = f"https://pypi.org/pypi/{package_name}/json"
+                response = requests.get(pypi_url)
+                response.raise_for_status()
+                latest_version = response.json()['info']['version']
+            except Exception as e:
+                print(f"Failed to fetch latest version from PyPI: {str(e)}")
+                return
+
+        # Compare versions using semantic versioning
+        try:
+            current_semver = semver.VersionInfo.parse(current_version)
+            latest_semver = semver.VersionInfo.parse(latest_version)
+        except ValueError:
+            # If versions don't follow semantic versioning, fall back to string comparison
+            if current_version == latest_version:
+                return
+        else:
+            # If versions follow semantic versioning, compare properly
+            if current_semver >= latest_semver:
+                return
+
+        # If we get here, there's a new version available
+        print(f"\nNew version of {package_name} available: {latest_version} (current: {current_version})")
+        
+        # Ask for user confirmation
+        while True:
+            response = input("Would you like to upgrade? [y/N]: ").lower().strip()
+            if response in ['y', 'yes']:
+                # Construct pip command
+                pip_command = f"{sys.executable} -m pip install --upgrade {package_name}"
+                print(f"\nUpgrading with command: {pip_command}")
+                
+                try:
+                    subprocess.check_call(pip_command.split())
+                    print(f"\nSuccessfully upgraded {package_name} to version {latest_version}")
+                except subprocess.CalledProcessError as e:
+                    print(f"\nFailed to upgrade: {str(e)}")
+                break
+            elif response in ['n', 'no', '']:
+                print("\nUpgrade cancelled")
+                break
+            else:
+                print("Please answer 'y' or 'n'")
+
+    except pkg_resources.DistributionNotFound:
+        print(f"Package {package_name} is not installed")
+    except Exception as e:
+        print(f"Error checking for updates: {str(e)}")
+
+
+if __name__ == "__main__":
+    auto_update()

pdd/bug_main.py

@@ -0,0 +1,99 @@
+import os
+import sys
+from typing import Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .bug_to_unit_test import bug_to_unit_test
+
+def bug_main(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    program_file: str,
+    current_output: str,
+    desired_output: str,
+    output: Optional[str] = None,
+    language: Optional[str] = "Python"
+) -> Tuple[str, float, str]:
+    """
+    Main function to generate a unit test based on observed and desired outputs.
+
+    :param ctx: Click context containing command-line parameters.
+    :param prompt_file: Path to the prompt file that generated the code.
+    :param code_file: Path to the code file being tested.
+    :param program_file: Path to the program used to run the code under test.
+    :param current_output: Path to the file containing the current (incorrect) output.
+    :param desired_output: Path to the file containing the desired (correct) output.
+    :param output: Optional path to save the generated unit test.
+    :param language: Optional programming language for the unit test. Defaults to "Python".
+    :return: A tuple containing the generated unit test, total cost, and model name used.
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "prompt_file": prompt_file,
+            "code_file": code_file,
+            "program_file": program_file,
+            "current_output": current_output,
+            "desired_output": desired_output
+        }
+        command_options = {
+            "output": output,
+            "language": language
+        }
+        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="bug",
+            command_options=command_options
+        )
+
+        # Load input files
+        prompt_content = input_strings["prompt_file"]
+        code_content = input_strings["code_file"]
+        program_content = input_strings["program_file"]
+        current_output_content = input_strings["current_output"]
+        desired_output_content = input_strings["desired_output"]
+
+        # Generate unit test
+        strength = ctx.obj.get('strength', 0.9)
+        temperature = ctx.obj.get('temperature', 0)
+        unit_test, total_cost, model_name = bug_to_unit_test(
+            current_output_content,
+            desired_output_content,
+            prompt_content,
+            code_content,
+            program_content,
+            strength,
+            temperature,
+            language
+        )
+
+        # Save results if output path is provided
+        if output_file_paths.get("output"):
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(output_file_paths["output"]), exist_ok=True)
+            with open(output_file_paths["output"], 'w') as f:
+                f.write(unit_test)
+
+        # Provide user feedback
+        if not ctx.obj.get('quiet', False):
+            rprint("[bold green]Unit test generated successfully.[/bold green]")
+            rprint(f"[bold]Model used:[/bold] {model_name}")
+            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+            if output:
+                rprint(f"[bold]Unit test saved to:[/bold] {output_file_paths['output']}")
+
+        # Always print unit test, even in quiet mode
+        rprint("[bold]Generated Unit Test:[/bold]")
+        rprint(unit_test)
+
+        return unit_test, total_cost, model_name
+
+    except Exception as e:
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+        sys.exit(1)

pdd/bug_to_unit_test.py

@@ -0,0 +1,159 @@
+from typing import Tuple, Optional
+from rich import print
+from rich.markdown import Markdown
+from rich.console import Console
+from .load_prompt_template import load_prompt_template
+from .llm_invoke import llm_invoke
+from .unfinished_prompt import unfinished_prompt
+from .continue_generation import continue_generation
+from .postprocess import postprocess
+from .preprocess import preprocess
+
+console = Console()
+
+def bug_to_unit_test(
+    current_output: str,
+    desired_output: str,
+    prompt_used_to_generate_the_code: str,
+    code_under_test: str,
+    program_used_to_run_code_under_test: str,
+    strength: float = 0.89,
+    temperature: float = 0.0,
+    language: str = "python"
+) -> Tuple[str, float, str]:
+    """
+    Generate a unit test from a code file with bug information.
+
+    Args:
+        current_output (str): Current output of the code
+        desired_output (str): Desired output of the code
+        prompt_used_to_generate_the_code (str): Original prompt used to generate the code
+        code_under_test (str): Code to be tested
+        program_used_to_run_code_under_test (str): Program used to run the code
+        strength (float, optional): Strength of the LLM model. Must be between 0 and 1. Defaults to 0.89.
+        temperature (float, optional): Temperature of the LLM model. Defaults to 0.0.
+        language (str, optional): Programming language. Defaults to "python".
+
+    Returns:
+        Tuple[str, float, str]: Generated unit test, total cost, and model name
+
+    Raises:
+        ValueError: If strength is not between 0 and 1
+    """
+    # Validate strength parameter
+    if not 0 <= strength <= 1:
+        raise ValueError("Strength parameter must be between 0 and 1")
+
+    total_cost = 0.0
+    final_model_name = ""
+
+    try:
+        # Step 1: Load the prompt template
+        prompt_template = load_prompt_template("bug_to_unit_test_LLM")
+        if not prompt_template:
+            raise ValueError("Failed to load prompt template")
+
+        # Step 2: Prepare input and run through LLM
+        preprocessed_prompt = preprocess(prompt_used_to_generate_the_code)
+        
+        input_json = {
+            "prompt_that_generated_code": preprocessed_prompt,
+            "current_output": current_output,
+            "desired_output": desired_output,
+            "code_under_test": code_under_test,
+            "program_used_to_run_code_under_test": program_used_to_run_code_under_test,
+            "language": language
+        }
+
+        console.print("[bold blue]Generating unit test...[/bold blue]")
+        response = llm_invoke(
+            prompt=prompt_template,
+            input_json=input_json,
+            strength=strength,
+            temperature=temperature,
+            verbose=True
+        )
+
+        total_cost += response['cost']
+        final_model_name = response['model_name']
+
+        # Step 3: Print markdown formatting
+        console.print(Markdown(response['result']))
+
+        # Step 4: Check if generation is complete
+        last_600_chars = response['result'][-600:] if len(response['result']) > 600 else response['result']
+        
+        reasoning, is_finished, unfinished_cost, unfinished_model = unfinished_prompt(
+            prompt_text=last_600_chars,
+            strength=0.89,
+            temperature=temperature,
+            verbose=False
+        )
+        
+        total_cost += unfinished_cost
+
+        if not is_finished:
+            console.print("[yellow]Generation incomplete. Continuing...[/yellow]")
+            continued_output, continued_cost, continued_model = continue_generation(
+                formatted_input_prompt=prompt_template,
+                llm_output=response['result'],
+                strength=strength,
+                temperature=temperature,
+                verbose=True
+            )
+            total_cost += continued_cost
+            final_model_name = continued_model
+            result = continued_output
+        else:
+            result = response['result']
+
+        # Post-process the result
+        final_code, postprocess_cost, postprocess_model = postprocess(
+            result,
+            language,
+            strength=0.89,
+            temperature=temperature,
+            verbose=True
+        )
+        total_cost += postprocess_cost
+
+        # Step 5: Print total cost
+        console.print(f"[bold green]Total Cost: ${total_cost:.6f}[/bold green]")
+
+        return final_code, total_cost, final_model_name
+
+    except Exception as e:
+        console.print(f"[bold red]Error: {str(e)}[/bold red]")
+        return "", 0.0, ""
+
+def main():
+    """Example usage of the bug_to_unit_test function"""
+    try:
+        current_output = "3"
+        desired_output = "5"
+        prompt = "create a function that adds two numbers in python"
+        code = """
+def add_numbers(a, b):
+    return a + 1
+        """
+        program = "python"
+
+        unit_test, cost, model = bug_to_unit_test(
+            current_output=current_output,
+            desired_output=desired_output,
+            prompt_used_to_generate_the_code=prompt,
+            code_under_test=code,
+            program_used_to_run_code_under_test=program
+        )
+
+        if unit_test:
+            console.print("[bold green]Generated Unit Test:[/bold green]")
+            console.print(unit_test)
+            console.print(f"[bold blue]Total Cost: ${cost:.6f}[/bold blue]")
+            console.print(f"[bold blue]Model Used: {model}[/bold blue]")
+
+    except Exception as e:
+        console.print(f"[bold red]Error in main: {str(e)}[/bold red]")
+
+if __name__ == "__main__":
+    main()