code-puppy 0.0.152__py3-none-any.whl → 0.0.154__py3-none-any.whl

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/message_history_processor.py

@@ -26,14 +26,6 @@ from code_puppy.summarization_agent import run_summarization_sync
 # Default is 50000 but can be customized in ~/.code_puppy/puppy.cfg
 
 
-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)
-
-
 def stringify_message_part(part) -> str:
     """
     Convert a message part to a string representation for token estimation or other uses.
@@ -84,9 +76,9 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
     for part in message.parts:
         part_str = stringify_message_part(part)
         if part_str:
-            total_tokens += estimate_token_count(part_str)
+            total_tokens += len(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/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.dist-info → code_puppy-0.0.154.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.152
+Version: 0.0.154
 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.dist-info → code_puppy-0.0.154.dist-info}/RECORD

@@ -2,10 +2,10 @@ code_puppy/__init__.py,sha256=ehbM1-wMjNmOXk_DBhhJECFyBv2dRHwwo7ucjHeM68E,107
 code_puppy/__main__.py,sha256=pDVssJOWP8A83iFkxMLY9YteHYat0EyWDQqMkKHpWp4,203
 code_puppy/agent.py,sha256=rWqJ2849HSrWPX-IzI31v2sH6_j5pnBRfuum3yxUNt8,7256
 code_puppy/callbacks.py,sha256=6wYB6K_fGSCkKKEFaYOYkJT45WaV5W_NhUIzcvVH_nU,5060
-code_puppy/config.py,sha256=-RaEpG-k5ObjaSYY8SNpVI1dXzujZxKWj-vlLRTsyHY,16166
+code_puppy/config.py,sha256=oJCVEp6cK4u4ynKe-1TGlpB_TW1Q4pp14oFhtGEWhbk,16165
 code_puppy/http_utils.py,sha256=BAvt4hed7fVMXglA7eS9gOb08h2YTuOyai6VmQq09fg,3432
 code_puppy/main.py,sha256=Vv5HSJnkgZhCvvOoXrJ2zqM5P-i47-RcYAU00Z1Pfx0,21733
-code_puppy/message_history_processor.py,sha256=O2rKp7W6YeIg93W8b0XySTUEQgIZm0f_06--_kzHugM,16145
+code_puppy/message_history_processor.py,sha256=aV-vcRcOQJPZPlrokB4CaLMxEU3Y4nDiabb9Ov_sJeU,15933
 code_puppy/model_factory.py,sha256=-_0kJ7qYmRTDk0v3mfp-UrYf0IaDLyG8IMBweDECwJg,11917
 code_puppy/models.json,sha256=dAfpMMI2EEeOMv0ynHSmMuJAYDLcZrs5gCLX3voC4-A,3252
 code_puppy/reopenable_async_client.py,sha256=4UJRaMp5np8cbef9F0zKQ7TPKOfyf5U-Kv-0zYUWDho,8274
@@ -82,7 +82,7 @@ code_puppy/tools/agent_tools.py,sha256=tG11PMmjuU-pYG1MFCgqsYiC1Q8C-zPsitAYXxl3m
 code_puppy/tools/command_runner.py,sha256=GVNsgwjTFD9tkNlycgMNmMoVPdmMkZkbAcHH5y6iMww,26070
 code_puppy/tools/common.py,sha256=pL-9xcRs3rxU7Fl9X9EUgbDp2-csh2LLJ5DHH_KAHKY,10596
 code_puppy/tools/file_modifications.py,sha256=oeNEQItqwMhGOeEN2TzGR7TjmgLsfFFdPaVMzWbfXIQ,30398
-code_puppy/tools/file_operations.py,sha256=rH0pOH0u7ZsQ7bUxaIH38nAiYF9RHmtR_mBNFYBe4ws,27334
+code_puppy/tools/file_operations.py,sha256=IxXEzNsotz3DHUV2YfslNf1_gSJrrOMUPEpI2b3TFw0,31093
 code_puppy/tools/token_check.py,sha256=cNrGOOKahXsnWsvh5xnMkL1NS9FjYur9QIRZGQFW-pE,1189
 code_puppy/tools/tools_content.py,sha256=bsBqW-ppd1XNAS_g50B3UHDQBWEALC1UneH6-afz1zo,2365
 code_puppy/tui/__init__.py,sha256=XesAxIn32zLPOmvpR2wIDxDAnnJr81a5pBJB4cZp1Xs,321
@@ -126,9 +126,9 @@ code_puppy/tui/tests/test_sidebar_history_navigation.py,sha256=JGiyua8A2B8dLfwiE
 code_puppy/tui/tests/test_status_bar.py,sha256=nYT_FZGdmqnnbn6o0ZuOkLtNUtJzLSmtX8P72liQ5Vo,1797
 code_puppy/tui/tests/test_timestamped_history.py,sha256=nVXt9hExZZ_8MFP-AZj4L4bB_1Eo_mc-ZhVICzTuw3I,1799
 code_puppy/tui/tests/test_tools.py,sha256=kgzzAkK4r0DPzQwHHD4cePpVNgrHor6cFr05Pg6DBWg,2687
-code_puppy-0.0.152.data/data/code_puppy/models.json,sha256=dAfpMMI2EEeOMv0ynHSmMuJAYDLcZrs5gCLX3voC4-A,3252
-code_puppy-0.0.152.dist-info/METADATA,sha256=uXmPOqNxbL-NC_0hEvvn4ns4jX3GoyGOSmHMrS5QdBw,19516
-code_puppy-0.0.152.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.152.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.152.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.152.dist-info/RECORD,,
+code_puppy-0.0.154.data/data/code_puppy/models.json,sha256=dAfpMMI2EEeOMv0ynHSmMuJAYDLcZrs5gCLX3voC4-A,3252
+code_puppy-0.0.154.dist-info/METADATA,sha256=r4J6tLEqJwVVG7j5eMrQRI1zMENfwZKdNo2KrOI_pBQ,19516
+code_puppy-0.0.154.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.154.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.154.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.154.dist-info/RECORD,,