code-puppy 0.0.152__tar.gz → 0.0.153__tar.gz

{code_puppy-0.0.152 → code_puppy-0.0.153}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.152
+Version: 0.0.153
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.152 → code_puppy-0.0.153}/code_puppy/config.py

@@ -76,7 +76,7 @@ def get_allow_recursion() -> bool:
     """
     val = get_value("allow_recursion")
     if val is None:
-        return False  # Default to False for safety
+        return True  # Default to False for safety
     return str(val).lower() in ("1", "true", "yes", "on")
 
 

{code_puppy-0.0.152 → code_puppy-0.0.153}/code_puppy/message_history_processor.py

@@ -31,7 +31,7 @@ def estimate_token_count(text: str) -> int:
     Simple token estimation using len(message) - 4.
     This replaces tiktoken with a much simpler approach.
     """
-    return max(1, len(text) - 4)
+    return int(max(1, len(text)) / 4)
 
 
 def stringify_message_part(part) -> str:
@@ -86,7 +86,7 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
         if part_str:
             total_tokens += estimate_token_count(part_str)
 
-    return max(1, total_tokens)
+    return int(max(1, total_tokens) / 4)
 
 
 def filter_huge_messages(messages: List[ModelMessage]) -> List[ModelMessage]:

{code_puppy-0.0.152 → code_puppy-0.0.153}/code_puppy/tools/file_operations.py

@@ -1,6 +1,7 @@
 # file_operations.py
 
 import os
+import tempfile
 from typing import List
 
 from pydantic import BaseModel, conint
@@ -46,7 +47,7 @@ class ListedFile(BaseModel):
 
 
 class ListFileOutput(BaseModel):
-    files: List[ListedFile]
+    content: str
     error: str | None = None
 
 
@@ -125,116 +126,182 @@ def is_project_directory(directory):
 def _list_files(
     context: RunContext, directory: str = ".", recursive: bool = True
 ) -> ListFileOutput:
-        
+    import subprocess
+    import tempfile
+    import shutil
+    import sys
+
     results = []
     directory = os.path.abspath(directory)
 
-    # Generate group_id for this tool execution
-    group_id = generate_group_id("list_files", directory)
-
-    emit_info(
-        "\n[bold white on blue] DIRECTORY LISTING [/bold white on blue]",
-        message_group=group_id,
-    )
-    emit_info(
-        f"\U0001f4c2 [bold cyan]{directory}[/bold cyan] [dim](recursive={recursive})[/dim]\n",
-        message_group=group_id,
-    )
-    emit_divider(message_group=group_id)
+    # Build string representation
+    output_lines = []
+    
+    directory_listing_header = "\n[bold white on blue] DIRECTORY LISTING [/bold white on blue]"
+    output_lines.append(directory_listing_header)
+    
+    directory_info = f"\U0001f4c2 [bold cyan]{directory}[/bold cyan] [dim](recursive={recursive})[/dim]\n"
+    output_lines.append(directory_info)
+    
+    divider = "[dim]" + "─" * 100 + "\n" + "[/dim]"
+    output_lines.append(divider)
+    
     if not os.path.exists(directory):
-        emit_error(f"Directory '{directory}' does not exist", message_group=group_id)
-        emit_divider(message_group=group_id)
-        return ListFileOutput(
-            files=[ListedFile(path=None, type=None, full_path=None, depth=None)]
-        )
+        error_msg = f"[red bold]Error:[/red bold] Directory '{directory}' does not exist"
+        output_lines.append(error_msg)
+        
+        output_lines.append(divider)
+        return ListFileOutput(content="\n".join(output_lines))
     if not os.path.isdir(directory):
-        emit_error(f"'{directory}' is not a directory", message_group=group_id)
-        emit_divider(message_group=group_id)
-        return ListFileOutput(
-            files=[ListedFile(path=None, type=None, full_path=None, depth=None)]
-        )
+        error_msg = f"[red bold]Error:[/red bold] '{directory}' is not a directory"
+        output_lines.append(error_msg)
+        
+        output_lines.append(divider)
+        return ListFileOutput(content="\n".join(output_lines))
 
     # Smart home directory detection - auto-limit recursion for performance
     # But allow recursion in tests (when context=None) or when explicitly requested
     if context is not None and is_likely_home_directory(directory) and recursive:
         if not is_project_directory(directory):
