janito 2.5.1__py3-none-any.whl → 2.6.0__py3-none-any.whl

janito/providers/anthropic/provider.py

@@ -1,67 +1,80 @@
-from janito.llm.provider import LLMProvider
-from janito.llm.model import LLMModelInfo
-from janito.llm.auth import LLMAuthManager
-from janito.llm.driver_config import LLMDriverConfig
-from janito.tools import get_local_tools_adapter
-from janito.providers.registry import LLMProviderRegistry
-
-from .model_info import MODEL_SPECS
-
-from janito.drivers.anthropic.driver import AnthropicModelDriver
-
-available = AnthropicModelDriver.available
-unavailable_reason = AnthropicModelDriver.unavailable_reason
-maintainer = "Needs maintainer"
-
-
-class AnthropicProvider(LLMProvider):
-    name = "anthropic"
-    maintainer = "Needs maintainer"
-    MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "claude-3-opus-20240229"
-
-    def __init__(
-        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
-    ):
-        # Ensure we always have a tools adapter, even if the driver itself is unavailable.
-        self._tools_adapter = get_local_tools_adapter()
-        if not self.available:
-            self._driver = None
-            return
-        self.auth_manager = auth_manager or LLMAuthManager()
-        self._api_key = self.auth_manager.get_credentials(type(self).name)
-        self._tools_adapter = get_local_tools_adapter()
-        self._info = config or LLMDriverConfig(model=None)
-        if not self._info.model:
-            self._info.model = self.DEFAULT_MODEL
-        if not self._info.api_key:
-            self._info.api_key = self._api_key
-        self.fill_missing_device_info(self._info)
-        self._driver = AnthropicModelDriver(tools_adapter=self._tools_adapter)
-
-    @property
-    def driver(self):
-        if not self.available:
-            raise ImportError(
-                f"AnthropicProvider unavailable: {self.unavailable_reason}"
-            )
-        return self._driver
-
-    @property
-    def available(self):
-        return available
-
-    @property
-    def unavailable_reason(self):
-        return unavailable_reason
-
-    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
-        from janito.llm.agent import LLMAgent
-        from janito.drivers.anthropic.driver import AnthropicModelDriver
-
-        # Always create a new driver with the passed-in tools_adapter
-        driver = AnthropicModelDriver(tools_adapter=tools_adapter)
-        return LLMAgent(self, tools_adapter, agent_name=agent_name, **kwargs)
-
-
-LLMProviderRegistry.register(AnthropicProvider.name, AnthropicProvider)
+from janito.llm.provider import LLMProvider
+from janito.llm.model import LLMModelInfo
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+
+from .model_info import MODEL_SPECS
+
+from janito.llm.provider import LLMProvider
+from janito.llm.model import LLMModelInfo
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from janito.drivers.openai.driver import OpenAIModelDriver
+
+class AnthropicProvider(LLMProvider):
+    name = "anthropic"
+    maintainer = "Needs maintainer"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "claude-3-7-sonnet-20250219"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        self._tools_adapter = get_local_tools_adapter()
+        self.auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self.auth_manager.get_credentials(type(self).name)
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver_config = config or LLMDriverConfig(model=None)
+        if not getattr(self._driver_config, 'model', None):
+            self._driver_config.model = self.DEFAULT_MODEL
+        if not self._driver_config.api_key:
+            self._driver_config.api_key = self._api_key
+        # Set the Anthropic OpenAI-compatible API endpoint
+        self._driver_config.base_url = "https://api.anthropic.com/v1/"
+        self.fill_missing_device_info(self._driver_config)
+        self._driver = None  # to be provided by factory/agent
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"AnthropicProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return OpenAIModelDriver.available
+
+    @property
+    def unavailable_reason(self):
+        return OpenAIModelDriver.unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance configured for Anthropic API.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        return driver
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        """Public, read-only access to the provider's LLMDriverConfig object."""
+        return self._driver_config
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(AnthropicProvider.name, AnthropicProvider)

