code-puppy 0.0.146__tar.gz → 0.0.148__tar.gz

{code_puppy-0.0.146 → code_puppy-0.0.148}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.146
+Version: 0.0.148
 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.146 → code_puppy-0.0.148}/code_puppy/agent.py

@@ -24,11 +24,19 @@ from code_puppy.tools.common import console
 
 def load_puppy_rules():
     global PUPPY_RULES
-    puppy_rules_path = Path("AGENT.md")
-    if puppy_rules_path.exists():
-        with open(puppy_rules_path, "r") as f:
-            puppy_rules = f.read()
-            return puppy_rules
+    
+    # Check for all 4 combinations of the rules file
+    possible_paths = ["AGENTS.md", "AGENT.md", "agents.md", "agent.md"]
+    
+    for path_str in possible_paths:
+        puppy_rules_path = Path(path_str)
+        if puppy_rules_path.exists():
+            with open(puppy_rules_path, "r") as f:
+                puppy_rules = f.read()
+                return puppy_rules
+    
+    # If none of the files exist, return None
+    return None
 
 
 # Load at import

{code_puppy-0.0.146 → code_puppy-0.0.148}/code_puppy/command_line/meta_command_handler.py

@@ -17,7 +17,7 @@ META_COMMANDS_HELP = """
 ~m <model>            Set active model
 ~motd                 Show the latest message of the day (MOTD)
 ~show                 Show puppy config key-values
-~set                  Set puppy config key-values (message_limit, protected_token_count, compaction_threshold, etc.)
+~set                  Set puppy config key-values (message_limit, protected_token_count, compaction_threshold, allow_recursion, etc.)
 ~<unknown>            Show unknown meta command warning
 """
 

{code_puppy-0.0.146 → code_puppy-0.0.148}/code_puppy/config.py

@@ -69,6 +69,17 @@ def get_owner_name():
 # using get_protected_token_count() and get_summarization_threshold()
 
 
+def get_allow_recursion() -> bool:
+    """
+    Get the allow_recursion configuration value.
+    Returns True if recursion is allowed, False otherwise.
+    """
+    val = get_value("allow_recursion")
+    if val is None:
+        return False  # Default to False for safety
+    return str(val).lower() in ("1", "true", "yes", "on")
+
+
 def get_model_context_length() -> int:
     """
     Get the context length for the currently configured model from models.json
@@ -93,9 +104,9 @@ def get_model_context_length() -> int:
 def get_config_keys():
     """
     Returns the list of all config keys currently in puppy.cfg,
-    plus certain preset expected keys (e.g. "yolo_mode", "model", "compaction_strategy", "message_limit").
+    plus certain preset expected keys (e.g. "yolo_mode", "model", "compaction_strategy", "message_limit", "allow_recursion").
     """
-    default_keys = ["yolo_mode", "model", "compaction_strategy", "message_limit"]
+    default_keys = ["yolo_mode", "model", "compaction_strategy", "message_limit", "allow_recursion"]
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     keys = set(config[DEFAULT_SECTION].keys()) if DEFAULT_SECTION in config else set()
@@ -351,7 +362,7 @@ def initialize_command_history_file():
 def get_yolo_mode():
     """
     Checks puppy.cfg for 'yolo_mode' (case-insensitive in value only).
