janito 1.14.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

janito/{agent/tools → tools/adapters/local}/search_text/core.py

@@ -1,7 +1,7 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.agent.tools_utils.utils import pluralize, display_path
+from janito.tools.tool_base import ToolBase
+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 .pattern_utils import prepare_pattern, format_result, summarize_total
@@ -9,7 +9,10 @@ from .match_lines import read_file_lines
 from .traverse_directory import traverse_directory
 
 
-@register_tool(name="search_text")
+from janito.tools.adapters.local.adapter import register_local_tool as register_tool
+
+
+@register_tool
 class SearchTextTool(ToolBase):
     """
     Search for a text pattern (regex or plain string) in all files within one or more directories or file paths and return matching lines or counts. Respects .gitignore.
@@ -17,6 +20,7 @@ class SearchTextTool(ToolBase):
         paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
         pattern (str): Regex pattern or plain text substring to search for in files. Must not be empty. Tries regex first, falls back to substring if regex is invalid.
         is_regex (bool): If True, treat pattern 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.
@@ -26,12 +30,15 @@ class SearchTextTool(ToolBase):
         If max_results is reached, appends a note to the output.
     """
 
+    tool_name = "search_text"
+
     def _handle_file(
         self,
         search_path,
         pattern,
         regex,
         use_regex,
+        case_sensitive,
         max_results,
         total_results,
         count_only,
@@ -42,6 +49,7 @@ class SearchTextTool(ToolBase):
                 pattern,
                 regex,
                 use_regex,
+                case_sensitive,
                 True,
                 max_results,
                 total_results,
@@ -54,6 +62,7 @@ class SearchTextTool(ToolBase):
                 pattern,
                 regex,
                 use_regex,
+                case_sensitive,
                 False,
                 max_results,
                 total_results,
@@ -71,13 +80,14 @@ class SearchTextTool(ToolBase):
         pattern,
         regex,
         use_regex,
+        case_sensitive,
         max_depth,
         max_results,
         total_results,
         count_only,
     ):
         info_str = tr(
-            "\U0001f50d Search {search_type} '{pattern}' in '{disp_path}'",
+            "🔍 Search {search_type} '{pattern}' in '{disp_path}'",
             search_type=("regex" if use_regex else "text"),
             pattern=pattern,
             disp_path=display_path(search_path),
@@ -86,13 +96,14 @@ class SearchTextTool(ToolBase):
             info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
         if count_only:
             info_str += " [count]"
-        self.report_info(ActionType.READ, info_str)
+        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,
                 pattern,
                 regex,
                 use_regex,
+                case_sensitive,
                 max_results,
                 total_results,
                 count_only,
@@ -104,6 +115,7 @@ class SearchTextTool(ToolBase):
                     pattern,
                     regex,
                     use_regex,
+                    case_sensitive,
                     max_depth,
                     max_results,
                     total_results,
@@ -116,6 +128,7 @@ class SearchTextTool(ToolBase):
                     pattern,
                     regex,
                     use_regex,
+                    case_sensitive,
                     max_depth,
                     max_results,
                     total_results,
@@ -123,13 +136,18 @@ class SearchTextTool(ToolBase):
                 )
         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}{max_flag}",
+                " ✅ {count} {file_word} from {num_files} {file_label}",
                 count=count,
-                file_word=file_word,
-                max_flag=" (max)" if dir_limit_reached else "",
-            )
+                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
 
@@ -138,12 +156,13 @@ class SearchTextTool(ToolBase):
         paths: str,
         pattern: str,
         is_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(
-            pattern, is_regex, self.report_error, self.report_warning
+            pattern, is_regex, case_sensitive, self.report_error, self.report_warning
         )
         if error_msg:
             return error_msg
@@ -157,6 +176,7 @@ class SearchTextTool(ToolBase):
                     pattern,
                     regex,
                     use_regex,
+                    case_sensitive,
                     max_depth,
                     max_results,
                     0,

janito/{agent/tools → tools/adapters/local}/search_text/match_lines.py

@@ -1,5 +1,5 @@
 import re
-from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
+from janito.gitignore_utils import GitignoreFilter
 import os
 
 
@@ -20,9 +20,11 @@ def is_binary_file(path, blocksize=1024):
     return False
 
 
