janito 2.29.0__tar.gz → 2.31.0__tar.gz

{janito-2.29.0 → janito-2.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.29.0
+Version: 2.31.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

janito-2.31.0/docs/CHANGELOG.md

@@ -0,0 +1,49 @@
+# Changelog
+
+All notable changes to Janito will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Removed
+
+- **Breaking Change**: Removed `--role` argument and interactive profile selection
+  - The `--role` argument has been completely removed from the CLI
+  - Interactive profile selection has been removed from chat mode
+  - Use `--profile <name>` or shorthand flags like `--developer` and `--market` instead
+  - Default behavior now uses the Developer profile when no profile is specified
+
+### Changed
+
+- Updated documentation to reflect removal of role argument
+- Added comprehensive profile documentation in `PROFILES.md`
+- Simplified profile selection to use explicit flags only
+
+## [Previous Versions]
+
+### Added
+
+- Initial support for profiles and roles
+- Interactive profile selection in chat mode
+- `--role` argument for specifying developer roles
+- `--profile` argument for system prompt templates
+- `--developer` and `--market` shorthand flags
+
+### Available Profiles
+
+- **Developer**: Optimized for software development tasks
+- **Market Analyst**: Specialized for market analysis and business insights
+
+### Supported Providers
+
+- Moonshot AI (default)
+- OpenAI
+- Anthropic
+- IBM WatsonX
+- Google AI
+
+---
+
+For detailed information about profiles and their usage, see [PROFILES.md](PROFILES.md).

janito-2.31.0/docs/PROFILES.md

@@ -0,0 +1,129 @@
+# Janito Profiles
+
+Janito supports predefined system prompts called "profiles" that help the AI understand the context and role it should play when responding to your requests.
+
+## Available Profiles
+
+### Developer Profile (`--developer` or `--profile developer`)
+
+The default profile optimized for software development tasks. This profile:
+
+- Focuses on code generation and debugging
+- Provides access to Python tools and development utilities
+- Emphasizes best practices and clean code
+- Includes file system operations and code execution capabilities
+
+**Usage:**
+```bash
+janito --developer "Create a REST API with FastAPI"
+janito --profile developer "Debug this Python script"
+```
+
+### Market Analyst Profile (`--market` or `--profile market-analyst`)
+
+A specialized profile for market analysis and business insights. This profile:
+
+- Focuses on data analysis and market research
+- Provides tools for web scraping and data processing
+- Emphasizes business context and market trends
+- Includes tools for generating reports and visualizations
+
+**Usage:**
+```bash
+janito --market "Analyze stock market trends for tech companies"
+janito --profile market-analyst "Scrape competitor pricing data"
+```
+
+## How Profiles Work
+
+Profiles are implemented as Jinja2 templates that generate system prompts based on:
+
+- The selected profile type
+- Available tools and permissions
+- Platform-specific configurations
+- User preferences
+
+When you use a profile, Janito automatically:
+
+1. Loads the appropriate template
+2. Injects relevant tool definitions
+3. Sets up platform-specific configurations
+4. Provides context-aware responses
+
+## Custom Profiles
+
+You can create custom profiles by adding system prompt files to:
+```
+~/.janito/profiles/
+```
+
+Each file should contain a plain text system prompt. The filename becomes the profile name.
+
+**Example:**
+```bash
+# Create a custom profile
+echo "You are a cybersecurity expert. Focus on security best practices, vulnerability analysis, and secure coding patterns." > ~/.janito/profiles/security-expert
+
+# Use the custom profile
+janito --profile security-expert "Review this code for security vulnerabilities"
+```
+
+## Profile Selection
+
+### Command Line
+Use `--profile <name>` to specify a profile:
+```bash
+janito --profile developer "Create a Python script"
+janito --profile market-analyst "Analyze this data"
+janito --profile security-expert "Review security"
+```
+
+### Shorthand Flags
+Use convenience flags for built-in profiles:
+```bash
+janito --developer "Create a Python script"      # Same as --profile developer
+janito --market "Analyze this data"              # Same as --profile market-analyst
+```
+
+### Interactive Mode
+When starting Janito in interactive mode without specifying a profile, it defaults to the Developer profile.
+
+## Profile Templates
+
+Profile templates are located in:
+```
+janito/agent/templates/profiles/
+├── system_prompt_template_developer.txt.j2
+└── system_prompt_template_market_analyst.txt.j2
+```
+
+These templates use Jinja2 syntax and can include:
+
+- Tool definitions
+- Platform-specific configurations
+- Dynamic content based on available tools
+- Conditional logic for different environments
+
+## Best Practices
+
+1. **Use appropriate profiles**: Choose the profile that best matches your task type
+
+2. **Create custom profiles**: For specialized domains, create custom profiles
+
+3. **Combine with tools**: Profiles work best when combined with Janito's built-in tools
+
+4. **Test and iterate**: Refine custom profiles based on results
+
+## Troubleshooting
+
+**Profile not found:**
+
+- Ensure custom profiles are saved in `~/.janito/profiles/`
+- Check file permissions and encoding (UTF-8 recommended)
+- Verify the profile name matches the filename
+
+**Profile not working as expected:**
+
+- Use `janito --show-system-prompt --profile <name>` to inspect the generated prompt
+- Check if tools are properly configured for your platform
+- Review the profile template for any platform-specific conditions

{janito-2.29.0 → janito-2.31.0}/docs/changelogs/CHANGELOG.md

@@ -467,9 +467,9 @@ For users upgrading from previous versions:
   - **CLI Integration**: New commands for plugin management (`--list-remote-plugins`, `--update-remote-plugins`)
 
 - **Documentation**: Comprehensive guides for remote plugin usage
-  - [Remote Plugins Guide](docs/guides/remote-plugins.md) - Complete documentation for remote plugin usage
-  - Updated [Plugin System Guide](docs/guides/plugins.md) with remote plugin integration
-  - Enhanced [README-PLUGINS.md](README-PLUGINS.md) with remote repository references
+  - [Remote Plugins Guide](../guides/remote-plugins.md) - Complete documentation for remote plugin usage
+  - Updated [Plugin System Guide](../guides/plugins.md) with remote plugin integration
+  - Enhanced [README-PLUGINS.md](../../README-PLUGINS.md) with remote repository references
 
 ### Changed
 

{janito-2.29.0 → janito-2.31.0}/docs/changelogs/CHANGELOG_2.23.0.md

@@ -17,9 +17,9 @@
   - **CLI Integration**: New commands for plugin management (`--list-remote-plugins`, `--update-remote-plugins`)
 
 - **Documentation**: Comprehensive guides for remote plugin usage
-  - [Remote Plugins Guide](docs/guides/remote-plugins.md) - Complete documentation for remote plugin usage
-  - Updated [Plugin System Guide](docs/guides/plugins.md) with remote plugin integration
-  - Enhanced [README-PLUGINS.md](README-PLUGINS.md) with remote repository references
+  - [Remote Plugins Guide](../guides/remote-plugins.md) - Complete documentation for remote plugin usage
+  - Updated [Plugin System Guide](../guides/plugins.md) with remote plugin integration
+  - Enhanced [README-PLUGINS.md](../../README-PLUGINS.md) with remote repository references
 
 ### Changed
 

{janito-2.29.0 → janito-2.31.0}/docs/guides/market-data-sources.md

@@ -138,7 +138,7 @@ For enhanced security, use the `/security` command in chat mode to restrict acce
 ## Related Documentation
 
 - [Stock Market Guide](stock-market-guide.md) - Comprehensive guide to accessing financial data
-- [Public Sources](public-sources.md) - Government and institutional data sources
+- [Public Sources](../public-sources.md) - Government and institutional data sources
 - [Using Tools](using_tools.md) - How to use Janito's data fetching capabilities
 - [CLI Options](../reference/cli-options.md) - Command-line options for data access
 

{janito-2.29.0 → janito-2.31.0}/docs/guides/stock-market-guide.md

@@ -118,7 +118,7 @@ janito "Compare performance of AAPL, MSFT, GOOGL, and TSLA over the past month"
 
 ## Related Documentation
 
-- [Public Data Sources](public-sources.md) - Government and public financial data
+- [Public Data Sources](../public-sources.md) - Government and public financial data
 - [Using Tools](using_tools.md) - How to use Janito's web scraping capabilities
 - [CLI Options](../reference/cli-options.md) - Command-line options for data fetching
 

{janito-2.29.0 → janito-2.31.0}/docs/plugins/README.md

@@ -6,7 +6,7 @@ This directory contains comprehensive documentation for the Janito plugin system
 
 - **[Plugin Development Guide](plugin-development.md)** - Complete guide for creating plugins
 - **[Remote Plugins](remote-plugins.md)** - Using plugins from remote repositories
-- **[Built-in Plugins](built-in-plugins.md)** - Documentation for included plugins
+- **[Built-in Plugins](../built-in-plugins.md)** - Documentation for included plugins
 - **[API Reference](api-reference.md)** - Technical details and interfaces
 - **[Examples](examples/)** - Working plugin examples
 
@@ -68,9 +68,9 @@ Add to `janito.json`:
 - [Configuration](configuration.md) - Plugin configuration options
 
 ### Built-in Plugins
-- [Git Analyzer](built-in-plugins/git-analyzer.md) - Git repository analysis
-- [Code Navigator](built-in-plugins/code-navigator.md) - Code navigation tools
-- [Example Plugin](built-in-plugins/example.md) - Basic plugin example
+- [Git Analyzer](../built-in-plugins/git-analyzer.md) - Git repository analysis
+- [Code Navigator](../built-in-plugins/code-navigator.md) - Code navigation tools
+- [Example Plugin](../built-in-plugins/example.md) - Basic plugin example
 
 ### Advanced Topics
 - [Plugin Architecture](architecture.md) - System design and internals

{janito-2.29.0 → janito-2.31.0}/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-2.29.0 → janito-2.31.0}/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-2.29.0 → janito-2.31.0}/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-2.29.0 → janito-2.31.0}/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-2.29.0 → janito-2.31.0}/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-2.29.0 → janito-2.31.0}/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-2.29.0 → janito-2.31.0}/janito/cli/chat_mode/session.py

