pdd-cli 0.0.2__py3-none-any.whl

pdd/prompts/trim_results_LLM.prompt

@@ -0,0 +1,83 @@
+% You are an expert JSON editor. You are tasked with trimming potential overlap between a partially generated text and its continuation. This is crucial for seamlessly combining text segments without duplication.
+
+% You will be given two pieces of text that will be appended together afterwards to form a coherent whole:
+<inputs>
+    1) This is the text that has been generated so far:
+    <generated_results>
+    {GENERATED_RESULTS}
+    </generated_results>
+
+    2) This is the continuation of the generation:
+    <continued_generation>
+    {CONTINUED_GENERATION}
+    </continued_generation>
+</inputs>
+
+% Your task is to:
+1. Compare the end of the generated_results with the beginning of the continued_generation.
+2. Identify any overlapping text.
+3. If overlap exists, trim it from the start of the continued_generation and be careful to keep or remove spaces so that the text makes sense.
+4. If no overlap exists, leave the continued_generation as is.
+5. Trim out the preamble text before the code block that starts with a triple backtick (```) including the triple backticks and language tag. Also, there might be a xml tag, 'llm_output', at the start or end of the continued_generation, which should be removed.
+
+% After completing these steps, provide your output in JSON format with the following keys:
+- explanation: A string explaining what was trimmed, if anything. If nothing was trimmed, explain why.
+- trimmed_continued_generation: The trimmed continued_generation string. If no trimming was necessary, this should be identical to the original continued_generation.
+
+% Ensure your JSON is properly formatted and contains only these two keys.
+
+% Here are example of how your outputs should look like for given inputs:
+<examples>
+    <example1>
+        <inputs>
+            <generated_results>
+            "The quick brown fox jumps over the lazy dog and the "
+            </generated_results>
+            <continued_generation>
+            """```text\n and the cat jumped over the lazy dog."""
+            </continued_generation>
+        </inputs>
+        <output>
+        {{
+        "explanation": "Trimmed '```text\n and the ' from the start of the continued_generation as it overlapped with the end of generated_results and the triple backticks indicate a start of a code block.",
+        "trimmed_continued_generation": "cat jumped over the lazy dog."
+        }}
+        </output>
+    </example1>
+
+    <example2>
+        <inputs>
+            <generated_results>
+            ""
+            </generated_results>
+            <continued_generation>
+            "Telling a short story. ```text\nThe quick brown fox jumps over the lazy dog."
+            </continued_generation>
+        </inputs>
+        <output>
+        {{
+        "explanation": "There was no overlap between the generated_results and the continued_generation. Trimmed preamble.","trimmed_continued_generation": "The quick brown fox jumps over the lazy dog."
+        }}
+        </output>
+    </example2>
+
+    <example3>
+        <inputs>
+            <generated_results>
+            '''\n        input_strings, output_file_paths, language = construct_paths(\n            input_file_paths=input_'''
+            </generated_results>
+            <continued_generation>
+            '''file_paths,\n            force=global_opts.force,\n            quiet=global_opts.quiet,\n            '''
+            </continued_generation>
+        </inputs>
+        <output>
+        {{
+        "explanation": "'file_paths' is a continuation of 'input_' so there is no overlap between the generated_results and the continued_generation.",
+        "trimmed_continued_generation": "file_paths,\n            force=global_opts.force,\n            quiet=global_opts.quiet,\n            "
+        }}
+        </output>
+    </example3>
+<examples>
+
+% Remember to carefully compare the texts to ensure accurate trimming and provide a clear explanation of your actions so that the trimmed_continued_generation can be properly appended to generated_results without needed further edits.
+

pdd/prompts/trim_results_start_LLM.prompt

@@ -0,0 +1,45 @@
+% You are an expert JSON editor. You will be processing the output of a language model (LLM) to extract the unfinished main code block being generated and provide an explanation of how you determined what to cut out. Here is the llm_output to process:
+<llm_output>
+{LLM_OUTPUT}
+</llm_output>
+
+% Your task is to trim away everything before the code block that starts with a triple backtick (```). Follow these steps:
+    1. Analyze the LLM output and locate the main code block. This block will start with a triple backtick (```) followed by a language tag (e.g. 'python').
+    2. Everything before this triple backtick should be removed.
+    3. Extract the entire code block, excluding the opening triple backticks and language tag (e.g. 'python').
+    4. Prepare an explanation of how you determined what to cut out. This should be a brief description of your process.
+    5. Format your output as a JSON object with two keys:
+        - 'explanation': Your explanation of how you determined what to cut out
+        - 'code_block': The extracted code block text
+
+% Here are examples of how your outputs should be given various inputs:
+<examples>
+    <example1>
+        <input>
+            <llm_output>
+            "Here is how you run the code: ```bash\npython code.py```\n\nHere is the code: ```python\ndef hello_world():\n    print('Hello, World!')\n\nhello_world()\ndef```"
+            </llm_output>
+        </input>
+        <output>    
+        {{
+        "explanation": "I identified the main unfinished code block which starts with triple backticks (```) in the text and removed all content before it. The remaining text, excluding the backticks and language tag, was extracted as the code block.",
+        "code_block": "def hello_world():\n    print('Hello, World!')\n\nhello_world()\ndef"
+        }}
+        </output>
+    </example1>
+    <example2>
+        <input>
+            <llm_output>
+            ""
+            </llm_output>
+        </input>
+        <output>    
+        {{
+        "explanation": "There is nothing.",
+        "code_block": ""
+        }}
+        </output>
+    </example2>
+</examples>
+
+% Please provide your output in this JSON format.

pdd/prompts/unfinished_prompt_LLM.prompt

@@ -0,0 +1,18 @@
+% You are tasked with determining whether a given prompt has finished outputting everything or if it still needs to continue. This is crucial for ensuring that all necessary information has been provided before proceeding with further actions. You will often be provided the last few hundred characters of the prompt_text to analyze and determine if it appears to be complete or if it seems to be cut off or unfinished. You are just looking at the prompt_text and not the entire prompt file. The beginning part of the prompt_text is not always provided, so you will need to make a judgment based on the text you are given.
+
+% Here is the prompt text to analyze:
+<prompt_text>
+    {PROMPT_TEXT}
+</prompt_text>
+
+% Carefully examine the provided prompt text and determine if it appears to be complete or if it seems to be cut off or unfinished. Consider the following factors:
+    1. Sentence structure: Are all sentences grammatically complete?
+    2. Content flow: Does the text end abruptly or does it have a natural conclusion?
+    3. Context: Based on the content, does it seem like all necessary information has been provided?
+    4. Formatting: Are there any unclosed parentheses, quotation marks, or other formatting issues that suggest incompleteness?
+
+% Provide your reasoning for why you believe the prompt is complete or incomplete.
+
+% Output a JSON object with two keys:
+    1. "reasoning": A string containing your structured reasoning
+    2. "is_finished": A boolean value (true if the prompt is complete, false if it's incomplete)

pdd/prompts/update_prompt_LLM.prompt

@@ -0,0 +1,19 @@
+% You are an expert LLM Prompt Engineer. Your goal is to take the original code and modified code, and to update the prompt that generated the original code.
+
+% Here are the inputs and outputs of this prompt:
+    Input: 
+        'input_prompt' - A string that contains the prompt that generated the original code.
+        'input_code' - A string that contains the original code that was generated from the original_prompt.
+        'modified_code' - A string that contains the code that was modified by the user.
+    Output: 
+        'modified_prompt' - A string that contains the updated prompt that will generate the modified code.
+
+% Here is the input_prompt to change: ```{input_prompt}```
+% Here is the input_code: ```{input_code}```
+% Here is the modified_code: ```{modified_code}```
+
+% To generate the modified prompt, perform the following sequence of steps:
+    1. Using the provided input_code and input_prompt, identify what the code does and how it was generated.
+    2. Compare the input_code and modified_code to determine the changes made by the user.
+    3. Identify what the modified_code does differently from the input_code.
+    4. Generate a modified_prompt that will guide the generation of the modified_code based on the identified changes.

pdd/prompts/xml_convertor_LLM.prompt

@@ -0,0 +1,54 @@
+% Here are examples of inserting in XML tags to improve the structure and readability of a prompt.
+<examples>
+    <example_1>
+        % Here is an example_raw_prompt that needs XML tagging:
+        <example_raw_prompt>
+        <include>context/xml/1/split_LLM.prompt</include>
+        </example_raw_prompt>
+
+        % Here is an example_tagged_prompt from the example_raw_prompt above:
+        <example_tagged_prompt>
+        <include>context/xml/1/split_xml_llm.prompt</include>
+        </example_tagged_prompt>
+    </example_1>
+
+    <example_2>
+        % Here is an example_raw_prompt that needs XML tagging:
+        <example_raw_prompt>
+        <include>context/xml/2/xml_convertor_LLM.prompt</include>
+        </example_raw_prompt>
+
+        % Here is an example_tagged_prompt from the example_raw_prompt above:
+        <example_tagged_prompt>
+        <include>context/xml/2/xml_convertor_xml_LLM.prompt</include>
+        </example_tagged_prompt>
+    </example_2>
+</examples>
+
+<role>You are an expert Prompt Engineer.</role>
+
+<task>Your goal is to enhance a given prompt by only adding XML tags where necessary to improve its structure and readability. Do not add any additional content or XML tags unless it is clearly required by the structure of the input_raw_prompt.</task>
+
+<context>
+Here is the input_raw_prompt that needs XML tagging to improve its organization: <input_raw_prompt>{raw_prompt}</input_raw_prompt>
+</context>
+
+<output_instructions>
+Output a string with the `input_raw_prompt` properly tagged using XML as metadata and structural elements to enhance clarity and organization. The output may include, but is not limited to:
+    1. `<instructions>`: Guidelines or directives for the model's output.
+    2. `<context>`: Background information or relevant data for understanding the task.
+    3. `<examples>`: Specific instances that guide the model's response.
+    4. `<formatting>`: Special formatting instructions for the output.
+</output_instructions>
+
+<steps>
+Follow these steps to tag the prompt:
+    Step 1. Write out the analysis of the input_raw_prompt by identifying components like instructions, context, and examples.
+    Step 2. Discuss what could be appropriate XML tags for this input_raw_prompt.
+    Step 3. Insert the XML tags at the correct locations in the input_raw_prompt without introducing any new content. Only add tags to existing content. The XML tags should be enhancing the input_raw_prompt's format, structure and readability.
+</steps>
+    
+<general_points>
+    - With triple backtick includes and curly bracket placeholders, there could be lots of text in them after preprocessing so XML tags will help to organize the content.
+    - No need to include the initial and ending triple backticks for the XML code block.  
+</general_points>

pdd/split.py

@@ -0,0 +1,119 @@
+from typing import Tuple
+from rich import print as rprint
+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 PromptSplit(BaseModel):
+    sub_prompt: str = Field(description="The extracted sub-prompt")
+    modified_prompt: str = Field(description="The modified original prompt")
+
+def split(
+    input_prompt: str,
+    input_code: str,
+    example_code: str,
+    strength: float,
+    temperature: float,
+    verbose: bool = False
+) -> Tuple[str, str, float]:
+    """
+    Split a prompt into a sub_prompt and modified_prompt.
+
+    Args:
+        input_prompt (str): The prompt to split
+        input_code (str): The code generated from the input_prompt
+        example_code (str): Example code showing usage
+        strength (float): LLM strength parameter (0-1)
+        temperature (float): LLM temperature parameter (0-1)
+        verbose (bool): Whether to print detailed information
+
+    Returns:
+        Tuple[str, str, float]: (sub_prompt, modified_prompt, total_cost)
+    """
+    total_cost = 0.0
+
+    # Input validation
+    if not all([input_prompt, input_code, example_code]):
+        raise ValueError("All input parameters (input_prompt, input_code, example_code) must be provided")
+    
+    if not 0 <= strength <= 1 or not 0 <= temperature <= 1:
+        raise ValueError("Strength and temperature must be between 0 and 1")
+
+    try:
+        # 1. Load prompt templates
+        split_prompt = load_prompt_template("split_LLM")
+        extract_prompt = load_prompt_template("extract_prompt_split_LLM")
+        
+        if not split_prompt or not extract_prompt:
+            raise ValueError("Failed to load prompt templates")
+
+        # 2. Preprocess prompts
+        processed_split_prompt = preprocess(
+            split_prompt,
+            recursive=False,
+            double_curly_brackets=True,
+            exclude_keys=['input_prompt', 'input_code', 'example_code']
+        )
+        
+        processed_extract_prompt = preprocess(
+            extract_prompt,
+            recursive=False,
+            double_curly_brackets=False
+        )
+
+        # 3. First LLM invocation
+        if verbose:
+            rprint("[bold blue]Running initial prompt split...[/bold blue]")
+
+        split_response = llm_invoke(
+            prompt=processed_split_prompt,
+            input_json={
+                "input_prompt": input_prompt,
+                "input_code": input_code,
+                "example_code": example_code
+            },
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+        
+        total_cost += split_response["cost"]
+
+        # 4. Extract JSON with second LLM invocation
+        if verbose:
+            rprint("[bold blue]Extracting split prompts...[/bold blue]")
+
+        extract_response = llm_invoke(
+            prompt=processed_extract_prompt,
+            input_json={"llm_output": split_response["result"]},
+            strength=0.89,  # Fixed strength for extraction
+            temperature=temperature,
+            output_pydantic=PromptSplit,
+            verbose=verbose
+        )
+        
+        total_cost += extract_response["cost"]
+
+        # Extract results
+        result: PromptSplit = extract_response["result"]
+        sub_prompt = result.sub_prompt
+        modified_prompt = result.modified_prompt
+
+        # 5. Print verbose output if requested
+        if verbose:
+            rprint("\n[bold green]Final Results:[/bold green]")
+            rprint(Markdown(f"### Sub Prompt\n{sub_prompt}"))
+            rprint(Markdown(f"### Modified Prompt\n{modified_prompt}"))
+            rprint(f"[bold cyan]Total Cost: ${total_cost:.6f}[/bold cyan]")
+
+        # 6. Return results
+        return sub_prompt, modified_prompt, total_cost
+
+    except Exception as e:
+        # Print an error message, then raise an exception that includes
+        # the prefix “Error in split function: …” in its final message.
+        rprint(f"[bold red]Error in split function: {str(e)}[/bold red]")
+        # Re-raise using the same exception type but with a modified message.
+        raise type(e)(f"Error in split function: {str(e)}") from e

pdd/split_main.py

@@ -0,0 +1,103 @@
+import sys
+from typing import Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .split import split
+
+def split_main(
+    ctx: click.Context,
+    input_prompt_file: str,
+    input_code_file: str,
+    example_code_file: str,
+    output_sub: Optional[str],
+    output_modified: Optional[str]
+) -> Tuple[str, str, float]:
+    """
+    CLI wrapper for splitting a prompt into a sub_prompt and modified_prompt.
+
+    Args:
+        ctx: Click context containing command-line parameters.
+        input_prompt_file: Path to the input prompt file to be split.
+        input_code_file: Path to the code file generated from the input prompt.
+        example_code_file: Path to the example code file showing usage.
+        output_sub: Optional path where to save the sub-prompt.
+        output_modified: Optional path where to save the modified prompt.
+
+    Returns:
+        Tuple containing:
+            - str: The sub-prompt content
+            - str: The modified prompt content
+            - float: The total cost of the operation
+
+    Raises:
+        SystemExit: If any error occurs during execution.
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "input_prompt": input_prompt_file,
+            "input_code": input_code_file,
+            "example_code": example_code_file
+        }
+        command_options = {
+            "output_sub": output_sub,
+            "output_modified": output_modified
+        }
+        
+        # Get input strings and output paths
+        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="split",
+            command_options=command_options
+        )
+
+        # Get parameters from context
+        strength = ctx.obj.get('strength', 0.5)
+        temperature = ctx.obj.get('temperature', 0)
+
+        # Call the split function
+        sub_prompt, modified_prompt, total_cost = split(
+            input_prompt=input_strings["input_prompt"],
+            input_code=input_strings["input_code"],
+            example_code=input_strings["example_code"],
+            strength=strength,
+            temperature=temperature,
+            verbose=not ctx.obj.get('quiet', False)
+        )
+
+        # Save the output files
+        try:
+            with open(output_file_paths["output_sub"], 'w') as f:
+                f.write(sub_prompt)
+            with open(output_file_paths["output_modified"], 'w') as f:
+                f.write(modified_prompt)
+        except IOError as e:
+            raise IOError(f"Failed to save output files: {str(e)}")
+
+        # Provide user feedback if not in quiet mode
+        if not ctx.obj.get('quiet', False):
+            rprint("[bold green]Successfully split the prompt![/bold green]")
+            rprint(f"[bold]Sub-prompt saved to:[/bold] {output_file_paths['output_sub']}")
+            rprint(f"[bold]Modified prompt saved to:[/bold] {output_file_paths['output_modified']}")
+            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+
+        return sub_prompt, modified_prompt, total_cost
+
+    except Exception as e:
+        # Handle errors and provide appropriate feedback
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+            
+            # Provide more specific error messages based on the exception type
+            if isinstance(e, FileNotFoundError):
+                rprint("[yellow]Hint: Check if all input files exist and are accessible.[/yellow]")
+            elif isinstance(e, IOError):
+                rprint("[yellow]Hint: Check file permissions and disk space.[/yellow]")
+            elif isinstance(e, ValueError):
+                rprint("[yellow]Hint: Check if input files have valid content.[/yellow]")
+        
+        sys.exit(1)

