bone-agent 1.4.0 → 2.0.1

package/src/tools/create_file.py

@@ -1,136 +0,0 @@
-"""File creation operations."""
-
-import os
-from pathlib import Path
-from typing import Optional, Tuple
-
-from utils.settings import MAX_FILE_PREVIEW_LINES
-from .helpers.base import tool
-from .helpers.path_resolver import PathResolver
-from .helpers.formatters import format_file_result
-
-
-def _validate_create_path(
-    path_str: str,
-    repo_root: Path,
-    gitignore_spec,
-    vault_root: Path = None,
-) -> Tuple[Optional[Path], Optional[str]]:
-    """Validate and resolve path for file creation.
-
-    Args:
-        path_str: Path string to validate
-        repo_root: Repository root directory
-        gitignore_spec: Optional PathSpec for .gitignore filtering
-        vault_root: Optional Obsidian vault root path
-
-    Returns:
-        (resolved_path, error_message) - error_message is None if valid
-    """
-    vault_path = Path(vault_root) if vault_root else None
-    resolver = PathResolver(repo_root=repo_root, gitignore_spec=gitignore_spec, vault_path=vault_path)
-    return resolver.resolve_and_validate(
-        path_str,
-        check_gitignore=True,
-        must_exist=False,  # File doesn't need to exist yet
-        enforce_boundary=True,
-    )
-
-
-@tool(
-    name="create_file",
-    description="Create a new file with optional initial content. File must not exist.",
-    parameters={
-        "type": "object",
-        "properties": {
-            "path_str": {"type": "string", "description": "Path to create"},
-            "content": {"type": "string", "description": "Initial content (omit for empty file)"}
-        },
-        "required": ["path_str"]
-    },
-)
-def create_file(
-    path_str: str,
-    repo_root: Path,
-    content: Optional[str] = None,
-    gitignore_spec = None,
-    vault_root: str = None,
-) -> str:
-    """Create a new file with optional initial content.
-
-    Creates a new file at the specified path, creating parent directories
-    if needed. The file must not already exist. Respects .gitignore.
-
-    Args:
-        path_str: Path string to the file to create
-        repo_root: Repository root directory (for path resolution)
-        content: Optional initial content for the file. If omitted, creates empty file.
-        gitignore_spec: Optional PathSpec for .gitignore filtering
-        vault_root: Optional Obsidian vault root path
-
-    Returns:
-        str: Formatted result with exit_code and status, including preview
-    """
-    try:
-        # Validate path
-        resolved, error = _validate_create_path(path_str, repo_root, gitignore_spec, vault_root=vault_root)
-        if error:
-            return format_file_result(exit_code=1, error=error, path=path_str)
-
-        # Check if already exists
-        if resolved.exists():
-            try:
-                rel_path = resolved.relative_to(repo_root)
-            except ValueError:
-                rel_path = resolved
-            return format_file_result(
-                exit_code=1,
-                error="File already exists",
-                path=str(rel_path)
-            )
-
-        # Create parent directories if needed
-        parent_dir = resolved.parent
-        if parent_dir != repo_root and not parent_dir.exists():
-            parent_dir.mkdir(parents=True, exist_ok=True)
-
-        # Write content or create empty file
-        if content is not None:
-            resolved.write_text(content, encoding="utf-8", newline="")
-        else:
-            content = ""
-            resolved.touch()
-
-        # Build result with content for display (truncate preview if needed)
-        result_lines = []
-        result_lines.append(f"exit_code=0")
-        try:
-            rel_path = resolved.relative_to(repo_root)
-        except ValueError:
-            rel_path = resolved
-        result_lines.append(f"path={rel_path}")
-        result_lines.append(f"content=File created successfully")
-        result_lines.append("")
-        result_lines.append(f"=== FILE_CONTENT ===")
-
-        # Truncate content for preview if it exceeds max lines
-        if content:
-            content_lines = content.splitlines(keepends=True)
-            if len(content_lines) > MAX_FILE_PREVIEW_LINES:
-                truncated_content = "".join(content_lines[:MAX_FILE_PREVIEW_LINES])
-                omitted = len(content_lines) - MAX_FILE_PREVIEW_LINES
-                result_lines.append(truncated_content)
-                result_lines.append(f"\n... ({omitted} more lines omitted from preview)")
-            else:
-                result_lines.append(content)
-
-        result_lines.append("=== END_FILE_CONTENT ===")
-
-        return "\n".join(result_lines) + "\n\n"
-
-    except PermissionError:
-        return format_file_result(exit_code=1, error="Permission denied", path=path_str)
-    except OSError as e:
-        return format_file_result(exit_code=1, error=f"Invalid filename: {e}", path=path_str)
-    except Exception as e:
-        return format_file_result(exit_code=1, error=str(e), path=path_str)