janito/providers/provider_static_info.py

@@ -1,17 +1,18 @@
-# Provider static metadata registry for listing purposes (name, maintainer, and future fields)
-STATIC_PROVIDER_METADATA = {
-    "openai": {
-    },
-    "google": {
-        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
-    },
-    "azure_openai": {
-        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
-    },
-    "anthropic": {
-        "maintainer": "Needs maintainer",
-    },
-    "deepseek": {
-        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
-    },
-}
+# Provider static metadata registry for listing purposes (name, maintainer, and future fields)
+STATIC_PROVIDER_METADATA = {
+    "openai": {
+    },
+    "google": {
+        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
+    },
+    "azure_openai": {
+        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
+    },
+    "anthropic": {
+        "maintainer": "Alberto Minetti <alberto.minetti@gmail.com>",
+    },
+
+    "deepseek": {
+        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
+    },
+}

janito/tools/adapters/local/__init__.py

@@ -1,65 +1,66 @@
-from .adapter import LocalToolsAdapter
-
-from .ask_user import AskUserTool
-from .copy_file import CopyFileTool
-from .create_directory import CreateDirectoryTool
-from .create_file import CreateFileTool
-from .fetch_url import FetchUrlTool
-from .find_files import FindFilesTool
-from .view_file import ViewFileTool
-from .move_file import MoveFileTool
-from .open_url import OpenUrlTool
-from .open_html_in_browser import OpenHtmlInBrowserTool
-from .python_code_run import PythonCodeRunTool
-from .python_command_run import PythonCommandRunTool
-from .python_file_run import PythonFileRunTool
-from .remove_directory import RemoveDirectoryTool
-from .remove_file import RemoveFileTool
-from .replace_text_in_file import ReplaceTextInFileTool
-from .run_bash_command import RunBashCommandTool
-from .run_powershell_command import RunPowershellCommandTool
-from .get_file_outline.core import GetFileOutlineTool
-from .get_file_outline.search_outline import SearchOutlineTool
-from .search_text.core import SearchTextTool
-from .validate_file_syntax.core import ValidateFileSyntaxTool
-
-# Singleton tools adapter with all standard tools registered
-from janito.tools.tool_base import ToolPermissions
-import os
-local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
-
-from janito.tools.permissions import get_global_allowed_permissions
-
-def get_local_tools_adapter(workdir=None):
-    import os
-    return LocalToolsAdapter(workdir=workdir or os.getcwd())
-
-# Register tools
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-]:
-    local_tools_adapter.register_tool(tool_class)
-
-# DEBUG: Print registered tools at startup
-
+from .adapter import LocalToolsAdapter
+
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .read_files import ReadFilesTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+
+from janito.tools.tool_base import ToolPermissions
+import os
+from janito.tools.permissions import get_global_allowed_permissions
+
+# Singleton tools adapter with all standard tools registered
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+def get_local_tools_adapter(workdir=None):
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    ReadFilesTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
+
+# DEBUG: Print registered tools at startup
+

janito/tools/adapters/local/adapter.py

