janito 2.7.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

janito/providers/azure_openai/provider.py

@@ -11,12 +11,13 @@ from janito.drivers.azure_openai.driver import AzureOpenAIModelDriver
 
 available = AzureOpenAIModelDriver.available
 unavailable_reason = AzureOpenAIModelDriver.unavailable_reason
-maintainer = "João Pinto <lamego.pinto@gmail.com>"
+maintainer = "João Pinto <janito@ikignosis.org>"
 
 
 class AzureOpenAIProvider(LLMProvider):
     name = "azure_openai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "azure_openai"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "azure_openai_deployment"
 
@@ -30,7 +31,7 @@ class AzureOpenAIProvider(LLMProvider):
             self._driver = None
             return
         self._auth_manager = auth_manager or LLMAuthManager()
-        self._api_key = self._auth_manager.get_credentials(type(self).name)
+        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 self._driver_config.model:
@@ -41,6 +42,7 @@ class AzureOpenAIProvider(LLMProvider):
             self._driver_config.extra["api_version"] = "2023-05-15"
         # Inject azure_deployment_name from config if present
         from janito.config import config as global_config
+
         deployment_name = global_config.get("azure_deployment_name")
         if deployment_name:
             self._driver_config.extra["azure_deployment_name"] = deployment_name
@@ -76,7 +78,10 @@ class AzureOpenAIProvider(LLMProvider):
         """
         if model_name is None:
             # Return all known specs, but note: only static ones are listed
-            return {name: model_info.to_dict() for name, model_info in self.MODEL_SPECS.items()}
+            return {
+                name: model_info.to_dict()
+                for name, model_info in self.MODEL_SPECS.items()
+            }
         if model_name in self.MODEL_SPECS:
             return self.MODEL_SPECS[model_name].to_dict()
         # Accept any deployment name as a valid model
@@ -120,4 +125,4 @@ class AzureOpenAIProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(AzureOpenAIProvider.name, AzureOpenAIProvider)
+LLMProviderRegistry.register(AzureOpenAIProvider.NAME, AzureOpenAIProvider)

janito/providers/deepseek/provider.py

@@ -12,9 +12,10 @@ available = OpenAIModelDriver.available
 unavailable_reason = OpenAIModelDriver.unavailable_reason
 
 
-class DeepseekProvider(LLMProvider):
+class DeepSeekProvider(LLMProvider):
     name = "deepseek"
-    maintainer = "Needs maintainer"
+    NAME = "deepseek"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
 
@@ -28,7 +29,7 @@ class DeepseekProvider(LLMProvider):
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            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 self._driver_config.model:
@@ -91,4 +92,4 @@ class DeepseekProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)
+LLMProviderRegistry.register(DeepSeekProvider.NAME, DeepSeekProvider)

janito/providers/google/model_info.py

@@ -10,7 +10,7 @@ MODEL_SPECS = {
         max_cot=24576,
         thinking_supported=True,
     ),
-        "gemini-2.5-pro": LLMModelInfo(
+    "gemini-2.5-pro": LLMModelInfo(
         name="gemini-2.5-pro",
         other={"description": "Google Gemini 2.5 Pro (OpenAI-compatible endpoint)"},
         open="google",
@@ -21,7 +21,9 @@ MODEL_SPECS = {
     ),
     "gemini-2.5-flash-lite-preview-06-17": LLMModelInfo(
         name="gemini-2.5-flash-lite-preview-06-17",
-        other={"description": "Google Gemini 2.5 Flash-Lite Preview (OpenAI-compatible endpoint)"},
+        other={
+            "description": "Google Gemini 2.5 Flash-Lite Preview (OpenAI-compatible endpoint)"
+        },
         open="google",
         driver="OpenAIModelDriver",
         max_response=64000,

janito/providers/google/provider.py

@@ -13,9 +13,11 @@ try:
 except ImportError:
     MODEL_SPECS = {}
 
+
 class GoogleProvider(LLMProvider):
     name = "google"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "google"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "gemini-2.5-flash"  # Default Gemini model
 
@@ -33,19 +35,23 @@ class GoogleProvider(LLMProvider):
             self._tools_adapter = get_local_tools_adapter()
             self._driver_config = config or LLMDriverConfig(model=None)
             # Only set default if model is not set by CLI/config
-            if not getattr(self._driver_config, '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 Gemini API endpoint for OpenAI compatibility
-            self._driver_config.base_url = "https://generativelanguage.googleapis.com/v1beta/openai/"
+            self._driver_config.base_url = (
+                "https://generativelanguage.googleapis.com/v1beta/openai/"
+            )
             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"GoogleOpenAIProvider unavailable: {self.unavailable_reason}")
+            raise ImportError(
+                f"GoogleOpenAIProvider unavailable: {self.unavailable_reason}"
+            )
         return self._driver
 
     @property
@@ -80,4 +86,4 @@ class GoogleProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(GoogleProvider.name, GoogleProvider)
+LLMProviderRegistry.register(GoogleProvider.NAME, GoogleProvider)

janito/providers/groq/__init__.py

@@ -0,0 +1 @@
+from .provider import GroqProvider

janito/providers/groq/model_info.py

@@ -0,0 +1,45 @@
+# Groq provider model specifications
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "moonshotai/kimi-k2-instruct": LLMModelInfo(
+        name="moonshotai/kimi-k2-instruct",
+        context=128000,
+        max_input=122880,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="groq",
+        driver="GroqModelDriver",
+        other={
+            "description": "Kimi K2 Instruct model by Moonshot AI",
+            "supports_tools": True,
+            "supports_streaming": True,
+            "supports_vision": False,
+            "supports_system_prompt": True,
+            "supports_temperature": True,
+            "supports_top_p": True,
+            "supports_frequency_penalty": True,
+            "supports_presence_penalty": True,
+            "supports_stop_sequences": True,
+            "supports_max_tokens": True,
+            "supports_seed": False,
+            "supports_json_mode": True,
+            "supports_logprobs": False,
+            "supports_top_logprobs": False,
+            "supports_response_format": True,
+            "supports_n": False,
+            "supports_best_of": False,
+            "supports_echo": False,
+            "supports_logit_bias": False,
+            "supports_user": False,
+            "supports_assistant": False,
+            "supports_system": False,
+            "supports_functions": True,
+            "supports_tool_calls": True,
+            "supports_stream_options": False,
+            "supports_include_usage": False,
+        },
+    )
+}

janito/providers/groq/provider.py

@@ -0,0 +1,76 @@
+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.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class GroqProvider(LLMProvider):
+    name = "groq"
+    NAME = "groq"
+    MAINTAINER = "Groq Inc. <support@groq.com>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "moonshotai/kimi-k2-instruct"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._tools_adapter = get_local_tools_adapter()
+            self._driver = None
+        else:
+            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=self.DEFAULT_MODEL)
+            if not self._driver_config.model:
+                self._driver_config.model = self.DEFAULT_MODEL
+
+            if not self._driver_config.api_key:
+                self._driver_config.api_key = self._api_key
+            self._driver_config.base_url = "https://api.groq.com/openai/v1"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"GroqProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        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):
+        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(GroqProvider.NAME, GroqProvider)

janito/providers/moonshotai/provider.py

@@ -6,13 +6,17 @@ from janito.tools import get_local_tools_adapter
 from janito.providers.registry import LLMProviderRegistry
 from .model_info import MOONSHOTAI_MODEL_SPECS
 
+
 class MoonshotAIProvider(LLMProvider):
     name = "moonshotai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "moonshotai"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MOONSHOTAI_MODEL_SPECS
     DEFAULT_MODEL = "kimi-k2-0711-preview"
 
-    def __init__(self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None):
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
         if not self.available:
             self._tools_adapter = get_local_tools_adapter()
             self._driver = None
@@ -49,7 +53,9 @@ class MoonshotAIProvider(LLMProvider):
     @property
     def driver(self) -> OpenAIModelDriver:
         if not self.available:
-            raise ImportError(f"MoonshotAIProvider unavailable: {self.unavailable_reason}")
+            raise ImportError(
+                f"MoonshotAIProvider unavailable: {self.unavailable_reason}"
+            )
         return self._driver
 
     @property
@@ -79,4 +85,5 @@ class MoonshotAIProvider(LLMProvider):
         self._tools_adapter.event_bus = event_bus
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
-LLMProviderRegistry.register(MoonshotAIProvider.name, MoonshotAIProvider)
+
+LLMProviderRegistry.register(MoonshotAIProvider.NAME, MoonshotAIProvider)

janito/providers/openai/model_info.py

@@ -123,5 +123,4 @@ MODEL_SPECS = {
         open="openai",
         driver="OpenAIModelDriver",
     ),
-
 }

janito/providers/openai/provider.py

@@ -14,11 +14,10 @@ unavailable_reason = OpenAIModelDriver.unavailable_reason
 
 class OpenAIProvider(LLMProvider):
     name = "openai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "openai"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = (
-        "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, 
-    )
+    DEFAULT_MODEL = "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini,
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
@@ -31,7 +30,7 @@ class OpenAIProvider(LLMProvider):
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            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 self._driver_config.model:
@@ -77,7 +76,7 @@ class OpenAIProvider(LLMProvider):
         Creates and returns a new OpenAIModelDriver instance with input/output queues.
         """
         driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.name
