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

janito/agent_events.py

@@ -0,0 +1,75 @@
+import attr
+from typing import Any, ClassVar, Optional
+from janito.event_bus.event import Event
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentEvent(Event):
+    """
+    Base class for events related to an agent.
+    Includes agent name for identification.
+    """
+
+    category: ClassVar[str] = "agent"
+    agent_name: Optional[str] = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentInitialized(AgentEvent):
+    """Emitted when an agent is initialized."""
+    pass
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentChatStarted(AgentEvent):
+    """Emitted when an agent starts a chat session."""
+    prompt: Optional[str] = None
+    messages: Optional[list] = None
+    role: Optional[str] = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentChatFinished(AgentEvent):
+    """Emitted when an agent completes a chat session."""
+    result: Any = None
+    loop_count: int = 0
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentProcessingResponse(AgentEvent):
+    """Emitted when an agent is processing a response."""
+    response: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentToolCallStarted(AgentEvent):
+    """Emitted when an agent starts processing a tool call."""
+    tool_call_id: Optional[str] = None
+    name: Optional[str] = None
+    arguments: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentToolCallFinished(AgentEvent):
+    """Emitted when an agent completes processing a tool call."""
+    tool_call_id: Optional[str] = None
+    name: Optional[str] = None
+    result: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentWaitingForResponse(AgentEvent):
+    """Emitted when an agent is waiting for a response from the LLM API."""
+    pass
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentReceivedResponse(AgentEvent):
+    """Emitted when an agent receives a response from the LLM API."""
+    response: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class AgentShutdown(AgentEvent):
+    """Emitted when an agent is shutting down."""
+    pass

janito/cli/chat_mode/session.py

@@ -31,6 +31,7 @@ class ChatShellState:
         self.mem_history = mem_history
         self.conversation_history = conversation_history
         self.paste_mode = False
+        self.interactive_mode = True  # Default to interactive mode
 
         self._pid = None
         self._stdout_path = None

janito/cli/chat_mode/shell/commands/__init__.py

@@ -11,6 +11,7 @@ from .session import HistoryShellHandler
 from .tools import ToolsShellHandler
 from .help import HelpShellHandler
 from .security_command import SecurityCommand
+from .interactive import InteractiveShellHandler
 from janito.cli.console import shared_console
 
 COMMAND_HANDLERS = {
@@ -45,6 +46,7 @@ COMMAND_HANDLERS = {
     "/help": HelpShellHandler,
     "/security": SecurityCommand,
     "/provider": ProviderCmdHandler,
+    "/interactive": InteractiveShellHandler,
 }
 
 

janito/cli/chat_mode/shell/commands/interactive.py

@@ -0,0 +1,33 @@
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class InteractiveShellHandler(ShellCmdHandler):
+    help_text = "Toggle interactive mode on/off"
+
+    def run(self):
+        args = self.after_cmd_line.strip().lower()
+        
+        if args not in ["on", "off"]:
+            shared_console.print(
+                "[bold red]Usage: /interactive on|off[/bold red]"
+            )
+            return
+        
+        # Get current interactive state from shell_state if available
+        current_state = getattr(self.shell_state, 'interactive_mode', True)
+        
+        if args == "on":
+            if current_state:
+                shared_console.print("[yellow]Interactive mode is already enabled.[/yellow]")
+            else:
+                if hasattr(self.shell_state, 'interactive_mode'):
+                    self.shell_state.interactive_mode = True
+                shared_console.print("[green]Interactive mode enabled.[/green]")
+        elif args == "off":
+            if not current_state:
+                shared_console.print("[yellow]Interactive mode is already disabled.[/yellow]")
+            else:
+                if hasattr(self.shell_state, 'interactive_mode'):
+                    self.shell_state.interactive_mode = False
+                shared_console.print("[green]Interactive mode disabled.[/green]")

janito/cli/chat_mode/toolbar.py

@@ -51,6 +51,20 @@ def assemble_bindings_line(width, permissions=None):
     )
 
 
