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

janito/cli/core/runner.py

@@ -2,7 +2,9 @@
 
 from janito.llm.driver_config import LLMDriverConfig
 from janito.provider_config import get_config_provider
-from janito.cli.core.model_guesser import guess_provider_from_model as _guess_provider_from_model
+from janito.cli.core.model_guesser import (
+    guess_provider_from_model as _guess_provider_from_model,
+)
 from janito.cli.verbose_output import print_verbose_info
 
 
@@ -22,10 +24,13 @@ def _choose_provider(args):
                 if guessed_provider:
                     if getattr(args, "verbose", False):
                         print_verbose_info(
-                            "Guessed provider", guessed_provider, style="magenta", align_content=True
+                            "Guessed provider",
+                            guessed_provider,
+                            style="magenta",
+                            align_content=True,
                         )
                     return guessed_provider
-            
+
             print(
                 "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
             )
@@ -151,9 +156,10 @@ def handle_runner(
     if unrestricted:
         # Patch: disable path security enforcement for this adapter instance
         setattr(adapter, "unrestricted_paths", True)
-        
+
         # Also disable URL whitelist restrictions in unrestricted mode
         from janito.tools.url_whitelist import get_url_whitelist_manager
+
         whitelist_manager = get_url_whitelist_manager()
         whitelist_manager.set_unrestricted_mode(True)
 
@@ -174,7 +180,23 @@ def handle_runner(
             "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
         )
         print_verbose_info("Agent role", agent_role, style="green")
-    if mode == "single_shot":
+
+    # Skip chat mode for list commands - handle them directly
+    from janito.cli.core.getters import GETTER_KEYS
+
+    skip_chat_mode = False
+    if args is not None:
+        for key in GETTER_KEYS:
+            if getattr(args, key, False):
+                skip_chat_mode = True
+                break
+
+    if skip_chat_mode:
+        # Handle list commands directly without prompt
+        from janito.cli.core.getters import handle_getter
+
+        handle_getter(args)
+    elif mode == "single_shot":
         from janito.cli.single_shot_mode.handler import (
             PromptHandler as SingleShotPromptHandler,
         )
@@ -208,4 +230,4 @@ def handle_runner(
 
 
 def get_prompt_mode(args):
-    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"
+    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"

janito/cli/core/setters.py

@@ -71,8 +71,8 @@ def _dispatch_set_key(key, value):
         return True
     if key == "allowed_sites":
         from janito.tools.url_whitelist import get_url_whitelist_manager
-        
-        sites = [site.strip() for site in value.split(',') if site.strip()]
+
+        sites = [site.strip() for site in value.split(",") if site.strip()]
         whitelist_manager = get_url_whitelist_manager()
         whitelist_manager.set_allowed_sites(sites)
         global_config.file_set("allowed_sites", value)
@@ -101,17 +101,32 @@ def _handle_set_base_url(value):
     return True
 
 
-def _handle_set_config_provider(value):
+def set_provider(value):
+    """Set the current provider.
+
+    Args:
+        value (str): The provider name to set
+
+    Raises:
+        ValueError: If the provider is not supported
+    """
     try:
         supported = ProviderRegistry().get_provider(value)
     except Exception:
-        print(
-            f"Error: Provider '{value}' is not supported. Run '--list-providers' to see the supported list."
+        raise ValueError(
+            f"Provider '{value}' is not supported. Run '--list-providers' to see the supported list."
         )
-        return True
     from janito.provider_config import set_config_provider
 
     set_config_provider(value)
+
+
+def _handle_set_config_provider(value):
+    try:
+        set_provider(value)
+    except ValueError as e:
+        print(f"Error: {str(e)}")
+        return True
     print(f"Provider set to '{value}'.")
     return True
 

janito/cli/main_cli.py

@@ -134,7 +134,10 @@ definition = [
     ),
     (
         ["--ping"],
-        {"action": "store_true", "help": "Ping/test connectivity for all providers (use with --list-providers)"},
+        {
+            "action": "store_true",
+            "help": "Ping/test connectivity for all providers (use with --list-providers)",
+        },
     ),
     (
         ["--list-drivers"],
@@ -157,7 +160,6 @@ definition = [
             "help": "List all providers with their regional API information",
         },
     ),
-
     (
         ["-l", "--list-models"],
         {"action": "store_true", "help": "List all supported models"},
@@ -232,7 +234,10 @@ definition = [
     ),
     (
         ["--list-resources"],
-        {"action": "store_true", "help": "List all resources (tools, commands, config) from loaded plugins"},
+        {
+            "action": "store_true",
+            "help": "List all resources (tools, commands, config) from loaded plugins",
+        },
     ),
 ]
 
@@ -292,9 +297,8 @@ class JanitoCLI:
 
         self.parser = argparse.ArgumentParser(
             description="Janito CLI - A tool for running LLM-powered workflows from the command line."
-            "\n\nExample usage: janito -p moonshotai -m kimi-k1-8k 'Your prompt here'\n\n"
+            "\n\nExample usage: janito -p moonshot -m kimi-k1-8k 'Your prompt here'\n\n"
             "Use -m or --model to set the model for the session.",
-
         )
         self._define_args()
         self.args = self.parser.parse_args()
@@ -346,8 +350,6 @@ class JanitoCLI:
 
                 argkwargs["version"] = f"Janito {janito_version}"
             self.parser.add_argument(*argnames, **argkwargs)
-        
-
 
     def _set_all_arg_defaults(self):
         # Gather all possible keys from definition, MODIFIER_KEYS, SETTER_KEYS, GETTER_KEYS
@@ -405,23 +407,25 @@ class JanitoCLI:
             or self.args.list_drivers
             or self.args.list_plugins
             or self.args.list_plugins_available
+            or self.args.list_resources
             or self.args.ping
         ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)
             return
         # Handle /rwx prefix for enabling all permissions
-        if self.args.user_prompt and self.args.user_prompt[0] == '/rwx':
+        if self.args.user_prompt and self.args.user_prompt[0] == "/rwx":
             self.args.read = True
             self.args.write = True
             self.args.exec = True
             # Remove the /rwx prefix from the prompt
             self.args.user_prompt = self.args.user_prompt[1:]
-        elif self.args.user_prompt and self.args.user_prompt[0].startswith('/'):
+        elif self.args.user_prompt and self.args.user_prompt[0].startswith("/"):
             # Skip LLM processing for other commands that start with /
             return
-            
+
         # 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
         if get_prompt_mode(self.args) == "single_shot" and not getattr(
             self.args, "profile", None
         ):
@@ -453,8 +457,6 @@ class JanitoCLI:
                 agent_role,
                 verbose_tools=self.args.verbose_tools,
             )
-        elif run_mode == RunMode.GET:
-            handle_getter(self.args)
 
     def _run_set_mode(self):
         if handle_api_key_set(self.args):

janito/cli/prompt_core.py

@@ -216,6 +216,8 @@ class PromptHandler:
             if on_event and final_event is not None:
                 on_event(final_event)
                 global_event_bus.publish(final_event)
+                # Terminal bell moved to token summary printing in session.py and handler.py
+                pass  # print('\a', end='', flush=True)
         except KeyboardInterrupt:
             # Capture user interrupt / cancellation
             self.console.print("[red]Interrupted by the user.[/red]")

janito/cli/prompt_setup.py

@@ -35,10 +35,10 @@ def setup_agent_and_prompt_handler(
     prompt handler that points to that agent.
     """
     no_tools_mode = False
-    if hasattr(args, 'no_tools_mode'):
-        no_tools_mode = getattr(args, 'no_tools_mode', False)
-    
-    zero_mode = getattr(args, 'zero', False)
+    if hasattr(args, "no_tools_mode"):
+        no_tools_mode = getattr(args, "no_tools_mode", False)
+
+    zero_mode = getattr(args, "zero", False)
     agent = create_configured_agent(
         provider_instance=provider_instance,
         llm_driver_config=llm_driver_config,

janito/cli/single_shot_mode/handler.py

@@ -125,6 +125,8 @@ class PromptHandler:
             print_token_message_summary(
                 shared_console, msg_count=1, usage=usage, elapsed=elapsed
             )
+            # Send terminal bell character to trigger TUI bell after printing token summary
+            print("\a", end="", flush=True)
         self._cleanup_driver_and_console()
 
     def _cleanup_driver_and_console(self):

janito/config_manager.py

@@ -60,6 +60,7 @@ class ConfigManager:
         if plugins_config:
             try:
                 from janito.plugins.manager import PluginManager
+
                 plugin_manager = PluginManager()
                 plugin_manager.load_plugins_from_config({"plugins": plugins_config})
             except Exception as e:
@@ -68,6 +69,7 @@ class ConfigManager:
             # Try loading from user config directory
             try:
                 from janito.plugins.manager import PluginManager
+
                 plugin_manager = PluginManager()
                 plugin_manager.load_plugins_from_user_config()
             except Exception as e:

janito/docs/GETTING_STARTED.md

@@ -13,7 +13,7 @@ pip install janito
 
 Janito supports multiple AI providers. Choose one to get started:
 
-**MoonshotAI (Recommended for Chinese users)**
+**Moonshot (Recommended for Chinese users)**
 1. Go to [Moonshot AI Platform](https://platform.moonshot.cn/)
 2. Sign up for an account
 3. Navigate to API Keys section
@@ -31,10 +31,10 @@ Janito supports multiple AI providers. Choose one to get started:
 
 ### 3. Configure Janito
 
-**MoonshotAI Setup:**
+**Moonshot Setup:**
 ```bash
-# Set MoonshotAI as your default provider
-janito --set-api-key YOUR_API_KEY -p moonshotai
+# Set Moonshot as your default provider
+janito --set-api-key YOUR_API_KEY -p moonshot
 
 # Verify it's working
 janito "Hello, can you introduce yourself?"
@@ -87,17 +87,17 @@ janito -W ./my_project "Create a REST API with FastAPI"
 ### Set as Default Provider
 ```bash
 # Make your chosen provider the permanent default
-janito --set provider=moonshotai  # or openai, ibm, etc.
+janito --set provider=moonshot  # or openai, ibm, etc.
 janito --set model=kimi-k1-8k     # or gpt-5, ibm/granite-3-8b-instruct, etc.
 ```
 
 ### Environment Variables
 You can also use environment variables:
 
-**MoonshotAI:**
+**Moonshot:**
 ```bash
-export MOONSHOTAI_API_KEY=your_key_here
-export JANITO_PROVIDER=moonshotai
+export MOONSHOT_API_KEY=your_key_here
+export JANITO_PROVIDER=moonshot
 export JANITO_MODEL=kimi-k1-8k
 ```
 
@@ -119,7 +119,7 @@ export JANITO_MODEL=ibm/granite-3-3-8b-instruct
 
 ## Available Models by Provider
 
-### MoonshotAI Models
+### Moonshot Models
 - **kimi-k1-8k**: Fast responses, good for general tasks
 - **kimi-k1-32k**: Better for longer contexts
 - **kimi-k1-128k**: Best for very long documents

janito/drivers/cerebras/__init__.py

@@ -1 +1 @@
-# Cerebras driver package
+# Cerebras driver package

janito/exceptions.py

@@ -9,11 +9,11 @@ class ToolCallException(Exception):
         self.error = error
         self.arguments = arguments
         self.original_exception = exception
-        
+
         # Build detailed error message
         details = []
         details.append(f"ToolCallException: {tool_name}: {error}")
-        
+
         if arguments is not None:
             details.append(f"Arguments received: {arguments}")
             if isinstance(arguments, dict):
@@ -25,8 +25,10 @@ class ToolCallException(Exception):
                 for i, value in enumerate(arguments):
                     details.append(f"  [{i}]: {repr(value)} ({type(value).__name__})")
             else:
-                details.append(f"Single argument: {repr(arguments)} ({type(arguments).__name__})")
-        
+                details.append(
+                    f"Single argument: {repr(arguments)} ({type(arguments).__name__})"
+                )
+
         super().__init__("\n".join(details))
 
 

janito/plugins/__init__.py

@@ -12,6 +12,6 @@ from .discovery import discover_plugins
 __all__ = [
     "PluginManager",
     "Plugin",
-    "PluginMetadata", 
+    "PluginMetadata",
     "discover_plugins",
-]
+]

janito/plugins/base.py

@@ -11,6 +11,7 @@ from janito.tools.tool_base import ToolBase
 @dataclass
 class PluginMetadata:
     """Metadata describing a plugin."""
+
     name: str
     version: str
     description: str
@@ -18,7 +19,7 @@ class PluginMetadata:
     license: str = "MIT"
     homepage: Optional[str] = None
     dependencies: List[str] = None
-    
+
     def __post_init__(self):
         if self.dependencies is None:
             self.dependencies = []
@@ -27,6 +28,7 @@ class PluginMetadata:
 @dataclass
 class PluginResource:
     """Represents a resource provided by a plugin."""
+
     name: str
     type: str  # "tool", "command", "config"
     description: str
@@ -36,66 +38,66 @@ class PluginResource:
 class Plugin(ABC):
     """
     Base class for all janito plugins.
-    
+
     Plugins can provide tools, commands, or other functionality.
     """
-    
+
     def __init__(self):
         self.metadata: PluginMetadata = self.get_metadata()
-    
+
     @abstractmethod
     def get_metadata(self) -> PluginMetadata:
         """Return metadata describing this plugin."""
         pass
-    
+
     def get_tools(self) -> List[Type[ToolBase]]:
         """
         Return a list of tool classes provided by this plugin.
-        
+
         Returns:
             List of ToolBase subclasses that should be registered
         """
         return []
-    
+
     def get_commands(self) -> Dict[str, Any]:
         """
         Return a dictionary of CLI commands provided by this plugin.
-        
+
         Returns:
             Dict mapping command names to command handlers
         """
         return {}
-    
+
     def initialize(self) -> None:
         """
         Called when the plugin is loaded.
         Override to perform any initialization needed.
         """
         pass
-    
+
     def cleanup(self) -> None:
         """
         Called when the plugin is unloaded.
         Override to perform any cleanup needed.
         """
         pass
-    
+
     def get_config_schema(self) -> Dict[str, Any]:
         """
         Return JSON schema for plugin configuration.
-        
+
         Returns:
             JSON schema dict describing configuration options
         """
         return {}
-    
+
     def validate_config(self, config: Dict[str, Any]) -> bool:
         """
         Validate plugin configuration.
-        
+
         Args:
             config: Configuration dict to validate
-            
+
         Returns:
             True if configuration is valid
         """
@@ -104,41 +106,47 @@ class Plugin(ABC):
     def get_resources(self) -> List[PluginResource]:
         """
         Return a list of resources provided by this plugin.
-        
+
         Returns:
             List of PluginResource objects describing the resources
         """
         resources = []
-        
+
         # Add tools as resources
         for tool_class in self.get_tools():
             tool_instance = tool_class()
-            tool_name = getattr(tool_instance, 'tool_name', tool_class.__name__)
-            tool_desc = getattr(tool_class, '__doc__', f"Tool: {tool_name}")
-            resources.append(PluginResource(
-                name=tool_name,
-                type="tool",
-                description=tool_desc or f"Tool provided by {self.metadata.name}"
-            ))
-        
+            tool_name = getattr(tool_instance, "tool_name", tool_class.__name__)
+            tool_desc = getattr(tool_class, "__doc__", f"Tool: {tool_name}")
+            resources.append(
+                PluginResource(
+                    name=tool_name,
+                    type="tool",
+                    description=tool_desc or f"Tool provided by {self.metadata.name}",
+                )
+            )
+
         # Add commands as resources
         commands = self.get_commands()
         for cmd_name, cmd_handler in commands.items():
-            cmd_desc = getattr(cmd_handler, '__doc__', f"Command: {cmd_name}")
-            resources.append(PluginResource(
-                name=cmd_name,
-                type="command",
-                description=cmd_desc or f"Command provided by {self.metadata.name}"
-            ))
-        
+            cmd_desc = getattr(cmd_handler, "__doc__", f"Command: {cmd_name}")
+            resources.append(
+                PluginResource(
+                    name=cmd_name,
+                    type="command",
+                    description=cmd_desc or f"Command provided by {self.metadata.name}",
+                )
+            )
+
         # Add config schema as resource
         config_schema = self.get_config_schema()
         if config_schema:
-            resources.append(PluginResource(
-                name=f"{self.metadata.name}_config",
-                type="config",
-                description=f"Configuration schema for {self.metadata.name} plugin",
-                schema=config_schema
-            ))
-        
-        return resources
+            resources.append(
+                PluginResource(
+                    name=f"{self.metadata.name}_config",
+                    type="config",
+                    description=f"Configuration schema for {self.metadata.name} plugin",
+                    schema=config_schema,
+                )
+            )
+
+        return resources

janito/plugins/builtin.py

@@ -0,0 +1,88 @@
+"""
+Builtin plugin system for janito-packaged plugins.
+
+This module provides the infrastructure for plugins that are bundled
+with janito and available by default without requiring external installation.
+"""
+
+import importlib
+from typing import Dict, List, Optional, Type
+from janito.plugins.base import Plugin
+
+
+class BuiltinPluginRegistry:
+    """Registry for builtin plugins that come packaged with janito."""
+
+    _plugins: Dict[str, Type[Plugin]] = {}
+
+    @classmethod
+    def register(cls, name: str, plugin_class: Type[Plugin]) -> None:
+        """Register a builtin plugin."""
+        cls._plugins[name] = plugin_class
+
+    @classmethod
+    def get_plugin_class(cls, name: str) -> Optional[Type[Plugin]]:
+        """Get the plugin class for a builtin plugin."""
+        return cls._plugins.get(name)
+
+    @classmethod
+    def list_builtin_plugins(cls) -> List[str]:
+        """List all registered builtin plugins."""
+        return list(cls._plugins.keys())
+
+    @classmethod
+    def is_builtin(cls, name: str) -> bool:
+        """Check if a plugin is builtin."""
+        return name in cls._plugins
+
+
+def register_builtin_plugin(name: str):
+    """Decorator to register a plugin as builtin."""
+
+    def decorator(plugin_class: Type[Plugin]) -> Type[Plugin]:
+        BuiltinPluginRegistry.register(name, plugin_class)
+        return plugin_class
+
+    return decorator
+
+
+def load_builtin_plugin(name: str) -> Optional[Plugin]:
+    """Load a builtin plugin by name."""
+    plugin_class = BuiltinPluginRegistry.get_plugin_class(name)
+    if plugin_class:
+        return plugin_class()
+    return None
+
+
+# Auto-register janito-coder plugins as builtin
+try:
+    from janito_coder.plugins import (
+        GitAnalyzerPlugin,
+        CodeNavigatorPlugin,
+        DependencyAnalyzerPlugin,
+        CodeFormatterPlugin,
+        TestRunnerPlugin,
+        LinterPlugin,
+        DebuggerPlugin,
+        PerformanceProfilerPlugin,
+        SecurityScannerPlugin,
+        DocumentationGeneratorPlugin,
+    )
+
+    # Register all janito-coder plugins as builtin
+    BuiltinPluginRegistry.register("git_analyzer", GitAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_navigator", CodeNavigatorPlugin)
+    BuiltinPluginRegistry.register("dependency_analyzer", DependencyAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_formatter", CodeFormatterPlugin)
+    BuiltinPluginRegistry.register("test_runner", TestRunnerPlugin)
+    BuiltinPluginRegistry.register("linter", LinterPlugin)
+    BuiltinPluginRegistry.register("debugger", DebuggerPlugin)
+    BuiltinPluginRegistry.register("performance_profiler", PerformanceProfilerPlugin)
+    BuiltinPluginRegistry.register("security_scanner", SecurityScannerPlugin)
+    BuiltinPluginRegistry.register(
+        "documentation_generator", DocumentationGeneratorPlugin
+    )
+
+except ImportError:
+    # janito-coder not available, skip registration
+    pass