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

janito/report_events.py

@@ -0,0 +1,38 @@
+import attr
+from typing import Any, ClassVar, Optional, Dict
+from enum import Enum
+from janito.event_bus.event import Event
+
+
+class ReportSubtype(Enum):
+    ACTION_INFO = "action_info"
+    ERROR = "error"
+    SUCCESS = "success"
+    WARNING = "warning"
+    STDOUT = "stdout"
+    STDERR = "stderr"
+    PROGRESS = "progress"
+
+
+class ReportAction(Enum):
+    READ = "READ"
+    CREATE = "CREATE"
+    DELETE = "DELETE"
+    UPDATE = "UPDATE"
+    EXECUTE = "EXECUTE"
+    # Add more as needed
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ReportEvent(Event):
+    """
+    Event for reporting status, errors, warnings, and output.
+    Uses enums for subtype and action for type safety and clarity.
+    """
+
+    category: ClassVar[str] = "report"
+    subtype: ReportSubtype
+    message: str
+    action: Optional[ReportAction] = None
+    tool: Optional[str] = None
+    context: Optional[Dict[str, Any]] = None

janito/termweb/app.py

@@ -1,6 +1,5 @@
 from quart import Quart, send_from_directory, request, jsonify, websocket
 import os
-from janito.agent.tools_utils.dir_walk_utils import walk_dir_with_gitignore
 
 app = Quart(__name__)
 
@@ -84,6 +83,7 @@ if __name__ == "__main__":
     import sys
 
     port = 8088
+    # Allow override from CLI for direct execution/testing
     if "--port" in sys.argv:
         idx = sys.argv.index("--port")
         if idx + 1 < len(sys.argv):

janito/tools/__init__.py

@@ -0,0 +1,16 @@
+from janito.tools.adapters.local import (
+    local_tools_adapter as _internal_local_tools_adapter,
+    LocalToolsAdapter,
+)
+
+
+def get_local_tools_adapter():
+
+    # Use set_verbose_tools on the returned adapter to set verbosity as needed
+    return _internal_local_tools_adapter
+
+
+__all__ = [
+    "LocalToolsAdapter",
+    "get_local_tools_adapter",
+]

janito/tools/adapters/__init__.py

@@ -0,0 +1 @@
+# Tools providers package: for plug-and-play tool collections, integrations, and adapters.

janito/tools/adapters/local/__init__.py

@@ -0,0 +1,54 @@
+from .adapter import LocalToolsAdapter
+
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+
+# Singleton tools adapter with all standard tools registered
+local_tools_adapter = LocalToolsAdapter()
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    MoveFileTool,
+    OpenUrlTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
+
+# DEBUG: Print registered tools at startup

janito/tools/adapters/local/adapter.py

@@ -0,0 +1,92 @@
+from typing import Type, Dict, Any
+from janito.tools.tools_adapter import ToolsAdapterBase as ToolsAdapter
+
+
+class LocalToolsAdapter(ToolsAdapter):
+    def disable_execution_tools(self):
+        """Unregister all tools with provides_execution = True."""
+        to_remove = [name for name, entry in self._tools.items()
+                     if getattr(entry["instance"], "provides_execution", False)]
+        for name in to_remove:
+            self.unregister_tool(name)
+
+    """
+    Adapter for local, statically registered tools in the agent/tools system.
+    Handles registration, lookup, enabling/disabling, listing, and now, tool execution (merged from executor).
+    """
+
+    def __init__(self, tools=None, event_bus=None, allowed_tools=None):
+        super().__init__(tools=tools, event_bus=event_bus, allowed_tools=allowed_tools)
+        self._tools: Dict[str, Dict[str, Any]] = {}
+        if tools:
+            for tool in tools:
+                self.register_tool(tool)
+
+    def register_tool(self, tool_class: Type):
+        instance = tool_class()
+        if not hasattr(instance, "run") or not callable(instance.run):
+            raise TypeError(
+                f"Tool '{tool_class.__name__}' must implement a callable 'run' method."
+            )
+        tool_name = getattr(instance, "tool_name", None)
+        if not tool_name or not isinstance(tool_name, str):
+            raise ValueError(
+                f"Tool '{tool_class.__name__}' must provide a class attribute 'tool_name' (str) for its registration name."
+            )
+        if tool_name in self._tools:
+            raise ValueError(f"Tool '{tool_name}' is already registered.")
+        self._tools[tool_name] = {
+            "function": instance.run,
+            "class": tool_class,
+            "instance": instance,
+        }
+
+    def unregister_tool(self, name: str):
+        if name in self._tools:
+            del self._tools[name]
+
+    def disable_tool(self, name: str):
+        self.unregister_tool(name)
+
+    def get_tool(self, name: str):
+        return self._tools[name]["instance"] if name in self._tools else None
+
+    def list_tools(self):
+        return list(self._tools.keys())
+
+    def get_tool_classes(self):
+        return [entry["class"] for entry in self._tools.values()]
+
+    def get_tools(self):
+        return [entry["instance"] for entry in self._tools.values()]
+
+
+    def add_tool(self, tool):
+        # Register by instance (useful for hand-built objects)
+        if not hasattr(tool, "run") or not callable(tool.run):
+            raise TypeError(f"Tool '{tool}' must implement a callable 'run' method.")
+        tool_name = getattr(tool, "tool_name", None)
+        if not tool_name or not isinstance(tool_name, str):
+            raise ValueError(
+                f"Tool '{tool}' must provide a 'tool_name' (str) attribute."
+            )
+        if tool_name in self._tools:
+            raise ValueError(f"Tool '{tool_name}' is already registered.")
+        self._tools[tool_name] = {
+            "function": tool.run,
+            "class": tool.__class__,
+            "instance": tool,
+        }
+
+
+# Optional: a local-tool decorator
+
+
+def register_local_tool(tool=None):
+    def decorator(cls):
+        LocalToolsAdapter().register_tool(cls)
+        return cls
+
+    if tool is None:
+        return decorator
+    return decorator(tool)

