janito 3.8.0__py3-none-any.whl → 3.10.0__py3-none-any.whl

janito/cli/rich_terminal_reporter.py

@@ -1,171 +1,170 @@
-from rich.console import Console
-from rich.markdown import Markdown
-from rich.pretty import Pretty
-from rich.panel import Panel
-from rich.text import Text
-from janito.event_bus.handler import EventHandlerBase
-import janito.driver_events as driver_events
-from janito.report_events import ReportSubtype, ReportAction
-from janito.event_bus.bus import event_bus
-from janito.llm import message_parts
-
-
-import sys
-
-
-class RichTerminalReporter(EventHandlerBase):
-    """
-    Handles UI rendering for janito events using Rich.
-
-    - For ResponseReceived events, iterates over the 'parts' field and displays each part appropriately:
-        - TextMessagePart: rendered as Markdown (uses 'content' field)
-        - Other MessageParts: displayed using Pretty or a suitable Rich representation
-    - For RequestFinished events, output is printed only if raw mode is enabled (using Pretty formatting).
-    - Report events (info, success, error, etc.) are always printed with appropriate styling.
-    """
-
-    def __init__(self, raw_mode=False):
-        from janito.cli.console import shared_console
-
-        self.console = shared_console
-        self.raw_mode = raw_mode
-        import janito.report_events as report_events
-
-        import janito.tools.tool_events as tool_events
-
-        super().__init__(driver_events, report_events, tool_events)
-        self._waiting_printed = False
-
-    def on_RequestStarted(self, event):
-        # Print waiting message with provider and model name
-        provider = None
-        model = None
-        if hasattr(event, "payload") and isinstance(event.payload, dict):
-            provider = event.payload.get("provider_name")
-            model = event.payload.get("model") or event.payload.get("model_name")
-        if not provider:
-            provider = getattr(event, "provider_name", None)
-        if not provider:
-            provider = getattr(event, "driver_name", None)
-        if not provider:
-            provider = "LLM"
-        if not model:
-            model = getattr(event, "model", None)
-        if not model:
-            model = getattr(event, "model_name", None)
-        if not model:
-            model = "?"
-        self.console.print(
-            f"[bold cyan]Waiting for {provider} (model: {model})...[/bold cyan]", end=""
-        )
-
-    def on_ResponseReceived(self, event):
-        parts = event.parts if hasattr(event, "parts") else None
-        if not parts:
-            self.console.print("[No response parts to display]")
-            self.console.file.flush()
-            return
-        for part in parts:
-            if isinstance(part, message_parts.TextMessagePart):
-                self.console.print(Markdown(part.content))
-                self.console.file.flush()
-
-    def delete_current_line(self):
-        """
-        Clears the entire current line in the terminal and returns the cursor to column 1.
-        """
-        sys.stdout.write("\033[2K\r")
-        sys.stdout.flush()
-
-    def on_RequestFinished(self, event):
-        self.delete_current_line()
-        self._waiting_printed = False
-        response = getattr(event, "response", None)
-        error = getattr(event, "error", None)
-        exception = getattr(event, "exception", None)
-
-        # Print error and exception if present
-        if error:
-            self.console.print(f"[bold red]Error:[/] {error}")
-            self.console.file.flush()
-        if exception:
-            self.console.print(f"[red]Exception:[/] {exception}")
-            self.console.file.flush()
-
-        if response is not None:
-            if self.raw_mode:
-                self.console.print(Pretty(response, expand_all=True))
-                self.console.file.flush()
-            # Check for 'code' and 'event' fields in the response
-            code = None
-            event_field = None
-            if isinstance(response, dict):
-                code = response.get("code")
-                event_field = response.get("event")
-            if event_field is not None:
-                self.console.print(f"[bold yellow]Event:[/] {event_field}")
-                self.console.file.flush()
-        # No output if not raw_mode or if response is None
-
-    def on_ToolCallError(self, event):
-        # Optionally handle tool call errors in a user-friendly way
-        error = getattr(event, "error", None)
-        tool = getattr(event, "tool_name", None)
-        if error and tool:
-            self.console.print(f"[bold red]Tool Error ({tool}):[/] {error}")
-            self.console.file.flush()
-
-    def on_ReportEvent(self, event):
-        # Special handling for security-related report events
-        subtype = getattr(event, "subtype", None)
-        msg = getattr(event, "message", None)
-        action = getattr(event, "action", None)
-        tool = getattr(event, "tool", None)
-        context = getattr(event, "context", None)
-        if (
-            subtype == ReportSubtype.ERROR
-            and msg
-            and "[SECURITY] Path access denied" in msg
-        ):
-            # Highlight security errors with a distinct style
-            self.console.print(
-                Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red")
-            )
-            self.console.file.flush()
-            return
-
-        msg = event.message if hasattr(event, "message") else None
-        subtype = event.subtype if hasattr(event, "subtype") else None
-        if not msg or not subtype:
-            return
-        if subtype == ReportSubtype.ACTION_INFO:
-            # Use orange for all write/modification actions
-            modification_actions = (
-                getattr(ReportAction, "UPDATE", None),
-                getattr(ReportAction, "WRITE", None),
-                getattr(ReportAction, "DELETE", None),
-                getattr(ReportAction, "CREATE", None),
-            )
-            style = (
-                "orange1"
-                if getattr(event, "action", None) in modification_actions
-                else "cyan"
-            )
-            self.console.print(Text(msg, style=style), end="")
-            self.console.file.flush()
-        elif subtype in (
-            ReportSubtype.SUCCESS,
-            ReportSubtype.ERROR,
-            ReportSubtype.WARNING,
-        ):
-            self.console.print(msg)
-            self.console.file.flush()
-        elif subtype == ReportSubtype.STDOUT:
-            self.console.print(msg)
-            self.console.file.flush()
-        elif subtype == ReportSubtype.STDERR:
-            self.console.print(Text(msg, style="on red"))
-            self.console.file.flush()
-        else:
-            self.console.print(msg)
-            self.console.file.flush()
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.pretty import Pretty
+from rich.panel import Panel
+from rich.text import Text
+from janito.event_bus.handler import EventHandlerBase
+import janito.driver_events as driver_events
+from janito.report_events import ReportSubtype, ReportAction
+from janito.event_bus.bus import event_bus
+from janito.llm import message_parts
+import janito.agent_events as agent_events
+
+
+import sys
+
+
+class RichTerminalReporter(EventHandlerBase):
+    """
+    Handles UI rendering for janito events using Rich.
+
+    - For ResponseReceived events, iterates over the 'parts' field and displays each part appropriately:
+        - TextMessagePart: rendered as Markdown (uses 'content' field)
+        - Other MessageParts: displayed using Pretty or a suitable Rich representation
+    - For RequestFinished events, output is printed only if raw mode is enabled (using Pretty formatting).
+    - Report events (info, success, error, etc.) are always printed with appropriate styling.
+    """
+
+    def __init__(self, raw_mode=False):
+        from janito.cli.console import shared_console
+
+        self.console = shared_console
+        self.raw_mode = raw_mode
+        import janito.report_events as report_events
+
+        import janito.tools.tool_events as tool_events
+
+        super().__init__(driver_events, report_events, tool_events, agent_events)
+        self._waiting_printed = False
+
+    def on_RequestStarted(self, event):
+        # Print waiting message with provider and model name
+        provider = None
+        model = None
+        if hasattr(event, "payload") and isinstance(event.payload, dict):
+            provider = event.payload.get("provider_name")
+            model = event.payload.get("model") or event.payload.get("model_name")
+        if not provider:
+            provider = getattr(event, "provider_name", None)
+        if not provider:
+            provider = getattr(event, "driver_name", None)
+        if not provider:
+            provider = "LLM"
+        if not model:
+            model = getattr(event, "model", None)
+        if not model:
+            model = getattr(event, "model_name", None)
+        if not model:
+            model = "?"
+        self.console.print(
+            f"[bold cyan]Waiting for {provider} (model: {model})...[/bold cyan]", end=""
+        )
+        self._waiting_printed = True
+
+    def on_AgentWaitingForResponse(self, event):
+        # Agent waiting - set flag but don't print anything
+        self._waiting_printed = True
+
+    def on_ResponseReceived(self, event):
+        parts = event.parts if hasattr(event, "parts") else None
+        if not parts:
+            self.console.print("[No response parts to display]")
+            self.console.file.flush()
+            return
+        for part in parts:
+            if isinstance(part, message_parts.TextMessagePart):
+                self.console.print(Markdown(part.content))
+                self.console.file.flush()
+
+    def delete_current_line(self):
+        """
+        Clears the entire current line in the terminal and returns the cursor to column 1.
+        """
+        # Use raw ANSI escape sequences but write directly to the underlying file
+        # to bypass Rich's escaping/interpretation
+        if hasattr(self.console, 'file') and hasattr(self.console.file, 'write'):
+            self.console.file.write("\r\033[2K")
+            self.console.file.flush()
+        else:
+            # Fallback to sys.stdout if console.file is not available
+            import sys
+            sys.stdout.write("\r\033[2K")
+            sys.stdout.flush()
+
+    def on_RequestFinished(self, event):
+        if self._waiting_printed:
+            self.delete_current_line()
+            self._waiting_printed = False
+
+    def on_AgentReceivedResponse(self, event):
+        # Clear any waiting message when agent receives response
+        if self._waiting_printed:
+            self.delete_current_line()
+            self._waiting_printed = False
+
+    def on_ToolCallError(self, event):
+        # Optionally handle tool call errors in a user-friendly way
+        error = getattr(event, "error", None)
+        tool = getattr(event, "tool_name", None)
+        if error and tool:
+            self.console.print(f"[bold red]Tool Error ({tool}):[/] {error}")
+            self.console.file.flush()
+
+    def on_ReportEvent(self, event):
+        # Special handling for security-related report events
+        subtype = getattr(event, "subtype", None)
+        msg = getattr(event, "message", None)
+        action = getattr(event, "action", None)
+        tool = getattr(event, "tool", None)
+        context = getattr(event, "context", None)
+        if (
+            subtype == ReportSubtype.ERROR
+            and msg
+            and "[SECURITY] Path access denied" in msg
+        ):
+            # Highlight security errors with a distinct style
+            self.console.print(
+                Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red")
+            )
+            self.console.file.flush()
+            return
+
+        msg = event.message if hasattr(event, "message") else None
+        subtype = event.subtype if hasattr(event, "subtype") else None
+        if not msg or not subtype:
+            return
+        if subtype == ReportSubtype.ACTION_INFO:
+            # Clear any waiting message before showing action info
+            if self._waiting_printed:
+                self.delete_current_line()
+                self._waiting_printed = False
+            # Use orange for all write/modification actions
+            modification_actions = (
+                getattr(ReportAction, "UPDATE", None),
+                getattr(ReportAction, "WRITE", None),
+                getattr(ReportAction, "DELETE", None),
+                getattr(ReportAction, "CREATE", None),
+            )
+            style = (
+                "orange1"
+                if getattr(event, "action", None) in modification_actions
+                else "cyan"
+            )
+            self.console.print(Text(msg, style=style), end="")
+            self.console.file.flush()
+        elif subtype in (
+            ReportSubtype.SUCCESS,
+            ReportSubtype.ERROR,
+            ReportSubtype.WARNING,
+        ):
+            self.console.print(msg)
+            self.console.file.flush()
+        elif subtype == ReportSubtype.STDOUT:
+            self.console.print(msg)
+            self.console.file.flush()
+        elif subtype == ReportSubtype.STDERR:
+            self.console.print(Text(msg, style="on red"))
+            self.console.file.flush()
+        else:
+            self.console.print(msg)
+            self.console.file.flush()

