pdd-cli 0.0.2__py3-none-any.whl

pdd/trace.py

@@ -0,0 +1,135 @@
+from typing import Tuple, Optional
+from rich import print
+from rich.console import Console
+from pydantic import BaseModel, Field
+import difflib
+from .load_prompt_template import load_prompt_template
+from .preprocess import preprocess
+from .llm_invoke import llm_invoke
+
+console = Console()
+
+class PromptLineOutput(BaseModel):
+    prompt_line: str = Field(description="The line from the prompt file that matches the code")
+
+def trace(
+    code_file: str,
+    code_line: int,
+    prompt_file: str,
+    strength: float = 0.5,
+    temperature: float = 0,
+    verbose: bool = False
+) -> Tuple[Optional[int], float, str]:
+    """
+    Trace a line of code back to its corresponding line in the prompt file.
+
+    Args:
+        code_file (str): Content of the code file
+        code_line (int): Line number in the code file
+        prompt_file (str): Content of the prompt file
+        strength (float, optional): Model strength. Defaults to 0.5
+        temperature (float, optional): Model temperature. Defaults to 0
+        verbose (bool, optional): Whether to print detailed information. Defaults to False
+
+    Returns:
+        Tuple[Optional[int], float, str]: (prompt line number, total cost, model name)
+    """
+    try:
+        # Input validation
+        if not all([code_file, prompt_file]) or not isinstance(code_line, int):
+            raise ValueError("Invalid input parameters")
+
+        total_cost = 0
+        model_name = ""
+
+        # Step 1: Extract the code line string
+        code_lines = code_file.splitlines()
+        if code_line < 1 or code_line > len(code_lines):
+            raise ValueError(f"Code line number {code_line} is out of range")
+        code_str = code_lines[code_line - 1]
+
+        # Step 2 & 3: Load and preprocess trace_LLM prompt
+        trace_prompt = load_prompt_template("trace_LLM")
+        if not trace_prompt:
+            raise ValueError("Failed to load trace_LLM prompt template")
+        trace_prompt = preprocess(trace_prompt, recursive=False, double_curly_brackets=False)
+
+        # Step 4: First LLM invocation
+        if verbose:
+            console.print("[bold blue]Running trace analysis...[/bold blue]")
+
+        trace_response = llm_invoke(
+            prompt=trace_prompt,
+            input_json={
+                "CODE_FILE": code_file,
+                "CODE_STR": code_str,
+                "PROMPT_FILE": prompt_file
+            },
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+
+        total_cost += trace_response['cost']
+        model_name = trace_response['model_name']
+
+        # Step 5: Load and preprocess extract_promptline_LLM prompt
+        extract_prompt = load_prompt_template("extract_promptline_LLM")
+        if not extract_prompt:
+            raise ValueError("Failed to load extract_promptline_LLM prompt template")
+        extract_prompt = preprocess(extract_prompt, recursive=False, double_curly_brackets=False)
+
+        # Step 6: Second LLM invocation
+        if verbose:
+            console.print("[bold blue]Extracting prompt line...[/bold blue]")
+
+        extract_response = llm_invoke(
+            prompt=extract_prompt,
+            input_json={"llm_output": trace_response['result']},
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose,
+            output_pydantic=PromptLineOutput
+        )
+
+        total_cost += extract_response['cost']
+        prompt_line_str = extract_response['result'].prompt_line
+
+        # Step 7: Find matching line in prompt file using fuzzy matching
+        prompt_lines = prompt_file.splitlines()
+        best_match = None
+        highest_ratio = 0
+
+        if verbose:
+            console.print(f"Searching for line: {prompt_line_str}")
+
+        normalized_search = prompt_line_str.strip()
+
+        for i, line in enumerate(prompt_lines, 1):
+            normalized_line = line.strip()
+            ratio = difflib.SequenceMatcher(None, normalized_search, normalized_line).ratio()
+
+            if verbose:
+                console.print(f"Line {i}: '{line}' - Match ratio: {ratio}")
+
+            # Increase threshold to 0.9 for more precise matching
+            if ratio > highest_ratio and ratio > 0.9:
+                # Additional check for exact content match after normalization
+                if normalized_search == normalized_line:
+                    highest_ratio = ratio
+                    best_match = i
+                    break  # Exit on exact match
+                highest_ratio = ratio
+                best_match = i
+
+        # Step 8: Return results
+        if verbose:
+            console.print(f"[green]Found matching line: {best_match}[/green]")
+            console.print(f"[green]Total cost: ${total_cost:.6f}[/green]")
+            console.print(f"[green]Model used: {model_name}[/green]")
+
+        return best_match, total_cost, model_name
+
+    except Exception as e:
+        console.print(f"[bold red]Error in trace function: {str(e)}[/bold red]")
+        return None, 0.0, ""

pdd/trace_main.py

@@ -0,0 +1,108 @@
+import click
+from rich import print as rprint
+from typing import Tuple, Optional
+import os
+import logging
+from .construct_paths import construct_paths
+from .trace import trace
+
+logging.basicConfig(level=logging.WARNING)
+logger = logging.getLogger(__name__)
+
+def trace_main(ctx: click.Context, prompt_file: str, code_file: str, code_line: int, output: Optional[str]) -> Tuple[str, float, str]:
+    """
+    Handle the core logic for the 'trace' command in the pdd CLI.
+
+    Args:
+        ctx (click.Context): The Click context object containing CLI options and parameters.
+        prompt_file (str): Path to the prompt file.
+        code_file (str): Path to the generated code file.
+        code_line (int): Line number in the code file to trace back to the prompt.
+        output (Optional[str]): Path to save the trace analysis results.
+
+    Returns:
+        Tuple[str, float, str]: A tuple containing the prompt line number, total cost, and model name.
+    """
+    quiet = ctx.obj.get('quiet', False)
+    logger.debug(f"Starting trace_main with quiet={quiet}")
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "prompt_file": prompt_file,
+            "code_file": code_file
+        }
+        command_options = {
+            "output": output
+        }
+        input_strings, output_file_paths, _ = construct_paths(
+            input_file_paths=input_file_paths,
+            force=ctx.obj.get('force', False),
+            quiet=quiet,
+            command="trace",
+            command_options=command_options
+        )
+        logger.debug("File paths constructed successfully")
+
+        # Load input files
+        prompt_content = input_strings["prompt_file"]
+        code_content = input_strings["code_file"]
+        logger.debug("Input files loaded")
+
+        # Perform trace analysis
+        strength = ctx.obj.get('strength', 0.5)
+        temperature = ctx.obj.get('temperature', 0.0)
+        try:
+            prompt_line, total_cost, model_name = trace(
+                code_content, code_line, prompt_content, strength, temperature
+            )
+            logger.debug(f"Trace analysis completed: prompt_line={prompt_line}, total_cost={total_cost}, model_name={model_name}")
+        except ValueError as e:
+            if not quiet:
+                rprint(f"[bold red]Invalid input: {e}[/bold red]")
+            logger.error(f"ValueError during trace analysis: {e}")
+            ctx.exit(1)
+
+        # Save results
+        if output:
+            output_path = output_file_paths.get("output")
+            output_dir = os.path.dirname(os.path.abspath(output_path))
+            if output_dir and not os.path.exists(output_dir):
+                try:
+                    os.makedirs(output_dir, exist_ok=True)
+                    logger.debug(f"Created output directory: {output_dir}")
+                except Exception as e:
+                    if not quiet:
+                        rprint(f"[bold red]Failed to create output directory: {e}[/bold red]")
+                    logger.error(f"Error creating output directory: {e}")
+                    ctx.exit(1)
+            try:
+                with open(output_path, 'w') as f:
+                    f.write(f"Prompt Line: {prompt_line}\n")
+                    f.write(f"Total Cost: ${total_cost:.6f}\n")
+                    f.write(f"Model Used: {model_name}\n")
+                logger.debug(f"Results saved to {output_path}")
+            except IOError as e:
+                if not quiet:
+                    rprint(f"[bold red]An unexpected error occurred: {e}[/bold red]")
+                logger.error(f"IOError while saving results: {e}")
+                ctx.exit(1)
+
+        # Provide user feedback
+        if not quiet:
+            rprint(f"[bold green]Trace Analysis Complete[/bold green]")
+            rprint(f"Corresponding prompt line: [cyan]{prompt_line}[/cyan]")
+            rprint(f"Total cost: [yellow]${total_cost:.6f}[/yellow]")
+            rprint(f"Model used: [magenta]{model_name}[/magenta]")
+
+        return prompt_line, total_cost, model_name
+
+    except FileNotFoundError as e:
+        if not quiet:
+            rprint(f"[bold red]File not found: {e}[/bold red]")
+        logger.error(f"FileNotFoundError: {e}")
+        ctx.exit(1)
+    except Exception as e:
+        if not quiet:
+            rprint(f"[bold red]An unexpected error occurred: {e}[/bold red]")
+        logger.error(f"Unexpected error: {e}")
+        ctx.exit(1)

