autobyteus 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/tools/file/edit_file.py

@@ -1,200 +0,0 @@
-import os
-import re
-import logging
-from typing import TYPE_CHECKING, List
-
-from autobyteus.tools.functional_tool import tool
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-_HUNK_HEADER_RE = re.compile(r"^@@ -(?P<old_start>\d+)(?:,(?P<old_count>\d+))? \+(?P<new_start>\d+)(?:,(?P<new_count>\d+))? @@")
-
-class PatchApplicationError(ValueError):
-    """Raised when a unified diff patch cannot be applied to the target file."""
-
-
-def _resolve_file_path(context: 'AgentContext', path: str) -> str:
-    """Resolves an absolute path for the given input, using the agent workspace when needed."""
-    if os.path.isabs(path):
-        final_path = path
-        logger.debug("edit_file: provided path '%s' is absolute.", path)
-    else:
-        if not context.workspace:
-            error_msg = ("Relative path '%s' provided, but no workspace is configured for agent '%s'. "
-                         "A workspace is required to resolve relative paths.")
-            logger.error(error_msg, path, context.agent_id)
-            raise ValueError(error_msg % (path, context.agent_id))
-        base_path = context.workspace.get_base_path()
-        if not base_path or not isinstance(base_path, str):
-            error_msg = ("Agent '%s' has a configured workspace, but it provided an invalid base path ('%s'). "
-                         "Cannot resolve relative path '%s'.")
-            logger.error(error_msg, context.agent_id, base_path, path)
-            raise ValueError(error_msg % (context.agent_id, base_path, path))
-        final_path = os.path.join(base_path, path)
-        logger.debug("edit_file: resolved relative path '%s' against workspace base '%s' to '%s'.", path, base_path, final_path)
-
-    normalized_path = os.path.normpath(final_path)
-    logger.debug("edit_file: normalized path to '%s'.", normalized_path)
-    return normalized_path
-
-
-def _apply_unified_diff(original_lines: List[str], patch: str) -> List[str]:
-    """Applies a unified diff patch to the provided original lines and returns the patched lines."""
-    if not patch or not patch.strip():
-        raise PatchApplicationError("Patch content is empty; nothing to apply.")
-
-    patched_lines: List[str] = []
-    orig_idx = 0
-    patch_lines = patch.splitlines(keepends=True)
-    line_idx = 0
-
-    while line_idx < len(patch_lines):
-        line = patch_lines[line_idx]
-
-        if line.startswith('---') or line.startswith('+++'):
-            logger.debug("edit_file: skipping diff header line '%s'.", line.strip())
-            line_idx += 1
-            continue
-
-        if not line.startswith('@@'):
-            stripped = line.strip()
-            if stripped == '':
-                line_idx += 1
-                continue
-            raise PatchApplicationError(f"Unexpected content outside of hunk header: '{stripped}'.")
-
-        match = _HUNK_HEADER_RE.match(line)
-        if not match:
-            raise PatchApplicationError(f"Malformed hunk header: '{line.strip()}'.")
-
-        old_start = int(match.group('old_start'))
-        old_count = int(match.group('old_count') or '1')
-        new_start = int(match.group('new_start'))
-        new_count = int(match.group('new_count') or '1')
-        logger.debug("edit_file: processing hunk old_start=%s old_count=%s new_start=%s new_count=%s.",
-                     old_start, old_count, new_start, new_count)
-
-        target_idx = old_start - 1 if old_start > 0 else 0
-        if target_idx > len(original_lines):
-            raise PatchApplicationError("Patch hunk starts beyond end of file.")
-        if target_idx < orig_idx:
-            raise PatchApplicationError("Patch hunks overlap or are out of order.")
-
-        patched_lines.extend(original_lines[orig_idx:target_idx])
-        orig_idx = target_idx
-
-        line_idx += 1
-        hunk_consumed = 0
-        removed = 0
-        added = 0
-
-        while line_idx < len(patch_lines):
-            hunk_line = patch_lines[line_idx]
-            if hunk_line.startswith('@@'):
-                break
-
-            if hunk_line.startswith('-'):
-                if orig_idx >= len(original_lines):
-                    raise PatchApplicationError("Patch attempts to remove lines beyond file length.")
-                if original_lines[orig_idx] != hunk_line[1:]:
-                    raise PatchApplicationError("Patch removal does not match file content.")
-                orig_idx += 1
-                hunk_consumed += 1
-                removed += 1
-            elif hunk_line.startswith('+'):
-                patched_lines.append(hunk_line[1:])
-                added += 1
-            elif hunk_line.startswith(' '):
-                if orig_idx >= len(original_lines):
-                    raise PatchApplicationError("Patch context exceeds file length.")
-                if original_lines[orig_idx] != hunk_line[1:]:
-                    raise PatchApplicationError("Patch context does not match file content.")
-                patched_lines.append(original_lines[orig_idx])
-                orig_idx += 1
-                hunk_consumed += 1
-            elif hunk_line.startswith('\\'):
-                if hunk_line.strip() == '\':
-                    if patched_lines:
-                        patched_lines[-1] = patched_lines[-1].rstrip('\n')
-                else:
-                    raise PatchApplicationError(f"Unsupported patch directive: '{hunk_line.strip()}'.")
-            elif hunk_line.strip() == '':
-                patched_lines.append(hunk_line)
-            else:
-                raise PatchApplicationError(f"Unsupported patch line: '{hunk_line.strip()}'.")
-
-            line_idx += 1
-
-        consumed_total = hunk_consumed
-        if old_count == 0:
-            if consumed_total != 0:
-                raise PatchApplicationError("Patch expects zero original lines but consumed some context.")
-        else:
-            if consumed_total != old_count:
-                raise PatchApplicationError(
-                    f"Patch expected to consume {old_count} original lines but consumed {consumed_total}.")
-
-        context_lines = consumed_total - removed
-        expected_new_lines = context_lines + added
-        if new_count == 0:
-            if expected_new_lines != 0:
-                raise PatchApplicationError("Patch declares zero new lines but produced changes.")
-        else:
-            if expected_new_lines != new_count:
-                raise PatchApplicationError(
-                    f"Patch expected to produce {new_count} new lines but produced {expected_new_lines}.")
-
-    patched_lines.extend(original_lines[orig_idx:])
-    return patched_lines
-
-
-@tool(name="edit_file", category=ToolCategory.FILE_SYSTEM)
-async def edit_file(context: 'AgentContext', path: str, patch: str, create_if_missing: bool = False) -> str:
-    """Applies a unified diff patch to update a text file without overwriting unrelated content.
-
-    Args:
-        path: Path to the target file. Relative paths are resolved against the agent workspace when available.
-        patch: Unified diff patch describing the edits to apply.
-        create_if_missing: When True, allows applying a patch that introduces content to a non-existent file.
-
-    Raises:
-        FileNotFoundError: If the file does not exist and create_if_missing is False.
-        PatchApplicationError: If the patch content cannot be applied cleanly.
-        IOError: If file reading or writing fails.
-    """
-    logger.debug("edit_file: requested edit for agent '%s' on path '%s'.", context.agent_id, path)
-    final_path = _resolve_file_path(context, path)
-
-    dir_path = os.path.dirname(final_path)
-    if dir_path and not os.path.exists(dir_path) and create_if_missing:
-        os.makedirs(dir_path, exist_ok=True)
-
-    file_exists = os.path.exists(final_path)
-    if not file_exists and not create_if_missing:
-        raise FileNotFoundError(f"The file at resolved path {final_path} does not exist.")
-
-    try:
-        original_lines: List[str]
-        if file_exists:
-            with open(final_path, 'r', encoding='utf-8') as source:
-                original_lines = source.read().splitlines(keepends=True)
-        else:
-            original_lines = []
-
-        patched_lines = _apply_unified_diff(original_lines, patch)
-
-        with open(final_path, 'w', encoding='utf-8') as destination:
-            destination.writelines(patched_lines)
-
-        logger.info("edit_file: successfully applied patch to '%s'.", final_path)
-        return f"File edited successfully at {final_path}"
-    except PatchApplicationError as patch_err:
-        logger.error("edit_file: failed to apply patch to '%s': %s", final_path, patch_err, exc_info=True)
-        raise patch_err
-    except Exception as exc:  # pragma: no cover - general safeguard
-        logger.error("edit_file: unexpected error while editing '%s': %s", final_path, exc, exc_info=True)
-        raise IOError(f"Could not edit file at '{final_path}': {exc}")

