pdd-cli 0.0.90__py3-none-any.whl → 0.0.121__py3-none-any.whl

pdd/summarize_directory.py

@@ -1,265 +1,264 @@
-from typing import Callable, Optional, Tuple
-from datetime import datetime
-try:
-    from datetime import UTC
-except ImportError:
-    # Python < 3.11 compatibility
-    from datetime import timezone
-    UTC = timezone.utc
-from io import StringIO
-import os
+from __future__ import annotations
+
 import glob
+import hashlib
+import io
 import csv
-
+import os
+from typing import Optional, List, Dict, Tuple, Callable
 from pydantic import BaseModel, Field
-from rich import print
-from rich.progress import track
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
 
-from .load_prompt_template import load_prompt_template
+# Internal imports based on package structure
 from .llm_invoke import llm_invoke
+from .load_prompt_template import load_prompt_template
 from . import DEFAULT_TIME
 
-class FileSummary(BaseModel):
-    file_summary: str = Field(description="The summary of the file")
+console = Console()
 
-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
+class FileSummary(BaseModel):
+    """Pydantic model for structured LLM output."""
+    file_summary: str = Field(..., description="A concise summary of the file contents.")
 
 def summarize_directory(
     directory_path: str,
     strength: float,
     temperature: float,
-    verbose: bool,
     time: float = DEFAULT_TIME,
+    verbose: bool = False,
     csv_file: Optional[str] = None,
     progress_callback: Optional[Callable[[int, int], None]] = None
 ) -> Tuple[str, float, str]:
     """
-    Summarize files in a directory and generate a CSV containing the summaries.
+    Summarizes files in a directory using an LLM, with caching based on content hashes.
 
-    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.
-        time (float): Time budget for LLM calls.
-        csv_file (Optional[str]): Current CSV file contents if it already exists.
-        progress_callback (Optional[Callable[[int, int], None]]): Callback for progress updates.
-            Called with (current, total) for each file processed. Used by TUI ProgressBar.
+    Args:
+        directory_path: Path to the directory/files (supports wildcards, e.g., 'src/*.py').
+        strength: Float (0-1) indicating LLM model strength.
+        temperature: Float controlling LLM randomness.
+        time: Float (0-1) controlling thinking effort.
+        verbose: Whether to print detailed logs.
+        csv_file: Existing CSV content string to check for cache hits.
+        progress_callback: Optional callback for progress updates (current, total).
 
     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.
+        Tuple containing:
+        - csv_output (str): The updated CSV content.
+        - total_cost (float): Total cost of LLM operations.
+        - model_name (str): Name of the model used (from the last successful call).
     """
-    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)
-
-        # Expand directory_path: support plain directories or glob patterns
+    
+    # Step 1: Input Validation
+    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)) and temperature >= 0):
+        raise ValueError("Invalid 'temperature' value.")
+    if not isinstance(verbose, bool):
+        raise ValueError("Invalid 'verbose' value.")
+    
+    # Parse existing CSV if provided to validate format and get cached entries
+    existing_data: Dict[str, Dict[str, str]] = {}
+    if csv_file:
         try:
-            normalized_input = normalize_path(directory_path)
+            f = io.StringIO(csv_file)
+            reader = csv.DictReader(f)
+            if reader.fieldnames and not all(field in reader.fieldnames for field in ['full_path', 'file_summary', 'content_hash']):
+                 raise ValueError("Missing required columns.")
+            for row in reader:
+                if 'full_path' in row and 'content_hash' in row:
+                    # Use normalized path for cache key consistency
+                    existing_data[os.path.normpath(row['full_path'])] = row
         except Exception:
-            normalized_input = directory_path
-
-        if os.path.isdir(normalized_input):
-            # Recursively include all files under the directory
-            search_pattern = os.path.join(normalized_input, "**", "*")
-        else:
-            # Treat as a glob pattern (may be a single file path too)
-            search_pattern = directory_path
-
-        # Get list of files first to ensure consistent order
-        all_files = sorted(glob.glob(search_pattern, recursive=True))
-        if not all_files:
-            if verbose:
-                print("[yellow]No files found.[/yellow]")
-            return csv_output, total_cost, model_name
-
-        # Pre-filter to get only processable files (for accurate progress count)
-        files = [
-            f for f in all_files
-            if not os.path.isdir(f)
-            and '__pycache__' not in f
-            and not f.endswith(('.pyc', '.pyo'))
-        ]
-
-        if not files:
-            if verbose:
-                print("[yellow]No processable 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}
-
-        # Determine iteration method: use callback if provided, else track()
-        # Disable track() when in TUI context (COLUMNS env var set) or callback provided
-        total_files = len(files)
-        use_track = progress_callback is None and "COLUMNS" not in os.environ
-
-        if use_track:
-            file_iterator = track(files, description="Processing files...")
-        else:
-            file_iterator = files
-
-        for idx, file_path in enumerate(file_iterator):
-            # Report progress if callback provided
-            if progress_callback is not None:
-                progress_callback(idx + 1, total_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,
-                        time=time,
-                        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:
+            raise ValueError("Invalid CSV file format.")
+
+    # Step 2: Load prompt template
+    prompt_template_name = "summarize_file_LLM"
+    prompt_template = load_prompt_template(prompt_template_name)
+    if not prompt_template:
+        raise FileNotFoundError(f"Prompt template '{prompt_template_name}' is empty or missing.")
+
+    # Step 3: Get list of files matching directory_path
+    # If directory_path is a directory, convert to recursive glob pattern
+    if os.path.isdir(directory_path):
+        search_pattern = os.path.join(directory_path, "**", "*")
+    else:
+        search_pattern = directory_path
+
+    files = glob.glob(search_pattern, recursive=True)
+    
+    # Filter out directories, keep only files
+    # Also filter out __pycache__ and .pyc/.pyo files
+    filtered_files = []
+    for f in files:
+        if os.path.isfile(f):
+            if "__pycache__" in f:
+                continue
+            if f.endswith(('.pyc', '.pyo')):
+                continue
+            filtered_files.append(f)
+    
+    files = filtered_files
+
+    # Step 4: Return early if no files
+    if not files:
+        # Return empty CSV header
+        output_io = io.StringIO()
+        writer = csv.DictWriter(output_io, fieldnames=['full_path', 'file_summary', 'content_hash'])
+        writer.writeheader()
+        return output_io.getvalue(), 0.0, "None"
+
+    results_data: List[Dict[str, str]] = []
+    total_cost = 0.0
+    last_model_name = "cached"
+
+    # Step 6: Iterate through files with progress reporting
+    total_files = len(files)
+
+    if progress_callback:
+        for i, file_path in enumerate(files):
+            progress_callback(i + 1, total_files)
+            cost, model = _process_single_file_logic(
+                file_path, 
+                existing_data, 
+                prompt_template, 
+                strength, 
+                temperature, 
+                time, 
+                verbose, 
+                results_data
+            )
+            total_cost += cost
+            if model != "cached":
+                last_model_name = model
+    else:
+        console.print(f"[bold blue]Summarizing {len(files)} files in '{directory_path}'...[/bold blue]")
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("{task.percentage:>3.0f}%"),
+            console=console
+        ) as progress:
+            task = progress.add_task("[cyan]Processing files...", total=len(files))
+            for file_path in files:
+                cost, model = _process_single_file_logic(
+                    file_path, 
+                    existing_data, 
+                    prompt_template, 
+                    strength, 
+                    temperature, 
+                    time, 
+                    verbose, 
+                    results_data
+                )
+                total_cost += cost
+                if model != "cached":
+                    last_model_name = model
+                progress.advance(task)
+
+    # Step 7: Generate CSV output
+    output_io = io.StringIO()
+    fieldnames = ['full_path', 'file_summary', 'content_hash']
+    writer = csv.DictWriter(output_io, fieldnames=fieldnames)
+    
+    writer.writeheader()
+    writer.writerows(results_data)
+    
+    csv_output = output_io.getvalue()
+    
+    return csv_output, total_cost, last_model_name
+
+def _process_single_file_logic(
+    file_path: str,
+    existing_data: Dict[str, Dict[str, str]],
+    prompt_template: str,
+    strength: float,
+    temperature: float,
+    time: float,
+    verbose: bool,
+    results_data: List[Dict[str, str]]
+) -> Tuple[float, str]:
+    """
+    Helper function to process a single file: read, hash, check cache, summarize if needed.
+    Returns (cost, model_name).
+    """
+    cost = 0.0
+    model_name = "cached"
+    
+    try:
+        # Step 6a: Read file
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+        
+        # Step 6b: Compute hash
+        current_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()
+        
+        summary = ""
+        
+        # Step 6c: Check cache (using normalized path)
+        normalized_path = os.path.normpath(file_path)
+        cache_hit = False
+        
+        if normalized_path in existing_data:
+            cached_entry = existing_data[normalized_path]
+            # Step 6d: Check hash match
+            if cached_entry.get('content_hash') == current_hash:
+                # Step 6e: Reuse summary
+                summary = cached_entry.get('file_summary', "")
+                cache_hit = True
                 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'
+                    console.print(f"[dim]Cache hit for {file_path}[/dim]")
 
-        return csv_output, total_cost, model_name
+        # Step 6f: Summarize if needed
+        if not cache_hit:
+            if verbose:
+                console.print(f"[dim]Summarizing {file_path}...[/dim]")
+            
+            llm_result = llm_invoke(
+                prompt=prompt_template,
+                input_json={"file_contents": content},
+                strength=strength,
+                temperature=temperature,
+                time=time,
+                output_pydantic=FileSummary,
+                verbose=verbose
+            )
+            
+            file_summary_obj: FileSummary = llm_result['result']
+            summary = file_summary_obj.file_summary
+            
+            cost = llm_result.get('cost', 0.0)
+            model_name = llm_result.get('model_name', "unknown")
+
+        # Step 6g: Store data
+        # Note: Requirement says "Store the relative path (not the full path)" in Step 6g description,
+        # but Output definition says "full_path". The existing code stored file_path (from glob).
+        # The new prompt Step 6g says "Store the relative path".
+        # However, the Output schema explicitly demands 'full_path'.
+        # To satisfy the Output schema which is usually the contract, we keep using file_path as 'full_path'.
+        # But we will calculate relative path if needed. 
+        # Given the conflict, usually the Output definition takes precedence for the CSV column name,
+        # but the value might need to be relative. 
+        # Let's stick to the existing behavior (glob path) which satisfied 'full_path' previously,
+        # unless 'relative path' implies os.path.relpath(file_path, start=directory_path_root).
+        # The prompt is slightly ambiguous: "Store the relative path... in the current data dictionary" vs Output "full_path".
+        # We will store the path as found by glob to ensure it matches the 'full_path' column expectation.
+        
+        results_data.append({
+            'full_path': file_path,
+            'file_summary': summary,
+            'content_hash': current_hash
+        })
 
     except Exception as e:
-        print(f"[red]An error occurred: {str(e)}[/red]")
-        raise
+        console.print(f"[bold red]Error processing file {file_path}:[/bold red] {e}")
+        results_data.append({
+            'full_path': file_path,
+            'file_summary': f"Error processing file: {str(e)}",
+            'content_hash': "error"
+        })
+        
+    return cost, model_name

pdd/sync_animation.py

@@ -336,8 +336,13 @@ def _draw_connecting_lines_and_arrows(state: AnimationState, console_width: int)
     max_x = max(all_branch_xs)
 
     # Draw horizontal line on line 2 (index 2)
-    for i in range(min_x, max_x + 1):
-        line_parts[2][i] = "─"
+    # Clamp drawing range to console width to prevent IndexError and wrapping
+    draw_start = max(min_x, 0)
+    draw_end = min(max_x, console_width - 1)
+    
+    if draw_start <= draw_end:
+        for i in range(draw_start, draw_end + 1):
+            line_parts[2][i] = "─"
     
     # Draw vertical connectors only where needed
     # Prompt always connects vertically (lines 0,1 above junction, lines 3,4,5 below)
@@ -639,5 +644,4 @@ def sync_animation(
         console.print_exception(show_locals=True)
         print(f"Error in animation: {e}", flush=True)
     finally:
-        _final_logo_animation_sequence(console)
-
+        _final_logo_animation_sequence(console)