janito/{agent/tools → tools/adapters/local}/ask_user.py

@@ -1,5 +1,5 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tool_registry import register_tool
+from janito.tools.tool_base import ToolBase
+from janito.tools.adapters.local.adapter import register_local_tool
 
 from rich import print as rich_print
 from janito.i18n import tr
@@ -8,16 +8,20 @@ from prompt_toolkit import PromptSession
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.formatted_text import HTML
+from janito.cli.chat_mode.prompt_style import chat_shell_style
 from prompt_toolkit.styles import Style
 
+toolbar_style = Style.from_dict({"bottom-toolbar": "fg:yellow bg:darkred"})
 
-@register_tool(name="ask_user")
+
+@register_local_tool
 class AskUserTool(ToolBase):
     """
-    Request clarification or input from the user whenever there is uncertainty, ambiguity, missing information, or multiple valid options. Returns the user's response as a string.
+    Prompts the user for clarification or input with a question.
 
     Args:
         question (str): The question to ask the user.
+
     Returns:
         str: The user's response as a string. Example:
             - "Yes"
@@ -25,8 +29,11 @@ class AskUserTool(ToolBase):
             - "Some detailed answer..."
     """
 
+    tool_name = "ask_user"
+
     def run(self, question: str) -> str:
 
+        print()  # Print an empty line before the question panel
         rich_print(Panel.fit(question, title=tr("Question"), style="cyan"))
 
         bindings = KeyBindings()
@@ -55,13 +62,13 @@ class AskUserTool(ToolBase):
             buf.validate_and_handle()
             _f12_index["value"] = (idx + 1) % len(_f12_instructions)
 
-        style = Style.from_dict(
-            {
-                "bottom-toolbar": "bg:#333333 #ffffff",
-                "b": "bold",
-                "prompt": "bold bg:#000080 #ffffff",
-            }
-        )
+            # Use shared CLI styles
+
+        # prompt_style contains the prompt area and input background
+        # toolbar_style contains the bottom-toolbar styling
+
+        # Use the shared chat_shell_style for input styling only
+        style = chat_shell_style
 
         def get_toolbar():
             f12_hint = ""
@@ -82,7 +89,7 @@ class AskUserTool(ToolBase):
             style=style,
         )
 
-        prompt_icon = HTML("<prompt>💬 </prompt>")
+        prompt_icon = HTML("<inputline>💬 </inputline>")
 
         while True:
             response = session.prompt(prompt_icon)
@@ -95,4 +102,14 @@ class AskUserTool(ToolBase):
                 session.multiline = False
                 continue
             else:
-                return response
+                sanitized = response.strip()
+                try:
+                    sanitized.encode("utf-8")
+                except UnicodeEncodeError:
+                    sanitized = sanitized.encode("utf-8", errors="replace").decode(
+                        "utf-8"
+                    )
+                    rich_print(
+                        "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
+                    )
+                return sanitized

janito/tools/adapters/local/copy_file.py