+def assemble_platform_line():
+    import platform
+    import sys
+    from janito.platform_discovery import PlatformDiscovery
+
+    discovery = PlatformDiscovery()
+    system_info = f"{platform.system()} {platform.release()}"
+    arch_info = platform.machine()
+    shell_info = discovery.detect_shell()
+    python_version = f"Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+    return f" Platform: {system_info} ({arch_info}) | Shell: {shell_info} | {python_version}"
+
+
 def _get_status(shell_state):
     _support = getattr(shell_state, "_support", False)
     _status = getattr(shell_state, "_status", None)
@@ -96,7 +110,8 @@ def get_toolbar_func(perf: PerformanceCollector, msg_count: int, shell_state):
         first_line = assemble_first_line(provider_name, model_name, role, agent=agent)
         permissions = _get_permissions()
         bindings_line = assemble_bindings_line(width, permissions)
-        toolbar_text = first_line + "\n" + bindings_line
+        platform_line = assemble_platform_line()
+        toolbar_text = first_line + "\n" + platform_line + "\n" + bindings_line
 
         return HTML(toolbar_text)
 

janito/cli/core/runner.py

@@ -38,6 +38,16 @@ def _choose_provider(args):
     return provider
 
 
+def _select_coder_model_for_provider(provider: str) -> str:
+    """Auto-select the best coder model for the given provider when --developer mode is used."""
+    coder_models = {
+        "alibaba": "qwen3-coder-plus",
+        "cerebras": "qwen-3-coder-480b",
+    }
+
+    return coder_models.get(provider)
+
+
 def _populate_driver_config_data(args, modifiers, provider, model):
     from janito.provider_config import get_effective_setting
 
@@ -80,6 +90,17 @@ def prepare_llm_driver_config(args, modifiers):
     if not model:
         model = get_effective_model(provider)
 
+    # Auto-select coder model when --developer mode is used and no model is specified
+    if not model and getattr(args, "developer", False):
+        model = _select_coder_model_for_provider(provider)
+        if model and getattr(args, "verbose", False):
+            print_verbose_info(
+                "Auto-selected coder model",
+                f"{model} for provider {provider} (developer mode)",
+                style="magenta",
+                align_content=True,
+            )
+
     # Validate that the chosen model is supported by the selected provider
     if model:
         from janito.provider_registry import ProviderRegistry
