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

autobyteus/skills/loader.py

@@ -0,0 +1,71 @@
+import os
+import logging
+import re
+from typing import Optional
+from autobyteus.skills.model import Skill
+
+logger = logging.getLogger(__name__)
+
+class SkillLoader:
+    """
+    Responsible for loading and parsing SKILL.md files.
+    Designed to be forgiving of minor formatting variations in LLM-generated content.
+    """
+
+    @staticmethod
+    def load_skill(path: str) -> Skill:
+        """
+        Loads a skill from a given directory path.
+        """
+        if not os.path.isdir(path):
+             raise FileNotFoundError(f"Skill directory not found: {path}")
+
+        skill_file = os.path.join(path, "SKILL.md")
+        if not os.path.exists(skill_file):
+            raise FileNotFoundError(f"SKILL.md not found in {path}")
+
+        try:
+            with open(skill_file, 'r', encoding='utf-8') as f:
+                raw_content = f.read()
+        except Exception as e:
+            raise IOError(f"Failed to read SKILL.md at {skill_file}: {e}")
+
+        return SkillLoader._parse_skill(raw_content, path)
+
+    @staticmethod
+    def _parse_skill(raw_content: str, root_path: str) -> Skill:
+        """
+        Parses the content of a SKILL.md file. 
+        Extracts metadata from the frontmatter block (delimited by ---).
+        """
+        # Extract the frontmatter block
+        # Using a regex that is forgiving of whitespace around delimiters
+        match = re.search(r'^\s*---\s*\n(.*?)\n\s*---\s*\n(.*)', raw_content, re.DOTALL | re.MULTILINE) 
+        
+        if not match:
+            raise ValueError("Invalid SKILL.md format: Could not find frontmatter block delimited by '---'")
+
+        frontmatter_text = match.group(1)
+        body_content = match.group(2).strip()
+
+        # Parse frontmatter lines (Key: Value)
+        metadata = {}
+        for line in frontmatter_text.splitlines():
+            if ":" in line:
+                key, value = line.split(":", 1)
+                metadata[key.strip().lower()] = value.strip()
+
+        name = metadata.get("name")
+        description = metadata.get("description")
+
+        if not name:
+            raise ValueError("Missing 'name' in SKILL.md metadata")
+        if not description:
+            raise ValueError("Missing 'description' in SKILL.md metadata")
+
+        return Skill(
+            name=name,
+            description=description,
+            content=body_content,
+            root_path=root_path
+        )

autobyteus/skills/model.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+@dataclass
+class Skill:
+    """
+    Represents a loaded skill.
+    """
+    name: str
+    description: str
+    content: str  # The body of the SKILL.md file
+    root_path: str  # The absolute path to the skill directory

autobyteus/skills/registry.py