@@ -18,16 +18,51 @@ class LocalToolsAdapter(ToolsAdapter):
     """
 
     def __init__(self, tools=None, event_bus=None, workdir=None):
+        """Create a new LocalToolsAdapter.
+
+        Parameters
+        ----------
+        tools : list, optional
+            An optional iterable with tool *classes* (not instances) that should
+            be registered immediately.
+        event_bus : janito.event_bus.bus.EventBus, optional
+            The event bus to which tool-related events will be published.  When
+            *None* (default) the **global** :pydata:`janito.event_bus.bus.event_bus`
+            singleton is used so that CLI components such as the
+            :class:`janito.cli.rich_terminal_reporter.RichTerminalReporter` will
+            receive security violation or execution events automatically.
+        workdir : str | pathlib.Path, optional
+            Base directory that path-security checks will allow.  Defaults to
+            the current working directory at the time of instantiation.
+        """
+        # Fall back to the global event bus so that ReportEvents emitted from
+        # the tools adapter (for example path-security violations) are visible
+        # to UI components even if the caller did not supply a custom bus.
+        if event_bus is None:
+            from janito.event_bus.bus import event_bus as global_event_bus
+            event_bus = global_event_bus
+
         super().__init__(tools=tools, event_bus=event_bus)
+
+        # Internal registry structure: { tool_name: {"class": cls, "instance": obj, "function": obj.run} }
         self._tools: Dict[str, Dict[str, Any]] = {}
-        self.workdir = workdir
-        if self.workdir:
-            import os
-            os.chdir(self.workdir)
+
+        import os
+        self.workdir = workdir or os.getcwd()
+        # Ensure *some* workdir is set – fallback to CWD.
+        if not self.workdir:
+            self.workdir = os.getcwd()
+        # Normalise by changing the actual process working directory for
+        # consistency with many file-system tools.
+        os.chdir(self.workdir)
+
         if tools:
             for tool in tools:
                 self.register_tool(tool)
 
+    # ---------------------------------------------------------------------
+    # Registration helpers
+    # ---------------------------------------------------------------------
     def register_tool(self, tool_class: Type):
         instance = tool_class()
         if not hasattr(instance, "run") or not callable(instance.run):
@@ -54,28 +89,43 @@ class LocalToolsAdapter(ToolsAdapter):
     def disable_tool(self, name: str):
         self.unregister_tool(name)
 
+    # ------------------------------------------------------------------
+    # Lookup helpers used by ToolsAdapterBase
+    # ------------------------------------------------------------------
     def get_tool(self, name: str):
         return self._tools[name]["instance"] if name in self._tools else None
 
     def list_tools(self):
-        return [name for name, entry in self._tools.items() if self.is_tool_allowed(entry["instance"])]
+        return [
+            name
+            for name, entry in self._tools.items()
+            if self.is_tool_allowed(entry["instance"])
+        ]
 
     def get_tool_classes(self):
-        return [entry["class"] for entry in self._tools.values() if self.is_tool_allowed(entry["instance"])]
+        return [
+            entry["class"]
+            for entry in self._tools.values()
+            if self.is_tool_allowed(entry["instance"])
+        ]
 
     def get_tools(self):
-        return [entry["instance"] for entry in self._tools.values() if self.is_tool_allowed(entry["instance"])]
-
-
+        return [
+            entry["instance"]
+            for entry in self._tools.values()
+            if self.is_tool_allowed(entry["instance"])
+        ]
+
+    # ------------------------------------------------------------------
+    # Convenience methods
+    # ------------------------------------------------------------------
     def add_tool(self, tool):
-        # Register by instance (useful for hand-built objects)
+        """Register an *instance* (instead of a class) as a tool."""
         if not hasattr(tool, "run") or not callable(tool.run):
             raise TypeError(f"Tool '{tool}' must implement a callable 'run' method.")
         tool_name = getattr(tool, "tool_name", None)
         if not tool_name or not isinstance(tool_name, str):
-            raise ValueError(
-                f"Tool '{tool}' must provide a 'tool_name' (str) attribute."
-            )
+            raise ValueError(f"Tool '{tool}' must provide a 'tool_name' (str) attribute.")
         if tool_name in self._tools:
             raise ValueError(f"Tool '{tool_name}' is already registered.")
         self._tools[tool_name] = {
@@ -85,17 +135,28 @@ class LocalToolsAdapter(ToolsAdapter):
         }
 
 
-# Optional: a local-tool decorator
-
+# -------------------------------------------------------------------------
+# Decorator helper for quick registration of local tools
+# -------------------------------------------------------------------------
 
 def register_local_tool(tool=None):
+    """Class decorator that registers the tool on the *singleton* adapter.
+
+    Example
+    -------
+    >>> @register_local_tool
+    ... class MyTool(BaseTool):
+    ...     ...
+    """
+
     def decorator(cls):
-        from janito.tools.tool_base import ToolPermissions
-        from janito.tools.permissions import get_global_allowed_permissions
+                # Register the tool on a *fresh* adapter instance to avoid circular
+        # import issues during package initialisation.  This keeps behaviour
+        # identical to the original implementation while still allowing
+        # immediate use via the singleton in janito.tools.adapters.local.
         LocalToolsAdapter().register_tool(cls)
         return cls
 
     if tool is None:
         return decorator
     return decorator(tool)
-

janito/tools/adapters/local/create_directory.py

@@ -10,9 +10,9 @@ import os
 @register_local_tool
 class CreateDirectoryTool(ToolBase):
     """