@@ -149,6 +170,15 @@ def handle_runner(
 
     load_disabled_tools_from_config()
 
+    # Disable bash tools when running in PowerShell
+    from janito.platform_discovery import PlatformDiscovery
+
+    pd = PlatformDiscovery()
+    if pd.detect_shell().startswith("PowerShell"):
+        from janito.tools.disabled_tools import DisabledToolsState
+
+        DisabledToolsState.disable_tool("run_bash_command")
+
     unrestricted = getattr(args, "unrestricted", False)
     adapter = janito.tools.get_local_tools_adapter(
         workdir=getattr(args, "workdir", None)
@@ -230,4 +260,7 @@ def handle_runner(
 
 
 def get_prompt_mode(args):
+    # If interactive flag is set, force chat mode regardless of user_prompt
+    if getattr(args, "interactive", False):
+        return "chat_mode"
     return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"

janito/cli/main_cli.py

@@ -204,6 +204,13 @@ definition = [
             "help": "Enable emoji usage in responses to make output more engaging and expressive",
         },
     ),
+    (
+        ["-i", "--interactive"],
+        {
+            "action": "store_true",
+            "help": "Signal that this is an interactive chat session",
+        },
+    ),
     (["user_prompt"], {"nargs": argparse.REMAINDER, "help": "Prompt to submit"}),
     (
         ["-e", "--event-log"],
@@ -256,6 +263,7 @@ MODIFIER_KEYS = [
     "read",
     "write",
     "emoji",
+    "interactive",
 ]
 SETTER_KEYS = ["set", "set_provider", "set_api_key", "unset"]
 GETTER_KEYS = [
@@ -420,6 +428,7 @@ class JanitoCLI:
 
         # If running in single shot mode and --profile is not provided, default to 'developer' profile
         # Skip profile selection for list commands that don't need it
+        # Also skip if interactive mode is enabled (forces chat mode)
         if get_prompt_mode(self.args) == "single_shot" and not getattr(
             self.args, "profile", None
         ):

janito/cli/prompt_core.py

@@ -3,6 +3,7 @@ Core PromptHandler: Handles prompt submission and response formatting for janito
 """
 
 import time
+import sys
 from janito import __version__ as VERSION
 from janito.performance_collector import PerformanceCollector
 from rich.status import Status
@@ -78,12 +79,27 @@ class PromptHandler:
         )
         return None
 
+    def _clear_current_line(self):
+        """
+        Clears the 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
+            sys.stdout.write("\r\033[2K")
+            sys.stdout.flush()
+
     def _handle_tool_call_started(self, inner_event, status):
-        """Handle ToolCallStarted event - pause the timer when ask_user tool is called."""
-        if hasattr(inner_event, 'tool_name') and inner_event.tool_name == 'ask_user':
-            # Pause the status timer by clearing the status
-            if status:
-                status.update("")
+        """Handle ToolCallStarted event - clear the status before any tool execution."""
+        # Always clear the status when any tool starts to avoid cluttering the UI
+        if status:
+            status.update("")
+            # Also clear the current line to ensure clean terminal output
+            self._clear_current_line()
         return None
 
     def _handle_tool_call_finished(self, inner_event):
@@ -217,42 +233,60 @@ class PromptHandler:
         """
         try:
             self._print_verbose_debug("Calling agent.chat()...")
-            
+
             # Show waiting status with elapsed time
             start_time = time.time()
-            
+
             # Get provider and model info for status display
-            provider_name = self.agent.get_provider_name() if hasattr(self.agent, 'get_provider_name') else 'LLM'
-            model_name = self.agent.get_model_name() if hasattr(self.agent, 'get_model_name') else 'unknown'
-            
-            status = Status(f"[bold blue]Waiting for {provider_name} (model: {model_name})...[/bold blue]")
-            
+            provider_name = (
+                self.agent.get_provider_name()
+                if hasattr(self.agent, "get_provider_name")
+                else "LLM"
+            )
+            model_name = (
+                self.agent.get_model_name()
+                if hasattr(self.agent, "get_model_name")
+                else "unknown"
+            )
+
+            status = Status(
+                f"[bold blue]Waiting for {provider_name} (model: {model_name})...[/bold blue]"
+            )
             # Thread coordination event
             stop_updater = threading.Event()
-            
+
             def update_status():
                 elapsed = time.time() - start_time
-                status.update(f"[bold blue]Waiting for {provider_name} (model: {model_name})... ({elapsed:.1f}s)[/bold blue]")
-            
+                status.update(
+                    f"[bold blue]Waiting for {provider_name} (model: {model_name})... ({elapsed:.1f}s)[/bold blue]"
+                )
+
             # Start status display and update timer
-            with status:
-                # Update status every second in a separate thread
-                def status_updater():
-                    while not stop_updater.is_set():
-                        update_status()
-                        stop_updater.wait(1.0)  # Wait for 1 second or until stopped
-                
-                updater_thread = threading.Thread(target=status_updater, daemon=True)
-                updater_thread.start()
-                
-                try:
-                    final_event = self.agent.chat(prompt=user_prompt)
-                finally:
-                    # Signal the updater thread to stop
-                    stop_updater.set()
-                    # Wait a bit for the thread to clean up
-                    updater_thread.join(timeout=0.1)
-                
+            status.start()
+
+            # Update status every second in a separate thread
+            def status_updater():
+                while not stop_updater.is_set():
+                    update_status()
+                    stop_updater.wait(1.0)  # Wait for 1 second or until stopped
+
+            updater_thread = threading.Thread(target=status_updater, daemon=True)
+            updater_thread.start()
+
+            try:
+                # Stop status before calling agent.chat() to prevent interference with tools
+                status.stop()
+                # Clear the current line after status is stopped
+                self._clear_current_line()
+
+                final_event = self.agent.chat(prompt=user_prompt)
+            finally:
+                # Signal the updater thread to stop
+                stop_updater.set()
+                # Wait a bit for the thread to clean up
+                updater_thread.join(timeout=0.1)
+                # Clear the current line after status is suspended/closed
+                self._clear_current_line()
             if hasattr(self.agent, "set_latest_event"):
                 self.agent.set_latest_event(final_event)
             self.agent.last_event = final_event