janito 2.27.1__py3-none-any.whl → 2.29.0__py3-none-any.whl

janito/cli/cli_commands/show_system_prompt.py

@@ -64,6 +64,7 @@ def _load_template(profile, templates_dir):
             # Also check user profiles directory
             from pathlib import Path
             import os
+
             user_profiles_dir = Path(os.path.expanduser("~/.janito/profiles"))
             user_template_path = user_profiles_dir / template_filename
             if user_template_path.exists():
@@ -116,11 +117,11 @@ def handle_show_system_prompt(args):
         Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
     )
     profile = getattr(args, "profile", None)
-    
+
     # Handle --market flag mapping to Market Analyst profile
     if profile is None and getattr(args, "market", False):
         profile = "Market Analyst"
-    
+
     if not profile:
         print(
             "[janito] No profile specified. The main agent runs without a system prompt template.\n"
@@ -134,11 +135,17 @@ def handle_show_system_prompt(args):
     if not template_content:
         # Try to load directly from package resources as fallback
         try:
-            template_content = resources.files("janito.agent.templates.profiles").joinpath(
-                f"system_prompt_template_{profile.lower().replace(' ', '_')}.txt.j2"
-            ).read_text(encoding="utf-8")
+            template_content = (
+                resources.files("janito.agent.templates.profiles")
+                .joinpath(
+                    f"system_prompt_template_{profile.lower().replace(' ', '_')}.txt.j2"
+                )
+                .read_text(encoding="utf-8")
+            )
         except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            print(f"[janito] Could not find profile '{profile}'. This may be a configuration issue.")
+            print(
+                f"[janito] Could not find profile '{profile}'. This may be a configuration issue."
+            )
             return
 
     template = Template(template_content)

janito/cli/core/getters.py

@@ -35,6 +35,7 @@ def get_current_provider():
     """Get the current provider from the global config."""
     return global_config.get("provider", "none")
 
+
 def handle_getter(args, config_mgr=None):
     provider_instance = None
     if getattr(args, "list_models", False):

janito/cli/core/model_guesser.py

@@ -8,44 +8,47 @@ from janito.providers.registry import LLMProviderRegistry
 def guess_provider_from_model(model_name: str) -> str:
     """
     Guess the provider based on the model name.
-    
+
     Args:
         model_name: The name of the model to guess the provider for
-        
+
     Returns:
         The provider name if a match is found, None otherwise
     """
     if not model_name:
         return None
-    
+
     model_name = model_name.lower()
-    
+
     # Check each provider's models
     for provider_name in LLMProviderRegistry.list_providers():
         provider_class = LLMProviderRegistry.get(provider_name)
         if not provider_class:
             continue
-            
+
         # Get model specs for this provider
         try:
-            if hasattr(provider_class, 'MODEL_SPECS'):
+            if hasattr(provider_class, "MODEL_SPECS"):
                 model_specs = provider_class.MODEL_SPECS
                 for spec_model_name in model_specs.keys():
                     if spec_model_name.lower() == model_name:
                         return provider_name
-            
-            # Handle special cases like moonshotai
-            if provider_name == "moonshotai":
+
+            # Handle special cases like moonshot
+            if provider_name == "moonshot":
                 try:
-                    from janito.providers.moonshotai.model_info import MOONSHOTAI_MODEL_SPECS
-                    for spec_model_name in MOONSHOTAI_MODEL_SPECS.keys():
+                    from janito.providers.moonshot.model_info import (
+                        MOONSHOT_MODEL_SPECS,
+                    )
+
+                    for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
                         if spec_model_name.lower() == model_name:
-                            return "moonshotai"
+                            return "moonshot"
                 except ImportError:
                     pass
-                    
+
         except Exception:
             # Skip providers that have issues accessing model specs
             continue
-    
-    return None
+
+    return None

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_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/rich_terminal_reporter.py

@@ -139,11 +139,12 @@ class RichTerminalReporter(EventHandlerBase):
         if not msg or not subtype:
             return
         if subtype == ReportSubtype.ACTION_INFO:
-            # Use orange for modification actions, cyan otherwise
+            # Use orange for all write/modification actions
             modification_actions = (
                 getattr(ReportAction, "UPDATE", None),
                 getattr(ReportAction, "WRITE", None),
                 getattr(ReportAction, "DELETE", None),
+                getattr(ReportAction, "CREATE", None),
             )
             style = (
                 "orange1"

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