@@ -119,9 +119,7 @@ class ChatSession:
         profile_system_prompt = None
         no_tools_mode = False
 
-        profile = self._determine_profile(
-            profile, role_arg, python_profile, market_profile
-        )
+        profile = self._determine_profile(profile, python_profile, market_profile)
 
         if (
             profile is None
@@ -136,31 +134,8 @@ class ChatSession:
             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):
@@ -308,25 +283,6 @@ class ChatSession:
                 )
             )
 
-            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
-
-            self.console.print(
-                Rule(
-                    f"[bold blue]Model: {model_name} ({provider_name}) | Backend: {backend_hostname}[/bold blue]"
-                )
-            )
-
             self._prompt_handler.run_prompt(cmd_input)
             end_time = time.time()
             elapsed = end_time - start_time
@@ -337,6 +293,8 @@ 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")
@@ -356,18 +314,18 @@ class ChatSession:
     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 = getattr(args, "role", 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, 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 and role_arg is None:
+        if python_profile and profile is None:
             return "Developer with Python Tools"
-        if market_profile and profile is None and role_arg is None:
+        if market_profile and profile is None:
             return "Market Analyst"
         return profile
 
@@ -517,9 +475,19 @@ class ChatSession:
         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: {total_tokens:,}[/dim]"
+            f"[dim]Session time: {duration_str} | Total tokens: {token_str}[/dim]"
         )
         self.console.print("[bold yellow]Goodbye![/bold yellow]")
 

janito-2.31.0/janito/cli/cli_commands/list_plugins.py

@@ -0,0 +1,117 @@
+"""
+CLI command to list available and loaded plugins.
+"""
+
+import argparse
+from typing import List, Dict, Any
+from janito.plugins.discovery import list_available_plugins, discover_plugins
+import os
+from janito.plugins.manager import PluginManager
+from janito.plugins.builtin import BuiltinPluginRegistry
+
+
+def handle_list_plugins(args: argparse.Namespace) -> None:
+    """List plugins command handler."""
+
+    if getattr(args, "list_plugins_available", False):
+        _list_available_plugins()
+    elif getattr(args, "list_resources", False):
+        _list_plugin_resources()
+    else:
+        _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()