janito 2.4.0__tar.gz → 2.5.1__tar.gz

janito-2.5.1/.vscode/settings.json

@@ -0,0 +1,19 @@
+{
+    "files.exclude": {
+        "**/__pycache__": true,
+        "**/build": true,
+        "**/dist": true,
+        "**/.eggs": true,
+        "**/*.egg-info": true,
+        "**/.tox": true,
+        "**/.nox": true,
+        "**/.hypothesis": true,
+        "**/.pytest_cache": true,
+        "**/.mypy_cache": true,
+        "**/.pyre": true,
+        "**/.ipynb_checkpoints": true,
+        "**/.ruff_cache": true,
+        "**/.janito": true,
+        "**/site": true
+    }
+}

janito-2.5.1/CHANGELOG.md

@@ -0,0 +1,103 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [2.5.0] - 2025-07-01
+### Added
+- Show working directory in chat mode startup message.
+- Bang (`!`) shell command handler for direct shell access from the chat interface.
+- Elapsed time reporting to token usage summary and improved terminal output styling.
+- CLI support for reading prompt from stdin and suppressing token usage summary in non-interactive mode.
+
+### Changed
+- Import `os` in help command handler for future extensibility.
+- Refactored `ChatSession._chat_loop` to reduce complexity by extracting command and prompt handling methods.
+- Refactored profile selection, removed `ProfileShellHandler`, and improved terminal reporter output for STDOUT/STDERR.
+- Refactored to remove `exec_enabled` argument from agent and CLI setup; now uses `args.exec` directly.
+- Improved terminal output: added `delete_current_line` to `RichTerminalReporter` for cleaner UI.
+- Refactored and cleaned up: removed redundant import of `handle_command`, removed backup, structure, and test strategy files, and added `.vscode/settings.json` for VSCode excludes.
+
+### Removed
+- MistralAI provider and driver references and related files.
+- Conversation history persistence and updated input history path.
+
+### Documentation
+- Removed inline web file viewer documentation from `README.md` for clarity and focus on core options.
+
+## [2.4.0]
+
+### Changed
+- Refactored tool permission management: migrated to a permission-based model (read/write/execute), updated CLI and docs, removed legacy execution toggling.
+- Enhanced tool permissions: tools are now grouped by permission, config supports tool_permissions, ask_user is read-only, and permissions are applied at startup.
+- Refined permission and tool output messages in shell commands; improved tool listing by permission class in tools.py.
+- Refactored agent and prompt handler setup, improved model switching, and enhanced user interrupt handling. Includes new /model shell command and fixes for provider registry ASCII fallback.
+- Refactored agent system prompt and permissions logic, switched to profile-based template selection, removed unused templates, and added --profile CLI support.
+- Refactored chat mode startup messages and permission reset handling for improved clarity.
+- Refactored ChatSession and ChatShellState: removed allow_execution logic and related assignments, use exec_enabled directly for execution control.
+- Refactored tool system to use latest git tag for version detection in release script.
+- Refined release script to recommend creating a new git tag if version exists on PyPI.
+- Removed termweb: web file viewer and related CLI/editor features, updated docs and config accordingly.
+- Removed temporary file x.txt.
+- Restored tool permissions to CLI defaults on /restart; store and retrieve default tool permissions in AllowedPermissionsState. Runner now sets and saves default permissions for restoration. Updated conversation_restart to restore or fallback to all-off permissions.
+- Updated disabled execution tools message for clarity.
+- Docs and UX: clarified permissions (read/write/exec), added profiles doc links, and removed localhost references from UI/toolbar.
+
+### Added
+- Agent/driver: drain driver's input queue before sending new messages in chat() to prevent stale DriverInput processing.
+
+### Fixed
+- Ensure tools adapter is always available in provider classes, even if driver is missing. Prevents AttributeError in generic code paths relying on execute_tool().
+
+## [2.3.1] - 2025-06-25
+### Changed
+- Bumped version to 2.3.1 in `version.py`, `pyproject.toml`, and `__init__.py`.
+
+## [2.3.0] - 2025-06-25
+### Added
+- requirements-dev.txt with development dependencies (pytest, pre-commit, ruff, detect-secrets, codespell, black) for code quality and testing
+- Java outline support to get_file_outline tool, including package-private methods
+- create_driver method to AzureOpenAIProvider for driver instantiation
+- CLI --version test and suppress pytest-asyncio deprecation warning
+- New dependencies: prompt_toolkit, lxml, requests, bs4 to requirements.txt
+
+### Changed
+- Improved error messages and documentation
+- Refined error handling in open_html_in_browser.py and open_url.py
+- Refactor remove_file tool: use ReportAction.DELETE for all file removal actions
+- Remove redundant _prepare_api_kwargs override in AzureOpenAIModelDriver
+- Refactor(azure_openai): use 'model' directly in API kwargs, remove deployment_name remapping
+- Add public read-only driver_config property to AzureOpenAIProvider
+- Add _prepare_api_kwargs to support deployment_name for Azure OpenAI API compatibility
+- Update toolbar bindings: add CTRL-C for interrupt/exit, clarify F1 usage
+- Update pyproject.toml optional-dependencies section for setuptools compatibility
+- Remove references to max_results in FindFilesTool docstring
+- Refactor: use .jsonl extension for input history files instead of .log
+- Refactor get_file_outline core logic to remove duplication and add tests
+- Test CLI: Ensure error on missing provider and validate supported models output for each provider
+- Configure dynamic dependencies in pyproject.toml
+- Define dependencies in requirements.txt: attrs, rich, pathspec, setuptools, pyyaml, jinja2
+- Add workdir support to LocalToolsAdapter and CLI; improve Python tool adapters
+- Friendly error message when the provider is not present from the available ones
+
+### Fixed
+- Ensure error on missing provider and validate supported models output for each provider
+- Update supported models table; remove o4-mini-high model from code and docs
+
+## [2.1.1] - 2024-06-23
+### Changed
+- Bumped version to 2.1.1 in `version.py`, `pyproject.toml`, and `__init__.py`.
+- docs: add DeepSeek setup guide, update navigation and references
+    - Add docs/deepseek-setup.md with setup instructions for DeepSeek provider
+    - Link DeepSeek setup in docs/index.md and mkdocs.yml navigation
+    - Fix model name: change 'deepseek-coder' to 'deepseek-reasoner' in DeepSeek provider and model_info
+    - Update DeepSeek provider docstrings and options to match supported models
+
+## [2.1.0] - 2024-06-09
+### Added
+
+### Changed
+- Bumped version to 2.1.0 in `version.py`, `pyproject.toml`, and `__init__.py`.
+
+---
+
+*Older changes may not be listed.*