janito/cli/single_shot_mode/handler.py

@@ -45,6 +45,25 @@ class PromptHandler:
     def handle(self) -> None:
         import traceback
 
+        # Check if interactive mode is requested - if so, switch to chat mode
+        if getattr(self.args, "interactive", False):
+            from janito.cli.chat_mode.session import ChatSession
+            from rich.console import Console
+
+            console = Console()
+            session = ChatSession(
+                console,
+                self.provider_instance,
+                self.llm_driver_config,
+                role=self.role,
+                args=self.args,
+                verbose_tools=getattr(self.args, "verbose_tools", False),
+                verbose_agent=getattr(self.args, "verbose_agent", False),
+                allowed_permissions=getattr(self, 'allowed_permissions', None),
+            )
+            session.run()
+            return
+
         user_prompt = " ".join(getattr(self.args, "user_prompt", [])).strip()
         # UTF-8 sanitize user_prompt
         sanitized = user_prompt

janito/llm/agent.py

@@ -4,6 +4,17 @@ from janito.conversation_history import LLMConversationHistory
 from janito.tools.tools_adapter import ToolsAdapterBase
 from queue import Queue, Empty
 from janito.driver_events import RequestStatus
+from janito.agent_events import (
+    AgentInitialized,
+    AgentChatStarted,
+    AgentChatFinished,
+    AgentProcessingResponse,
+    AgentToolCallStarted,
+    AgentToolCallFinished,
+    AgentWaitingForResponse,
+    AgentReceivedResponse,
+    AgentShutdown
+)
 from typing import Any, Optional, List, Iterator, Union
 import threading
 import logging