pdd/track_cost.py

@@ -0,0 +1,102 @@
+import functools
+from datetime import datetime
+import csv
+import os
+import click
+from rich import print as rprint
+from typing import Any, Tuple
+
+def track_cost(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        ctx = click.get_current_context()
+        if ctx is None:
+            return func(*args, **kwargs)
+
+        start_time = datetime.now()
+        try:
+            result = func(*args, **kwargs)
+        except Exception as e:
+            raise e
+        end_time = datetime.now()
+
+        try:
+            if ctx.obj and hasattr(ctx.obj, 'get'):
+                output_cost_path = ctx.obj.get('output_cost') or os.getenv('PDD_OUTPUT_COST_PATH')
+            else:
+                output_cost_path = os.getenv('PDD_OUTPUT_COST_PATH')
+            
+            if not output_cost_path:
+                return result
+
+            command_name = ctx.command.name
+
+            cost, model_name = extract_cost_and_model(result)
+
+            input_files, output_files = collect_files(args, kwargs)
+
+            timestamp = start_time.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3]
+
+            row = {
+                'timestamp': timestamp,
+                'model': model_name,
+                'command': command_name,
+                'cost': cost,
+                'input_files': ';'.join(input_files),
+                'output_files': ';'.join(output_files),
+            }
+
+            file_exists = os.path.isfile(output_cost_path)
+            fieldnames = ['timestamp', 'model', 'command', 'cost', 'input_files', 'output_files']
+
+            with open(output_cost_path, 'a', newline='', encoding='utf-8') as csvfile:
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                if not file_exists:
+                    writer.writeheader()
+                writer.writerow(row)
+
+            print(f"Debug: Writing row to CSV: {row}")
+            print(f"Debug: Input files: {input_files}")
+            print(f"Debug: Output files: {output_files}")
+
+        except Exception as e:
+            rprint(f"[red]Error tracking cost: {e}[/red]")
+
+        return result
+
+    return wrapper
+
+def extract_cost_and_model(result: Any) -> Tuple[Any, str]:
+    if isinstance(result, tuple) and len(result) >= 3:
+        return result[-2], result[-1]
+    return '', ''
+
+def collect_files(args, kwargs):
+    input_files = []
+    output_files = []
+
+    # Collect from args
+    for arg in args:
+        if isinstance(arg, str):
+            input_files.append(arg)
+        elif isinstance(arg, list):
+            input_files.extend([f for f in arg if isinstance(f, str)])
+
+    # Collect from kwargs
+    for k, v in kwargs.items():
+        if k == 'output_cost':
+            continue
+        if isinstance(v, str):
+            if k.startswith('output'):
+                output_files.append(v)
+            else:
+                input_files.append(v)
+        elif isinstance(v, list):
+            if k.startswith('output'):
+                output_files.extend([f for f in v if isinstance(f, str)])
+            else:
+                input_files.extend([f for f in v if isinstance(f, str)])
+
+    print(f"Debug: Collected input files: {input_files}")
+    print(f"Debug: Collected output files: {output_files}")
+    return input_files, output_files