@@ -0,0 +1,84 @@
+import os
+import shutil
+from typing import List, Union
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_base import ToolBase
+from janito.tools.tool_utils import display_path
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_local_tool
+class CopyFileTool(ToolBase):
+    """
+    Copy one or more files to a target directory, or copy a single file to a new file.
+    Args:
+        sources (str): Space-separated path(s) to the file(s) to copy.
+            For multiple sources, provide a single string with paths separated by spaces.
+        target (str): Destination path. If copying multiple sources, this must be an existing directory.
+        overwrite (bool, optional): Overwrite existing files. Default: False.
+            Recommended only after reading the file to be overwritten.
+    Returns:
+        str: Status string for each copy operation.
+    """
+
+    tool_name = "copy_file"
+
+    def run(self, sources: str, target: str, overwrite: bool = False) -> str:
+        source_list = [src for src in sources.split() if src]
+        messages = []
+        if len(source_list) > 1:
+            if not os.path.isdir(target):
+                return tr(
+                    "❗ Target must be an existing directory when copying multiple files: '{target}'",
+                    target=display_path(target),
+                )
+            for src in source_list:
+                if not os.path.isfile(src):
+                    messages.append(
+                        tr(
+                            "❗ Source file does not exist: '{src}'",
+                            src=display_path(src),
+                        )
+                    )
+                    continue
+                dst = os.path.join(target, os.path.basename(src))
+                messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        else:
+            src = source_list[0]
+            if os.path.isdir(target):
+                dst = os.path.join(target, os.path.basename(src))
+            else:
+                dst = target
+            messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        return "\n".join(messages)
+
+    def _copy_one(self, src, dst, overwrite=False) -> str:
+        disp_src = display_path(src)
+        disp_dst = display_path(dst)
+        if not os.path.isfile(src):
+            return tr("❗ Source file does not exist: '{src}'", src=disp_src)
+        if os.path.exists(dst) and not overwrite:
+            return tr(
+                "❗ Target already exists: '{dst}'. Set overwrite=True to replace.",
+                dst=disp_dst,
+            )
+        try:
+            os.makedirs(os.path.dirname(dst), exist_ok=True)
+            shutil.copy2(src, dst)
+            note = (
+                "\n⚠️ Overwrote existing file. (recommended only after reading the file to be overwritten)"
+                if (os.path.exists(dst) and overwrite)
+                else ""
+            )
+            self.report_success(
+                tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst)
+            )
+            return tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst) + note
+        except Exception as e:
+            return tr(
+                "❗ Copy failed from '{src}' to '{dst}': {err}",
+                src=disp_src,
+                dst=disp_dst,
+                err=str(e),
+            )

janito/{agent/tools → tools/adapters/local}/create_directory.py

@@ -1,14 +1,13 @@
-from janito.agent.tool_registry import register_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 
-# from janito.agent.tools_utils.expand_path import expand_path
-from janito.agent.tools_utils.utils import display_path
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
 from janito.i18n import tr
 import os
 
 
-@register_tool(name="create_directory")
+@register_local_tool
 class CreateDirectoryTool(ToolBase):
     """
     Create a new directory at the specified file_path.
@@ -16,17 +15,19 @@ class CreateDirectoryTool(ToolBase):
         file_path (str): Path for the new directory.
     Returns:
         str: Status message indicating the result. Example:
-            - "✅ Successfully created the directory at ..."
-            - "❗ Cannot create directory: ..."
+            - "5c5 Successfully created the directory at ..."
+            - "5d7 Cannot create directory: ..."
     """
 
+    tool_name = "create_directory"
+
     def run(self, file_path: str) -> str:
         # file_path = expand_path(file_path)
         # Using file_path as is
         disp_path = display_path(file_path)