@@ -53,6 +64,9 @@ class LLMAgent:
         self._latest_event = None
         self.verbose_agent = verbose_agent
         self.driver = None  # Will be set by setup_agent if available
+        
+        # Emit agent initialized event
+        event_bus.publish(AgentInitialized(agent_name=self.agent_name))
 
     def get_provider_name(self):
         # Try to get provider name from driver, fallback to llm_provider, else '?'
@@ -178,11 +192,17 @@ class LLMAgent:
         Wait for a single event from the output queue (with timeout), process it, and return the result.
         This function is intended to be called from the main agent loop, which controls the overall flow.
         """
+        # Emit agent waiting for response event
+        event_bus.publish(AgentWaitingForResponse(agent_name=self.agent_name))
+        
         if getattr(self, "verbose_agent", False):
             print("[agent] [DEBUG] Entered _process_next_response")
         elapsed = 0.0
         if getattr(self, "verbose_agent", False):
             print("[agent] [DEBUG] Waiting for event from output_queue...")
+        # Show initial wait message
+        if getattr(self, "verbose_agent", False):
+            print(f"[agent] [DEBUG] Starting to wait for LLM response... (timeout: {max_wait_time}s)")
         # Let KeyboardInterrupt propagate to caller
         return self._poll_for_event(poll_timeout, max_wait_time)
 
@@ -197,7 +217,14 @@ class LLMAgent:
                     print(error_msg)
                     print("[DEBUG] Exiting _process_next_response due to timeout")
                     return None, False
+                # Show elapsed time info while waiting
+                if getattr(self, "verbose_agent", False):
+                    print(f"[agent] [DEBUG] Waiting for LLM response... ({elapsed:.1f}s elapsed)")
                 continue
+            
+            # Emit agent received response event
+            event_bus.publish(AgentReceivedResponse(agent_name=self.agent_name, response=event))
+            
             if getattr(self, "verbose_agent", False):
                 print(f"[agent] [DEBUG] Received event from output_queue: {event}")
             event_bus.publish(event)
@@ -227,6 +254,10 @@ class LLMAgent:
         """
         if getattr(self, "verbose_agent", False):
             print("[agent] [INFO] Handling ResponseReceived event.")