pdd/summarize_directory.py

@@ -0,0 +1,212 @@
+from typing import Optional, Tuple
+from datetime import datetime, UTC
+from io import StringIO
+import os
+import glob
+import csv
+
+from pydantic import BaseModel, Field
+from rich import print
+from rich.progress import track
+
+from .load_prompt_template import load_prompt_template
+from .llm_invoke import llm_invoke
+
+class FileSummary(BaseModel):
+    file_summary: str = Field(description="The summary of the file")
+
+def validate_csv_format(csv_content: str) -> bool:
+    """Validate CSV has required columns and proper format."""
+    try:
+        if not csv_content or csv_content.isspace():
+            return False
+        reader = csv.DictReader(StringIO(csv_content.lstrip()))
+        if not reader.fieldnames:
+            return False
+        required_columns = {'full_path', 'file_summary', 'date'}
+        if not all(col in reader.fieldnames for col in required_columns):
+            return False
+        try:
+            first_row = next(reader, None)
+            if not first_row:
+                return True
+            return all(key in first_row for key in required_columns)
+        except csv.Error:
+            return False
+    except Exception:
+        return False
+
+def normalize_path(path: str) -> str:
+    """Normalize path for consistent comparison."""
+    return os.path.normpath(path.strip().strip('"').strip())
+
+def parse_date(date_str: str) -> datetime:
+    """Parse date string to datetime with proper error handling."""
+    try:
+        dt = datetime.fromisoformat(date_str.strip())
+        return dt if dt.tzinfo else dt.replace(tzinfo=UTC)
+    except Exception:
+        return datetime.now(UTC)
+
+def parse_existing_csv(csv_content: str, verbose: bool = False) -> dict:
+    """Parse existing CSV file and return normalized data."""
+    existing_data = {}
+    try:
+        # Clean the CSV content by removing leading/trailing whitespace from each line
+        cleaned_lines = [line.strip() for line in csv_content.splitlines()]
+        cleaned_content = '\n'.join(cleaned_lines)
+        
+        reader = csv.DictReader(StringIO(cleaned_content))
+        for row in reader:
+            try:
+                normalized_path = normalize_path(row['full_path'])
+                existing_data[normalized_path] = {
+                    'file_summary': row['file_summary'].strip().strip('"'),
+                    'date': row['date'].strip()
+                }
+                if verbose:
+                    print(f"[green]Parsed existing entry for: {normalized_path}[/green]")
+            except Exception as e:
+                if verbose:
+                    print(f"[yellow]Warning: Skipping invalid CSV row: {str(e)}[/yellow]")
+    except Exception as e:
+        if verbose:
+            print(f"[yellow]Warning: Error parsing CSV: {str(e)}[/yellow]")
+        raise ValueError("Invalid CSV file format.")
+    return existing_data
+
+def summarize_directory(
+    directory_path: str,
+    strength: float,
+    temperature: float,
+    verbose: bool,
+    csv_file: Optional[str] = None
+) -> Tuple[str, float, str]:
+    """
+    Summarize files in a directory and generate a CSV containing the summaries.
+
+    Parameters:
+        directory_path (str): Path to the directory to summarize with wildcard (e.g., /path/to/directory/*.py)
+        strength (float): Between 0 and 1 that is the strength of the LLM model to use.
+        temperature (float): Controls the randomness of the LLM's output.
+        verbose (bool): Whether to print out the details of the function.
+        csv_file (Optional[str]): Current CSV file contents if it already exists.
+
+    Returns:
+        Tuple[str, float, str]: A tuple containing:
+            - csv_output (str): Updated CSV content with 'full_path', 'file_summary', and 'date'.
+            - total_cost (float): Total cost of the LLM runs.
+            - model_name (str): Name of the LLM model used.
+    """
+    try:
+        if not isinstance(directory_path, str) or not directory_path:
+            raise ValueError("Invalid 'directory_path'.")
+        if not (0.0 <= strength <= 1.0):
+            raise ValueError("Invalid 'strength' value.")
+        if not isinstance(temperature, (int, float)) or temperature < 0:
+            raise ValueError("Invalid 'temperature' value.")
+        if not isinstance(verbose, bool):
+            raise ValueError("Invalid 'verbose' value.")
+
+        prompt_template = load_prompt_template("summarize_file_LLM")
+        if not prompt_template:
+            raise FileNotFoundError("Prompt template 'summarize_file_LLM.prompt' not found.")
+
+        csv_output = "full_path,file_summary,date\n"
+        total_cost = 0.0
+        model_name = "None"
+
+        existing_data = {}
+        if csv_file:
+            if not validate_csv_format(csv_file):
+                raise ValueError("Invalid CSV file format.")
+            existing_data = parse_existing_csv(csv_file, verbose)
+
+        # Get list of files first to ensure consistent order
+        files = sorted(glob.glob(directory_path, recursive=True))
+        if not files:
+            if verbose:
+                print("[yellow]No files found.[/yellow]")
+            return csv_output, total_cost, model_name
+
+        # Get all modification times at once to ensure consistent order
+        file_mod_times = {f: os.path.getmtime(f) for f in files}
+
+        for file_path in track(files, description="Processing files..."):
+            try:
+                relative_path = os.path.relpath(file_path)
+                normalized_path = normalize_path(relative_path)
+                file_mod_time = file_mod_times[file_path]
+                date_generated = datetime.now(UTC).isoformat()
+
+                if verbose:
+                    print(f"\nProcessing file: {normalized_path}")
+                    print(f"Modification time: {datetime.fromtimestamp(file_mod_time, UTC)}")
+
+                needs_summary = True
+                if normalized_path in existing_data:
+                    try:
+                        existing_entry = existing_data[normalized_path]
+                        existing_date = parse_date(existing_entry['date'])
+                        file_date = datetime.fromtimestamp(file_mod_time, UTC)
+                        
+                        if verbose:
+                            print(f"Existing date: {existing_date}")
+                            print(f"File date: {file_date}")
+                        
+                        # Explicitly check if file is newer
+                        if file_date > existing_date:
+                            if verbose:
+                                print(f"[blue]File modified, generating new summary[/blue]")
+                            needs_summary = True
+                        else:
+                            needs_summary = False
+                            file_summary = existing_entry['file_summary']
+                            date_generated = existing_entry['date']
+                            if verbose:
+                                print(f"[green]Reusing existing summary[/green]")
+                    except Exception as e:
+                        if verbose:
+                            print(f"[yellow]Warning: Date comparison error: {str(e)}[/yellow]")
+                        needs_summary = True
+                elif verbose:
+                    print("[blue]New file, generating summary[/blue]")
+
+                if needs_summary:
+                    if verbose:
+                        print(f"[blue]Generating summary for: {normalized_path}[/blue]")
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        file_contents = f.read()
+
+                    input_params = {"file_contents": file_contents}
+                    response = llm_invoke(
+                        prompt=prompt_template,
+                        input_json=input_params,
+                        strength=strength,
+                        temperature=temperature,
+                        verbose=verbose,
+                        output_pydantic=FileSummary
+                    )
+
+                    if response.get('error'):
+                        file_summary = "Error in summarization."
+                        if verbose:
+                            print(f"[red]Error summarizing file: {response['error']}[/red]")
+                    else:
+                        file_summary = response['result'].file_summary
+                        total_cost += response.get('cost', 0.0)
+                        model_name = response.get('model_name', model_name)
+
+                csv_output += f'"{relative_path}","{file_summary.replace(chr(34), "")}",{date_generated}\n'
+
+            except Exception as e:
+                if verbose:
+                    print(f"[red]Error processing file: {str(e)}[/red]")
+                date_generated = datetime.now(UTC).isoformat()
+                csv_output += f'"{relative_path}","Error processing file",{date_generated}\n'
+
+        return csv_output, total_cost, model_name
+
+    except Exception as e:
+        print(f"[red]An error occurred: {str(e)}[/red]")
+        raise