janito 3.9.0__py3-none-any.whl → 3.11.0__py3-none-any.whl

janito/cli/rich_terminal_reporter.py

@@ -1,179 +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.
-        """
-        # 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):
-        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,6 +192,9 @@ 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
@@ -204,6 +221,10 @@ class LLMAgent:
                 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)
@@ -233,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
@@ -249,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)
@@ -257,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 = []
@@ -316,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()
@@ -339,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
 
@@ -502,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/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/plugins/tools/local/create_directory.py

@@ -6,6 +6,7 @@ from janito.report_events import ReportAction
 from janito.i18n import tr
 import os
 from janito.tools.path_utils import expand_path
+from pathlib import Path
 
 
 @register_local_tool
@@ -43,6 +44,8 @@ class CreateDirectoryTool(ToolBase):
                         "❌ Path '{disp_path}' exists and is not a directory.",
                         disp_path=disp_path,
                     )
+                # Generate content summary
+                content_summary = self._get_directory_summary(path)
                 self.report_error(
                     tr(
                         "❗ Directory '{disp_path}' already exists.",
@@ -50,8 +53,9 @@ class CreateDirectoryTool(ToolBase):
                     )
                 )
                 return tr(
-                    "❗ Cannot create directory: '{disp_path}' already exists.",
+                    "❗ Cannot create directory: '{disp_path}' already exists.\n{summary}",
                     disp_path=disp_path,
+                    summary=content_summary,
                 )
             os.makedirs(path, exist_ok=True)
             self.report_success(tr("✅ Directory created"))
@@ -68,3 +72,42 @@ class CreateDirectoryTool(ToolBase):
                 )
             )
             return tr("❌ Cannot create directory: {error}", error=e)
+
+    def _get_directory_summary(self, path: str) -> str:
+        """Generate a summary of directory contents."""
+        try:
+            path_obj = Path(path)
+            if not path_obj.exists() or not path_obj.is_dir():
+                return ""
+            
+            items = list(path_obj.iterdir())
+            if not items:
+                return "Directory is empty."
+            
+            # Count files and directories
+            file_count = sum(1 for item in items if item.is_file())
+            dir_count = sum(1 for item in items if item.is_dir())
+            
+            summary_parts = []
+            if file_count > 0:
+                summary_parts.append(f"{file_count} file{'s' if file_count != 1 else ''}")
+            if dir_count > 0:
+                summary_parts.append(f"{dir_count} subdirector{'y' if dir_count == 1 else 'ies'}")
+            
+            # Show first few items as examples
+            examples = []
+            for item in sorted(items)[:3]:  # Show up to 3 items
+                if item.is_dir():
+                    examples.append(f"📁 {item.name}")
+                else:
+                    examples.append(f"📄 {item.name}")
+            
+            result = f"Contains: {', '.join(summary_parts)}."
+            if examples:
+                result += f"\nExamples: {', '.join(examples)}"
+                if len(items) > 3:
+                    result += f" (and {len(items) - 3} more)"
+            
+            return result
+        except Exception:
+            return "Unable to read directory contents."