+        
+        # Emit agent processing response event
+        event_bus.publish(AgentProcessingResponse(agent_name=self.agent_name, response=event))
+        
         from janito.llm.message_parts import FunctionCallMessagePart
 
         # Skip tool processing if no tools adapter is available
@@ -243,6 +274,15 @@ class LLMAgent:
                     print(
                         f"[agent] [DEBUG] Tool call detected: {getattr(part, 'name', repr(part))} with arguments: {getattr(part, 'arguments', None)}"
                     )
+                
+                # Emit agent tool call started event
+                event_bus.publish(AgentToolCallStarted(
+                    agent_name=self.agent_name,
+                    tool_call_id=getattr(part, 'tool_call_id', None),
+                    name=getattr(part, 'name', None),
+                    arguments=getattr(part, 'arguments', None)
+                ))
+                
                 tool_calls.append(part)
                 try:
                     result = self.tools_adapter.execute_function_call_message_part(part)
@@ -251,6 +291,14 @@ class LLMAgent:
                     # instead of letting it propagate to the user
                     result = str(e)
                 tool_results.append(result)
+                
+                # Emit agent tool call finished event
+                event_bus.publish(AgentToolCallFinished(
+                    agent_name=self.agent_name,
+                    tool_call_id=getattr(part, 'tool_call_id', None),
+                    name=getattr(part, 'name', None),
+                    result=result
+                ))
         if tool_calls:
             # Prepare tool_calls message for assistant
             tool_calls_list = []
@@ -310,6 +358,14 @@ class LLMAgent:
         role: str = "user",
         config=None,
     ):
+        # Emit agent chat started event
+        event_bus.publish(AgentChatStarted(
+            agent_name=self.agent_name,
+            prompt=prompt,
+            messages=messages,
+            role=role
+        ))
+        
         self._clear_driver_queues()
         self._validate_and_update_history(prompt, messages, role)
         self._ensure_system_prompt()
@@ -333,6 +389,12 @@ class LLMAgent:
                     f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
                 )
             if self._should_exit_chat_loop(result, added_tool_results):
+                # Emit agent chat finished event
+                event_bus.publish(AgentChatFinished(
+                    agent_name=self.agent_name,
+                    result=result,
+                    loop_count=loop_count
+                ))
                 return result
             loop_count += 1
 