autobyteus/tools/file/list_directory.py

@@ -1,168 +0,0 @@
-# file: autobyteus/autobyteus/tools/file/list_directory.py
-"""
-This module provides a tool for listing directory contents in a structured,
-tree-like format, mirroring the behavior of the Codex Rust implementation.
-"""
-
-import asyncio
-import logging
-import os
-from pathlib import Path
-from collections import deque
-from dataclasses import dataclass
-from typing import List, Deque, Tuple, Optional, TYPE_CHECKING
-
-from autobyteus.tools.functional_tool import tool
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-# Constants from the design document
-INDENTATION_SPACES = 2
-MAX_ENTRY_LENGTH = 500
-
-@dataclass
-class DirEntry:
-    """Represents a collected directory entry for sorting and formatting."""
-    name: str
-    kind: str
-    depth: int
-
-@tool(name="list_directory", category=ToolCategory.FILE_SYSTEM)
-async def list_directory(
-    context: 'AgentContext',
-    path: str,
-    depth: int = 2,
-    limit: int = 25,
-    offset: int = 1
-) -> str:
-    """
-    Lists the contents of a directory in a structured, tree-like format.
-
-    This tool performs a breadth-first traversal of the specified directory up to a
-    given depth. It returns a deterministic, lexicographically sorted list of entries,
-    formatted with indentation and tree glyphs to represent the hierarchy.
-
-    Args:
-        path: The path to the directory to list. Relative paths are resolved against the agent's workspace.
-        depth: The maximum directory depth to traverse. Must be > 0.
-        limit: The maximum number of entries to return in the output. Must be > 0.
-        offset: The 1-indexed entry number to start from, for pagination. Must be > 0.
-    """
-    # --- 1. Argument Validation ---
-    logger.debug(f"list_directory for agent {context.agent_id}, initial path: {path}")
-
-    final_path: str
-    if os.path.isabs(path):
-        final_path = path
-        logger.debug(f"Path '{path}' is absolute. Using it directly.")
-    else:
-        if not context.workspace:
-            error_msg = f"Relative path '{path}' provided, but no workspace is configured for agent '{context.agent_id}'. A workspace is required to resolve relative paths."
-            logger.error(error_msg)
-            raise ValueError(error_msg)
-
-        base_path = context.workspace.get_base_path()
-        if not base_path or not isinstance(base_path, str):
-            error_msg = f"Agent '{context.agent_id}' has a configured workspace, but it provided an invalid base path ('{base_path}'). Cannot resolve relative path '{path}'."
-            logger.error(error_msg)
-            raise ValueError(error_msg)
-
-        final_path = os.path.join(base_path, path)
-        logger.debug(f"Path '{path}' is relative. Resolved to '{final_path}' using workspace base path '{base_path}'.")
-
-    final_path = os.path.normpath(final_path)
-
-    if not Path(final_path).is_dir():
-        raise FileNotFoundError(f"Directory not found at path: {final_path}")
-    if depth <= 0 or limit <= 0 or offset <= 0:
-        raise ValueError("depth, limit, and offset must all be greater than zero.")
-
-    # --- 2. Asynchronous Traversal ---
-    loop = asyncio.get_running_loop()
-    all_entries = await loop.run_in_executor(
-        None, _traverse_directory_bfs, Path(final_path), depth
-    )
-
-    # --- 3. Slicing ---
-    total_found = len(all_entries)
-    start_index = offset - 1
-    end_index = start_index + limit
-    sliced_entries = all_entries[start_index:end_index]
-
-    # --- 4. Formatting ---
-    output_lines = [f"Absolute path: {final_path}"]
-    
-    # To correctly apply tree glyphs, we need to know which entry is the last in its directory
-    # This is complex with BFS. A simpler, visually acceptable approach is taken here.
-    # For a more accurate glyph representation like the Rust version, we would need to
-    # process entries directory by directory after collection.
-    for i, entry in enumerate(sliced_entries):
-        # A simplified glyph logic: last item in the slice gets the closing glyph
-        is_last = (i == len(sliced_entries) - 1)
-        output_lines.append(_format_entry_line(entry, is_last))
-
-    if total_found > end_index:
-        output_lines.append(f"More than {limit} entries found.")
-
-    return "\n".join(output_lines)
-
-
-def _traverse_directory_bfs(start_path: Path, max_depth: int) -> List[DirEntry]:
-    """
-    Performs a breadth-first traversal of a directory. This is a synchronous function
-    designed to be run in a thread pool executor.
-    """
-    collected: List[DirEntry] = []
-    queue: Deque[Tuple[Path, int]] = deque([(start_path, 0)])
-
-    while queue:
-        current_path, current_depth = queue.popleft()
-
-        if current_depth >= max_depth:
-            continue
-
-        try:
-            # Use os.scandir for efficiency as it fetches file type info
-            entries_at_level = []
-            for entry in os.scandir(current_path):
-                kind = "[unknown]"
-                if entry.is_dir():
-                    kind = "[dir]"
-                    queue.append((Path(entry.path), current_depth + 1))
-                elif entry.is_file():
-                    kind = "[file]"
-                elif entry.is_symlink():
-                    kind = "[link]"
-
-                # Truncate long filenames
-                display_name = entry.name
-                if len(display_name) > MAX_ENTRY_LENGTH:
-                    display_name = display_name[:MAX_ENTRY_LENGTH] + "..."
-                
-                entries_at_level.append(DirEntry(name=display_name, kind=kind, depth=current_depth + 1))
-            
-            # Sort entries at the current level before adding to the main list
-            entries_at_level.sort(key=lambda e: e.name)
-            collected.extend(entries_at_level)
-
-        except (PermissionError, OSError) as e:
-            logger.warning(f"Could not read directory '{current_path}': {e}")
-            continue
-    
-    return collected
-
-
-def _format_entry_line(entry: DirEntry, is_last_in_slice: bool) -> str:
-    """Formats a single directory entry into its final string representation."""
-    # This simplified glyph logic doesn't know about siblings, just the slice.
-    # A full implementation would require grouping by parent path after collection.
-    prefix = "└─ " if is_last_in_slice else "├─ "
-    
-    # Indentation is based on depth from the root search path
-    indentation = " " * INDENTATION_SPACES * (entry.depth -1)
-    
-    return f"{indentation}{prefix}{entry.kind} {entry.name}"