{janito-2.4.0 → janito-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.4.0
+Version: 2.5.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <lamego.pinto@gmail.com>
 Project-URL: Homepage, https://github.com/janito-dev/janito
@@ -167,19 +167,6 @@ Janito has configuration options, like `--set api-key API_KEY` and `--set provid
 
 ### Advanced Options
 
-- **Enable Inline Web File Viewer for Clickable Links**
-  
-  By default, Janito can open referenced files in a browser-based viewer when you click on file links in supported terminals. To enable this feature for your session, use the `--web` flag:
-  
-  ```bash
-  janito --web
-  ```
-
-  This starts the lightweight web file viewer () in the background, allowing you to inspect files referenced in responses directly in your browser. Combine with interactive mode or prompts as needed.
-  
-  > **Tip:** Use with the interactive shell for the best experience with clickable file links.
-
-
 - **Enable Execution Tools (Code/Shell Execution)**
   
   By default, **all tool privileges (read, write, execute)** are disabled for safety. This means Janito starts with no permissions to run tools that read, write, or execute code/shell commands unless you explicitly enable them.
@@ -232,7 +219,7 @@ janito -r -w -x "Run this code: print('Hello, world!')"
 ### Core CLI Options
 | Option                  | Description                                                                 |
 |------------------------|-----------------------------------------------------------------------------|
-| `--web`          | Enable the builtin lightweight web file viewer for clickable file links (). |
+
 | `--version`            | Show program version                                                        |
 | `--list-tools`         | List all registered tools                                                   |
 | `--list-providers`     | List all supported LLM providers                                            |

{janito-2.4.0 → janito-2.5.1}/README.md

@@ -136,19 +136,6 @@ Janito has configuration options, like `--set api-key API_KEY` and `--set provid
 
 ### Advanced Options
 
-- **Enable Inline Web File Viewer for Clickable Links**
-  
-  By default, Janito can open referenced files in a browser-based viewer when you click on file links in supported terminals. To enable this feature for your session, use the `--web` flag:
-  
-  ```bash
-  janito --web
-  ```
-
-  This starts the lightweight web file viewer () in the background, allowing you to inspect files referenced in responses directly in your browser. Combine with interactive mode or prompts as needed.
-  
-  > **Tip:** Use with the interactive shell for the best experience with clickable file links.
-
-
 - **Enable Execution Tools (Code/Shell Execution)**
   
   By default, **all tool privileges (read, write, execute)** are disabled for safety. This means Janito starts with no permissions to run tools that read, write, or execute code/shell commands unless you explicitly enable them.
@@ -201,7 +188,7 @@ janito -r -w -x "Run this code: print('Hello, world!')"
 ### Core CLI Options
 | Option                  | Description                                                                 |
 |------------------------|-----------------------------------------------------------------------------|
-| `--web`          | Enable the builtin lightweight web file viewer for clickable file links (). |
+
 | `--version`            | Show program version                                                        |
 | `--list-tools`         | List all registered tools                                                   |
 | `--list-providers`     | List all supported LLM providers                                            |

janito-2.5.1/adding_mcp.txt

@@ -0,0 +1,138 @@
+Below is a **minimal-yet-complete “router loop”** that lets any Chat Completions model talk to a remote **MCP server** exactly the same way the Agents SDK/Responses API does under the hood.
+Feel free to copy-paste and adapt.
+
+---
+
+## 0  Dependencies & setup
+
+```bash
+pip install openai httpx python-dotenv       # ↩︎ async-friendly HTTP client
+export OPENAI_API_KEY=sk-...
+```
+
+---
+
+## 1  One-time discovery of all MCP tools
+
+```python
+import httpx, json, os
+from openai import OpenAI
+
+client = OpenAI()                                   # Chat Completions client
+MCP_SERVERS = {                                     # label → URL
+    "weather": "http://localhost:8000/v1/mcp",
+}
+
+tool_registry = {}          # name → {id, server, schema}
+for label, url in MCP_SERVERS.items():
+    r = httpx.post(url, json={"method": "list_tools", "id": 1})
+    for t in r.json()["result"]:
+        tool_registry[t["name"]] = {
+            "id":     t["id"],
+            "server": url,
+            "schema": t,        # already JSON-Schema compliant ✅
+        }
+
+TOOLS_FOR_OPENAI = [v["schema"] for v in tool_registry.values()]
+```
+
+The list-tools → JSON-Schema mapping is exactly what Chat Completions expects (via the `tools` parameter) ([help.openai.com][1]).
+
+---
+
+## 2  Chat → router loop
+
+```python
+messages = [
+    {"role": "system",
+     "content": "You can call the tools provided to help the user."},
+    {"role": "user",
+     "content": "What’s the weather in Zurich right now?"}
+]
+
+while True:
+    resp = client.chat.completions.create(
+        model       = "gpt-4o-mini",
+        messages    = messages,
+        tools       = TOOLS_FOR_OPENAI,
+        tool_choice = "auto",        # let the model decide :contentReference[oaicite:1]{index=1}
+        temperature = 0,
+    )
+
+    msg = resp.choices[0].message
+
+    # CASE A – assistant wants to call one or more tools
+    if msg.tool_calls:
+        messages.append(msg)                       # keep the call stub
+        for call in msg.tool_calls:
+            tool_name = call.function.name
+            args = json.loads(call.function.arguments)
+
+            m = tool_registry[tool_name]
+            result = httpx.post(
+                m["server"],
+                json={
+                    "method": "call_tool",
+                    "params": {"id": m["id"], "arguments": args},
+                    "id": 42
+                }
+            ).json()["result"]
+
+            # Echo the result back so the model can finish the thought
+            messages.append({
+                "role":         "tool",
+                "tool_call_id": call.id,
+                "content":      json.dumps(result)
+            })
+        continue             # ↩︎ model may want more tool calls.
+
+    # CASE B – we’re done (plain assistant message)
+    print(msg.content)
+    break
+```
+
+**Key points**
+
+| Why                | What to remember                                                             |
+| ------------------ | ---------------------------------------------------------------------------- |
+| **Tool discovery** | Cache the JSON once; refresh on a schedule to save tokens.                   |
+| **Routing**        | Map *tool name* → (MCP URL, tool id). No need to expose ids to the model.    |
+| **Multiple calls** | The loop continues until the model returns a message *without* `tool_calls`. |
+| **Safety**         | Validate the tool name and arguments against `tool_registry` before firing.  |
+
+---
+
+## 3  Streaming (optional)
+
+Add `stream=True` to the `client.chat.completions.create` call and accumulate the chunks’ `delta` fields until you see `finish_reason == "tool_calls"` or `"stop"` ([cookbook.openai.com][2]).
+Streamed tool calls arrive in exactly the same order; route each as soon as the JSON fragment closes to slash latency.
+
+---
+
+## 4  Handling more than one MCP server
+
+Just keep extending `MCP_SERVERS` and the discovery loop; `tool_registry` remains a flat map, so collisions are impossible. The runtime cost is one HTTP request per server at startup.
+
+---
+
+## 5  Production checklist
+
+| Risk                                 | Mitigation                                                                                                                |
+| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| **Prompt-injection via tool output** | JSON-schema-validate **again** after the MCP call; escape any HTML.                                                       |
+| **Runaway streams / DoS**            | Timeouts on both Chat Completions and MCP HTTP calls; token/byte ceilings.                                                |
+| **Secrets in tool arguments**        | Never log raw arguments; redact before shipping logs or traces.                                                           |
+| **Token cost for huge schemas**      | SHA-256 hash the last tool list; only resend when it changes.                                                             |
+| **Model refuses to call a tool**     | Use `tool_choice={"type":"function","function":{"name":"…"}}` or `"required"` to force a call ([learn.microsoft.com][3]). |
+
+---
+
+### Why not just switch to the Responses API?
+
+Chat Completions works fine, but with Responses you get automatic **list\_tools/call\_tool** plumbing, background runs, retries, and built-in tracing for free. If you’re starting fresh, Responses is simpler; if you’re locked into Chat Completions (e.g., legacy infra, cost model), the loop above is all you need.
+
+Happy hacking!
+
+[1]: https://help.openai.com/en/articles/8555517-function-calling-in-the-openai-api "Function Calling in the OpenAI API | OpenAI Help Center"
+[2]: https://cookbook.openai.com/examples/how_to_stream_completions "How to stream completions"
+[3]: https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/function-calling "How to use function calling with Azure OpenAI in Azure AI Foundry Models - Azure OpenAI | Microsoft Learn"

{janito-2.4.0 → janito-2.5.1}/janito/agent/setup_agent.py

@@ -20,7 +20,7 @@ def setup_agent(
     output_queue=None,
     verbose_tools=False,
     verbose_agent=False,
-    exec_enabled=False,
+    
     allowed_permissions=None,
     profile=None,
     profile_system_prompt=None,
@@ -156,6 +156,7 @@ def setup_agent(
     agent.template_vars["profile"] = profile
     # Store template path and context for dynamic prompt refresh
     agent.system_prompt_template = str(template_path)
+    
     agent._template_vars = context.copy()
     agent._original_template_vars = context.copy()
     return agent
@@ -170,7 +171,7 @@ def create_configured_agent(
     verbose_agent=False,
     templates_dir=None,
     zero_mode=False,
-    exec_enabled=False,
+    
     allowed_permissions=None,
     profile=None,
     profile_system_prompt=None,
@@ -212,7 +213,7 @@ def create_configured_agent(
         output_queue=output_queue,
         verbose_tools=verbose_tools,
         verbose_agent=verbose_agent,
-        exec_enabled=exec_enabled,
+        
         allowed_permissions=allowed_permissions,
         profile=profile,
         profile_system_prompt=profile_system_prompt,

janito-2.5.1/janito/agent/templates/profiles/system_prompt_template_assistant.txt.j2

@@ -0,0 +1 @@
+You are a helpful assistant.

janito-2.5.1/janito/cli/chat_mode/script_runner.py

@@ -0,0 +1,153 @@
+"""
+Scripted runner for Janito chat mode.
+
+This utility allows you to execute the interactive ``ChatSession`` logic with
+an *in-memory* list of user inputs, making it much easier to write automated
+unit or integration tests for the chat CLI without resorting to fragile
+pseudo-terminal tricks.
+
+The runner monkey-patches the private ``_handle_input`` method so that the
+chat loop thinks it is receiving interactive input, while in reality the
+values come from the provided list.  All output is captured through a
+``rich.console.Console`` instance configured with ``record=True`` so the test
+can later inspect the rendered text.
+
+Typical usage
+-------------
+>>> from janito.cli.chat_mode.script_runner import ChatScriptRunner
+>>> inputs = ["Hello!", "/exit"]
+>>> runner = ChatScriptRunner(inputs)
+>>> transcript = runner.run()
+>>> assert "Hello!" in transcript
+
+The ``ChatScriptRunner`` purposefully replaces the internal call to the agent
+with a real agent call by default. If you want to use a stub, you must modify the runner implementation.
+"""
+from __future__ import annotations
+
+from types import MethodType
+from typing import List, Optional
+
+from rich.console import Console
+
+from janito.cli.chat_mode.session import ChatSession
+from janito.provider_registry import ProviderRegistry
+from janito.llm.driver_config import LLMDriverConfig
+
+__all__ = ["ChatScriptRunner"]
+
+
+auth_warning = (
+    "[yellow]ChatScriptRunner is executing in stubbed-agent mode; no calls to an "
+    "external LLM provider will be made.[/yellow]"
+)
+
+
+
+class ChatScriptRunner:
+    """Run a **ChatSession** non-interactively using a predefined set of inputs."""
+
+    def __init__(
+        self,
+        inputs: List[str],
+        *,
+        console: Optional[Console] = None,
+        provider: str = "openai",
+        model: str = "gpt-4.1",
+        use_real_agent: bool = True,
+        **chat_session_kwargs,
+    ) -> None:
+        """Create the runner.
+
+        Parameters
+        ----------
+        inputs:
+            Ordered list of strings that will be fed to the chat loop.
+        console:
+            Optional *rich* console.  If *None*, a new one is created with
+            *record=True* so that output can later be retrieved through
+            :py:meth:`rich.console.Console.export_text`.
+        use_real_agent:
+        chat_session_kwargs:
+            Extra keyword arguments forwarded to :class:`janito.cli.chat_mode.session.ChatSession`.
+        """
+        self._input_queue = list(inputs)
+        self.console = console or Console(record=True)
+        self.provider = provider
+        self.model = model
+        self.use_real_agent = use_real_agent
+        # Ensure we always pass a non-interactive *args* namespace so that the
+        # normal ChatSession logic skips the Questionary profile prompt which
+        # is incompatible with headless test runs.
+        if "args" not in chat_session_kwargs or chat_session_kwargs["args"] is None:
+            from types import SimpleNamespace
+            chat_session_kwargs["args"] = SimpleNamespace(
+                profile="developer",
+                provider=self.provider,
+                model=self.model,
+            )
+
+        # Create the ChatSession instance **after** we monkey-patch methods that rely on
+        # prompt-toolkit so that no attempt is made to instantiate terminal UIs in
+        # a headless environment like CI.
+
+        # 1) Patch *ChatSession._create_prompt_session* to do nothing – the
+        #    interactive session object is irrelevant for scripted runs.
+        from types import MethodType as _MT
+        if "_original_create_prompt_session" not in ChatSession.__dict__:
+            ChatSession._original_create_prompt_session = ChatSession._create_prompt_session  # type: ignore[attr-defined]
+        ChatSession._create_prompt_session = _MT(lambda _self: None, ChatSession)  # type: ignore[method-assign]
+
+        # Resolve provider instance now so that ChatSession uses a ready agent
+        provider_instance = ProviderRegistry().get_instance(self.provider)
+        if provider_instance is None:
+            raise RuntimeError(f"Provider '{self.provider}' is not available on this system.")
+        driver_config = LLMDriverConfig(model=self.model)
+        chat_session_kwargs.setdefault("provider_instance", provider_instance)
+        chat_session_kwargs.setdefault("llm_driver_config", driver_config)
+
+        self.chat_session = ChatSession(console=self.console, **chat_session_kwargs)
+
+
+        # Monkey-patch the *ChatSession._handle_input* method so that it pops
+        # from our in-memory queue instead of reading from stdin.
+        def _script_handle_input(this: ChatSession, _prompt_session_unused):  # noqa: D401
+            if not self._input_queue:
+                # Signal normal shutdown
+                this._handle_exit()
+                return None
+            return self._input_queue.pop(0)
+
+        # Bind the method to the *chat_session* instance.
+        self.chat_session._handle_input = MethodType(  # type: ignore[assignment]
+            _script_handle_input, self.chat_session
+        )
+
+    # ---------------------------------------------------------------------
+    # Public helpers
+    # ---------------------------------------------------------------------
+    def run(self) -> str:
+        """Execute the chat session and return the captured transcript."""
+        self.chat_session.run()
+        return self.console.export_text()
+
+    # ---------------------------------------------------------------------
+    # Helpers to introspect results
+    # ---------------------------------------------------------------------
+    def get_history(self):
+        """Return the structured conversation history produced by the LLM."""
+        try:
+            return self.chat_session.shell_state.conversation_history.get_history()
+        except Exception:
+            return []
+
+    def get_last_response(self) -> str | None:
+        """Return the *assistant* content of the last message, if any."""
+        history = self.get_history()
+        for message in reversed(history):
+            if message.get("role") == "assistant":
+                return message.get("content")
+        return None
+
+    # Convenience alias so tests can simply call *runner()*
+    __call__ = run

{janito-2.4.0 → janito-2.5.1}/janito/cli/chat_mode/session.py

@@ -54,7 +54,7 @@ class ChatSession:
         args=None,
         verbose_tools=False,
         verbose_agent=False,
-        exec_enabled=False,
+        
         allowed_permissions=None,
     ):
 
@@ -76,12 +76,9 @@ class ChatSession:
                 from janito.cli.chat_mode.session_profile_select import select_profile
 
                 result = select_profile()
-                if (
-                    isinstance(result, dict)
-                    and result.get("profile") is None
-                    and result.get("profile_system_prompt")
-                ):
-                    profile_system_prompt = result["profile_system_prompt"]
+                if isinstance(result, dict):
+                    profile = result.get("profile")
+                    profile_system_prompt = result.get("profile_system_prompt")
                 elif isinstance(result, str) and result.startswith("role:"):
                     role = result[len("role:") :].strip()
                     profile = "developer"
@@ -105,7 +102,7 @@ class ChatSession:
             role=role,
             verbose_tools=verbose_tools,
             verbose_agent=verbose_agent,
-            exec_enabled=exec_enabled,
+            
             allowed_permissions=allowed_permissions,
             profile=profile,
             profile_system_prompt=profile_system_prompt,
@@ -163,6 +160,14 @@ class ChatSession:
             f"[bold green]Janito Chat Mode v{__version__}[/bold green]"
         )
         self.console.print("[green]/help for commands   /exit or Ctrl+C to quit[/green]")
+        import os
+        cwd = os.getcwd()
+        home = os.path.expanduser('~')
+        if cwd.startswith(home):
+            cwd_display = '~' + cwd[len(home):]
+        else:
+            cwd_display = cwd
+        self.console.print(f"[green]Working Dir:[/green] {cwd_display}")
 
         # Inform user if no privileges are enabled
         from janito.cli.chat_mode.shell.commands._priv_check import user_has_any_privileges
@@ -185,40 +190,55 @@ class ChatSession:
                 continue
             if self._handle_exit_conditions(cmd_input):
                 break
-            if cmd_input.startswith("/"):
-                handle_command(cmd_input, shell_state=self.shell_state)
+            if self._handle_command_input(cmd_input):
                 continue
             self.user_input_history.append(cmd_input)
-            try:
-                final_event = (
-                    self._prompt_handler.agent.last_event
-                    if hasattr(self._prompt_handler.agent, "last_event")
+            self._process_prompt(cmd_input)
+
+    def _handle_command_input(self, cmd_input):
+        if cmd_input.startswith("/"):
+            handle_command(cmd_input, shell_state=self.shell_state)
+            return True
+        if cmd_input.startswith("!"):
+            # Pass everything after ! to the bang handler
+            handle_command(f"! {cmd_input[1:]}", shell_state=self.shell_state)
+            return True
+        return False
+
+    def _process_prompt(self, cmd_input):
+        try:
+            import time
+            final_event = (
+                self._prompt_handler.agent.last_event
+                if hasattr(self._prompt_handler.agent, "last_event")
+                else None
+            )
+            start_time = time.time()
+            self._prompt_handler.run_prompt(cmd_input)
+            end_time = time.time()
+            elapsed = end_time - start_time
+            self.msg_count += 1
+            # After prompt, print the stat line using the shared core function
+            from janito.formatting_token import print_token_message_summary
+
+            usage = self.performance_collector.get_last_request_usage()
+            print_token_message_summary(self.console, self.msg_count, usage, elapsed=elapsed)
+            # Print exit reason if present in the final event
+            if final_event and hasattr(final_event, "metadata"):
+                exit_reason = (
+                    final_event.metadata.get("exit_reason")
+                    if hasattr(final_event, "metadata")
                     else None
                 )
-                self._prompt_handler.run_prompt(cmd_input)
-                self.msg_count += 1
-                # After prompt, print the stat line using the shared core function
-                from janito.formatting_token import print_token_message_summary
-
-                usage = self.performance_collector.get_last_request_usage()
-                print_token_message_summary(self.console, self.msg_count, usage)
-                # Print exit reason if present in the final event
-                if final_event and hasattr(final_event, "metadata"):
-                    exit_reason = (
-                        final_event.metadata.get("exit_reason")
-                        if hasattr(final_event, "metadata")
-                        else None
+                if exit_reason:
+                    self.console.print(
+                        f"[bold yellow]Exit reason: {exit_reason}[/bold yellow]"
                     )
-                    if exit_reason:
-                        self.console.print(
-                            f"[bold yellow]Exit reason: {exit_reason}[/bold yellow]"
-                        )
-
-            except Exception as exc:
-                self.console.print(f"[red]Exception in agent: {exc}[/red]")
-                import traceback
 
-                self.console.print(traceback.format_exc())
+        except Exception as exc:
+            self.console.print(f"[red]Exception in agent: {exc}[/red]")
+            import traceback
+            self.console.print(traceback.format_exc())
 
     def _create_prompt_session(self):
         return PromptSession(

{janito-2.4.0 → janito-2.5.1}/janito/cli/chat_mode/session_profile_select.py

@@ -22,7 +22,7 @@ def select_profile():
         style=custom_style
     ).ask()
     if answer == "helpful assistant":
-        return {"profile": None, "profile_system_prompt": "You are an helpful assistant"}
+        return {"profile": "assistant", "profile_system_prompt": None}
     if answer == "using role...":
         role_name = questionary.text("Enter the role name:").ask()
         return f"role:{role_name}"