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

janito/{plugins → plugins_backup_20250825_070018}/auto_loader.py

@@ -13,7 +13,7 @@ from janito.plugins.discovery import list_available_plugins
 # List of core plugins that should be enabled by default
 CORE_PLUGINS = [
     "core.filemanager",
-    "core.codeanalyzer",
+    "core.codeanalyzer", 
     "core.system",
     "core.imagedisplay",
     "dev.pythondev",
@@ -26,23 +26,23 @@ CORE_PLUGINS = [
 def load_core_plugins(pm: PluginManager = None) -> List[str]:
     """
     Load all core plugins.
-
+    
     Args:
         pm: PluginManager instance. If None, creates a new one.
-
+        
     Returns:
         List of successfully loaded plugin names
     """
     if pm is None:
         pm = PluginManager()
-
+    
     # Ensure plugins directory is in search path
     plugins_dir = Path.cwd() / "plugins"
     if plugins_dir.exists():
         pm.add_plugin_path(str(plugins_dir))
-
+    
     loaded = []
-
+    
     # Load core plugins
     for plugin_name in CORE_PLUGINS:
         try:
@@ -50,14 +50,14 @@ def load_core_plugins(pm: PluginManager = None) -> List[str]:
                 loaded.append(plugin_name)
         except Exception as e:
             print(f"Warning: Failed to load core plugin {plugin_name}: {e}")
-
+    
     return loaded
 
 
 def get_loaded_core_plugins() -> List[str]:
     """
     Get list of currently loaded core plugins.
-
+    
     Returns:
         List of loaded core plugin names
     """
@@ -69,10 +69,10 @@ def get_loaded_core_plugins() -> List[str]:
 def is_core_plugin(plugin_name: str) -> bool:
     """
     Check if a plugin is a core plugin.
-
+    
     Args:
         plugin_name: Name of the plugin to check
-
+        
     Returns:
         True if it's a core plugin
     """
@@ -82,11 +82,10 @@ def is_core_plugin(plugin_name: str) -> bool:
 # Auto-load core plugins when module is imported
 _plugin_manager = None
 
-
 def get_plugin_manager() -> PluginManager:
     """Get the global plugin manager with core plugins loaded."""
     global _plugin_manager
     if _plugin_manager is None:
         _plugin_manager = PluginManager()
         load_core_plugins(_plugin_manager)
-    return _plugin_manager
+    return _plugin_manager

janito/plugins_backup_20250825_070018/builtin.py

@@ -0,0 +1,102 @@
+"""
+Builtin plugin system for janito-packaged plugins.
+
+This module provides the infrastructure for plugins that are bundled
+with janito and available by default without requiring external installation.
+"""
+
+import importlib
+from typing import Dict, List, Optional, Type
+from janito.plugin_system.base import Plugin
+
+
+class BuiltinPluginRegistry:
+    """Registry for builtin plugins that come packaged with janito."""
+
+    _plugins: Dict[str, Type[Plugin]] = {}
+
+    @classmethod
+    def register(cls, name: str, plugin_class: Type[Plugin]) -> None:
+        """Register a builtin plugin."""
+        cls._plugins[name] = plugin_class
+
+    @classmethod
+    def get_plugin_class(cls, name: str) -> Optional[Type[Plugin]]:
+        """Get the plugin class for a builtin plugin."""
+        return cls._plugins.get(name)
+
+    @classmethod
+    def list_builtin_plugins(cls) -> List[str]:
+        """List all registered builtin plugins."""
+        return list(cls._plugins.keys())
+
+    @classmethod
+    def is_builtin(cls, name: str) -> bool:
+        """Check if a plugin is builtin."""
+        return name in cls._plugins
+
+
+def register_builtin_plugin(name: str):
+    """Decorator to register a plugin as builtin."""
+
+    def decorator(plugin_class: Type[Plugin]) -> Type[Plugin]:
+        BuiltinPluginRegistry.register(name, plugin_class)
+        return plugin_class
+
+    return decorator
+
+
+def load_builtin_plugin(name: str) -> Optional[Plugin]:
+    """Load a builtin plugin by name."""
+    plugin_class = BuiltinPluginRegistry.get_plugin_class(name)
+    if plugin_class:
+        return plugin_class()
+    return None
+
+
+# Auto-register janito-coder plugins as builtin
+try:
+    from janito_coder.plugins import (
+        GitAnalyzerPlugin,
+        CodeNavigatorPlugin,
+        DependencyAnalyzerPlugin,
+        CodeFormatterPlugin,
+        TestRunnerPlugin,
+        LinterPlugin,
+        DebuggerPlugin,
+        PerformanceProfilerPlugin,
+        SecurityScannerPlugin,
+        DocumentationGeneratorPlugin,
+    )
+
+    # Register all janito-coder plugins as builtin
+    BuiltinPluginRegistry.register("git_analyzer", GitAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_navigator", CodeNavigatorPlugin)
+    BuiltinPluginRegistry.register("dependency_analyzer", DependencyAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_formatter", CodeFormatterPlugin)
+    BuiltinPluginRegistry.register("test_runner", TestRunnerPlugin)
+    BuiltinPluginRegistry.register("linter", LinterPlugin)
+    BuiltinPluginRegistry.register("debugger", DebuggerPlugin)
+    BuiltinPluginRegistry.register("performance_profiler", PerformanceProfilerPlugin)
+    BuiltinPluginRegistry.register("security_scanner", SecurityScannerPlugin)
+    BuiltinPluginRegistry.register(
+        "documentation_generator", DocumentationGeneratorPlugin
+    )
+
+    # Register core tools plugin
+    from janito.plugins.tools import CoreToolsPlugin
+
+    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
+
+except ImportError:
+    # janito-coder not available, skip registration
+    pass
+
+# Register core tools plugin (always available)
+try:
+    from janito.plugins.tools import CoreToolsPlugin
+
+    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
+except ImportError:
+    # Should not happen, but handle gracefully
+    pass

janito/plugins_backup_20250825_070018/config.py

@@ -0,0 +1,84 @@
+"""
+Configuration management for plugins using user directory.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+
+def get_user_config_dir() -> Path:
+    """Get the user configuration directory."""
+    return Path.home() / ".janito"
+
+
+def get_plugins_config_path() -> Path:
+    """Get the path to the plugins configuration file."""
+    return get_user_config_dir() / "plugins.json"
+
+
+def load_plugins_config() -> Dict[str, Any]:
+    """
+    Load plugins configuration from user directory.
+
+    Returns:
+        Dict containing plugins configuration
+    """
+    config_path = get_plugins_config_path()
+
+    if not config_path.exists():
+        # Create default config if it doesn't exist
+        default_config = {
+            "plugins": {
+                "paths": [str(Path.home() / ".janito" / "plugins"), "./plugins"],
+                "load": {},
+            }
+        }
+
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Save default config
+        with open(config_path, "w") as f:
+            json.dump(default_config, f, indent=2)
+
+        return default_config
+
+    try:
+        with open(config_path, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError) as e:
+        print(f"Warning: Failed to load plugins config from {config_path}: {e}")
+        return {"plugins": {"paths": [], "load": {}}}
+
+
+def save_plugins_config(config: Dict[str, Any]) -> bool:
+    """
+    Save plugins configuration to user directory.
+
+    Args:
+        config: Configuration dict to save
+
+    Returns:
+        True if saved successfully
+    """
+    config_path = get_plugins_config_path()
+
+    try:
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+        return True
+    except IOError as e:
+        print(f"Error: Failed to save plugins config to {config_path}: {e}")
+        return False
+
+
+def get_user_plugins_dir() -> Path:
+    """Get the user plugins directory."""
+    plugins_dir = get_user_config_dir() / "plugins"
+    plugins_dir.mkdir(parents=True, exist_ok=True)
+    return plugins_dir

janito/plugins_backup_20250825_070018/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+Core Plugin Package
+
+Contains essential system and file management plugins.
+"""
+
+__all__ = ["filemanager", "codeanalyzer", "system"]

janito/plugins_backup_20250825_070018/core/codeanalyzer/__init__.py

@@ -0,0 +1,43 @@
+"""
+Code Analyzer Plugin
+
+Tools for understanding and searching code structure.
+"""
+
+from typing import List, Optional
+
+
+def get_file_outline(path: str) -> str:
+    """Get file structure (classes, functions, etc.)"""
+    return f"get_file_outline(path='{path}')"
+
+
+get_file_outline.tool_name = "get_file_outline"
+
+
+def search_outline(path: str) -> str:
+    """Search within file outlines"""
+    return f"search_outline(path='{path}')"
+
+
+search_outline.tool_name = "search_outline"
+
+
+def search_text(
+    paths: str,
+    query: str,
+    use_regex: bool = False,
+    case_sensitive: bool = True,
+    max_depth: Optional[int] = None,
+) -> str:
+    """Full-text search across files with regex support"""
+    return f"search_text(paths='{paths}', query='{query}', regex={use_regex})"
+
+
+search_text.tool_name = "search_text"
+
+
+# Plugin metadata
+__plugin_name__ = "core.codeanalyzer"
+__plugin_description__ = "Code analysis and structure understanding"
+__plugin_tools__ = [get_file_outline, search_outline, search_text]

janito/plugins_backup_20250825_070018/core/codeanalyzer/tools/get_file_outline/__init__.py

@@ -0,0 +1 @@
+# Outline tools and parsers package

janito/plugins_backup_20250825_070018/core/codeanalyzer/tools/get_file_outline/core.py

@@ -0,0 +1,122 @@
+from janito.tools.adapters.local.adapter import register_local_tool
+from .python_outline import parse_python_outline
+from .markdown_outline import parse_markdown_outline
+from janito.formatting import OutlineFormatter
+from .java_outline import parse_java_outline
+import os
+from janito.tools.path_utils import expand_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.tool_utils import display_path, pluralize
+from janito.i18n import tr
+
+from janito.tools.adapters.local.adapter import register_local_tool as register_tool
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_tool
+class GetFileOutlineTool(ToolBase):
+    """
+    Get an outline of a file's structure. Supports Python and Markdown files.
+
+    Args:
+        path (str): Path to the file to outline.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "get_file_outline"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str) -> str:
+        try:
+            path = expand_path(path)
+            self.report_action(
+                tr(
+                    "📄 Outline file '{disp_path}' ...",
+                    disp_path=display_path(path),
+                ),
+                ReportAction.READ,
+            )
+            ext = os.path.splitext(path)[1].lower()
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+            return self._outline_by_extension(ext, lines)
+        except Exception as e:
+            self.report_error(
+                tr("❌ Error reading file: {error}", error=e),
+                ReportAction.READ,
+            )
+            return tr("Error reading file: {error}", error=e)
+
+    def _outline_by_extension(self, ext, lines):
+        if ext == ".py":
+            outline_items = parse_python_outline(lines)
+            outline_type = "python"
+            table = OutlineFormatter.format_outline_table(outline_items)
+            self.report_success(
+                tr(
+                    "✅ Outlined {count} {item_word}",
+                    count=len(outline_items),
+                    item_word=pluralize("item", len(outline_items)),
+                ),
+                ReportAction.READ,
+            )
+            return (
+                tr(
+                    "Outline: {count} items ({outline_type})\n",
+                    count=len(outline_items),
+                    outline_type=outline_type,
+                )
+                + table
+            )
+        elif ext == ".md":
+            outline_items = parse_markdown_outline(lines)
+            outline_type = "markdown"
+            table = OutlineFormatter.format_markdown_outline_table(outline_items)
+            self.report_success(
+                tr(
+                    "✅ Outlined {count} {item_word}",
+                    count=len(outline_items),
+                    item_word=pluralize("item", len(outline_items)),
+                ),
+                ReportAction.READ,
+            )
+            return (
+                tr(
+                    "Outline: {count} items ({outline_type})\n",
+                    count=len(outline_items),
+                    outline_type=outline_type,
+                )
+                + table
+            )
+        elif ext == ".java":
+            outline_items = parse_java_outline(lines)
+            outline_type = "java"
+            table = OutlineFormatter.format_outline_table(outline_items)
+            self.report_success(
+                tr(
+                    "✅ Outlined {count} {item_word}",
+                    count=len(outline_items),
+                    item_word=pluralize("item", len(outline_items)),
+                ),
+                ReportAction.READ,
+            )
+            return (
+                tr(
+                    "Outline: {count} items ({outline_type})\n",
+                    count=len(outline_items),
+                    outline_type=outline_type,
+                )
+                + table
+            )
+        else:
+            outline_type = "default"
+            self.report_success(
+                tr("✅ Outlined {count} items", count=len(lines)),
+                ReportAction.READ,
+            )
+            return tr(
+                "Outline: {count} lines ({outline_type})\nFile has {count} lines.",
+                count=len(lines),
+                outline_type=outline_type,
+            )

janito/plugins_backup_20250825_070018/core/codeanalyzer/tools/search_text/__init__.py

@@ -0,0 +1 @@
+from .core import SearchTextTool

janito/plugins_backup_20250825_070018/core/codeanalyzer/tools/search_text/core.py

@@ -0,0 +1,205 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import pluralize, display_path
+from janito.i18n import tr
+import os
+from janito.tools.path_utils import expand_path
+from .pattern_utils import prepare_pattern, format_result, summarize_total
+from .match_lines import read_file_lines
+from .traverse_directory import traverse_directory
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+from janito.tools.adapters.local.adapter import register_local_tool as register_tool
+
+
+@register_tool
+class SearchTextTool(ToolBase):
+    """
+    Search for a text query in all files within one or more directories or file paths and return matching lines or counts. Respects .gitignore.
+    Args:
+        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
+        query (str): Text or regular expression to search for in files. Must not be empty. When use_regex=True, this is treated as a regex pattern; otherwise as plain text.
+        use_regex (bool): If True, treat query as a regular expression. If False, treat as plain text (default).
+        case_sensitive (bool): If False, perform a case-insensitive search. Default is True (case sensitive).
+        max_depth (int, optional): Maximum directory depth to search. If 0 (default), search is recursive with no depth limit. If >0, limits recursion to that depth. Setting max_depth=1 disables recursion (only top-level directory). Ignored for file paths.
+        max_results (int, optional): Maximum number of results to return. Defaults to 100. 0 means no limit.
+        count_only (bool): If True, return only the count of matches per file and total, not the matching lines. Default is False.
+    Returns:
+        str: If count_only is False, matching lines from files as a newline-separated string, each formatted as 'filepath:lineno: line'.
+             If count_only is True, returns per-file and total match counts.
+        If max_results is reached, appends a note to the output.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "search_text"
+
+    def _handle_file(
+        self,
+        search_path,
+        query,
+        regex,
+        use_regex,
+        case_sensitive,
+        max_results,
+        total_results,
+        count_only,
+    ):
+        if count_only:
+            match_count, dir_limit_reached, _ = read_file_lines(
+                search_path,
+                query,
+                regex,
+                use_regex,
+                case_sensitive,
+                True,
+                max_results,
+                total_results,
+            )
+            per_file_counts = [(search_path, match_count)] if match_count > 0 else []
+            return [], dir_limit_reached, per_file_counts
+        else:
+            dir_output, dir_limit_reached, match_count_list = read_file_lines(
+                search_path,
+                query,
+                regex,
+                use_regex,
+                case_sensitive,
+                False,
+                max_results,
+                total_results,
+            )
+            per_file_counts = (
+                [(search_path, len(match_count_list))]
+                if match_count_list and len(match_count_list) > 0
+                else []
+            )
+            return dir_output, dir_limit_reached, per_file_counts
+
+    def _handle_path(
+        self,
+        search_path,
+        query,
+        regex,
+        use_regex,
+        case_sensitive,
+        max_depth,
+        max_results,
+        total_results,
+        count_only,
+    ):
+        info_str = tr(
+            "🔍 Search {search_type} '{query}' in '{disp_path}'",
+            search_type=("regex" if use_regex else "text"),
+            query=query,
+            disp_path=display_path(search_path),
+        )
+        if max_depth > 0:
+            info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
+        if count_only:
+            info_str += " [count]"
+        self.report_action(info_str, ReportAction.READ)
+        if os.path.isfile(search_path):
+            dir_output, dir_limit_reached, per_file_counts = self._handle_file(
+                search_path,
+                query,
+                regex,
+                use_regex,
+                case_sensitive,
+                max_results,
+                total_results,
+                count_only,
+            )
+        else:
+            if count_only:
+                per_file_counts, dir_limit_reached, _ = traverse_directory(
+                    search_path,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    True,
+                )
+                dir_output = []
+            else:
+                dir_output, dir_limit_reached, per_file_counts = traverse_directory(
+                    search_path,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    False,
+                )
+        count = sum(count for _, count in per_file_counts)
+        file_word = pluralize("match", count)
+        num_files = len(per_file_counts)
+        file_label = pluralize("file", num_files)
+        file_word_max = file_word + (" (max)" if dir_limit_reached else "")
+        self.report_success(
+            tr(
+                " ✅ {count} {file_word}/{num_files} {file_label}",
+                count=count,
+                file_word=file_word_max,
+                num_files=num_files,
+                file_label=file_label,
+            ),
+            ReportAction.READ,
+        )
+        return info_str, dir_output, dir_limit_reached, per_file_counts
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
+    def run(
+        self,
+        paths: str,
+        query: str,
+        use_regex: bool = False,
+        case_sensitive: bool = False,
+        max_depth: int = 0,
+        max_results: int = 100,
+        count_only: bool = False,
+    ) -> str:
+        regex, use_regex, error_msg = prepare_pattern(
+            query, use_regex, case_sensitive, self.report_error, self.report_warning
+        )
+        if error_msg:
+            return error_msg
+        paths_list = [expand_path(p) for p in paths.split()]
+        results = []
+        all_per_file_counts = []
+        for search_path in paths_list:
+            info_str, dir_output, dir_limit_reached, per_file_counts = (
+                self._handle_path(
+                    search_path,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_depth,
+                    max_results,
+                    0,
+                    count_only,
+                )
+            )
+            if count_only:
+                all_per_file_counts.extend(per_file_counts)
+            result_str = format_result(
+                query,
+                use_regex,
+                dir_output,
+                dir_limit_reached,
+                count_only,
+                per_file_counts,
+            )
+            results.append(info_str + "\n" + result_str)
+            if dir_limit_reached:
+                break
+        if count_only:
+            results.append(summarize_total(all_per_file_counts))
+        return "\n\n".join(results)