autobyteus/tools/file/search_files.py

@@ -1,188 +0,0 @@
-# file: autobyteus/autobyteus/tools/file/search_files.py
-"""
-This module provides a high-performance fuzzy file search tool.
-It uses 'git ls-files' for speed in Git repositories and falls back
-to a filesystem walk for other directories, respecting .gitignore.
-"""
-
-import asyncio
-import json
-import logging
-import os
-import subprocess
-from pathlib import Path
-from typing import List, Dict, Optional, Tuple, TYPE_CHECKING
-
-from rapidfuzz import process, fuzz
-from pathspec import PathSpec
-from pathspec.patterns import GitWildMatchPattern
-
-from autobyteus.tools.functional_tool import tool
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-
-@tool(name="search_files", category=ToolCategory.FILE_SYSTEM)
-async def search_files(
-    context: 'AgentContext',
-    query: Optional[str] = None,
-    path: str = '.',
-    limit: int = 64,
-    exclude_patterns: Optional[List[str]] = None
-) -> str:
-    """
-    Performs a high-performance fuzzy search for files in a directory.
-
-    This tool intelligently discovers files. If the search directory is a Git repository,
-    it uses the highly efficient 'git ls-files' command. Otherwise, it performs a
-    standard filesystem walk. In both cases, it respects .gitignore rules and any
-    additional exclusion patterns provided. The search results are returned as a
-    JSON string, with each result including the file path and a relevance score.
-
-    Args:
-        query: The fuzzy search pattern. If omitted, the tool lists all discoverable files up to the limit.
-        path: The directory to search in. Relative paths are resolved against the agent's workspace. Defaults to the workspace root.
-        limit: The maximum number of results to return.
-        exclude_patterns: A list of glob patterns to exclude from the search, in addition to .gitignore rules.
-    """
-    final_path = _resolve_search_path(context, path)
-    if not final_path.is_dir():
-        raise FileNotFoundError(f"The specified search path does not exist or is not a directory: {final_path}")
-
-    exclude = exclude_patterns or []
-    files, discovery_method = await _discover_files(final_path, exclude)
-
-    if not query:
-        # If no query, just return the first 'limit' files found
-        matches = [{"path": f, "score": 100} for f in files[:limit]]
-        result_summary = {
-            "discovery_method": discovery_method,
-            "total_files_scanned": len(files),
-            "matches_found": len(matches),
-            "results": matches
-        }
-        return json.dumps(result_summary, indent=2)
-
-    # Use rapidfuzz to find the best matches
-    results = process.extract(
-        query,
-        files,
-        scorer=fuzz.WRatio,
-        limit=limit,
-        score_cutoff=50
-    )
-
-    file_matches = [{"path": path, "score": round(score)} for path, score, _ in results]
-    
-    result_summary = {
-        "discovery_method": discovery_method,
-        "total_files_scanned": len(files),
-        "matches_found": len(file_matches),
-        "results": file_matches
-    }
-    return json.dumps(result_summary, indent=2)
-
-
-def _resolve_search_path(context: 'AgentContext', path: str) -> Path:
-    """Resolves the search path against the agent's workspace if relative."""
-    if os.path.isabs(path):
-        return Path(path)
-    
-    if not context.workspace:
-        raise ValueError(f"Relative path '{path}' provided, but no workspace is configured for agent '{context.agent_id}'.")
-    
-    base_path = context.workspace.get_base_path()
-    if not base_path:
-        raise ValueError(f"Agent '{context.agent_id}' has a workspace, but it provided an invalid base path.")
-        
-    return Path(os.path.normpath(os.path.join(base_path, path)))
-
-
-async def _is_git_repository_async(path: Path) -> bool:
-    """Asynchronously checks if a given path is within a Git repository."""
-    process = await asyncio.create_subprocess_exec(
-        "git", "rev-parse", "--is-inside-work-tree",
-        cwd=str(path),
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-    )
-    stdout, _ = await process.communicate()
-    return stdout.decode().strip() == "true"
-
-
-async def _get_files_from_git_async(path: Path) -> List[str]:
-    """Uses 'git ls-files' to get a list of all tracked and untracked files."""
-    try:
-        process = await asyncio.create_subprocess_exec(
-            "git", "ls-files", "-co", "--exclude-standard",
-            cwd=str(path),
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout_bytes, stderr_bytes = await process.communicate()
-        if process.returncode != 0:
-            stderr = stderr_bytes.decode().strip()
-            logger.error(f"Failed to run 'git ls-files' in '{path}': {stderr}")
-            return []
-        
-        stdout = stdout_bytes.decode().strip()
-        return stdout.strip().split("\n") if stdout.strip() else []
-    except (subprocess.CalledProcessError, FileNotFoundError) as e:
-        logger.error(f"Failed to run 'git ls-files': {e}")
-        return []
-
-
-def _get_files_with_walk_sync(path: Path, exclude_patterns: List[str]) -> List[str]:
-    """Synchronously walks the filesystem to find files, respecting ignore patterns."""
-    files: List[str] = []
-    
-    all_exclude_patterns = exclude_patterns[:]
-    gitignore_path = path / ".gitignore"
-    if gitignore_path.is_file():
-        try:
-            with open(gitignore_path, "r", encoding='utf-8') as f:
-                all_exclude_patterns.extend(f.read().splitlines())
-        except Exception as e:
-            logger.warning(f"Could not read .gitignore file at '{gitignore_path}': {e}")
-
-    spec = PathSpec.from_lines(GitWildMatchPattern, all_exclude_patterns)
-
-    for root, _, filenames in os.walk(path, topdown=True):
-        root_path = Path(root)
-        for filename in filenames:
-            full_path = root_path / filename
-            try:
-                relative_path = full_path.relative_to(path)
-                if not spec.match_file(str(relative_path)):
-                    files.append(str(relative_path))
-            except (ValueError, IsADirectoryError):
-                # Handles cases like broken symlinks
-                continue
-    return files
-
-
-async def _get_files_with_walk_async(path: Path, exclude_patterns: List[str]) -> List[str]:
-    """Runs the synchronous walk in a thread pool."""
-    loop = asyncio.get_running_loop()
-    return await loop.run_in_executor(
-        None, _get_files_with_walk_sync, path, exclude_patterns
-    )
-
-
-async def _discover_files(cwd: Path, exclude: List[str]) -> Tuple[List[str], str]:
-    """Orchestrates the file discovery, choosing between Git and os.walk."""
-    if await _is_git_repository_async(cwd):
-        logger.info(f"Using 'git ls-files' for fast file discovery in '{cwd}'.")
-        files = await _get_files_from_git_async(cwd)
-        # Git ls-files already handles gitignore, but we may have extra excludes
-        if exclude:
-            spec = PathSpec.from_lines(GitWildMatchPattern, exclude)
-            files = [f for f in files if not spec.match_file(f)]
-        return files, "git"
-    else:
-        logger.info(f"Using 'os.walk' to scan directory '{cwd}'.")
-        return await _get_files_with_walk_async(cwd, exclude), "os_walk"