package/src/tools/directory.py

@@ -1,389 +0,0 @@
-"""Directory listing operations."""
-
-import fnmatch
-import os
-from pathlib import Path
-from typing import Optional, Tuple, Dict, List
-
-from .helpers.base import tool
-from .helpers.path_resolver import PathResolver
-from .helpers.file_helpers import GitignoreFilter
-from .helpers.formatters import format_file_result
-from . import constants
-
-
-def _group_items_by_directory(items, show_files, show_dirs) -> Dict:
-    """Group items by their parent directory for smart truncation.
-
-    Args:
-        items: List of (kind, rel_path, size, raw_path, line_count) tuples
-        show_files: Whether files are included in results
-        show_dirs: Whether directories are included in results
-
-    Returns:
-        Dict mapping parent_dir -> {'dirs': [dir_items], 'files': [file_items]}
-    """
-    groups = {}
-
-    for kind, rel_path, size, raw_path, line_count in items:
-        # Get parent directory
-        if '/' in rel_path:
-            parent_dir = Path(rel_path).parent
-        else:
-            parent_dir = Path('.')  # Root level
-
-        if parent_dir not in groups:
-            groups[parent_dir] = {'dirs': [], 'files': []}
-
-        if kind == 'DIR ':
-            groups[parent_dir]['dirs'].append((kind, rel_path, size, raw_path, line_count))
-        else:  # FILE
-            groups[parent_dir]['files'].append((kind, rel_path, size, raw_path, line_count))
-
-    return groups
-
-
-def _apply_smart_truncation(items, show_files, show_dirs, hit_limit=False) -> Tuple[List, Optional[Dict]]:
-    """Apply smart truncation to directory listing results.
-
-    Truncation Strategy:
-    - If total items < TRUNCATION_THRESHOLD: No truncation
-    - If total items >= TRUNCATION_THRESHOLD:
-      * ALL directories are shown (preserve structure)
-      * Files are sampled: top MAX_FILES_PER_FOLDER per directory
-      * Truncation metadata returned for message generation
-
-    Args:
-        items: List of (kind, rel_path, size, raw_path) tuples
-        show_files: Whether files are included in results
-        show_dirs: Whether directories are included in results
-        hit_limit: Whether we hit MAX_TOTAL_ITEMS during collection
-
-    Returns:
-        Tuple of:
-        - List of items after truncation
-        - None if no truncation, or dict with truncation metadata
-    """
-    total_count = len(items)
-
-    # Fast path: no truncation needed
-    if total_count < constants.TRUNCATION_THRESHOLD:
-        return items, None
-
-    # Group items by parent directory
-    groups = _group_items_by_directory(items, show_files, show_dirs)
-
-    # Apply truncation per directory
-    truncated_items = []
-    total_dirs_shown = 0
-    total_files_shown = 0
-    total_files_omitted = 0
-
-    # Sort directories alphabetically for consistent output
-    for parent_dir in sorted(groups.keys(), key=lambda p: str(p)):
-        group = groups[parent_dir]
-
-        # Always include all directories
-        if show_dirs:
-            truncated_items.extend(group['dirs'])
-            total_dirs_shown += len(group['dirs'])
-
-        # Truncate files if needed
-        if show_files and group['files']:
-            # Sort files alphabetically and take top N
-            sorted_files = sorted(group['files'], key=lambda x: x[1])  # Sort by rel_path
-            files_to_show = sorted_files[:constants.MAX_FILES_PER_FOLDER]
-            truncated_items.extend(files_to_show)
-
-            total_files_shown += len(files_to_show)
-            total_files_omitted += len(group['files']) - len(files_to_show)
-
-    # Build truncation info
-    truncation_info = {
-        'total': total_count,
-        'shown': len(truncated_items),
-        'omitted': total_count - len(truncated_items),
-        'dirs_shown': total_dirs_shown,
-        'files_shown': total_files_shown,
-        'files_omitted': total_files_omitted,
-        'all_dirs_shown': True
-    }
-
-    return truncated_items, truncation_info
-
-
-def _validate_directory_path(
-    path_str: str,
-    repo_root: Path,
-    vault_root: str = None
-) -> Tuple[Optional[Path], Optional[str]]:
-    """Validate and resolve path for directory listing.
-
-    This function wraps PathResolver.resolve_and_validate() for the directory
-    tool's specific needs, ensuring the path is a directory.
-
-    Args:
-        path_str: Path string to validate
-        repo_root: Repository root directory
-        vault_root: Optional Obsidian vault root path
-
-    Returns:
-        (resolved_path, error_message) - error_message is None if valid
-    """
-    from pathlib import Path as P
-    vault_path = P(vault_root) if vault_root else None
-    # Use PathResolver for centralized validation
-    resolver = PathResolver(repo_root=repo_root, gitignore_spec=None, vault_path=vault_path)
-    resolved, error = resolver.resolve_and_validate(
-        path_str,
-        check_gitignore=False,  # Directory listing shows everything
-        must_exist=True,
-        must_be_dir=True,  # Must be a directory
-        enforce_boundary=True
-    )
-
-    if error:
-        return None, error
-
-    return resolved, None
-
-
-@tool(
-    name="list_directory",
-    description="List directory contents (preferred over PowerShell).",
-    parameters={
-        "type": "object",
-        "properties": {
-            "path_str": {"type": "string", "description": "Path to list (default: '.')"},
-            "recursive": {"type": "boolean", "description": "List recursively (default: false)"},
-            "show_files": {"type": "boolean", "description": "Include files (default: true)"},
-            "show_dirs": {"type": "boolean", "description": "Include directories (default: true)"},
-            "pattern": {"type": "string", "description": "Glob filter (e.g., \"*.py\")"}
-        },
-        "required": ["path_str"]
-    },
-)
-def list_directory(
-    path_str: str,
-    repo_root: Path,
-    recursive: bool = False,
-    show_files: bool = True,
-    show_dirs: bool = True,
-    pattern: Optional[str] = None,
-    gitignore_spec = None,
-    vault_root: str = None
-) -> str:
-    """List directory contents.
-
-    Directory listing that respects .gitignore and shows file sizes in a
-    consistent format.
-
-    Args:
-        path_str: Path string to the directory to list
-        repo_root: Repository root directory (for path resolution)
-        recursive: List recursively
-        show_files: Include files in output
-        show_dirs: Include directories in output
-        pattern: Optional glob pattern to filter results (e.g., "*.py")
-        gitignore_spec: Optional PathSpec for .gitignore filtering
-        vault_root: Optional Obsidian vault root path
-
-    Returns:
-        str: Formatted result with exit_code, items_count, and directory listing
-    """
-    try:
-        # Validate path
-        resolved, error = _validate_directory_path(path_str, repo_root, vault_root=vault_root)
-        if error:
-            return format_file_result(
-                exit_code=1,
-                error=error,
-                path=path_str
-            )
-
-        def _match_pattern(rel_path: Path) -> bool:
-            if not pattern:
-                return True
-            return fnmatch.fnmatch(rel_path.as_posix(), pattern)
-
-        # Create gitignore filter if spec is provided
-        gitignore_filter = GitignoreFilter(repo_root=repo_root, gitignore_spec=gitignore_spec) if gitignore_spec else None
-
-        def _is_ignored(path: Path) -> bool:
-            if path.name == ".gitignore":
-                return True
-            if ".git" in path.parts:
-                return True
-            if gitignore_filter is None:
-                return False
-            # Use GitignoreFilter for consistent behavior
-            return gitignore_filter.is_ignored(path)
-
-        # Collect items
-        items = []
-        base_dir = resolved
-        hit_limit = False  # Track if we hit constants.MAX_TOTAL_ITEMS
-
-        def _count_lines(file_path: Path) -> int:
-            """Count lines in a file efficiently."""
-            try:
-                with open(file_path, 'rb') as f:
-                    return sum(1 for _ in f) - 1  # Subtract 1 for last newline, but handle empty files
-            except (OSError, IOError):
-                return 0
-
-        def _add_item(kind, rel_path, size_str, raw_path, line_count=None):
-            nonlocal hit_limit
-            if kind == "FILE" and not show_files:
-                return
-            if kind == "DIR " and not show_dirs:
-                return
-            if not _match_pattern(rel_path):
-                return
-            if hit_limit:
-                return
-            if len(items) >= constants.MAX_TOTAL_ITEMS:
-                hit_limit = True
-                return
-            items.append((kind, str(rel_path), size_str, raw_path, line_count))
-
-        if recursive:
-            stack = [resolved]
-            while stack and not hit_limit:
-                current = stack.pop()
-                try:
-                    with os.scandir(current) as it:
-                        for entry in it:
-                            try:
-                                if entry.is_symlink():
-                                    continue
-                            except OSError:
-                                continue
-
-                            is_dir = entry.is_dir(follow_symlinks=False)
-                            is_file = entry.is_file(follow_symlinks=False)
-
-                            if not is_dir and not is_file:
-                                continue
-
-                            entry_path = Path(entry.path)
-
-                            if _is_ignored(entry_path):
-                                continue
-
-                            rel_path = entry_path.relative_to(base_dir)
-
-                            if is_file:
-                                try:
-                                    size = f"{entry.stat(follow_symlinks=False).st_size:>10}"
-                                    line_count = _count_lines(entry_path)
-                                except OSError:
-                                    size = "         ?"
-                                    line_count = 0
-                                _add_item("FILE", rel_path, size, entry_path, line_count)
-                            else:
-                                _add_item("DIR ", rel_path, "          ", entry_path, line_count=0)
-                                stack.append(entry_path)
-                except PermissionError:
-                    continue
-        else:
-            with os.scandir(resolved) as it:
-                for entry in it:
-                    try:
-                        if entry.is_symlink():
-                            continue
-                    except OSError:
-                        continue
-
-                    is_dir = entry.is_dir(follow_symlinks=False)
-                    is_file = entry.is_file(follow_symlinks=False)
-
-                    if not is_dir and not is_file:
-                        continue
-
-                    entry_path = Path(entry.path)
-
-                    if _is_ignored(entry_path):
-                        continue
-
-                    rel_path = entry_path.relative_to(base_dir)
-
-                    if is_file:
-                        try:
-                            size = f"{entry.stat(follow_symlinks=False).st_size:>10}"
-                            line_count = _count_lines(entry_path)
-                        except OSError:
-                            size = "         ?"
-                            line_count = 0
-                        _add_item("FILE", rel_path, size, entry_path, line_count)
-                    else:
-                        _add_item("DIR ", rel_path, "          ", entry_path, line_count=0)
-
-        # Sort: directories first, then alphabetically
-        items.sort(key=lambda x: (0 if x[0] == "DIR " else 1, x[1]))
-
-        # Format output
-        if not items:
-            try:
-                rel_path = resolved.relative_to(repo_root)
-            except ValueError:
-                rel_path = resolved
-            return format_file_result(
-                exit_code=0,
-                content="(empty directory)",
-                path=str(rel_path),
-                items_count=0
-            )
-
-        # Apply smart truncation if needed
-        truncated_items, truncation_info = _apply_smart_truncation(items, show_files, show_dirs, hit_limit)
-
-        # Build lines with truncation message
-        lines = []
-        for kind, rel_path, size, _, line_count in truncated_items:
-            if kind == "FILE":
-                lines.append(f"{kind}  {rel_path}  {line_count:6} lines  {size} bytes")
-            else:
-                lines.append(f"{kind}  {rel_path}  {line_count:6} lines")
-
-        # Add truncation message at end
-        if truncation_info:
-            lines.append("")
-            msg = f"[{truncation_info['files_omitted']} file(s) omitted ({truncation_info['shown']} shown from {truncation_info['total']} total items)]"
-            if hit_limit:
-                msg += f"\n[WARNING: Listing stopped at {constants.MAX_TOTAL_ITEMS} items to prevent context overflow. Use filters or specific paths to explore further.]"
-            lines.append(msg)
-
-        content = "\n".join(lines)
-
-        # Update truncation info to indicate if we hit the hard limit
-        if truncation_info and hit_limit:
-            truncation_info['hit_limit'] = True
-            truncation_info['max_items'] = constants.MAX_TOTAL_ITEMS
-
-        try:
-            rel_path = resolved.relative_to(repo_root)
-        except ValueError:
-            rel_path = resolved
-
-        return format_file_result(
-            exit_code=0,
-            content=content,
-            path=str(rel_path),
-            items_count=truncation_info['total'] if truncation_info else len(items),
-            truncated=(truncation_info is not None),
-            truncation_info=truncation_info
-        )
-
-    except PermissionError:
-        return format_file_result(
-            exit_code=1,
-            error="Permission denied",
-            path=path_str
-        )
-    except Exception as e:
-        return format_file_result(
-            exit_code=1,
-            error=str(e),
-            path=path_str
-        )