+            tools_adapter=self._tools_adapter, provider_name=self.NAME
         )
         driver.config = self._driver_config
         # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
@@ -108,4 +107,4 @@ class OpenAIProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(OpenAIProvider.name, OpenAIProvider)
+LLMProviderRegistry.register(OpenAIProvider.NAME, OpenAIProvider)

janito/tools/__init__.py

@@ -7,6 +7,7 @@ from janito.tools.adapters.local import (
 def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     # Use set_verbose_tools on the returned adapter to set verbosity as needed
     import os
+
     if workdir is not None and not os.path.exists(workdir):
         os.makedirs(workdir, exist_ok=True)
     # Permissions are now managed globally; ignore allowed_permissions argument except for backward compatibility
@@ -16,6 +17,7 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     if workdir is not None:
         try:
             import os
+
             if not os.path.exists(workdir):
                 os.makedirs(workdir, exist_ok=True)
             os.chdir(workdir)

janito/tools/adapters/local/__init__.py

@@ -31,9 +31,11 @@ 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,
@@ -63,4 +65,3 @@ for tool_class in [
     local_tools_adapter.register_tool(tool_class)
 
 # DEBUG: Print registered tools at startup
-

janito/tools/adapters/local/adapter.py

@@ -40,6 +40,7 @@ class LocalToolsAdapter(ToolsAdapter):
         # 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)
@@ -48,6 +49,7 @@ class LocalToolsAdapter(ToolsAdapter):
         self._tools: Dict[str, Dict[str, Any]] = {}
 
         import os
+
         self.workdir = workdir or os.getcwd()
         # Ensure *some* workdir is set – fallback to CWD.
         if not self.workdir:
@@ -93,27 +95,39 @@ class LocalToolsAdapter(ToolsAdapter):
     # Lookup helpers used by ToolsAdapterBase
     # ------------------------------------------------------------------
     def get_tool(self, name: str):
-        return self._tools[name]["instance"] if name in self._tools else None
+        from janito.tools.disabled_tools import is_tool_disabled
+
+        if name in self._tools and not is_tool_disabled(name):
+            return self._tools[name]["instance"]
+        return None
 
     def list_tools(self):
+        from janito.tools.disabled_tools import is_tool_disabled
+
         return [
             name
             for name, entry in self._tools.items()
-            if self.is_tool_allowed(entry["instance"])
+            if self.is_tool_allowed(entry["instance"]) and not is_tool_disabled(name)
         ]
 
     def get_tool_classes(self):
+        from janito.tools.disabled_tools import is_tool_disabled
+
         return [
             entry["class"]
             for entry in self._tools.values()
             if self.is_tool_allowed(entry["instance"])
+            and not is_tool_disabled(entry["instance"].tool_name)
         ]
 
     def get_tools(self):
+        from janito.tools.disabled_tools import is_tool_disabled
+
         return [
             entry["instance"]
             for entry in self._tools.values()
             if self.is_tool_allowed(entry["instance"])
+            and not is_tool_disabled(entry["instance"].tool_name)
         ]
 
     # ------------------------------------------------------------------
@@ -125,7 +139,9 @@ class LocalToolsAdapter(ToolsAdapter):
             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] = {
@@ -139,6 +155,7 @@ class LocalToolsAdapter(ToolsAdapter):
 # Decorator helper for quick registration of local tools
 # -------------------------------------------------------------------------
 
+
 def register_local_tool(tool=None):
     """Class decorator that registers the tool on the *singleton* adapter.
 
@@ -150,7 +167,7 @@ def register_local_tool(tool=None):
     """
 
     def decorator(cls):
-                # Register the tool on a *fresh* adapter instance to avoid circular
+        # 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.

janito/tools/adapters/local/ask_user.py

@@ -27,6 +27,7 @@ class AskUserTool(ToolBase):
             - "No"
             - "Some detailed answer..."
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "ask_user"
 

janito/tools/adapters/local/copy_file.py

@@ -21,6 +21,7 @@ class CopyFileTool(ToolBase):
     Returns:
         str: Status string for each copy operation.
     """
+
     permissions = ToolPermissions(read=True, write=True)
     tool_name = "copy_file"
 

janito/tools/adapters/local/create_directory.py

@@ -18,6 +18,7 @@ class CreateDirectoryTool(ToolBase):
             - "5c5 Successfully created the directory at ..."
             - "5d7 Cannot create directory: ..."
     """
+
     permissions = ToolPermissions(write=True)
     tool_name = "create_directory"
 

janito/tools/adapters/local/create_file.py

@@ -25,6 +25,7 @@ class CreateFileTool(ToolBase):
 
     Note: Syntax validation is automatically performed after this operation.
     """
+
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 

janito/tools/adapters/local/delete_text_in_file.py

@@ -19,6 +19,7 @@ class DeleteTextInFileTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
+
     permissions = ToolPermissions(read=True, write=True)
     tool_name = "delete_text_in_file"
 
@@ -62,7 +63,7 @@ class DeleteTextInFileTool(ToolBase):
             return tr(
                 "Deleted {count} block(s) between markers in {path}. ",
                 count=deleted_blocks,
-                path=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)

janito/tools/adapters/local/fetch_url.py

@@ -21,6 +21,7 @@ class FetchUrlTool(ToolBase):
             - "No lines found for the provided search strings."
             - "Warning: Empty URL provided. Operation skipped."
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "fetch_url"
 

janito/tools/adapters/local/find_files.py

@@ -61,7 +61,9 @@ class FindFilesTool(ToolBase):
                     break
         return dir_output
 
-    def _handle_directory_path(self, directory, patterns, max_depth, include_gitignored):
+    def _handle_directory_path(
+        self, directory, patterns, max_depth, include_gitignored
+    ):
         dir_output = set()
         for root, dirs, files in walk_dir_with_gitignore(
             directory,
@@ -73,9 +75,7 @@ class FindFilesTool(ToolBase):
                     dir_output.update(self._match_directories(root, dirs, pat))
                 else:
                     dir_output.update(self._match_files(root, files, pat))
-                    dir_output.update(
-                        self._match_dirs_without_slash(root, dirs, pat)
-                    )
+                    dir_output.update(self._match_dirs_without_slash(root, dirs, pat))
         return dir_output
 
     def _report_search(self, pattern, disp_path, depth_msg):
@@ -131,9 +131,10 @@ class FindFilesTool(ToolBase):
             if os.path.isfile(directory):
                 dir_output = self._handle_path(directory, patterns)
             elif os.path.isdir(directory):
-                dir_output = self._handle_directory_path(directory, patterns, max_depth, include_gitignored)
+                dir_output = self._handle_directory_path(
+                    directory, patterns, max_depth, include_gitignored
+                )
             self._report_success(len(dir_output))
             results.extend(self._format_output(directory, dir_output))
         result = "\n".join(results)
         return result
-

janito/tools/adapters/local/get_file_outline/core.py

@@ -20,6 +20,7 @@ class GetFileOutlineTool(ToolBase):
     Args:
         path (str): Path to the file to outline.
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "get_file_outline"
 

janito/tools/adapters/local/get_file_outline/java_outline.py

@@ -1,6 +1,7 @@
 import re
 from typing import List, Dict
 
+
 def parse_java_outline(lines: List[str]) -> List[Dict]:
     """
     Parses Java source code lines and extracts classes and methods with their signatures.
@@ -9,19 +10,23 @@ def parse_java_outline(lines: List[str]) -> List[Dict]:
     outline = []
     class_pattern = re.compile(r"\bclass\s+(\w+)(\s*<[^>]+>)?")
     # Match methods with or without visibility modifiers (including package-private)
-    method_pattern = re.compile(r"^(?:\s*(public|protected|private)\s+)?(?:static\s+)?([\w<>\[\]]+)\s+(\w+)\s*\(([^)]*)\)")
+    method_pattern = re.compile(
+        r"^(?:\s*(public|protected|private)\s+)?(?:static\s+)?([\w<>\[\]]+)\s+(\w+)\s*\(([^)]*)\)"
+    )
     current_class = None
     for idx, line in enumerate(lines, 1):
         class_match = class_pattern.search(line)
         if class_match:
             class_name = class_match.group(1)
             generics = class_match.group(2) or ""
-            outline.append({
-                "type": "class",
-                "name": class_name,
-                "generics": generics.strip("<>") if generics else None,
-                "line": idx
-            })
+            outline.append(
+                {
+                    "type": "class",
+                    "name": class_name,
+                    "generics": generics.strip("<>") if generics else None,
+                    "line": idx,
+                }
+            )
             current_class = class_name
         else:
             method_match = method_pattern.search(line)
@@ -29,12 +34,14 @@ def parse_java_outline(lines: List[str]) -> List[Dict]:
                 return_type = method_match.group(2)
                 method_name = method_match.group(3)
                 params = method_match.group(4)
-                outline.append({
-                    "type": "method",
-                    "class": current_class,
-                    "name": method_name,
-                    "return_type": return_type,
-                    "parameters": params.strip(),
-                    "line": idx
-                })
+                outline.append(
+                    {
+                        "type": "method",
+                        "class": current_class,
+                        "name": method_name,
+                        "return_type": return_type,
+                        "parameters": params.strip(),
+                        "line": idx,
+                    }
+                )
     return outline

janito/tools/adapters/local/get_file_outline/search_outline.py

@@ -11,6 +11,7 @@ class SearchOutlineTool(ToolBase):
     Returns:
         str: Outline search result or status message.
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "search_outline"
 

janito/tools/adapters/local/move_file.py

@@ -20,6 +20,7 @@ class MoveFileTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
+
     permissions = ToolPermissions(read=True, write=True)
     tool_name = "move_file"