-    Create a new directory at the specified file_path.
+    Create a new directory at the specified path.
     Args:
-        file_path (str): Path for the new directory.
+        path (str): Path for the new directory.
     Returns:
         str: Status message indicating the result. Example:
             - "5c5 Successfully created the directory at ..."
@@ -21,17 +21,17 @@ class CreateDirectoryTool(ToolBase):
     permissions = ToolPermissions(write=True)
     tool_name = "create_directory"
 
-    def run(self, file_path: str) -> str:
-        # file_path = expand_path(file_path)
-        # Using file_path as is
-        disp_path = display_path(file_path)
+    def run(self, path: str) -> str:
+        # path = expand_path(path)
+        # Using path as is
+        disp_path = display_path(path)
         self.report_action(
             tr("📁 Create directory '{disp_path}' ...", disp_path=disp_path),
             ReportAction.CREATE,
         )
         try:
-            if os.path.exists(file_path):
-                if not os.path.isdir(file_path):
+            if os.path.exists(path):
+                if not os.path.isdir(path):
                     self.report_error(
                         tr(
                             "❌ Path '{disp_path}' exists and is not a directory.",
@@ -52,7 +52,7 @@ class CreateDirectoryTool(ToolBase):
                     "❗ Cannot create directory: '{disp_path}' already exists.",
                     disp_path=disp_path,
                 )
-            os.makedirs(file_path, exist_ok=True)
+            os.makedirs(path, exist_ok=True)
             self.report_success(tr("✅ Directory created"))
             return tr(
                 "✅ Successfully created the directory at '{disp_path}'.",

janito/tools/adapters/local/create_file.py

@@ -16,7 +16,7 @@ class CreateFileTool(ToolBase):
     Create a new file with the given content.
 
     Args:
-        file_path (str): Path to the file to create.
+        path (str): Path to the file to create.
         content (str): Content to write to the file.
         overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
     Returns:
@@ -28,13 +28,13 @@ class CreateFileTool(ToolBase):
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
-    def run(self, file_path: str, content: str, overwrite: bool = False) -> str:
-        expanded_file_path = file_path  # Using file_path as is
-        disp_path = display_path(expanded_file_path)
-        file_path = expanded_file_path
-        if os.path.exists(file_path) and not overwrite:
+    def run(self, path: str, content: str, overwrite: bool = False) -> str:
+        expanded_path = path  # Using path as is
+        disp_path = display_path(expanded_path)
+        path = expanded_path
+        if os.path.exists(path) and not overwrite:
             try:
-                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                with open(path, "r", encoding="utf-8", errors="replace") as f:
                     existing_content = f.read()
             except Exception as e:
                 existing_content = f"[Error reading file: {e}]"
@@ -44,14 +44,14 @@ class CreateFileTool(ToolBase):
                 existing_content=existing_content,
             )
         # Determine if we are overwriting an existing file
-        is_overwrite = os.path.exists(file_path) and overwrite
+        is_overwrite = os.path.exists(path) and overwrite
         if is_overwrite:
             # Overwrite branch: log only overwrite warning (no create message)
             self.report_action(
-                tr("⚠️ Overwriting file '{disp_path}'", disp_path=disp_path),
+                tr("⚠️  Overwriting file '{disp_path}'", disp_path=disp_path),
                 ReportAction.CREATE,
             )
-        dir_name = os.path.dirname(file_path)
+        dir_name = os.path.dirname(path)
         if dir_name:
             os.makedirs(dir_name, exist_ok=True)
         if not is_overwrite:
@@ -60,14 +60,14 @@ class CreateFileTool(ToolBase):
                 tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
                 ReportAction.CREATE,
             )
