janito 2.27.1__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,19 +180,21 @@ def handle_runner(
             "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
         )
         print_verbose_info("Agent role", agent_role, style="green")
-    
+
     # 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 (
@@ -222,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)
@@ -103,20 +103,23 @@ def _handle_set_base_url(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:
-        raise ValueError(f"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."
+        )
     from janito.provider_config import set_config_provider
+
     set_config_provider(value)
-    
+
 
 def _handle_set_config_provider(value):
     try:

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
@@ -412,20 +414,21 @@ class JanitoCLI:
             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)):
+        if get_prompt_mode(self.args) == "single_shot" and not getattr(
+            self.args, "profile", None
+        ):
             self.args.profile = "developer"
         provider = self._get_provider_or_default()
         if provider is None:

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

@@ -12,24 +12,24 @@ 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."""
@@ -38,9 +38,11 @@ class BuiltinPluginRegistry:
 
 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
 
 
@@ -66,7 +68,7 @@ try:
         SecurityScannerPlugin,
         DocumentationGeneratorPlugin,
     )
-    
+
     # Register all janito-coder plugins as builtin
     BuiltinPluginRegistry.register("git_analyzer", GitAnalyzerPlugin)
     BuiltinPluginRegistry.register("code_navigator", CodeNavigatorPlugin)
@@ -77,8 +79,10 @@ try:
     BuiltinPluginRegistry.register("debugger", DebuggerPlugin)
     BuiltinPluginRegistry.register("performance_profiler", PerformanceProfilerPlugin)
     BuiltinPluginRegistry.register("security_scanner", SecurityScannerPlugin)
-    BuiltinPluginRegistry.register("documentation_generator", DocumentationGeneratorPlugin)
-    
+    BuiltinPluginRegistry.register(
+        "documentation_generator", DocumentationGeneratorPlugin
+    )
+
 except ImportError:
     # janito-coder not available, skip registration
-    pass
+    pass

janito/plugins/config.py

@@ -21,35 +21,32 @@ def get_plugins_config_path() -> Path:
 def load_plugins_config() -> Dict[str, Any]:
     """
     Load plugins configuration from user directory.
-    
+
     Returns:
         Dict containing plugins configuration
     """
     config_path = get_plugins_config_path()
-    
+
     if not config_path.exists():
         # Create default config if it doesn't exist
         default_config = {
             "plugins": {
-                "paths": [
-                    str(Path.home() / ".janito" / "plugins"),
-                    "./plugins"
-                ],
-                "load": {}
+                "paths": [str(Path.home() / ".janito" / "plugins"), "./plugins"],
+                "load": {},
             }
         }
-        
+
         # Ensure directory exists
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Save default config
-        with open(config_path, 'w') as f:
+        with open(config_path, "w") as f:
             json.dump(default_config, f, indent=2)
-        
+
         return default_config
-    
+
     try:
-        with open(config_path, 'r') as f:
+        with open(config_path, "r") as f:
             return json.load(f)
     except (json.JSONDecodeError, IOError) as e:
         print(f"Warning: Failed to load plugins config from {config_path}: {e}")
@@ -59,20 +56,20 @@ def load_plugins_config() -> Dict[str, Any]:
 def save_plugins_config(config: Dict[str, Any]) -> bool:
     """
     Save plugins configuration to user directory.
-    
+
     Args:
         config: Configuration dict to save
-        
+
     Returns:
         True if saved successfully
     """
     config_path = get_plugins_config_path()
-    
+
     try:
         # Ensure directory exists
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        with open(config_path, 'w') as f:
+
+        with open(config_path, "w") as f:
             json.dump(config, f, indent=2)
         return True
     except IOError as e:
@@ -84,4 +81,4 @@ def get_user_plugins_dir() -> Path:
     """Get the user plugins directory."""
     plugins_dir = get_user_config_dir() / "plugins"
     plugins_dir.mkdir(parents=True, exist_ok=True)
-    return plugins_dir
+    return plugins_dir