pdd/unfinished_prompt.py

@@ -0,0 +1,114 @@
+from typing import Tuple
+from pydantic import BaseModel, Field
+from rich import print as rprint
+from .load_prompt_template import load_prompt_template
+from .llm_invoke import llm_invoke
+
+class PromptAnalysis(BaseModel):
+    reasoning: str = Field(description="Structured reasoning for the completeness assessment")
+    is_finished: bool = Field(description="Boolean indicating whether the prompt is complete")
+
+def unfinished_prompt(
+    prompt_text: str,
+    strength: float = 0.5,
+    temperature: float = 0,
+    verbose: bool = False
+) -> Tuple[str, bool, float, str]:
+    """
+    Analyze whether a given prompt is complete or needs to continue.
+
+    Args:
+        prompt_text (str): The prompt text to analyze
+        strength (float, optional): Strength of the LLM model. Defaults to 0.5.
+        temperature (float, optional): Temperature of the LLM model. Defaults to 0.
+        verbose (bool, optional): Whether to print detailed information. Defaults to False.
+
+    Returns:
+        Tuple[str, bool, float, str]: Contains:
+            - reasoning: Structured reasoning for the completeness assessment
+            - is_finished: Boolean indicating whether the prompt is complete
+            - total_cost: Total cost of the analysis
+            - model_name: Name of the LLM model used
+
+    Raises:
+        ValueError: If input parameters are invalid
+        Exception: If there's an error loading the prompt template or invoking the LLM
+    """
+    try:
+        # Input validation
+        if not isinstance(prompt_text, str) or not prompt_text.strip():
+            raise ValueError("Prompt text must be a non-empty string")
+        
+        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")
+
+        # Step 1: Load the prompt template
+        if verbose:
+           rprint("[blue]Loading prompt template...[/blue]")
+        
+        prompt_template = load_prompt_template("unfinished_prompt_LLM")
+        if not prompt_template:
+            raise Exception("Failed to load prompt template")
+
+        # Step 2: Prepare input and invoke LLM
+        input_json = {"PROMPT_TEXT": prompt_text}
+        
+        if verbose:
+            rprint("[blue]Invoking LLM model...[/blue]")
+            try:
+                rprint(f"Input text: {prompt_text}")
+            except:
+                print(f"Input text: {prompt_text}")
+            rprint(f"Model strength: {strength}")
+            rprint(f"Temperature: {temperature}")
+
+        response = llm_invoke(
+            prompt=prompt_template,
+            input_json=input_json,
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose,
+            output_pydantic=PromptAnalysis
+        )
+
+        # Step 3: Extract and return results
+        result: PromptAnalysis = response['result']
+        total_cost = response['cost']
+        model_name = response['model_name']
+
+        if verbose:
+           rprint("[green]Analysis complete![/green]")
+           rprint(f"Reasoning: {result.reasoning}")
+           rprint(f"Is finished: {result.is_finished}")
+           rprint(f"Total cost: ${total_cost:.6f}")
+           rprint(f"Model used: {model_name}")
+
+        return (
+            result.reasoning,
+            result.is_finished,
+            total_cost,
+            model_name
+        )
+
+    except Exception as e:
+        rprint("[red]Error in unfinished_prompt:[/red]", str(e))
+        raise
+
+# Example usage
+if __name__ == "__main__":
+    sample_prompt = "Write a function that"
+    try:
+        reasoning, is_finished, cost, model = unfinished_prompt(
+            prompt_text=sample_prompt,
+            verbose=True
+        )
+        rprint("\n[blue]Results:[/blue]")
+        rprint(f"Complete? {'Yes' if is_finished else 'No'}")
+        rprint(f"Reasoning: {reasoning}")
+        rprint(f"Cost: ${cost:.6f}")
+        rprint(f"Model: {model}")
+    except Exception as e:
+        rprint("[red]Error in example:[/red]", str(e))