-        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+        with open(path, "w", encoding="utf-8", errors="replace") as f:
             f.write(content)
         new_lines = content.count("\n") + 1 if content else 0
         self.report_success(
             tr("✅ {new_lines} lines", new_lines=new_lines), ReportAction.CREATE
         )
         # Perform syntax validation and append result
-        validation_result = validate_file_syntax(file_path)
+        validation_result = validate_file_syntax(path)
         if is_overwrite:
             # Overwrite branch: return minimal overwrite info to user
             return (

janito/tools/adapters/local/delete_text_in_file.py

@@ -12,7 +12,7 @@ class DeleteTextInFileTool(ToolBase):
     Delete all occurrences of text between start_marker and end_marker (inclusive) in a file, using exact string markers.
 
     Args:
-        file_path (str): Path to the file to modify.
+        path (str): Path to the file to modify.
         start_marker (str): The starting delimiter string.
         end_marker (str): The ending delimiter string.
 
@@ -24,14 +24,14 @@ class DeleteTextInFileTool(ToolBase):
 
     def run(
         self,
-        file_path: str,
+        path: str,
         start_marker: str,
         end_marker: str,
         backup: bool = False,
     ) -> str:
         from janito.tools.tool_utils import display_path
 
-        disp_path = display_path(file_path)
+        disp_path = display_path(path)
         info_msg = tr(
             "📝 Delete text in {disp_path} between markers: '{start_marker}' ... '{end_marker}'",
             disp_path=disp_path,
@@ -40,7 +40,7 @@ class DeleteTextInFileTool(ToolBase):
         )
         self.report_action(info_msg, ReportAction.CREATE)
         try:
-            content = self._read_file_content(file_path)
+            content = self._read_file_content(path)
             occurrences, match_lines = self._find_marker_blocks(
                 content, start_marker, end_marker
             )
@@ -49,27 +49,27 @@ class DeleteTextInFileTool(ToolBase):
                     tr(" ℹ️ No blocks found between markers."), ReportAction.CREATE
                 )
                 return tr(
-                    "No blocks found between markers in {file_path}.",
-                    file_path=file_path,
+                    "No blocks found between markers in {path}.",
+                    path=path,
                 )
 
             new_content, deleted_blocks = self._delete_blocks(
                 content, start_marker, end_marker
             )
-            self._write_file_content(file_path, new_content)
-            validation_result = validate_file_syntax(file_path)
+            self._write_file_content(path, new_content)
+            validation_result = validate_file_syntax(path)
             self._report_success(match_lines)
             return tr(
-                "Deleted {count} block(s) between markers in {file_path}. ",
+                "Deleted {count} block(s) between markers in {path}. ",
                 count=deleted_blocks,
-                file_path=file_path
+                path=path
             ) + (f"\n{validation_result}" if validation_result else "")
         except Exception as e:
             self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.REPLACE)
             return tr("Error deleting text: {error}", error=e)
 
-    def _read_file_content(self, file_path):
-        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+    def _read_file_content(self, path):
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
             return f.read()
 
     def _find_marker_blocks(self, content, start_marker, end_marker):
@@ -110,11 +110,11 @@ class DeleteTextInFileTool(ToolBase):
             count += 1
         return new_content, count
 
-    def _backup_file(self, file_path, backup_path):
-        shutil.copy2(file_path, backup_path)
+    def _backup_file(self, path, backup_path):
+        shutil.copy2(path, backup_path)
 
-    def _write_file_content(self, file_path, content):
-        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+    def _write_file_content(self, path, content):
+        with open(path, "w", encoding="utf-8", errors="replace") as f:
             f.write(content)
 
     def _report_success(self, match_lines):