janito 2.28.0__py3-none-any.whl → 2.30.0__py3-none-any.whl

janito/README.md

@@ -116,11 +116,11 @@ Janito includes powerful built-in tools for:
 - System commands
 - And more...
 
-### Profiles and Roles
+### Profiles
 Use predefined system prompts:
 ```bash
-janito --profile developer "Create a REST API"
-janito --role python-expert "Optimize this algorithm"
+janito --developer "Create a REST API"  # Same as --profile developer
+janito --market "Analyze market trends"   # Same as --profile market-analyst
 ```
 
 ### Environment Variables

janito/agent/setup_agent.py

@@ -25,10 +25,14 @@ def _load_template_content(profile, templates_dir):
 
     Spaces in the profile name are converted to underscores to align with the file-naming convention (e.g. "Developer with Python Tools" ➜ "Developer_with_Python_Tools" (matches: system_prompt_template_Developer_with_Python_Tools.txt.j2)).
     """
-    # Sanitize profile for filename resolution (convert whitespace to underscores)
-    sanitized_profile = re.sub(r"\s+", "_", profile.strip()) if profile else profile
-
+    sanitized_profile = re.sub(r"\s+", "_", profile.strip())
     template_filename = f"system_prompt_template_{sanitized_profile}.txt.j2"
+
+    return _find_template_file(template_filename, templates_dir)
+
+
+def _find_template_file(template_filename, templates_dir):
+    """Find and load template file from various locations."""
     template_path = templates_dir / template_filename
 
     # 1) Check local templates directory
@@ -96,39 +100,9 @@ def _load_template_content(profile, templates_dir):
         )
 
     raise FileNotFoundError(error_msg)
-    # Replace spaces in profile name with underscores for filename resolution
-    sanitized_profile = re.sub(r"\\s+", "_", profile.strip()) if profile else profile
-    """
-    Loads the template content for the given profile from the specified directory or package resources.
-    If the profile template is not found in the default locations, tries to load from the user profiles directory ~/.janito/profiles.
-    """
-
-    # Sanitize profile name by replacing spaces with underscores to match filename conventions
-    sanitized_profile = re.sub(r"\\s+", "_", profile.strip())
-    template_filename = f"system_prompt_template_{sanitized_profile}.txt.j2"
-    template_path = templates_dir / template_filename
-    if template_path.exists():
-        with open(template_path, "r", encoding="utf-8") as file:
-            return file.read(), template_path
-    # Try package import fallback
-    try:
-        with importlib.resources.files("janito.agent.templates.profiles").joinpath(
-            template_filename
-        ).open("r", encoding="utf-8") as file:
-            return file.read(), template_path
-    except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-        # Try user profiles directory
-        user_profiles_dir = Path(os.path.expanduser("~/.janito/profiles"))
-        user_template_path = user_profiles_dir / profile
-        if user_template_path.exists():
-            with open(user_template_path, "r", encoding="utf-8") as file:
-                return file.read(), user_template_path
-        raise FileNotFoundError(
-            f"[janito] Could not find profile-specific template '{template_filename}' in {template_path} nor in janito.agent.templates.profiles package nor in user profiles directory {user_template_path}."
-        )
 
 
-def _prepare_template_context(role, profile, allowed_permissions):
+def _prepare_template_context(role, profile, allowed_permissions, args=None):
     """
     Prepares the context dictionary for Jinja2 template rendering.
     """
@@ -148,6 +122,11 @@ def _prepare_template_context(role, profile, allowed_permissions):
             perm_str += "x"
         allowed_permissions = perm_str or None
     context["allowed_permissions"] = allowed_permissions
+
+    # Add emoji flag for system prompt
+    context["emoji_enabled"] = (
+        getattr(args, "emoji", False) if "args" in locals() else False
+    )
     # Inject platform info if execute permission is present
     if allowed_permissions and "x" in allowed_permissions:
         pd = PlatformDiscovery()
@@ -171,6 +150,11 @@ def _prepare_template_context(role, profile, allowed_permissions):
         else:
             context["allowed_sites_info"] = f"Restricted to: {', '.join(allowed_sites)}"
 
+    # Add emoji flag for system prompt
+    context["emoji_enabled"] = (
+        getattr(args, "emoji", False) if "args" in locals() else False
+    )
+
     return context
 
 
@@ -267,7 +251,9 @@ def setup_agent(
     template_content, template_path = _load_template_content(profile, templates_dir)
 
     template = Template(template_content)
-    context = _prepare_template_context(role, profile, allowed_permissions)
+    context = _prepare_template_context(
+        role, profile, allowed_permissions, locals().get("args")
+    )
 
     # Debug output if requested
     debug_flag = False

janito/agent/templates/profiles/system_prompt_template_Developer_with_Python_Tools.txt.j2

@@ -88,4 +88,10 @@ You are: {{ role | default('developer') }}
 {# Trying to prevent surrogates generation, found this frequently in gpt4.1/windows #}
 - While writing code, if you need an emoji or special Unicode character in a string, then insert the actual character (e.g., 📖) directly instead of using surrogate pairs or escape sequences.
 {% endif %}
+{% if emoji_enabled %}
+## Emoji Usage
+- Feel free to use emojis in your responses to make them more engaging and expressive 🎉
+- Use appropriate emojis to enhance communication: ✅ for success, ⚠️ for warnings, 🔄 for progress, etc.
+- Emojis should complement the message, not replace clear explanations
+{% endif %}
 

janito/agent/templates/profiles/system_prompt_template_developer.txt.j2

@@ -78,4 +78,10 @@ You are: {{ role | default('software developer') }}
 {# Trying to prevent surrogates generation, found this frequently in gpt4.1/windows #}
 - While writing code, if you need an emoji or special Unicode character in a string, then insert the actual character (e.g., 📖) directly instead of using surrogate pairs or escape sequences.
 {% endif %}
+{% if emoji_enabled %}
+## Emoji Usage
+- Feel free to use emojis in your responses to make them more engaging and expressive 🎉
+- Use appropriate emojis to enhance communication: ✅ for success, ⚠️ for warnings, 🔄 for progress, etc.
+- Emojis should complement the message, not replace clear explanations
+{% endif %}
 

janito/agent/templates/profiles/system_prompt_template_market_analyst.txt.j2

@@ -107,4 +107,10 @@ When asked about specific stocks or market movements, provide detailed analysis
 {% endfor %}
 {% endif %}
 
-## Guidelines
+## Guidelines
+{% if emoji_enabled %}
+## Emoji Usage
+- Feel free to use emojis in your responses to make them more engaging and expressive 📊
+- Use appropriate emojis to enhance communication: 📈 for uptrends, 📉 for downtrends, 💰 for profits, ⚠️ for warnings, etc.
+- Emojis should complement the message, not replace clear financial analysis
+{% endif %}

janito/agent/templates/profiles/system_prompt_template_model_conversation_without_tools_or_context.txt.j2

@@ -50,4 +50,10 @@ You are: {{ role | default('helpful assistant') }}
 ## Guidelines
 - Provide helpful, accurate, and concise responses
 - Ask clarifying questions when needed
-- Maintain a friendly and professional tone
+- Maintain a friendly and professional tone
+{% if emoji_enabled %}
+## Emoji Usage
+- Feel free to use emojis in your responses to make them more engaging and expressive 😊
+- Use appropriate emojis to enhance communication: ✅ for confirmations, ❓ for questions, 💡 for ideas, etc.
+- Emojis should complement the message, not replace clear communication
+{% endif %}

janito/cli/chat_mode/session.py

@@ -63,6 +63,7 @@ class ChatSession:
         allowed_permissions=None,
     ):
         self.console = console
+        self.session_start_time = time.time()
         self.user_input_history = UserInputHistory()
         self.input_dicts = self.user_input_history.load()
         self.mem_history = InMemoryHistory()
@@ -114,22 +115,11 @@ class ChatSession:
         self.multi_line_mode = getattr(args, "multi", False) if args else False
 
     def _select_profile_and_role(self, args, role):
-        profile = getattr(args, "profile", None) if args is not None else None
-        role_arg = getattr(args, "role", None) if args is not None else None
-        python_profile = (
-            getattr(args, "developer", False) if args is not None else False
-        )
-        market_profile = getattr(args, "market", False) if args is not None else False
+        profile, role_arg, python_profile, market_profile = self._extract_args(args)
         profile_system_prompt = None
         no_tools_mode = False
 
-        # Handle --developer flag
-        if python_profile and profile is None and role_arg is None:
-            profile = "Developer with Python Tools"
-
-        # Handle --market flag
-        if market_profile and profile is None and role_arg is None:
-            profile = "Market Analyst"
+        profile = self._determine_profile(profile, python_profile, market_profile)
 
         if (
             profile is None
@@ -137,45 +127,15 @@ class ChatSession:
             and not python_profile
             and not market_profile
         ):
-            # Skip interactive profile selection for list commands
-            from janito.cli.core.getters import GETTER_KEYS
-
-            # Check if any getter command is active - these don't need interactive mode
+            skip_profile_selection = self._should_skip_profile_selection(args)
+        else:
             skip_profile_selection = False
-            if args is not None:
-                for key in GETTER_KEYS:
-                    if getattr(args, key, False):
-                        skip_profile_selection = True
-                        break
 
             if skip_profile_selection:
                 profile = "Developer with Python Tools"  # Default for non-interactive commands
             else:
-                try:
-                    from janito.cli.chat_mode.session_profile_select import (
-                        select_profile,
-                    )
-
-                    result = select_profile()
-                    if isinstance(result, dict):
-                        profile = result.get("profile")
-                        profile_system_prompt = result.get("profile_system_prompt")
-                        no_tools_mode = result.get("no_tools_mode", False)
-                    elif isinstance(result, str) and result.startswith("role:"):
-                        role = result[len("role:") :].strip()
-                        profile = "Developer with Python Tools"
-                    else:
-                        profile = (
-                            "Developer with Python Tools"
-                            if result == "Developer"
-                            else result
-                        )
-                except ImportError:
-                    profile = "Raw Model Session (no tools, no context)"
-        if role_arg is not None:
-            role = role_arg
-            if profile is None:
                 profile = "Developer with Python Tools"
+
         return profile, role, profile_system_prompt, no_tools_mode
 
     def _create_conversation_history(self):
@@ -314,52 +274,8 @@ class ChatSession:
             )
             start_time = time.time()
 
-            # Print rule line with model info before processing prompt
-            model_name = (
-                self.agent.get_model_name()
-                if hasattr(self.agent, "get_model_name")
-                else "Unknown"
-            )
-            provider_name = (
-                self.agent.get_provider_name()
-                if hasattr(self.agent, "get_provider_name")
-                else "Unknown"
-            )
-
-            backend_hostname = "Unknown"
-            candidates = []
-            drv = getattr(self.agent, "driver", None)
-            if drv is not None:
-                cfg = getattr(drv, "config", None)
-                if cfg is not None:
-                    b = getattr(cfg, "base_url", None)
-                    if b:
-                        candidates.append(b)
-                direct_base = getattr(drv, "base_url", None)
-                if direct_base:
-                    candidates.append(direct_base)
-            cfg2 = getattr(self.agent, "config", None)
-            if cfg2 is not None:
-                b2 = getattr(cfg2, "base_url", None)
-                if b2:
-                    candidates.append(b2)
-            top_base = getattr(self.agent, "base_url", None)
-            if top_base:
-                candidates.append(top_base)
-            from urllib.parse import urlparse
-
-            for candidate in candidates:
-                try:
-                    if not candidate:
-                        continue
-                    parsed = urlparse(str(candidate))
-                    host = parsed.netloc or parsed.path
-                    if host:
-                        backend_hostname = host
-                        break
-                except Exception:
-                    backend_hostname = str(candidate)
-                    break
+            model_name, provider_name = self._get_model_info()
+            backend_hostname = self._get_backend_hostname()
 
             self.console.print(
                 Rule(
@@ -377,8 +293,6 @@ class ChatSession:
             print_token_message_summary(
                 self.console, self.msg_count, usage, elapsed=elapsed
             )
-            # Send terminal bell character to trigger TUI bell after printing token summary
-            print("\a", end="", flush=True)
             if final_event and hasattr(final_event, "metadata"):
                 exit_reason = (
                     final_event.metadata.get("exit_reason")
@@ -395,6 +309,102 @@ class ChatSession:
 
             self.console.print(traceback.format_exc())
 
+    def _extract_args(self, args):
+        """Extract profile and role arguments from args."""
+        profile = getattr(args, "profile", None) if args is not None else None
+        role_arg = None
+        python_profile = (
+            getattr(args, "developer", False) if args is not None else False
+        )
+        market_profile = getattr(args, "market", False) if args is not None else False
+        return profile, role_arg, python_profile, market_profile
+
+    def _determine_profile(self, profile, python_profile, market_profile):
+        """Determine the profile based on flags and arguments."""
+        if python_profile and profile is None:
+            return "Developer with Python Tools"
+        if market_profile and profile is None:
+            return "Market Analyst"
+        return profile
+
+    def _should_skip_profile_selection(self, args):
+        """Check if profile selection should be skipped for getter commands."""
+        from janito.cli.core.getters import GETTER_KEYS
+
+        if args is None:
+            return False
+
+        for key in GETTER_KEYS:
+            if getattr(args, key, False):
+                return True
+        return False
+
+    def _get_model_info(self):
+        """Get model and provider information."""
+        model_name = (
+            self.agent.get_model_name()
+            if hasattr(self.agent, "get_model_name")
+            else "Unknown"
+        )
+        provider_name = (
+            self.agent.get_provider_name()
+            if hasattr(self.agent, "get_provider_name")
+            else "Unknown"
+        )
+        return model_name, provider_name
+
+    def _get_backend_hostname(self):
+        """Extract backend hostname from agent configuration."""
+        candidates = self._collect_base_urls()
+        return self._parse_hostname_from_urls(candidates)
+
+    def _collect_base_urls(self):
+        """Collect all possible base URLs from agent configuration."""
+        candidates = []
+
+        # Collect from driver
+        drv = getattr(self.agent, "driver", None)
+        if drv is not None:
+            cfg = getattr(drv, "config", None)
+            if cfg is not None:
+                b = getattr(cfg, "base_url", None)
+                if b:
+                    candidates.append(b)
+            direct_base = getattr(drv, "base_url", None)
+            if direct_base:
+                candidates.append(direct_base)
+
+        # Collect from agent config
+        cfg2 = getattr(self.agent, "config", None)
+        if cfg2 is not None:
+            b2 = getattr(cfg2, "base_url", None)
+            if b2:
+                candidates.append(b2)
+
+        # Collect from agent directly
+        top_base = getattr(self.agent, "base_url", None)
+        if top_base:
+            candidates.append(top_base)
+
+        return candidates
+
+    def _parse_hostname_from_urls(self, candidates):
+        """Parse hostname from a list of URL candidates."""
+        from urllib.parse import urlparse
+
+        for candidate in candidates:
+            try:
+                if not candidate:
+                    continue
+                parsed = urlparse(str(candidate))
+                host = parsed.netloc or parsed.path
+                if host:
+                    return host
+            except Exception:
+                return str(candidate)
+
+        return "Unknown"
+
     def _create_prompt_session(self):
         return PromptSession(
             style=chat_shell_style,
@@ -416,7 +426,25 @@ class ChatSession:
         else:
             try:
                 cmd_input = session.prompt(HTML("<inputline>💬 </inputline>"))
-            except (KeyboardInterrupt, EOFError):
+            except KeyboardInterrupt:
+                # Ask for confirmation on Ctrl+C
+                from prompt_toolkit import prompt
+
+                try:
+                    confirm = prompt(
+                        "Are you sure you want to exit? (y/n): ",
+                        style=self._create_prompt_session().style,
+                    )
+                    if confirm.lower() == "y":
+                        self._handle_exit()
+                        return None
+                    else:
+                        return ""  # Return empty string to continue
+                except (KeyboardInterrupt, EOFError):
+                    # Handle second Ctrl+C or Ctrl+D as immediate exit
+                    self._handle_exit()
+                    return None
+            except EOFError:
                 self._handle_exit()
                 return None
         sanitized = cmd_input.strip()
@@ -430,7 +458,37 @@ class ChatSession:
         return sanitized
 
     def _handle_exit(self):
-        self.console.print("[bold yellow]Exiting chat. Goodbye![/bold yellow]")
+        session_duration = time.time() - self.session_start_time
+
+        # Get total token usage from performance collector
+        from janito.perf_singleton import performance_collector
+
+        total_tokens = performance_collector.get_token_usage().get("total_tokens", 0)
+
+        # Format session duration
+        if session_duration < 60:
+            duration_str = f"{session_duration:.1f}s"
+        elif session_duration < 3600:
+            duration_str = f"{session_duration/60:.1f}m"
+        else:
+            duration_str = f"{session_duration/3600:.1f}h"
+
+        # Format tokens in k/m/t as appropriate
+        if total_tokens >= 1_000_000_000:
+            token_str = f"{total_tokens/1_000_000_000:.1f}t"
+        elif total_tokens >= 1_000_000:
+            token_str = f"{total_tokens/1_000_000:.1f}m"
+        elif total_tokens >= 1_000:
+            token_str = f"{total_tokens/1_000:.1f}k"
+        else:
+            token_str = f"{total_tokens}"
+
+        self.console.print(f"[bold yellow]Session completed![/bold yellow]")
+        self.console.print(
+            f"[dim]Session time: {duration_str} | Total tokens: {token_str}[/dim]"
+        )
+        self.console.print("[bold yellow]Goodbye![/bold yellow]")
+
         if hasattr(self, "agent") and hasattr(self.agent, "join_driver"):
             if (
                 hasattr(self.agent, "input_queue")

janito/cli/cli_commands/list_plugins.py

@@ -14,80 +14,104 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
     """List plugins command handler."""
 
     if getattr(args, "list_plugins_available", False):
-        # List available plugins
-        available = list_available_plugins()
-        builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
-
-        if available or builtin_plugins:
-            print("Available plugins:")
-
-            # Show builtin plugins first
-            if builtin_plugins:
-                print("  Builtin plugins:")
-                for plugin in builtin_plugins:
-                    print(f"    - {plugin} [BUILTIN]")
-
-            # Show other available plugins
-            other_plugins = [p for p in available if p not in builtin_plugins]
-            if other_plugins:
-                print("  External plugins:")
-                for plugin in other_plugins:
-                    print(f"    - {plugin}")
-        else:
-            print("No plugins found in search paths")
-            print("Search paths:")
-            print(f"  - {os.getcwd()}/plugins")
-            print(f"  - {os.path.expanduser('~')}/.janito/plugins")
+        _list_available_plugins()
     elif getattr(args, "list_resources", False):
-        # List all resources from loaded plugins
-        manager = PluginManager()
-        all_resources = manager.list_all_resources()
-
-        if all_resources:
-            print("Plugin Resources:")
-            for plugin_name, resources in all_resources.items():
-                metadata = manager.get_plugin_metadata(plugin_name)
-                print(
-                    f"\n{plugin_name} v{metadata.version if metadata else 'unknown'}:"
-                )
-
-                # Group resources by type
-                tools = [r for r in resources if r["type"] == "tool"]
-                commands = [r for r in resources if r["type"] == "command"]
-                configs = [r for r in resources if r["type"] == "config"]
-
-                if tools:
-                    print("  Tools:")
-                    for tool in tools:
-                        print(f"    - {tool['name']}: {tool['description']}")
-
-                if commands:
-                    print("  Commands:")
-                    for cmd in commands:
-                        print(f"    - {cmd['name']}: {cmd['description']}")
-
-                if configs:
-                    print("  Configuration:")
-                    for config in configs:
-                        print(f"    - {config['name']}: {config['description']}")
-        else:
-            print("No plugins loaded")
+        _list_plugin_resources()
     else:
-        # List loaded plugins
-        manager = PluginManager()
-        loaded = manager.list_plugins()
-
-        if loaded:
-            print("Loaded plugins:")
-            for plugin_name in loaded:
-                metadata = manager.get_plugin_metadata(plugin_name)
-                is_builtin = BuiltinPluginRegistry.is_builtin(plugin_name)
-                if metadata:
-                    builtin_tag = " [BUILTIN]" if is_builtin else ""
-                    print(f"  - {metadata.name} v{metadata.version}{builtin_tag}")
-                    print(f"    {metadata.description}")
-                    if metadata.author:
-                        print(f"    Author: {metadata.author}")
-                    print()
-        else:
-            print("No plugins loaded")
+        _list_loaded_plugins()
+
+
+def _list_available_plugins():
+    """List available plugins."""
+    available = list_available_plugins()
+    builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
+
+    if available or builtin_plugins:
+        print("Available plugins:")
+        _print_builtin_plugins(builtin_plugins)
+        _print_external_plugins(available, builtin_plugins)
+    else:
+        print("No plugins found in search paths")
+        print("Search paths:")
+        print(f"  - {os.getcwd()}/plugins")
+        print(f"  - {os.path.expanduser('~')}/.janito/plugins")
+
+
+def _print_builtin_plugins(builtin_plugins):
+    """Print builtin plugins."""
+    if builtin_plugins:
+        print("  Builtin plugins:")
+        for plugin in builtin_plugins:
+            print(f"    - {plugin} [BUILTIN]")
+
+
+def _print_external_plugins(available, builtin_plugins):
+    """Print external plugins."""
+    other_plugins = [p for p in available if p not in builtin_plugins]
+    if other_plugins:
+        print("  External plugins:")
+        for plugin in other_plugins:
+            print(f"    - {plugin}")
+
+
+def _list_plugin_resources():
+    """List all resources from loaded plugins."""
+    manager = PluginManager()
+    all_resources = manager.list_all_resources()
+
+    if all_resources:
+        print("Plugin Resources:")
+        for plugin_name, resources in all_resources.items():
+            metadata = manager.get_plugin_metadata(plugin_name)
+            print(f"\n{plugin_name} v{metadata.version if metadata else 'unknown'}:")
+            _print_resources_by_type(resources)
+    else:
+        print("No plugins loaded")
+
+
+def _print_resources_by_type(resources):
+    """Print resources grouped by type."""
+    tools = [r for r in resources if r["type"] == "tool"]
+    commands = [r for r in resources if r["type"] == "command"]
+    configs = [r for r in resources if r["type"] == "config"]
+
+    if tools:
+        print("  Tools:")
+        for tool in tools:
+            print(f"    - {tool['name']}: {tool['description']}")
+
+    if commands:
+        print("  Commands:")
+        for cmd in commands:
+            print(f"    - {cmd['name']}: {cmd['description']}")
+
+    if configs:
+        print("  Configuration:")
+        for config in configs:
+            print(f"    - {config['name']}: {config['description']}")
+
+
+def _list_loaded_plugins():
+    """List loaded plugins."""
+    manager = PluginManager()
+    loaded = manager.list_plugins()
+
+    if loaded:
+        print("Loaded plugins:")
+        for plugin_name in loaded:
+            _print_plugin_details(manager, plugin_name)
+    else:
+        print("No plugins loaded")
+
+
+def _print_plugin_details(manager, plugin_name):
+    """Print details for a loaded plugin."""
+    metadata = manager.get_plugin_metadata(plugin_name)
+    is_builtin = BuiltinPluginRegistry.is_builtin(plugin_name)
+    if metadata:
+        builtin_tag = " [BUILTIN]" if is_builtin else ""
+        print(f"  - {metadata.name} v{metadata.version}{builtin_tag}")
+        print(f"    {metadata.description}")
+        if metadata.author:
+            print(f"    Author: {metadata.author}")
+        print()