-            emit_warning(
-                "🏠 Detected home directory - limiting to non-recursive listing for performance",
-                message_group=group_id,
-            )
-            emit_info(
-                f"💡 To force recursive listing in home directory, use list_files('{directory}', recursive=True) explicitly",
-                message_group=group_id,
-            )
+            warning_msg = "[yellow bold]Warning:[/yellow bold] 🏠 Detected home directory - limiting to non-recursive listing for performance"
+            output_lines.append(warning_msg)
+            
+            info_msg = f"[dim]💡 To force recursive listing in home directory, use list_files('{directory}', recursive=True) explicitly[/dim]"
+            output_lines.append(info_msg)
             recursive = False
-    folder_structure = {}
-    file_list = []
-    for root, dirs, files in os.walk(directory):
-        # Filter out ignored directories
-        dirs[:] = [d for d in dirs if not should_ignore_path(os.path.join(root, d))]
+            
+    # Create a temporary ignore file with our ignore patterns
+    ignore_file = None
+    try:
+        # Find ripgrep executable - first check system PATH, then virtual environment
+        rg_path = shutil.which("rg")
+        if not rg_path:
+            # Try to find it in the virtual environment
+            # Use sys.executable to determine the Python environment path
+            python_dir = os.path.dirname(sys.executable)
+            # Check both 'bin' (Unix) and 'Scripts' (Windows) directories
+            for rg_dir in ["bin", "Scripts"]:
+                venv_rg_path = os.path.join(python_dir, "rg")
+                if os.path.exists(venv_rg_path):
+                    rg_path = venv_rg_path
+                    break
+                # Also check with .exe extension for Windows
+                venv_rg_exe_path = os.path.join(python_dir, "rg.exe")
+                if os.path.exists(venv_rg_exe_path):
+                    rg_path = venv_rg_exe_path
+                    break
         
-        rel_path = os.path.relpath(root, directory)
-        depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
-        if rel_path == ".":
-            rel_path = ""
+        if not rg_path:
+            error_msg = f"[red bold]Error:[/red bold] ripgrep (rg) not found. Please install ripgrep to use this tool."
+            output_lines.append(error_msg)
+            return ListFileOutput(content="\n".join(output_lines))
+            
+        # Build command for ripgrep --files
+        cmd = [rg_path, "--files"]
         
-        # Add directory entry for subdirectories (except root)
-        if rel_path:
-            dir_path = os.path.join(directory, rel_path)
-            results.append(
-                ListedFile(
-                    path=rel_path,
-                    type="directory",
-                    size=0,
-                    full_path=dir_path,
-                    depth=depth,
-                )
-            )
-            folder_structure[rel_path] = {
-                "path": rel_path,
-                "depth": depth,
-                "full_path": dir_path,
-            }
-        else:  # Root directory - add both directories and files
-            # Add directories
-            for d in dirs:
-                dir_path = os.path.join(root, d)
+        # For non-recursive mode, we'll limit depth after getting results
+        if not recursive:
+            cmd.extend(["--max-depth", "1"])
+            
+        # Add ignore patterns to the command via a temporary file
+        from code_puppy.tools.common import IGNORE_PATTERNS
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.ignore') as f:
+            ignore_file = f.name
+            for pattern in IGNORE_PATTERNS:
+                f.write(f"{pattern}\n")
+        
+        cmd.extend(["--ignore-file", ignore_file])
+        cmd.append(directory)
+        
+        # Run ripgrep to get file listing
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        
+        # Process the output lines
+        files = result.stdout.strip().split('\n') if result.stdout.strip() else []
+        
+        # Create ListedFile objects with metadata
+        for file_path in files:
+            if not file_path:  # Skip empty lines
+                continue
+                
+            full_path = os.path.join(directory, file_path)
+            
+            # Skip if file doesn't exist (though it should)
+            if not os.path.exists(full_path):
+                continue
+                
+            # For non-recursive mode, skip files in subdirectories
+            if not recursive and os.sep in file_path:
+                continue
+                
+            # Check if path is a file or directory
+            if os.path.isfile(full_path):
+                entry_type = "file"
+                size = os.path.getsize(full_path)
+            elif os.path.isdir(full_path):
+                entry_type = "directory"
+                size = 0
+            else:
+                # Skip if it's neither a file nor directory
+                continue
+                
+            try:
+                # Get stats for the entry
+                stat_info = os.stat(full_path)
+                actual_size = stat_info.st_size
+                
+                # For files, we use the actual size; for directories, we keep size=0
+                if entry_type == "file":
+                    size = actual_size
+                
+                # Calculate depth
+                depth = file_path.count(os.sep)
+                
+                # Add directory entries if needed for files
+                if entry_type == "file":
+                    dir_path = os.path.dirname(file_path)
+                    if dir_path:
+                        # Add directory path components if they don't exist
+                        path_parts = dir_path.split(os.sep)
+                        for i in range(len(path_parts)):
+                            partial_path = os.sep.join(path_parts[:i+1])
+                            # Check if we already added this directory
+                            if not any(f.path == partial_path and f.type == "directory" for f in results):
+                                results.append(
+                                    ListedFile(
+                                        path=partial_path,
+                                        type="directory",
+                                        size=0,
+                                        full_path=os.path.join(directory, partial_path),
+                                        depth=partial_path.count(os.sep),
+                                    )
+                                )
+                
+                # Add the entry (file or directory)
                 results.append(
                     ListedFile(
-                        path=d,
-                        type="directory",
-                        size=0,
-                        full_path=dir_path,
+                        path=file_path,
+                        type=entry_type,
+                        size=size,
+                        full_path=full_path,
                         depth=depth,
                     )
                 )