@@ -496,6 +558,9 @@ class LLMAgent:
         :param timeout: Optional timeout in seconds.
         Handles KeyboardInterrupt gracefully.
         """
+        # Emit agent shutdown event
+        event_bus.publish(AgentShutdown(agent_name=self.agent_name))
+        
         if (
             hasattr(self, "driver")
             and self.driver

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

@@ -3,9 +3,9 @@ from janito.tools.path_utils import expand_path
 from janito.i18n import tr
 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.plugins.tools.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 janito.plugins.tools.local.adapter import register_local_tool as register_tool
 
 from .python_validator import validate_python
 from .json_validator import validate_json
@@ -17,6 +17,7 @@ from .markdown_validator import validate_markdown
 from .js_validator import validate_js
 from .css_validator import validate_css
 from .jinja2_validator import validate_jinja2
+from .txt_validator import validate_txt
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 
@@ -37,6 +38,8 @@ def _get_validator(ext):
         ".css": validate_css,
         ".j2": validate_jinja2,
         ".jinja2": validate_jinja2,
+        ".txt": validate_txt,
+        ".text": validate_txt,
     }
     return mapping.get(ext)
 
@@ -79,6 +82,7 @@ class ValidateFileSyntaxTool(ToolBase):
       - Markdown (.md)
       - JavaScript (.js)
       - Jinja2 templates (.j2, .jinja2)
+      - Text files (.txt, .text) [UTF-8 validation]
 
     Args:
         path (str): Path to the file to validate.
@@ -86,6 +90,7 @@ class ValidateFileSyntaxTool(ToolBase):
         str: Validation status message. Example:
             - "✅ Syntax OK"
             - "⚠️ Warning: Syntax error: <error message>"
+            - "⚠️ Warning: UTF-8 decoding error: <error details>"
             - "⚠️ Warning: Unsupported file extension: <ext>"
     """
 

janito/plugins/core/filemanager/tools/validate_file_syntax/txt_validator.py

@@ -0,0 +1,28 @@
+"""Text file validator for UTF-8 encoding validation."""
+
+import codecs
+from pathlib import Path
+
+
+def validate_txt(path: str) -> str:
+    """
+    Validate a text file for UTF-8 encoding issues.
+    
+    Args:
+        path (str): Path to the text file to validate
+        
+    Returns:
+        str: Validation status message
+            - "✅ Syntax OK" if file is valid UTF-8
+            - "⚠️ Warning: UTF-8 decoding error: <error details>" if invalid
+    """
+    try:
+        # Try to read the file with UTF-8 encoding
+        with codecs.open(path, 'r', encoding='utf-8') as f:
+            # Read the entire file to trigger any decoding errors
+            f.read()
+        return "✅ Syntax OK"
+    except UnicodeDecodeError as e:
+        return f"⚠️ Warning: UTF-8 decoding error: {e}"
+    except Exception as e:
+        return f"⚠️ Warning: File read error: {e}"

janito/plugins/manager.py

@@ -14,7 +14,7 @@ from .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
+from janito.plugins.tools.local import LocalToolsAdapter
 
 logger = logging.getLogger(__name__)
 

janito/{tools/adapters → plugins/tools}/local/__init__.py

@@ -30,6 +30,7 @@ from .show_image_grid import ShowImageGridTool
 from janito.tools.tool_base import ToolPermissions
 import os
 from janito.tools.permissions import get_global_allowed_permissions
+from janito.platform_discovery import PlatformDiscovery
 
 # Singleton tools adapter with all standard tools registered
 local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
@@ -40,6 +41,9 @@ def get_local_tools_adapter(workdir=None):
 
 
 # Register tools
+pd = PlatformDiscovery()
+is_powershell = pd.detect_shell().startswith("PowerShell")
+
 for tool_class in [
     AskUserTool,
     CopyFileTool,
@@ -68,6 +72,9 @@ for tool_class in [
     ShowImageTool,
     ShowImageGridTool,
 ]:
+    # Skip bash tools when running in PowerShell
+    if is_powershell and tool_class.__name__ in ["RunBashCommandTool"]:
+        continue
     local_tools_adapter.register_tool(tool_class)
 
 # DEBUG: Print registered tools at startup

janito/{tools/adapters → plugins/tools}/local/adapter.py

@@ -207,7 +207,7 @@ def register_local_tool(tool=None):
         # Register the tool on a *fresh* adapter instance to avoid circular
         # import issues during package initialisation.  This keeps behaviour
         # identical to the original implementation while still allowing
-        # immediate use via the singleton in janito.tools.adapters.local.
+        # immediate use via the singleton in janito.plugins.tools.local.
         LocalToolsAdapter().register_tool(cls)
         return cls
 

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

@@ -1,5 +1,5 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.local.adapter import register_local_tool
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 from rich import print as rich_print

janito/{tools/adapters → plugins/tools}/local/copy_file.py

@@ -2,7 +2,7 @@ import os
 from janito.tools.path_utils import expand_path
 import shutil
 from typing import List, Union
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.local.adapter import register_local_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.tools.tool_utils import display_path
 from janito.report_events import ReportAction