janito 3.1.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

janito/plugins_backup_20250825_070018/manager.py

@@ -0,0 +1,243 @@
+"""
+Plugin manager for loading and managing plugins.
+"""
+
+import os
+import sys
+import importlib
+import importlib.util
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import logging
+
+from janito.plugin_system.base import Plugin, PluginMetadata
+from .discovery import discover_plugins
+from .config import load_plugins_config, get_user_plugins_dir
+from .builtin import BuiltinPluginRegistry, load_builtin_plugin
+from janito.tools.adapters.local import LocalToolsAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    """
+    Manages plugin loading, registration, and lifecycle.
+    """
+
+    def __init__(self, tools_adapter: Optional[LocalToolsAdapter] = None):
+        self.tools_adapter = tools_adapter or LocalToolsAdapter()
+        self.plugins: Dict[str, Plugin] = {}
+        self.plugin_configs: Dict[str, Dict[str, Any]] = {}
+        self.plugin_paths: List[Path] = []
+
+    def add_plugin_path(self, path: str) -> None:
+        """Add a directory to search for plugins."""
+        plugin_path = Path(path)
+        if plugin_path.exists() and plugin_path.is_dir():
+            self.plugin_paths.append(plugin_path)
+            if str(plugin_path) not in sys.path:
+                sys.path.insert(0, str(plugin_path))
+
+    def load_plugin(
+        self, plugin_name: str, config: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """
+        Load a plugin by name.
+
+        Args:
+            plugin_name: Name of the plugin to load
+            config: Optional configuration for the plugin
+
+        Returns:
+            True if plugin loaded successfully
+        """
+        try:
+            if plugin_name in self.plugins:
+                logger.warning(f"Plugin {plugin_name} already loaded")
+                return True
+
+            plugin = discover_plugins(plugin_name, self.plugin_paths)
+            if not plugin:
+                logger.error(f"Plugin {plugin_name} not found")
+                return False
+
+            # Store config
+            if config:
+                self.plugin_configs[plugin_name] = config
+
+            # Validate config if provided
+            if config and hasattr(plugin, "validate_config"):
+                if not plugin.validate_config(config):
+                    logger.error(f"Invalid configuration for plugin {plugin_name}")
+                    return False
+
+            # Initialize plugin
+            plugin.initialize()
+
+            # Register tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                self.tools_adapter.register_tool(tool_class)
+
+            # Store plugin
+            self.plugins[plugin_name] = plugin
+
+            logger.info(f"Successfully loaded plugin: {plugin_name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to load plugin {plugin_name}: {e}")
+            return False
+
+    def unload_plugin(self, plugin_name: str) -> bool:
+        """
+        Unload a plugin.
+
+        Args:
+            plugin_name: Name of the plugin to unload
+
+        Returns:
+            True if plugin unloaded successfully
+        """
+        try:
+            if plugin_name not in self.plugins:
+                logger.warning(f"Plugin {plugin_name} not loaded")
+                return False
+
+            plugin = self.plugins[plugin_name]
+
+            # Unregister tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                tool_name = getattr(tool_class(), "tool_name", None)
+                if tool_name:
+                    self.tools_adapter.unregister_tool(tool_name)
+
+            # Cleanup plugin
+            plugin.cleanup()
+
+            # Remove from registry
+            del self.plugins[plugin_name]
+            if plugin_name in self.plugin_configs:
+                del self.plugin_configs[plugin_name]
+
+            logger.info(f"Successfully unloaded plugin: {plugin_name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to unload plugin {plugin_name}: {e}")
+            return False
+
+    def list_plugins(self) -> List[str]:
+        """Return list of loaded plugin names."""
+        return list(self.plugins.keys())
+
+    def get_plugin(self, plugin_name: str) -> Optional[Plugin]:
+        """Get a loaded plugin by name."""
+        return self.plugins.get(plugin_name)
+
+    def get_plugin_metadata(self, plugin_name: str) -> Optional[PluginMetadata]:
+        """Get metadata for a loaded plugin."""
+        plugin = self.plugins.get(plugin_name)
+        return plugin.metadata if plugin else None
+
+    def load_plugins_from_config(self, config: Dict[str, Any]) -> None:
+        """
+        Load plugins from configuration.
+
+        Args:
+            config: Configuration dict with plugin settings
+        """
+        plugins_config = config.get("plugins", {})
+
+        # Add plugin paths
+        for path in plugins_config.get("paths", []):
+            self.add_plugin_path(path)
+
+        # Load plugins
+        for plugin_name, plugin_config in plugins_config.get("load", {}).items():
+            if isinstance(plugin_config, bool):
+                if plugin_config:
+                    self.load_plugin(plugin_name)
+            else:
+                self.load_plugin(plugin_name, plugin_config)
+
+    def load_plugins_from_user_config(self) -> None:
+        """
+        Load plugins from user configuration directory.
+        Uses ~/.janito/plugins.json instead of janito.json
+        """
+        config = load_plugins_config()
+        self.load_plugins_from_config(config)
+
+    def reload_plugin(self, plugin_name: str) -> bool:
+        """
+        Reload a plugin.
+
+        Args:
+            plugin_name: Name of the plugin to reload
+
+        Returns:
+            True if plugin reloaded successfully
+        """
+        config = self.plugin_configs.get(plugin_name)
+        self.unload_plugin(plugin_name)
+        return self.load_plugin(plugin_name, config)
+
+    def get_loaded_plugins_info(self) -> Dict[str, Dict[str, Any]]:
+        """Get information about all loaded plugins."""
+        info = {}
+        for name, plugin in self.plugins.items():
+            info[name] = {
+                "metadata": plugin.metadata,
+                "tools": [tool.__name__ for tool in plugin.get_tools()],
+                "commands": list(plugin.get_commands().keys()),
+                "config": self.plugin_configs.get(name, {}),
+                "builtin": BuiltinPluginRegistry.is_builtin(name),
+                "resources": [
+                    {
+                        "name": resource.name,
+                        "type": resource.type,
+                        "description": resource.description,
+                        "schema": resource.schema,
+                    }
+                    for resource in plugin.get_resources()
+                ],
+            }
+        return info
+
+    def get_plugin_resources(self, plugin_name: str) -> List[Dict[str, Any]]:
+        """
+        Get resources provided by a specific plugin.
+
+        Args:
+            plugin_name: Name of the plugin
+
+        Returns:
+            List of resource dictionaries
+        """
+        plugin = self.plugins.get(plugin_name)
+        if not plugin:
+            return []
+
+        return [
+            {
+                "name": resource.name,
+                "type": resource.type,
+                "description": resource.description,
+                "schema": resource.schema,
+            }
+            for resource in plugin.get_resources()
+        ]
+
+    def list_all_resources(self) -> Dict[str, List[Dict[str, Any]]]:
+        """
+        List all resources from all loaded plugins.
+
+        Returns:
+            Dict mapping plugin names to their resources
+        """
+        all_resources = {}
+        for plugin_name in self.plugins:
+            all_resources[plugin_name] = self.get_plugin_resources(plugin_name)
+        return all_resources

janito/{plugins → plugins_backup_20250825_070018}/tools/delete_text_in_file.py

@@ -15,6 +15,7 @@ class DeleteTextInFile(ToolBase):
         path (str): Path to the file to modify.
         start_marker (str): The starting delimiter string.
         end_marker (str): The ending delimiter string.
+        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
 
     Returns:
         str: Status message indicating the result.

janito/plugins_backup_20250825_070018/tools/get_file_outline/java_outline.py

@@ -0,0 +1,47 @@
+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.
+    Returns a list of outline items: {type, name, return_type, parameters, generics, line}
+    """
+    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*\(([^)]*)\)"
+    )
+    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,
+                }
+            )
+            current_class = class_name
+        else:
+            method_match = method_pattern.search(line)
+            if method_match:
+                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,
+                    }
+                )
+    return outline

janito/plugins_backup_20250825_070018/tools/get_file_outline/markdown_outline.py

@@ -0,0 +1,14 @@
+import re
+from typing import List
+
+
+def parse_markdown_outline(lines: List[str]):
+    header_pat = re.compile(r"^(#+)\s+(.*)")
+    outline = []
+    for idx, line in enumerate(lines):
+        match = header_pat.match(line)
+        if match:
+            level = len(match.group(1))
+            title = match.group(2).strip()
+            outline.append({"level": level, "title": title, "line": idx + 1})
+    return outline

janito/plugins_backup_20250825_070018/tools/get_file_outline/python_outline.py

@@ -0,0 +1,303 @@
+import re
+from typing import List
+
+
+def handle_assignment(idx, assign_match, outline):
+    var_name = assign_match.group(2)
+    var_type = "const" if var_name.isupper() else "var"
+    outline.append(
+        {
+            "type": var_type,
+            "name": var_name,
+            "start": idx + 1,
+            "end": idx + 1,
+            "parent": "",
+            "docstring": "",
+        }
+    )
+
+
+def handle_main(idx, outline):
+    outline.append(
+        {
+            "type": "main",
+            "name": "__main__",
+            "start": idx + 1,
+            "end": idx + 1,
+            "parent": "",
+            "docstring": "",
+        }
+    )
+
+
+def close_stack_objects(idx, indent, stack, obj_ranges):
+    while stack and indent < stack[-1][2]:
+        popped = stack.pop()
+        obj_ranges.append((popped[0], popped[1], popped[3], idx, popped[4], popped[2]))
+
+
+def close_last_top_obj(idx, last_top_obj, stack, obj_ranges):
+    if last_top_obj and last_top_obj in stack:
+        stack.remove(last_top_obj)
+        obj_ranges.append(
+            (
+                last_top_obj[0],
+                last_top_obj[1],
+                last_top_obj[3],
+                idx,
+                last_top_obj[4],
+                last_top_obj[2],
+            )
+        )
+        return None
+    return last_top_obj
+
+
+def handle_class(idx, class_match, indent, stack, last_top_obj):
+    name = class_match.group(2)
+    parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
+    obj = ("class", name, indent, idx + 1, parent)
+    stack.append(obj)
+    if indent == 0:
+        last_top_obj = obj
+    return last_top_obj
+
+
+def handle_function(idx, func_match, indent, stack, last_top_obj):
+    name = func_match.group(2)
+    parent = ""
+    for s in reversed(stack):
+        if s[0] == "class" and indent > s[2]:
+            parent = s[1]
+            break
+    obj = ("function", name, indent, idx + 1, parent)
+    stack.append(obj)
+    if indent == 0:
+        last_top_obj = obj
+    return last_top_obj
+
+
+def process_line(idx, line, regexes, stack, obj_ranges, outline, last_top_obj):
+    class_pat, func_pat, assign_pat, main_pat = regexes
+    class_match = class_pat.match(line)
+    func_match = func_pat.match(line)
+    assign_match = assign_pat.match(line)
+    indent = len(line) - len(line.lstrip())
+    # If a new top-level class or function starts, close the previous one
+    if (class_match or func_match) and indent == 0 and last_top_obj:
+        last_top_obj = close_last_top_obj(idx, last_top_obj, stack, obj_ranges)
+    if class_match:
+        last_top_obj = handle_class(idx, class_match, indent, stack, last_top_obj)
+    elif func_match:
+        last_top_obj = handle_function(idx, func_match, indent, stack, last_top_obj)
+    elif assign_match and indent == 0:
+        handle_assignment(idx, assign_match, outline)
+    main_match = main_pat.match(line)
+    if main_match:
+        handle_main(idx, outline)
+    close_stack_objects(idx, indent, stack, obj_ranges)
+    return last_top_obj
+
+
+def extract_signature_and_decorators(lines, start_idx):
+    """
+    Extracts the signature line and leading decorators for a given function/class/method.
+    Returns (signature:str, decorators:List[str], signature_lineno:int)
+    """
+    decorators = []
+    sig_line = None
+    sig_lineno = start_idx
+    for i in range(start_idx - 1, -1, -1):
+        striped = lines[i].strip()
+        if striped.startswith("@"):
+            decorators.insert(0, striped)
+            sig_lineno = i
+        elif not striped:
+            continue
+        else:
+            break
+    # Find the signature line itself
+    for k in range(start_idx, len(lines)):
+        striped = lines[k].strip()
+        if striped.startswith("def ") or striped.startswith("class "):
+            sig_line = striped
+            sig_lineno = k
+            break
+    return sig_line, decorators, sig_lineno
+
+
+def extract_docstring(lines, start_idx, end_idx):
+    """Extracts a docstring from lines[start_idx:end_idx] if present."""
+    for i in range(start_idx, min(end_idx, len(lines))):
+        line = lines[i].lstrip()
+        if not line:
+            continue
+        if line.startswith('"""') or line.startswith("'''"):
+            quote = line[:3]
+            doc = line[3:]
+            if doc.strip().endswith(quote):
+                return doc.strip()[:-3].strip()
+            docstring_lines = [doc]
+            for j in range(i + 1, min(end_idx, len(lines))):
+                line = lines[j]
+                if line.strip().endswith(quote):
+                    docstring_lines.append(line.strip()[:-3])
+                    return "\n".join([d.strip() for d in docstring_lines]).strip()
+                docstring_lines.append(line)
+            break
+        else:
+            break
+    return ""
+
+
+def build_outline_entry(obj, lines, outline):
+    obj_type, name, start, end, parent, indent = obj
+    # Determine if this is a method
+    if obj_type == "function" and parent:
+        outline_type = "method"
+    elif obj_type == "function":
+        outline_type = "function"
+    else:
+        outline_type = obj_type
+    docstring = extract_docstring(lines, start, end)
+    outline.append(
+        {
+            "type": outline_type,
+            "name": name,
+            "start": start,
+            "end": end,
+            "parent": parent,
+            "docstring": docstring,
+        }
+    )
+
+
+def process_lines(lines, regexes):
+    outline = []
+    stack = []
+    obj_ranges = []
+    last_top_obj = None
+    for idx, line in enumerate(lines):
+        last_top_obj = process_line(
+            idx, line, regexes, stack, obj_ranges, outline, last_top_obj
+        )
+    # Close any remaining open objects
+    for popped in stack:
+        obj_ranges.append(
+            (popped[0], popped[1], popped[3], len(lines), popped[4], popped[2])
+        )
+    return outline, obj_ranges
+
+
+def build_outline(obj_ranges, lines, outline):
+    for obj in obj_ranges:
+        build_outline_entry(obj, lines, outline)
+    return outline
+
+
+def parse_python_outline(lines: List[str]):
+    class_pat = re.compile(r"^(\s*)class\s+(\w+)")
+    func_pat = re.compile(r"^(\s*)def\s+(\w+)")
+    assign_pat = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=.*")
+    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
+    outline = []
+    stack = []
+    obj_ranges = []
+    last_top_obj = None
+    for idx, line in enumerate(lines):
+        class_match = class_pat.match(line)
+        func_match = func_pat.match(line)
+        assign_match = assign_pat.match(line)
+        indent = len(line) - len(line.lstrip())
+        parent = ""
+        for s in reversed(stack):
+            if s[0] == "class" and indent > s[2]:
+                parent = s[1]
+                break
+        if class_match:
+            obj = ("class", class_match.group(2), idx + 1, None, parent, indent)
+            stack.append(obj)
+            last_top_obj = obj
+        elif func_match:
+            obj = ("function", func_match.group(2), idx + 1, None, parent, indent)
+            stack.append(obj)
+            last_top_obj = obj
+        elif assign_match and indent == 0:
+            outline.append(
+                {
+                    "type": "const" if assign_match.group(2).isupper() else "var",
+                    "name": assign_match.group(2),
+                    "start": idx + 1,
+                    "end": idx + 1,
+                    "parent": "",
+                    "signature": line.strip(),
+                    "decorators": [],
+                    "docstring": "",
+                }
+            )
+        if line.strip().startswith("if __name__ == "):
+            outline.append(
+                {
+                    "type": "main",
+                    "name": "__main__",
+                    "start": idx + 1,
+                    "end": idx + 1,
+                    "parent": "",
+                    "signature": line.strip(),
+                    "decorators": [],
+                    "docstring": "",
+                }
+            )
+        # Close stack objects if indent falls back
+        while stack and indent <= stack[-1][5] and idx + 1 > stack[-1][2]:
+            finished = stack.pop()
+            outline_entry = finished[:2] + (
+                finished[2],
+                idx + 1,
+                finished[4],
+                finished[5],
+            )
+            build_outline_entry(outline_entry, lines, outline)
+    # Close any remaining objects
+    while stack:
+        finished = stack.pop()
+        outline_entry = finished[:2] + (
+            finished[2],
+            len(lines),
+            finished[4],
+            finished[5],
+        )
+        build_outline_entry(outline_entry, lines, outline)
+    return outline
+
+    class_pat = re.compile(r"^(\s*)class\s+(\w+)")
+    func_pat = re.compile(r"^(\s*)def\s+(\w+)")
+    assign_pat = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=.*")
+    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
+    regexes = (class_pat, func_pat, assign_pat, main_pat)
+    outline, obj_ranges = process_lines(lines, regexes)
+    return build_outline(obj_ranges, lines, outline)
+
+
+def extract_docstring(lines, start_idx, end_idx):
+    """Extracts a docstring from lines[start_idx:end_idx] if present."""
+    for i in range(start_idx, min(end_idx, len(lines))):
+        line = lines[i].lstrip()
+        if not line:
+            continue
+        if line.startswith('"""') or line.startswith("'''"):
+            quote = line[:3]
+            doc = line[3:]
+            if doc.strip().endswith(quote):
+                return doc.strip()[:-3].strip()
+            docstring_lines = [doc]
+            for j in range(i + 1, min(end_idx, len(lines))):
+                line = lines[j]
+                if line.strip().endswith(quote):
+                    docstring_lines.append(line.strip()[:-3])
+                    return "\n".join([d.strip() for d in docstring_lines]).strip()
+                docstring_lines.append(line)
+            break
+        else:
+            break
+    return ""

janito/plugins_backup_20250825_070018/tools/get_file_outline/search_outline.py

@@ -0,0 +1,36 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+class SearchOutlineTool(ToolBase):
+    """
+    Tool for searching outlines in files.
+
+    Args:
+        path (str): Path to the file for which to generate an outline.
+    Returns:
+        str: Outline search result or status message.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "search_outline"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str) -> str:
+        from janito.tools.tool_utils import display_path
+        from janito.i18n import tr
+
+        self.report_action(
+            tr(
+                "🔍 Searching for outline in '{disp_path}'",
+                disp_path=display_path(path),
+            ),
+            ReportAction.READ,
+        )
+        # ... rest of implementation ...
+        # Example warnings and successes:
+        # self.report_warning(tr("No files found with supported extensions."))
+        # self.report_warning(tr("Error reading {path}: {error}", path=path, error=e))
+        # self.report_success(tr("✅ {count} {match_word} found", count=len(output), match_word=pluralize('match', len(output))))
+        pass