pdd/update_main.py

@@ -0,0 +1,96 @@
+import sys
+from typing import Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .update_prompt import update_prompt
+from .git_update import git_update
+
+def update_main(
+    ctx: click.Context,
+    input_prompt_file: str,
+    modified_code_file: str,
+    input_code_file: Optional[str],
+    output: Optional[str],
+    git: bool = False,
+) -> Tuple[str, float, str]:
+    """
+    CLI wrapper for updating prompts based on modified code.
+
+    :param ctx: Click context object containing CLI options and parameters.
+    :param input_prompt_file: Path to the original prompt file.
+    :param modified_code_file: Path to the modified code file.
+    :param input_code_file: Optional path to the original code file. If None, Git history is used if --git is True.
+    :param output: Optional path to save the updated prompt.
+    :param git: Use Git history to retrieve the original code if True.
+    :return: Tuple containing the updated prompt, total cost, and model name.
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {"input_prompt_file": input_prompt_file, "modified_code_file": modified_code_file}
+        if input_code_file:
+            input_file_paths["input_code_file"] = input_code_file
+
+        # Validate input requirements
+        if not git and input_code_file is None:
+            raise ValueError("Must provide an input code file or use --git option.")
+
+        command_options = {"output": output}
+        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="update",
+            command_options=command_options,
+        )
+
+        # Extract input strings
+        input_prompt = input_strings["input_prompt_file"]
+        modified_code = input_strings["modified_code_file"]
+        input_code = input_strings.get("input_code_file")
+
+        # Update prompt using appropriate method
+        if git:
+            if input_code_file:
+                raise ValueError("Cannot use both --git and provide an input code file.")
+            modified_prompt, total_cost, model_name = git_update(
+                input_prompt=input_prompt,
+                modified_code_file=modified_code_file,
+                strength=ctx.obj.get("strength", 0.5),
+                temperature=ctx.obj.get("temperature", 0),
+                verbose=ctx.obj.get("verbose", False)
+            )
+        else:
+            if input_code is None:
+                raise ValueError("Must provide an input code file or use --git option.")
+            modified_prompt, total_cost, model_name = update_prompt(
+                input_prompt=input_prompt,
+                input_code=input_code,
+                modified_code=modified_code,
+                strength=ctx.obj.get("strength", 0.5),
+                temperature=ctx.obj.get("temperature", 0),
+                verbose=ctx.obj.get("verbose", False)
+            )
+
+        # Save the modified prompt
+        with open(output_file_paths["output"], "w") as f:
+            f.write(modified_prompt)
+
+        # Provide user feedback
+        if not ctx.obj.get("quiet", False):
+            rprint("[bold green]Prompt updated successfully.[/bold green]")
+            rprint(f"[bold]Model used:[/bold] {model_name}")
+            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+            rprint(f"[bold]Updated prompt saved to:[/bold] {output_file_paths['output']}")
+
+        return modified_prompt, total_cost, model_name
+
+    except ValueError as e:
+        if not ctx.obj.get("quiet", False):
+            rprint(f"[bold red]Input error:[/bold red] {str(e)}")
+        sys.exit(1)
+    except Exception as e:
+        if not ctx.obj.get("quiet", False):
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+        sys.exit(1)

pdd/update_prompt.py

@@ -0,0 +1,115 @@
+from typing import Tuple
+from rich.console import Console
+from rich.markdown import Markdown
+from pydantic import BaseModel, Field
+from .load_prompt_template import load_prompt_template
+from .preprocess import preprocess
+from .llm_invoke import llm_invoke
+
+class PromptUpdate(BaseModel):
+    modified_prompt: str = Field(description="The updated prompt that will generate the modified code")
+
+def update_prompt(
+    input_prompt: str,
+    input_code: str,
+    modified_code: str,
+    strength: float,
+    temperature: float,
+    verbose: bool = False
+) -> Tuple[str, float, str]:
+    """
+    Update a prompt based on the original and modified code.
+
+    Args:
+        input_prompt (str): The original prompt that generated the code
+        input_code (str): The original generated code
+        modified_code (str): The modified code
+        strength (float): The strength parameter for the LLM model (0-1)
+        temperature (float): The temperature parameter for the LLM model (0-1)
+        verbose (bool, optional): Whether to print detailed output. Defaults to False.
+
+    Returns:
+        Tuple[str, float, str]: (modified_prompt, total_cost, model_name)
+
+    Raises:
+        ValueError: If input parameters are invalid
+        RuntimeError: If there's an error in LLM processing
+    """
+    console = Console()
+
+    # Input validation
+    if not all([input_prompt, input_code, modified_code]):
+        raise ValueError("All input strings (prompt, code, modified code) must be non-empty")
+    
+    if not (0 <= strength <= 1 and 0 <= temperature <= 1):
+        raise ValueError("Strength and temperature must be between 0 and 1")
+
+    try:
+        # Step 1: Load and preprocess prompt templates
+        update_prompt_template = load_prompt_template("update_prompt_LLM")
+        extract_prompt_template = load_prompt_template("extract_prompt_update_LLM")
+
+        if not update_prompt_template or not extract_prompt_template:
+            raise RuntimeError("Failed to load prompt templates")
+
+        update_prompt_processed = preprocess(update_prompt_template, False, False)
+        extract_prompt_processed = preprocess(extract_prompt_template, False, False)
+
+        # Step 2: First LLM invocation
+        if verbose:
+            console.print("[bold blue]Running first LLM invocation...[/bold blue]")
+
+        first_response = llm_invoke(
+            prompt=update_prompt_processed,
+            input_json={
+                "input_prompt": input_prompt,
+                "input_code": input_code,
+                "modified_code": modified_code
+            },
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+
+        if not first_response or not isinstance(first_response, dict) or 'result' not in first_response:
+            raise RuntimeError("First LLM invocation failed")
+
+        # Step 3: Second LLM invocation
+        if verbose:
+            console.print("[bold blue]Running second LLM invocation...[/bold blue]")
+
+        second_response = llm_invoke(
+            prompt=extract_prompt_processed,
+            input_json={"llm_output": first_response['result']},
+            strength=0.5,
+            temperature=temperature,
+            output_pydantic=PromptUpdate,
+            verbose=verbose
+        )
+
+        if not second_response or not isinstance(second_response, dict) or 'result' not in second_response:
+            raise RuntimeError("Second LLM invocation failed")
+
+        # Step 4: Print modified prompt if verbose
+        if verbose:
+            console.print("\n[bold green]Modified Prompt:[/bold green]")
+            console.print(Markdown(second_response['result'].modified_prompt))
+
+        # Step 5: Calculate total cost
+        total_cost = first_response['cost'] + second_response['cost']
+
+        if verbose:
+            console.print(f"\n[bold yellow]Total Cost: ${total_cost:.6f}[/bold yellow]")
+            console.print(f"[bold cyan]Model Used: {first_response['model_name']}[/bold cyan]")
+
+        # Step 6: Return results
+        return (
+            second_response['result'].modified_prompt,
+            total_cost,
+            first_response['model_name']
+        )
+
+    except Exception as e:
+        error_msg = f"Error in update_prompt: {str(e)}"
+        console.print(f"[bold red]{error_msg}[/bold red]")
+        raise RuntimeError(error_msg)