-        self.report_info(
-            ActionType.WRITE,
+        self.report_action(
             tr("📁 Create directory '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.CREATE,
         )
         try:
             if os.path.exists(file_path):

janito/tools/adapters/local/create_file.py

@@ -0,0 +1,82 @@
+import os
+from janito.tools.adapters.local.adapter import register_local_tool
+
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
+
+
+@register_local_tool
+class CreateFileTool(ToolBase):
+    """
+    Create a new file with the given content.
+
+    Args:
+        file_path (str): Path to the file to create.
+        content (str): Content to write to the file.
+        overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "✅ Successfully created the file at ..."
+
+    Note: Syntax validation is automatically performed after this operation.
+    """
+
+    tool_name = "create_file"
+
+    def run(self, file_path: str, content: str, overwrite: bool = False) -> str:
+        expanded_file_path = file_path  # Using file_path as is
+        disp_path = display_path(expanded_file_path)
+        file_path = expanded_file_path
+        if os.path.exists(file_path) and not overwrite:
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                    existing_content = f.read()
+            except Exception as e:
+                existing_content = f"[Error reading file: {e}]"
+            return tr(
+                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
+                disp_path=disp_path,
+                existing_content=existing_content,
+            )
+        # Determine if we are overwriting an existing file
+        is_overwrite = os.path.exists(file_path) and overwrite
+        if is_overwrite:
+            # Overwrite branch: log only overwrite warning (no create message)
+            self.report_action(
+                tr("⚠️ Overwriting file '{disp_path}'", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        dir_name = os.path.dirname(file_path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        if not is_overwrite:
+            # Create branch: log file creation message
+            self.report_action(
+                tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+        new_lines = content.count("\n") + 1 if content else 0
+        self.report_success(
+            tr("✅ {new_lines} lines", new_lines=new_lines), ReportAction.CREATE
+        )
+        # Perform syntax validation and append result
+        validation_result = validate_file_syntax(file_path)
+        if is_overwrite:
+            # Overwrite branch: return minimal overwrite info to user
+            return (
+                tr("✅ {new_lines} lines", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )
+        else:
+            # Create branch: return detailed create success to user
+            return (
+                tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )

janito/tools/adapters/local/delete_text_in_file.py

@@ -0,0 +1,136 @@
+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.i18n import tr
+import shutil
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
+
+
+@register_local_tool
+class DeleteTextInFileTool(ToolBase):
+    """
+    Delete all occurrences of text between start_marker and end_marker (inclusive) in a file, using exact string markers.
+
+    Args:
+        file_path (str): Path to the file to modify.
+        start_marker (str): The starting delimiter string.
+        end_marker (str): The ending delimiter string.
+        backup (bool, optional): If True, create a backup (.bak) before deleting. Defaults to False.
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    tool_name = "delete_text_in_file"
+
+    def run(
+        self,
+        file_path: str,
+        start_marker: str,
+        end_marker: str,
+        backup: bool = False,
+    ) -> str:
+        from janito.tools.tool_utils import display_path
+
+        disp_path = display_path(file_path)
+        info_msg = tr(
+            "📝 Delete text in {disp_path} between markers: '{start_marker}' ... '{end_marker}'",
+            disp_path=disp_path,
+            start_marker=start_marker,
+            end_marker=end_marker,
+        )
+        self.report_action(info_msg, ReportAction.CREATE)
+        try:
+            content = self._read_file_content(file_path)
+            occurrences, match_lines = self._find_marker_blocks(
+                content, start_marker, end_marker
+            )
+            if occurrences == 0:
+                self.report_warning(
+                    tr(" ℹ️ No blocks found between markers."), ReportAction.CREATE
+                )
+                return tr(
+                    "No blocks found between markers in {file_path}.",
+                    file_path=file_path,
+                )
+            backup_path = file_path + ".bak"
+            if backup:
+                self._backup_file(file_path, backup_path)
+            new_content, deleted_blocks = self._delete_blocks(
+                content, start_marker, end_marker
+            )
+            self._write_file_content(file_path, new_content)
+            validation_result = validate_file_syntax(file_path)
+            self._report_success(match_lines)
+            return tr(
+                "Deleted {count} block(s) between markers in {file_path}. (backup at {backup_path})",
+                count=deleted_blocks,
+                file_path=file_path,
+                backup_path=backup_path if backup else "N/A",
+            ) + (f"\n{validation_result}" if validation_result else "")
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.REPLACE)
+            return tr("Error deleting text: {error}", error=e)
+
+    def _read_file_content(self, file_path):
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            return f.read()
+
+    def _find_marker_blocks(self, content, start_marker, end_marker):
+        """Find all blocks between start_marker and end_marker, return count and starting line numbers."""
+        lines = content.splitlines(keepends=True)
+        joined = "".join(lines)
+        match_lines = []
+        idx = 0
+        occurrences = 0
+        while True:
+            start_idx = joined.find(start_marker, idx)
+            if start_idx == -1:
+                break
+            end_idx = joined.find(end_marker, start_idx + len(start_marker))
+            if end_idx == -1:
+                break
+            upto = joined[:start_idx]
+            line_no = upto.count("\n") + 1
+            match_lines.append(line_no)
+            idx = end_idx + len(end_marker)
+            occurrences += 1
+        return occurrences, match_lines
+
+    def _delete_blocks(self, content, start_marker, end_marker):
+        """Delete all blocks between start_marker and end_marker (inclusive)."""
+        count = 0
+        new_content = content
+        while True:
+            start_idx = new_content.find(start_marker)
+            if start_idx == -1:
+                break
+            end_idx = new_content.find(end_marker, start_idx + len(start_marker))
+            if end_idx == -1:
+                break
+            new_content = (
+                new_content[:start_idx] + new_content[end_idx + len(end_marker) :]
+            )
+            count += 1
+        return new_content, count
+
+    def _backup_file(self, file_path, backup_path):
+        shutil.copy2(file_path, backup_path)
+
+    def _write_file_content(self, file_path, content):
+        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+
+    def _report_success(self, match_lines):
+        if match_lines:
+            lines_str = ", ".join(str(line_no) for line_no in match_lines)
+            self.report_success(
+                tr(
+                    " ✅ deleted block(s) starting at line(s): {lines_str}",
+                    lines_str=lines_str,
+                ),
+                ReportAction.CREATE,
+            )
+        else:
+            self.report_success(
+                tr(" ✅ deleted block(s) (lines unknown)"), ReportAction.CREATE
+            )