-                folder_structure[d] = {
-                    "path": d,
-                    "depth": depth,
-                    "full_path": dir_path,
-                }
-        
-        # Add files to results
-        for file in files:
-            file_path = os.path.join(root, file)
-            if should_ignore_path(file_path):
+            except (FileNotFoundError, PermissionError, OSError):
+                # Skip files we can't access
                 continue
-            rel_file_path = os.path.join(rel_path, file) if rel_path else file
-            try:
-                size = os.path.getsize(file_path)
-                file_info = {
-                    "path": rel_file_path,
-                    "type": "file",
-                    "size": size,
-                    "full_path": file_path,
-                    "depth": depth,
-                }
-                results.append(ListedFile(**file_info))
-                file_list.append(file_info)
-            except (FileNotFoundError, PermissionError):
-                continue
-        if not recursive:
-            break
+    except subprocess.TimeoutExpired:
+        error_msg = f"[red bold]Error:[/red bold] List files command timed out after 30 seconds"
+        output_lines.append(error_msg)
+        return ListFileOutput(content="\n".join(output_lines))
+    except Exception as e:
+        error_msg = f"[red bold]Error:[/red bold] Error during list files operation: {e}"
+        output_lines.append(error_msg)
+        return ListFileOutput(content="\n".join(output_lines))
+    finally:
+        # Clean up the temporary ignore file
+        if ignore_file and os.path.exists(ignore_file):
+            os.unlink(ignore_file)
 
     def format_size(size_bytes):
         if size_bytes < 1024:
@@ -275,20 +342,31 @@ def _list_files(
         else:
             return "\U0001f4c4"
 
-    if results:
-        files = sorted([f for f in results if f.type == "file"], key=lambda x: x.path)
-        emit_info(
-            f"\U0001f4c1 [bold blue]{os.path.basename(directory) or directory}[/bold blue]",
-            message_group=group_id,
-        )
+    dir_count = sum(1 for item in results if item.type == "directory")
+    file_count = sum(1 for item in results if item.type == "file")
+    total_size = sum(item.size for item in results if item.type == "file")
+    
+    # Build the directory header section
+    dir_name = os.path.basename(directory) or directory
+    dir_header = f"\U0001f4c1 [bold blue]{dir_name}[/bold blue]"
+    output_lines.append(dir_header)
+    
+    # Sort all items by path for consistent display
     all_items = sorted(results, key=lambda x: x.path)
+    
+    # Build file and directory tree representation
     parent_dirs_with_content = set()
-    for i, item in enumerate(all_items):
+    for item in all_items:
+        # Skip root directory entries with no path
         if item.type == "directory" and not item.path:
             continue
+        
+        # Track parent directories that contain files/dirs
         if os.sep in item.path:
             parent_path = os.path.dirname(item.path)
             parent_dirs_with_content.add(parent_path)
+            
+        # Calculate indentation depth based on path separators
         depth = item.path.count(os.sep) + 1 if item.path else 0
         prefix = ""
         for d in range(depth):
@@ -296,29 +374,32 @@ def _list_files(
                 prefix += "\u2514\u2500\u2500 "
             else:
                 prefix += "    "
+                
+        # Get the display name (basename) of the item
         name = os.path.basename(item.path) or item.path
+        
+        # Add directory or file line with appropriate formatting
         if item.type == "directory":
-            emit_info(
-                f"{prefix}\U0001f4c1 [bold blue]{name}/[/bold blue]",
-                message_group=group_id,
-            )
+            dir_line = f"{prefix}\U0001f4c1 [bold blue]{name}/[/bold blue]"
+            output_lines.append(dir_line)
         else:
             icon = get_file_icon(item.path)
             size_str = format_size(item.size)
-            emit_info(
-                f"{prefix}{icon} [green]{name}[/green] [dim]({size_str})[/dim]",
-                message_group=group_id,
-            )
-    dir_count = sum(1 for item in results if item.type == "directory")
-    file_count = sum(1 for item in results if item.type == "file")
-    total_size = sum(item.size for item in results if item.type == "file")
-    emit_info("\n[bold cyan]Summary:[/bold cyan]", message_group=group_id)
-    emit_info(
-        f"\U0001f4c1 [blue]{dir_count} directories[/blue], \U0001f4c4 [green]{file_count} files[/green] [dim]({format_size(total_size)} total)[/dim]",
-        message_group=group_id,
-    )
-    emit_divider(message_group=group_id)
-    return ListFileOutput(files=results)
+            file_line = f"{prefix}{icon} [green]{name}[/green] [dim]({size_str})[/dim]"
+            output_lines.append(file_line)
+    
+    # Add summary information
+    summary_header = "\n[bold cyan]Summary:[/bold cyan]"
+    output_lines.append(summary_header)
+    
+    summary_line = f"\U0001f4c1 [blue]{dir_count} directories[/blue], \U0001f4c4 [green]{file_count} files[/green] [dim]({format_size(total_size)} total)[/dim]"
+    output_lines.append(summary_line)
+    
+    final_divider = "[dim]" + "─" * 100 + "\n" + "[/dim]"
+    output_lines.append(final_divider)
+    
+    # Return both the content string and the list of ListedFile objects
+    return ListFileOutput(content="\n".join(output_lines), files=results)
 
 
 def _read_file(
@@ -530,25 +611,18 @@ def register_list_files(agent):
                 Defaults to True.
 
         Returns:
-            ListFileOutput: A structured response containing:
-                - files (List[ListedFile]): List of files and directories found, where
-                  each ListedFile contains:
-                  - path (str | None): Relative path from the listing directory
-                  - type (str | None): "file" or "directory"
-                  - size (int): File size in bytes (0 for directories)
-                  - full_path (str | None): Absolute path to the item
-                  - depth (int | None): Nesting depth from the root directory
+            ListFileOutput: A response containing:
+                - content (str): String representation of the directory listing
                 - error (str | None): Error message if listing failed
 
         Examples:
             >>> # List current directory
             >>> result = list_files(ctx)
-            >>> for file in result.files:
-            ...     print(f"{file.type}: {file.path} ({file.size} bytes)")
+            >>> print(result.content)
 
             >>> # List specific directory non-recursively
             >>> result = list_files(ctx, "/path/to/project", recursive=False)
-            >>> print(f"Found {len(result.files)} items")
+            >>> print(result.content)
 
             >>> # Handle potential errors
             >>> result = list_files(ctx, "/nonexistent/path")
@@ -566,9 +640,13 @@ def register_list_files(agent):
             warning = "Recursion disabled globally for list_files - returning non-recursive results"
             recursive = False
         result = _list_files(context, directory, recursive)
+        
+        # Emit the content directly to ensure it's displayed to the user
+        emit_info(result.content, message_group=generate_group_id("list_files", directory))
+        
         if warning:
             result.error = warning
-        return  result
+        return result
 
 
 def register_read_file(agent):

{code_puppy-0.0.152 → code_puppy-0.0.153}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.152"
+version = "0.0.153"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"