-def match_line(line, pattern, regex, use_regex):
+def match_line(line, pattern, regex, use_regex, case_sensitive):
     if use_regex:
         return regex and regex.search(line)
+    if not case_sensitive:
+        return pattern in line.lower()
     return pattern in line
 
 
@@ -34,7 +36,14 @@ def should_limit(max_results, total_results, match_count, count_only, dir_output
 
 
 def read_file_lines(
-    path, pattern, regex, use_regex, count_only, max_results, total_results
+    path,
+    pattern,
+    regex,
+    use_regex,
+    case_sensitive,
+    count_only,
+    max_results,
+    total_results,
 ):
     dir_output = []
     dir_limit_reached = False
@@ -44,7 +53,7 @@ def read_file_lines(
             open_kwargs = {"mode": "r", "encoding": "utf-8"}
             with open(path, **open_kwargs) as f:
                 for lineno, line in enumerate(f, 1):
-                    if match_line(line, pattern, regex, use_regex):
+                    if match_line(line, pattern, regex, use_regex, case_sensitive):
                         match_count += 1
                         if not count_only:
                             dir_output.append(f"{path}:{lineno}: {line.rstrip()}")

janito/{agent/tools → tools/adapters/local}/search_text/pattern_utils.py

@@ -1,11 +1,14 @@
 import re
 from janito.i18n import tr
-from janito.agent.tools_utils.utils import pluralize
+from janito.tools.tool_utils import pluralize
 
 
-def prepare_pattern(pattern, is_regex, report_error, report_warning):
+def prepare_pattern(pattern, is_regex, case_sensitive, report_error, report_warning):
     if not pattern:
-        report_error(tr("Error: Empty search pattern provided. Operation aborted."))
+        report_error(
+            tr("Error: Empty search pattern provided. Operation aborted."),
+            ReportAction.SEARCH,
+        )
         return (
             None,
             False,
@@ -15,7 +18,10 @@ def prepare_pattern(pattern, is_regex, report_error, report_warning):
     use_regex = False
     if is_regex:
         try:
-            regex = re.compile(pattern)
+            flags = 0
+            if not case_sensitive:
+                flags |= re.IGNORECASE
+            regex = re.compile(pattern, flags=flags)
             use_regex = True
         except re.error as e:
             report_warning(tr("⚠️ Invalid regex pattern."))
@@ -30,6 +36,8 @@ def prepare_pattern(pattern, is_regex, report_error, report_warning):
         # Do not compile as regex if is_regex is False; treat as plain text
         regex = None
         use_regex = False
+        if not case_sensitive:
+            pattern = pattern.lower()
     return regex, use_regex, None
 
 

janito/{agent/tools → tools/adapters/local}/search_text/traverse_directory.py

@@ -1,5 +1,5 @@
 import os
-from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
+from janito.gitignore_utils import GitignoreFilter
 from .match_lines import match_line, should_limit, read_file_lines
 
 
@@ -24,13 +24,21 @@ def filter_dirs(dirs, root, gitignore_filter):
 
 
 def process_file_count_only(
-    file_path, per_file_counts, pattern, regex, use_regex, max_results, total_results
+    file_path,
+    per_file_counts,
+    pattern,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_results,
+    total_results,
 ):
     match_count, file_limit_reached, _ = read_file_lines(
         file_path,
         pattern,
         regex,
         use_regex,
+        case_sensitive,
         True,
         max_results,
         total_results + sum(count for _, count in per_file_counts),
@@ -47,6 +55,7 @@ def process_file_collect(
     pattern,
     regex,
     use_regex,
+    case_sensitive,
     max_results,
     total_results,
 ):
@@ -55,6 +64,7 @@ def process_file_collect(
         pattern,
         regex,
         use_regex,
+        case_sensitive,
         False,
         max_results,
         total_results + len(dir_output),
@@ -79,6 +89,7 @@ def traverse_directory(
     pattern,
     regex,
     use_regex,
+    case_sensitive,
     max_depth,
     max_results,
     total_results,
@@ -103,6 +114,7 @@ def traverse_directory(
                     pattern,
                     regex,
                     use_regex,
+                    case_sensitive,
                     max_results,
                     total_results,
                 )
@@ -117,6 +129,7 @@ def traverse_directory(
                     pattern,
                     regex,
                     use_regex,
+                    case_sensitive,
                     max_results,
                     total_results,
                 )

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/core.py

@@ -1,9 +1,10 @@
 import os
 from janito.i18n import tr
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.agent.tools_utils.utils import display_path
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import display_path
+from janito.tools.adapters.local.adapter import register_local_tool as register_tool
 
 from .python_validator import validate_python
 from .json_validator import validate_json
@@ -59,7 +60,6 @@ def validate_file_syntax(
         return _handle_validation_error(e, report_warning)
 
 
-@register_tool(name="validate_file_syntax")
 class ValidateFileSyntaxTool(ToolBase):
     """
     Validate a file for syntax issues.
@@ -83,14 +83,16 @@ class ValidateFileSyntaxTool(ToolBase):
             - "⚠️ Warning: Unsupported file extension: <ext>"
     """
 
+    tool_name = "validate_file_syntax"
+
     def run(self, file_path: str) -> str:
         disp_path = display_path(file_path)
-        self.report_info(
-            ActionType.READ,
+        self.report_action(
             tr(
-                "\U0001f50e Validate syntax for file '{disp_path}' ...",
+                "🔎 Validate syntax for file '{disp_path}' ...",
                 disp_path=disp_path,
             ),
+            ReportAction.READ,
         )
         result = validate_file_syntax(
             file_path,
@@ -99,7 +101,6 @@ class ValidateFileSyntaxTool(ToolBase):
             report_success=self.report_success,
         )
         if result.startswith("✅"):
-            self.report_success(result)
-        elif result.startswith("⚠️"):
-            self.report_warning(tr("⚠️ ") + result.lstrip("⚠️ "))
+            self.report_success(result, ReportAction.READ)
+
         return result

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/css_validator.py

@@ -32,4 +32,4 @@ def validate_css(file_path: str) -> str:
             "⚠️ Warning: CSS syntax issues found:\n{errors}", errors="\n".join(errors)
         )
         return msg
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/html_validator.py

@@ -90,4 +90,4 @@ def _build_result_message(warnings, lxml_error):
         msg += lxml_error
     if msg:
         return msg.strip()
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/js_validator.py

@@ -24,4 +24,4 @@ def validate_js(file_path: str) -> str:
             errors="\n".join(errors),
         )
         return msg
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/json_validator.py

@@ -3,4 +3,4 @@ def validate_json(file_path: str) -> str:
 
     with open(file_path, "r", encoding="utf-8") as f:
         json.load(f)
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/markdown_validator.py

@@ -106,4 +106,4 @@ def _build_markdown_result(errors):
             errors="\n".join(errors),
         )
         return msg
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/ps1_validator.py

@@ -29,4 +29,4 @@ def validate_ps1(file_path: str) -> str:
             errors="\n".join(errors),
         )
         return msg
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/python_validator.py

@@ -2,4 +2,4 @@ def validate_python(file_path: str) -> str:
     import py_compile
 
     py_compile.compile(file_path, doraise=True)
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/xml_validator.py

@@ -8,4 +8,4 @@ def validate_xml(file_path: str) -> str:
         return tr("⚠️ lxml not installed. Cannot validate XML.")
     with open(file_path, "rb") as f:
         etree.parse(f)
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools → tools/adapters/local}/validate_file_syntax/yaml_validator.py

@@ -3,4 +3,4 @@ def validate_yaml(file_path: str) -> str:
 
     with open(file_path, "r", encoding="utf-8") as f:
         yaml.safe_load(f)
-    return "✅ Syntax valid"
+    return "✅ OK"

janito/{agent/tools/get_lines.py → tools/adapters/local/view_file.py}

@@ -1,12 +1,12 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.agent.tools_utils.utils import pluralize
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import pluralize
 from janito.i18n import tr
 
 
-@register_tool(name="get_lines")
-class GetLinesTool(ToolBase):
+@register_local_tool
+class ViewFileTool(ToolBase):
     """
     Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
 
@@ -25,12 +25,20 @@ class GetLinesTool(ToolBase):
             - "❗ not found"
     """
 
+    tool_name = "view_file"
+
     def run(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
-        from janito.agent.tools_utils.utils import display_path
+        import os
+        from janito.tools.tool_utils import display_path
 
         disp_path = display_path(file_path)
-        self._report_read_info(disp_path, from_line, to_line)
+        self.report_action(
+            tr("📖 View '{disp_path}'", disp_path=disp_path),
+            ReportAction.READ,
+        )
         try:
+            if os.path.isdir(file_path):
+                return self._list_directory(file_path, disp_path)
             lines = self._read_file_lines(file_path)
             selected, selected_len, total_lines = self._select_lines(
                 lines, from_line, to_line
@@ -40,26 +48,36 @@ class GetLinesTool(ToolBase):
                 disp_path, from_line, to_line, selected_len, total_lines
             )
             return header + "".join(selected)
+        except FileNotFoundError as e:
+            self.report_warning(tr("❗ not found"))
+            return f"Error reading file: {e}"
         except Exception as e:
-            return self._handle_read_error(e)
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)
 
-    def _report_read_info(self, disp_path, from_line, to_line):
-        """Report the info message for reading lines."""
-        if from_line and to_line:
-            self.report_info(
-                ActionType.READ,
-                tr(
-                    "📖 Read file '{disp_path}' {from_line}-{to_line}",
-                    disp_path=disp_path,
-                    from_line=from_line,
-                    to_line=to_line,
-                ),
-            )
-        else:
-            self.report_info(
-                ActionType.READ,
-                tr("📖 Read file '{disp_path}'", disp_path=disp_path),
+    def _list_directory(self, file_path, disp_path):
+        import os
+
+        try:
+            entries = os.listdir(file_path)
+            entries.sort()
+            # Suffix subdirectories with '/'
+            formatted_entries = []
+            for entry in entries:
+                full_path = os.path.join(file_path, entry)
+                if os.path.isdir(full_path):
+                    formatted_entries.append(entry + "/")
+                else:
+                    formatted_entries.append(entry)
+            header = (
+                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
             )
+            listing = "\n".join(formatted_entries)
+            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
+            return header + listing + "\n"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
+            return tr("Error listing directory: {error}", error=e)
 
     def _read_file_lines(self, file_path):
         """Read all lines from the file."""
@@ -143,7 +161,7 @@ class GetLinesTool(ToolBase):
     def _handle_read_error(self, e):
         """Handle file read errors and report appropriately."""
         if isinstance(e, FileNotFoundError):
-            self.report_error(tr("❗ not found"))
+            self.report_error(tr("❗ not found"), ReportAction.READ)
             return tr("❗ not found")
-        self.report_error(tr(" ❌ Error: {error}", error=e))
+        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
         return tr("Error reading file: {error}", error=e)

janito/tools/inspect_registry.py

@@ -0,0 +1,17 @@
+def check_tools_registry():
+    # Import and use the singleton tools adapter instance
+    from janito.tools.adapters.local import local_tools_adapter
+
+    print("Available tool names:", local_tools_adapter.list_tools())
+    print(
+        "Available tool classes:",
+        [cls.__name__ for cls in local_tools_adapter.get_tool_classes()],
+    )
+    print(
+        "Available tool instances:",
+        [tool.name for tool in local_tools_adapter.get_tools()],
+    )
+
+
+if __name__ == "__main__":
+    check_tools_registry()

janito/tools/tool_base.py

@@ -0,0 +1,105 @@
+from janito.report_events import ReportEvent, ReportSubtype, ReportAction
+from janito.event_bus.bus import event_bus as default_event_bus
+
+
+class ToolBase:
+    """
+    Base class for all tools in the janito project.
+    Extend this class to implement specific tool functionality.
+    """
+    provides_execution = False  # Indicates if the tool provides execution capability (default: False)
+
+    def __init__(self, name=None, event_bus=None):
+        self.name = name or self.__class__.__name__
+        self._event_bus = event_bus or default_event_bus
+
+    @property
+    def event_bus(self):
+        return self._event_bus
+
+    @event_bus.setter
+    def event_bus(self, bus):
+        self._event_bus = bus or default_event_bus
+
+    def report_action(self, message: str, action: ReportAction, context: dict = None):
+        """
+        Report that a tool action is starting. This should be the first reporting call for every tool action.
+        """
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ACTION_INFO,
+                message="  " + message,
+                action=action,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_info(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ACTION_INFO,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_error(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ERROR,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_success(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.SUCCESS,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_warning(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.WARNING,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_stdout(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.STDOUT,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_stderr(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.STDERR,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def run(self, *args, **kwargs):
+        raise NotImplementedError("Subclasses must implement the run method.")