@@ -0,0 +1,70 @@
+import os
+import logging
+from typing import Dict, List, Optional
+from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.skills.model import Skill
+from autobyteus.skills.loader import SkillLoader
+
+logger = logging.getLogger(__name__)
+
+class SkillRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry for managing and discovering agent skills.
+    """
+
+    def __init__(self):
+        self._skills: Dict[str, Skill] = {}
+        logger.info("SkillRegistry initialized.")
+
+    def register_skill_from_path(self, path: str) -> Skill:
+        """
+        Loads a skill from the given path and registers it.
+        If a skill with the same name already exists, it will be overwritten.
+        """
+        try:
+            skill = SkillLoader.load_skill(path)
+            self._skills[skill.name] = skill
+            logger.info(f"Skill '{skill.name}' registered from path: {path}")
+            return skill
+        except Exception as e:
+            logger.error(f"Failed to register skill from path '{path}': {e}")
+            raise
+
+    def discover_skills(self, directory_path: str):
+        """
+        Scans a directory for skill subdirectories (those containing SKILL.md) 
+        and registers them.
+        """
+        if not os.path.isdir(directory_path):
+            logger.warning(f"Discovery directory not found: {directory_path}")
+            return
+
+        logger.debug(f"Discovering skills in: {directory_path}")
+        for entry in os.scandir(directory_path):
+            if entry.is_dir():
+                skill_md_path = os.path.join(entry.path, "SKILL.md")
+                if os.path.exists(skill_md_path):
+                    try:
+                        self.register_skill_from_path(entry.path)
+                    except Exception:
+                        # Continue discovering other skills even if one fails
+                        continue
+
+    def get_skill(self, name: str) -> Optional[Skill]:
+        """
+        Retrieves a skill by its name.
+        """
+        return self._skills.get(name)
+
+    def list_skills(self) -> List[Skill]:
+        """
+        Returns a list of all registered skills.
+        """
+        return list(self._skills.values())
+
+    def clear(self):
+        """
+        Clears all registered skills. Primarily for testing.
+        """
+        self._skills.clear()
+        logger.debug("SkillRegistry cleared.")

autobyteus/task_management/tools/todo_tools/add_todo.py

@@ -16,11 +16,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 def _notify_todo_update(context: 'AgentContext'):
-    if context.phase_manager and context.phase_manager.notifier:
+    if context.status_manager and context.status_manager.notifier:
         todo_list = context.state.todo_list
         if todo_list:
             todos_for_llm = [todo.model_dump(mode='json') for todo in todo_list.get_all_todos()]
-            context.phase_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
+            context.status_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
             logger.debug(f"Agent '{context.agent_id}': Notified ToDo list update with {len(todos_for_llm)} items.")
 
 class AddToDo(BaseTool):

autobyteus/task_management/tools/todo_tools/create_todo_list.py

@@ -17,11 +17,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 def _notify_todo_update(context: 'AgentContext'):
-    if context.phase_manager and context.phase_manager.notifier:
+    if context.status_manager and context.status_manager.notifier:
         todo_list = context.state.todo_list
         if todo_list:
             todos_for_llm = [todo.model_dump(mode='json') for todo in todo_list.get_all_todos()]
-            context.phase_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
+            context.status_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
             logger.debug(f"Agent '{context.agent_id}': Notified ToDo list update with {len(todos_for_llm)} items.")
 
 class CreateToDoList(BaseTool):

autobyteus/task_management/tools/todo_tools/update_todo_status.py

@@ -13,11 +13,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 def _notify_todo_update(context: 'AgentContext'):
-    if context.phase_manager and context.phase_manager.notifier:
+    if context.status_manager and context.status_manager.notifier:
         todo_list = context.state.todo_list
         if todo_list:
             todos_for_llm = [todo.model_dump(mode='json') for todo in todo_list.get_all_todos()]
-            context.phase_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
+            context.status_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
             logger.debug(f"Agent '{context.agent_id}': Notified ToDo list update with {len(todos_for_llm)} items.")
 
 class UpdateToDoStatus(BaseTool):

autobyteus/tools/__init__.py

@@ -15,17 +15,28 @@ from .tool_config import ToolConfig # Configuration data object, primarily for c
 from .tool_origin import ToolOrigin
 from .tool_category import ToolCategory
 
+# Tool Formatting Registration Support
+# Tool Formatting Registration Support
+from autobyteus.tools.usage.registries.tool_formatting_registry import ToolFormattingRegistry, register_tool_formatter
+from autobyteus.tools.usage.registries.tool_formatter_pair import ToolFormatterPair
+from autobyteus.tools.usage.formatters.base_formatter import BaseSchemaFormatter, BaseExampleFormatter
+
+
 logger = logging.getLogger(__name__)
 
 # --- Re-export specific tools for easier access ---
 
 # Functional tools (decorated functions are now instances)
-from .bash.bash_executor import bash_executor
 from .file.read_file import read_file
 from .file.write_file import write_file
-from .file.edit_file import edit_file
-from .file.search_files import search_files
-from .file.list_directory import list_directory
+from .file.patch_file import patch_file
+from .skill.load_skill import load_skill
+
+# Terminal tools (PTY-based stateful terminal)
+from .terminal.tools.run_bash import run_bash
+from .terminal.tools.start_background_process import start_background_process
+from .terminal.tools.get_process_output import get_process_output
+from .terminal.tools.stop_background_process import stop_background_process
 
 # General Class-based tools
 try:
@@ -33,7 +44,6 @@ try:
 except ModuleNotFoundError as import_err:
     logger.warning("Search tool not available: %s", import_err)
     Search = None
-from .timer import Timer
 try:
     from .multimedia.image_tools import GenerateImageTool, EditImageTool
 except ModuleNotFoundError as import_err:
@@ -51,33 +61,14 @@ except ModuleNotFoundError as import_err:
     logger.warning("Download media tool not available: %s", import_err)
     DownloadMediaTool = None
 
-# Standalone Browser tools
-try:
-    from .browser.standalone.navigate_to import NavigateTo as StandaloneNavigateTo # Alias to avoid name clash
-    from .browser.standalone.webpage_reader import WebPageReader as StandaloneWebPageReader # Alias
-    from .browser.standalone.webpage_screenshot_taker import WebPageScreenshotTaker as StandaloneWebPageScreenshotTaker # Alias
-    from .browser.standalone.webpage_image_downloader import WebPageImageDownloader
-    from .browser.standalone.web_page_pdf_generator import WebPagePDFGenerator
-except ModuleNotFoundError as import_err:
-    logger.warning('Standalone browser tools not available: %s', import_err)
-    StandaloneNavigateTo = None
-    StandaloneWebPageReader = None
-    StandaloneWebPageScreenshotTaker = None
-    WebPageImageDownloader = None
-    WebPagePDFGenerator = None
-
-# Session-Aware Browser tools
+# Web tools
 try:
-    from .browser.session_aware.browser_session_aware_navigate_to import BrowserSessionAwareNavigateTo
-    from .browser.session_aware.browser_session_aware_web_element_trigger import BrowserSessionAwareWebElementTrigger
-    from .browser.session_aware.browser_session_aware_webpage_reader import BrowserSessionAwareWebPageReader
-    from .browser.session_aware.browser_session_aware_webpage_screenshot_taker import BrowserSessionAwareWebPageScreenshotTaker
+    from .web.read_url_tool import ReadUrl
 except ModuleNotFoundError as import_err:
-    logger.warning('Session-aware browser tools not available: %s', import_err)
-    BrowserSessionAwareNavigateTo = None
-    BrowserSessionAwareWebElementTrigger = None
-    BrowserSessionAwareWebPageReader = None
-    BrowserSessionAwareWebPageScreenshotTaker = None
+    logger.warning("ReadUrl tool not available: %s", import_err)
+    ReadUrl = None
+
+
 
 
 __all__ = [
@@ -92,31 +83,27 @@ __all__ = [
     "ToolCategory",
 
     # Re-exported functional tool instances
-    "bash_executor",
+    "run_bash",
+    "start_background_process",
+    "get_process_output",
+    "stop_background_process",
     "read_file",
     "write_file",
-    "edit_file",
-    "search_files",
-    "list_directory",
+    "patch_file",
+    "load_skill",
 
     # Re-exported general class-based tools
     "Search",
-    "Timer",
     "GenerateImageTool",
     "EditImageTool",
     "ReadMediaFile",
     "DownloadMediaTool",
 
-    # Re-exported Standalone Browser tools
-    "StandaloneNavigateTo",
-    "StandaloneWebPageReader",
-    "StandaloneWebPageScreenshotTaker",
-    "WebPageImageDownloader",
-    "WebPagePDFGenerator",
-
-    # Re-exported Session-Aware Browser tools
-    "BrowserSessionAwareNavigateTo",
-    "BrowserSessionAwareWebElementTrigger",
-    "BrowserSessionAwareWebPageReader",
-    "BrowserSessionAwareWebPageScreenshotTaker",
+    # Re-exported Web tools
+    "ReadUrl",
+
+    # Tool Formatting
+    "register_tool_formatter",
+    "BaseSchemaFormatter", 
+    "BaseExampleFormatter",
 ]

autobyteus/tools/base_tool.py

@@ -174,6 +174,13 @@ class BaseTool(ABC, EventEmitter, metaclass=ToolMeta):
     async def _execute(self, context: 'AgentContext', **kwargs) -> Any:
         raise NotImplementedError("Subclasses must implement the '_execute' method.")
 
+    async def cleanup(self) -> None:
+        """
+        Lifecycle hook invoked during agent shutdown to release resources held by the tool.
+        Default implementation is a no-op.
+        """
+        return None
+
     @classmethod
     def tool_usage(cls) -> str:
         logger.warning("BaseTool.tool_usage() is deprecated. Tool usage is now generated by formatters.")

autobyteus/tools/file/__init__.py

@@ -1,13 +1,9 @@
-from .edit_file import edit_file
+from .patch_file import patch_file
 from .read_file import read_file
 from .write_file import write_file
-from .search_files import search_files
-from .list_directory import list_directory
 
 __all__ = [
-    "edit_file",
+    "patch_file",
     "read_file",
     "write_file",
-    "search_files",
-    "list_directory",
 ]

autobyteus/tools/file/patch_file.py

@@ -0,0 +1,149 @@
+import os
+import logging
+from typing import TYPE_CHECKING, List
+
+from pydantic import Field
+
+from autobyteus.tools.functional_tool import tool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.diff_utils import apply_unified_diff, PatchApplicationError
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+
+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("patch_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("patch_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("patch_file: normalized path to '%s'.", normalized_path)
+    return normalized_path
+
+
+@tool(name="patch_file", category=ToolCategory.FILE_SYSTEM)
+async def patch_file(
+    context: 'AgentContext',
+    path: str = Field(..., description="Path to the target file."),
+    patch: str = Field(
+        ...,
+        description=(
+            "Unified diff hunks describing edits to apply. "
+            "Example:\n"
+            "--- a/sample.txt\n"
+            "+++ b/sample.txt\n"
+            "@@ -1,2 +1,2 @@\n"
+            "-old line\n"
+            "+new line\n"
+            " unchanged line"
+        ),
+    ),
+) -> 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.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        PatchApplicationError: If the patch content cannot be applied cleanly.
+        IOError: If file reading or writing fails.
+    """
+    logger.debug("patch_file: requested patch for agent '%s' on path '%s'.", context.agent_id, path)
+    return_path = os.path.normpath(path)
+    
+    # Detailed logging for debugging patch content
+    logger.info("patch_file: ===== PATCH ARGUMENT DEBUG START =====")
+    logger.info("patch_file: raw patch repr: %r", patch)
+    logger.info("patch_file: patch length: %d chars", len(patch) if patch else 0)
+    patch_lines = patch.splitlines(keepends=True) if patch else []
+    for i, line in enumerate(patch_lines, 1):
+        prefix = line[0] if line else '<empty>'
+        logger.info("patch_file: line %d: prefix=%r content=%r", i, prefix, line)
+    logger.info("patch_file: ===== PATCH ARGUMENT DEBUG END =====")
+    
+    final_path = _resolve_file_path(context, path)
+
+    file_exists = os.path.exists(final_path)
+    if not file_exists:
+        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 = []
+
+        # Log original file content for comparison
+        logger.info("patch_file: ===== ORIGINAL FILE DEBUG START =====")
+        for i, line in enumerate(original_lines, 1):
+            logger.info("patch_file: original line %d: %r", i, line)
+        logger.info("patch_file: ===== ORIGINAL FILE DEBUG END =====")
+
+        patched_lines = None
+        patch_error = None
+        retry_strategies = [
+            (0, False),
+            (1, False),
+            (1, True),
+            (2, True),
+        ]
+        for fuzz_factor, ignore_whitespace in retry_strategies:
+            try:
+                patched_lines = apply_unified_diff(
+                    original_lines,
+                    patch,
+                    fuzz_factor=fuzz_factor,
+                    ignore_whitespace=ignore_whitespace,
+                )
+                if (fuzz_factor, ignore_whitespace) != (0, False):
+                    logger.info(
+                        "patch_file: applied with fuzz=%d ignore_whitespace=%s.",
+                        fuzz_factor,
+                        ignore_whitespace,
+                    )
+                break
+            except PatchApplicationError as patch_err:
+                patch_error = patch_err
+                logger.warning(
+                    "patch_file: patch failed with fuzz=%d ignore_whitespace=%s: %s",
+                    fuzz_factor,
+                    ignore_whitespace,
+                    patch_err,
+                )
+                continue
+        if patched_lines is None:
+            raise patch_error or PatchApplicationError("Patch could not be applied.")
+
+        with open(final_path, 'w', encoding='utf-8') as destination:
+            destination.writelines(patched_lines)
+
+        logger.info("patch_file: successfully applied patch to '%s'.", final_path)
+        return f"File patched successfully at {return_path}"
+    except PatchApplicationError as patch_err:
+        logger.error("patch_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("patch_file: unexpected error while patching '%s': %s", final_path, exc, exc_info=True)
+        raise IOError(f"Could not patch file at '{final_path}': {exc}")

autobyteus/tools/file/read_file.py

@@ -1,6 +1,8 @@
 import os
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
+
+from pydantic import Field
 
 from autobyteus.tools import tool
 from autobyteus.tools.tool_category import ToolCategory
@@ -11,15 +13,32 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 @tool(name="read_file", category=ToolCategory.FILE_SYSTEM)
-async def read_file(context: 'AgentContext', path: str) -> str:
+async def read_file(
+    context: 'AgentContext',
+    path: str,
+    start_line: Optional[int] = None,
+    end_line: Optional[int] = None,
+    include_line_numbers: bool = Field(
+        True,
+        description="If true, prefix each returned line with its line number (default).",
+    ),
+) -> str:
     """
-    Reads content from a specified file.
+    Reads content from a specified file. Supports optional 1-based inclusive line ranges via start_line/end_line.
+    Each returned line is prefixed with its line number when include_line_numbers is true.
     'path' is the path to the file. If relative, it must be resolved against a configured agent workspace.
-    Raises ValueError if a relative path is given without a valid workspace.
+    Raises ValueError if a relative path is given without a valid workspace or if line range arguments are invalid.
     Raises FileNotFoundError if the file does not exist.
     Raises IOError if file reading fails for other reasons.
     """
     logger.debug(f"Functional read_file tool for agent {context.agent_id}, initial path: {path}")
+
+    if start_line is not None and start_line < 1:
+        raise ValueError(f"start_line must be >= 1 when provided; got {start_line}.")
+    if end_line is not None and end_line < 1:
+        raise ValueError(f"end_line must be >= 1 when provided; got {end_line}.")
+    if start_line is not None and end_line is not None and end_line < start_line:
+        raise ValueError(f"end_line ({end_line}) must be >= start_line ({start_line}).")
     
     final_path: str
     if os.path.isabs(path):
@@ -48,7 +67,19 @@ async def read_file(context: 'AgentContext', path: str) -> str:
         
     try:
         with open(final_path, 'r', encoding='utf-8') as file:
-            content = file.read()
+            selected_lines = []
+            for line_no, line in enumerate(file, start=1):
+                if start_line is not None and line_no < start_line:
+                    continue
+                if end_line is not None and line_no > end_line:
+                    break
+                if include_line_numbers:
+                    line_text = line.rstrip('\n')
+                    line_suffix = '\n' if line.endswith('\n') else ''
+                    selected_lines.append(f"{line_no}: {line_text}{line_suffix}")
+                else:
+                    selected_lines.append(line)
+            content = ''.join(selected_lines)
         logger.info(f"File successfully read from '{final_path}' for agent '{context.agent_id}'.")
         return content
     except Exception as e:

autobyteus/tools/file/write_file.py

@@ -23,8 +23,10 @@ async def write_file(context: 'AgentContext', path: str, content: str) -> str:
     logger.debug(f"Functional write_file tool for agent {context.agent_id}, initial path: {path}")
     
     final_path: str
+    return_path: str
     if os.path.isabs(path):
         final_path = path
+        return_path = final_path
         logger.debug(f"Path '{path}' is absolute. Using it directly.")
     else:
         if not context.workspace:
@@ -39,6 +41,7 @@ async def write_file(context: 'AgentContext', path: str, content: str) -> str:
             raise ValueError(error_msg)
             
         final_path = os.path.join(base_path, path)
+        return_path = os.path.normpath(path)
         logger.debug(f"Path '{path}' is relative. Resolved to '{final_path}' using workspace base path '{base_path}'.")
 
     try:
@@ -53,7 +56,7 @@ async def write_file(context: 'AgentContext', path: str, content: str) -> str:
             file.write(content)
             
         logger.info(f"File successfully written to '{final_path}' for agent '{context.agent_id}'.")
-        return f"File created/updated at {final_path}"
+        return f"File created/updated at {return_path}"
     except Exception as e:
         logger.error(f"Error writing file to final path '{final_path}' for agent {context.agent_id}: {e}", exc_info=True)
         raise IOError(f"Could not write file at '{final_path}': {str(e)}")