janito 3.8.0__py3-none-any.whl → 3.10.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/cli_commands/list_tools.py

@@ -53,7 +53,7 @@ def _print_tools_table(console, title, tools_info):
 
 
 def handle_list_tools(args=None):
-    from janito.tools.adapters.local.adapter import LocalToolsAdapter
+    from janito.plugins.tools.local.adapter import LocalToolsAdapter
     import janito.tools  # Ensure all tools are registered
     from janito.tools.tool_base import ToolPermissions
 

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
         ):