-    Defaults to False if not set.
+    Defaults to True if not set.
     Allowed values for ON: 1, '1', 'true', 'yes', 'on' (all case-insensitive for value).
     """
     true_vals = {"1", "true", "yes", "on"}
@@ -360,7 +371,7 @@ def get_yolo_mode():
         if str(cfg_val).strip().lower() in true_vals:
             return True
         return False
-    return False
+    return True
 
 
 def get_mcp_disabled():

{code_puppy-0.0.146 → code_puppy-0.0.148}/code_puppy/tools/file_operations.py

@@ -41,6 +41,7 @@ class ListedFile(BaseModel):
     path: str | None
     type: str | None
     size: int = 0
+    full_path: str | None
     depth: int | None
 
 
@@ -124,6 +125,7 @@ def is_project_directory(directory):
 def _list_files(
     context: RunContext, directory: str = ".", recursive: bool = True
 ) -> ListFileOutput:
+        
     results = []
     directory = os.path.abspath(directory)
 
@@ -153,7 +155,8 @@ def _list_files(
         )
 
     # Smart home directory detection - auto-limit recursion for performance
-    if is_likely_home_directory(directory) and recursive:
+    # 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",
@@ -167,22 +170,24 @@ def _list_files(
     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))]
+        
         rel_path = os.path.relpath(root, directory)
         depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
         if rel_path == ".":
             rel_path = ""
+        
+        # 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,
-                    }
+                    path=rel_path,
+                    type="directory",
+                    size=0,
+                    full_path=dir_path,
+                    depth=depth,
                 )
             )
             folder_structure[rel_path] = {
@@ -190,6 +195,26 @@ def _list_files(
                 "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)
+                results.append(
+                    ListedFile(
+                        path=d,
+                        type="directory",
+                        size=0,
+                        full_path=dir_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):
@@ -284,8 +309,6 @@ def _list_files(
                 f"{prefix}{icon} [green]{name}[/green] [dim]({size_str})[/dim]",
                 message_group=group_id,
             )
-    else:
-        emit_warning("Directory is empty", 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")
@@ -433,207 +456,18 @@ def _grep(context: RunContext, search_string: str, directory: str = ".") -> Grep
     return GrepOutput(matches=matches)
 
 
-# Exported top-level functions for direct import by tests and other code
-
-
-def list_files(context, directory=".", recursive=True):
-    return _list_files(context, directory, recursive)
-
-
-def read_file(context, file_path, start_line=None, num_lines=None):
-    return _read_file(context, file_path, start_line, num_lines)
-
-
-def grep(context, search_string, directory="."):
-    return _grep(context, search_string, directory)
-
-
-def register_file_operations_tools(agent):
-    @agent.tool
-    def list_files(
-        context: RunContext, directory: str = ".", recursive: bool = True
-    ) -> ListFileOutput:
-        """List files and directories with intelligent filtering and safety features.
-
-        This tool provides comprehensive directory listing with smart home directory
-        detection, project-aware recursion, and token-safe output. It automatically
-        ignores common build artifacts, cache directories, and other noise while
-        providing rich file metadata and visual formatting.
-
-        Args:
-            context (RunContext): The PydanticAI runtime context for the agent.
-            directory (str, optional): Path to the directory to list. Can be relative
-                or absolute. Defaults to "." (current directory).
-            recursive (bool, optional): Whether to recursively list subdirectories.
-                Automatically disabled for home directories unless they contain
-                project indicators. 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
-                - error (str | None): Error message if listing failed
-
-        Note:
-            - Automatically ignores common patterns (.git, node_modules, __pycache__, etc.)
-            - Limits output to 10,000 tokens for safety (suggests non-recursive if exceeded)
-            - Smart home directory detection prevents performance issues
-            - Files are displayed with appropriate icons and size formatting
-            - Project directories are detected via common configuration files
-
-        Examples:
-            >>> result = list_files(ctx, "./src", recursive=True)
-            >>> if not result.error:
-            ...     for file in result.files:
-            ...         if file.type == "file" and file.path.endswith(".py"):
-            ...             print(f"Python file: {file.path} ({file.size} bytes)")
-
-        Best Practice:
-            - Use recursive=False for initial exploration of unknown directories
-            - When encountering "too many files" errors, try non-recursive listing
-            - Check the error field before processing the files list
-        """
-        list_files_result = _list_files(context, directory, recursive)
-        num_tokens = (
-            len(list_files_result.model_dump_json()) / 4
-        )  # Rough estimate of tokens
-        if num_tokens > 10000:
-            return ListFileOutput(
-                files=[],
-                error="Too many files - tokens exceeded. Try listing non-recursively",
-            )
-        return list_files_result
-
-    @agent.tool
-    def read_file(
-        context: RunContext,
-        file_path: str = "",
-        start_line: int | None = None,
-        num_lines: int | None = None,
-    ) -> ReadFileOutput:
-        """Read file contents with optional line-range selection and token safety.
-
-        This tool provides safe file reading with automatic token counting and
-        optional line-range selection for handling large files efficiently.
-        It protects against reading excessively large files that could overwhelm
-        the agent's context window.
-
-        Args:
-            context (RunContext): The PydanticAI runtime context for the agent.
-            file_path (str): Path to the file to read. Can be relative or absolute.
-                Cannot be empty.
-            start_line (int | None, optional): Starting line number for partial reads
-                (1-based indexing). If specified, num_lines must also be provided.
-                Defaults to None (read entire file).
-            num_lines (int | None, optional): Number of lines to read starting from
-                start_line. Must be specified if start_line is provided.
-                Defaults to None (read to end of file).
-
-        Returns:
-            ReadFileOutput: A structured response containing:
-                - content (str | None): The file contents or error message
-                - num_tokens (int): Estimated token count (constrained to < 10,000)
-                - error (str | None): Error message if reading failed
-
-        Note:
-            - Files larger than 10,000 estimated tokens cannot be read entirely
-            - Token estimation uses ~4 characters per token approximation
-            - Line numbers are 1-based (first line is line 1)
-            - Supports UTF-8 encoding with fallback error handling
-            - Non-existent files return "FILE NOT FOUND" for backward compatibility
-
-        Examples:
-            >>> # Read entire file
-            >>> result = read_file(ctx, "config.py")
-            >>> if not result.error:
-            ...     print(f"File has {result.num_tokens} tokens")
-            ...     print(result.content)
-
-            >>> # Read specific line range
-            >>> result = read_file(ctx, "large_file.py", start_line=100, num_lines=50)
-            >>> # Reads lines 100-149
-
-        Raises:
-            ValueError: If file exceeds 10,000 token safety limit (caught and returned as error)
-
-        Best Practice:
-            - For large files, use line-range reading to avoid token limits
-            - Always check the error field before processing content
-            - Use grep tool first to locate relevant sections in large files
-            - Prefer reading configuration files entirely, code files in chunks
-        """
-        return _read_file(context, file_path, start_line, num_lines)
-
-    @agent.tool
-    def grep(
-        context: RunContext, search_string: str = "", directory: str = "."
-    ) -> GrepOutput:
-        """Recursively search for text patterns across files with intelligent filtering.
-
-        This tool provides powerful text searching across directory trees with
-        automatic filtering of irrelevant files, binary detection, and match limiting
-        for performance. It's essential for code exploration and finding specific
-        patterns or references.
-
-        Args:
-            context (RunContext): The PydanticAI runtime context for the agent.
-            search_string (str): The text pattern to search for. Performs exact
-                string matching (not regex). Cannot be empty.
-            directory (str, optional): Root directory to start the recursive search.
-                Can be relative or absolute. Defaults to "." (current directory).
-
-        Returns:
-            GrepOutput: A structured response containing:
-                - matches (List[MatchInfo]): List of matches found, where each
-                  MatchInfo contains:
-                  - file_path (str | None): Absolute path to the file containing the match
-                  - line_number (int | None): Line number where match was found (1-based)
-                  - line_content (str | None): Full line content containing the match
-
-        Note:
-            - Automatically ignores common patterns (.git, node_modules, __pycache__, etc.)
-            - Skips binary files and handles Unicode decode errors gracefully
-            - Limited to 200 matches maximum for performance and relevance
-            - UTF-8 encoding with error tolerance for text files
-            - Results are not sorted - appear in filesystem traversal order
-
-        Examples:
-            >>> # Search for function definitions
-            >>> result = grep(ctx, "def calculate_", "./src")
-            >>> for match in result.matches:
-            ...     print(f"{match.file_path}:{match.line_number}: {match.line_content.strip()}")
-
-            >>> # Find configuration references
-            >>> result = grep(ctx, "DATABASE_URL", ".")
-            >>> print(f"Found {len(result.matches)} references to DATABASE_URL")
-
-        Warning:
-            - Large codebases may hit the 200 match limit
-            - Search is case-sensitive and literal (no regex patterns)
-            - Binary files are automatically skipped with warnings
-
-        Best Practice:
-            - Use specific search terms to avoid too many matches
-            - Start with narrow directory scope for faster results
-            - Combine with read_file to examine matches in detail
-            - For case-insensitive search, try multiple variants manually
-        """
-        return _grep(context, search_string, directory)
-
-
 def register_list_files(agent):
     """Register only the list_files tool."""
+    from code_puppy.config import get_allow_recursion
 
     @agent.tool(strict=False)
     def list_files(
         context: RunContext, directory: str = ".", recursive: bool = True
     ) -> ListFileOutput:
         """List files and directories with intelligent filtering and safety features.
+        
+        This function will only allow recursive listing when the allow_recursion 
+        configuration is set to true via the /set allow_recursion=true command.
 
         This tool provides comprehensive directory listing with smart home directory
         detection, project-aware recursion, and token-safe output. It automatically
@@ -646,7 +480,8 @@ def register_list_files(agent):
                 or absolute. Defaults to "." (current directory).
             recursive (bool, optional): Whether to recursively list subdirectories.
                 Automatically disabled for home directories unless they contain
-                project indicators. Defaults to True.
+                project indicators. Also requires allow_recursion=true in config.
+                Defaults to True.
 
         Returns:
             ListFileOutput: A structured response containing:
@@ -680,7 +515,14 @@ def register_list_files(agent):
             - Check for errors in the response
             - Combine with grep to find specific file patterns
         """
-        return _list_files(context, directory, recursive)
+        warning=None
+        if recursive and not get_allow_recursion():
+            warning = "Recursion disabled globally for list_files - returning non-recursive results"
+            recursive = False
+        result = _list_files(context, directory, recursive)
+        if warning:
+            result.error = warning
+        return  result
 
 
 def register_read_file(agent):

{code_puppy-0.0.146 → code_puppy-0.0.148}/pyproject.toml

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