janito 2.9.0__py3-none-any.whl → 2.12.0__py3-none-any.whl

janito/README.md

@@ -0,0 +1,149 @@
+# Janito CLI
+
+A powerful command-line tool for running LLM-powered workflows with built-in tool execution capabilities.
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install janito
+```
+
+### First-Time Setup
+
+1. **Get your API key**: Sign up at [Moonshot AI](https://platform.moonshot.cn/) and get your API key
+2. **Set your API key**:
+   ```bash
+   janito --set-api-key YOUR_MOONSHOT_API_KEY -p moonshotai
+   ```
+
+### Basic Usage
+
+**MoonshotAI (Recommended - Default Provider)**
+```bash
+# Using the default provider (moonshotai) and model
+janito "Create a Python script that reads a CSV file"
+
+# Using a specific MoonshotAI model
+janito -m kimi-k1-8k "Explain quantum computing"
+```
+
+**Other Providers**
+```bash
+# OpenAI
+janito -p openai -m gpt-4 "Write a React component"
+
+# Anthropic
+janito -p anthropic -m claude-3-5-sonnet-20241022 "Analyze this code"
+
+# Google
+janito -p google -m gemini-2.0-flash-exp "Generate unit tests"
+```
+
+### Interactive Chat Mode
+
+Start an interactive session:
+```bash
+janito --chat
+```
+
+In chat mode, you can:
+
+- Have multi-turn conversations
+- Execute code and commands
+- Read and write files
+- Use built-in tools
+
+### Available Commands
+
+- `janito --list-providers` - List all supported providers
+- `janito --list-models` - List all available models
+- `janito --list-tools` - List available tools
+- `janito --show-config` - Show current configuration
+
+### Configuration
+
+Set default provider and model:
+```bash
+janito --set provider=moonshotai
+janito --set model=kimi-k1-8k
+```
+
+## Providers
+
+### MoonshotAI (Recommended)
+
+- **Models**: kimi-k1-8k, kimi-k1-32k, kimi-k1-128k, kimi-k2-turbo-preview
+- **Strengths**: Excellent Chinese/English support, competitive pricing, fast responses
+- **Setup**: Get API key from [Moonshot AI Platform](https://platform.moonshot.cn/)
+
+### OpenAI
+
+- **Models**: gpt-4, gpt-4-turbo, gpt-3.5-turbo
+- **Setup**: Get API key from [OpenAI Platform](https://platform.openai.com/)
+
+### Anthropic
+
+- **Models**: claude-3-5-sonnet-20241022, claude-3-opus-20240229
+- **Setup**: Get API key from [Anthropic Console](https://console.anthropic.com/)
+
+### Google
+
+- **Models**: gemini-2.0-flash-exp, gemini-1.5-pro
+- **Setup**: Get API key from [Google AI Studio](https://makersuite.google.com/)
+
+## Advanced Features
+
+### Tool Usage
+
+Janito includes powerful built-in tools for:
+
+- File operations (read, write, search)
+- Code execution
+- Web scraping
+- System commands
+- And more...
+
+### Profiles and Roles
+Use predefined system prompts:
+```bash
+janito --profile developer "Create a REST API"
+janito --role python-expert "Optimize this algorithm"
+```
+
+### Environment Variables
+You can also configure via environment variables:
+```bash
+export MOONSHOTAI_API_KEY=your_key_here
+export JANITO_PROVIDER=moonshotai
+export JANITO_MODEL=kimi-k1-8k
+```
+
+## Examples
+
+### Code Generation
+```bash
+janito "Create a Python FastAPI application with user authentication"
+```
+
+### File Analysis
+```bash
+janito "Analyze the performance bottlenecks in my_app.py"
+```
+
+### Data Processing
+```bash
+janito "Process this CSV file and generate summary statistics"
+```
+
+### Web Development
+```bash
+janito "Create a responsive landing page with Tailwind CSS"
+```
+
+## Support
+
+- **Documentation**: Check individual provider directories for detailed setup guides
+- **Issues**: Report bugs and feature requests on GitHub
+- **Discord**: Join our community for help and discussions

janito/cli/chat_mode/script_runner.py

@@ -52,8 +52,8 @@ class ChatScriptRunner:
         inputs: List[str],
         *,
         console: Optional[Console] = None,
-        provider: str = "openai",
-        model: str = "gpt-4.1",
+        provider: str = "moonshotai",
+        model: str = "kimi-k1-8k",
         use_real_agent: bool = True,
         **chat_session_kwargs,
     ) -> None:

janito/cli/chat_mode/session.py

@@ -109,6 +109,9 @@ class ChatSession:
         )
         self._support = False
 
+        # Check if multi-line mode should be enabled by default
+        self.multi_line_mode = getattr(args, "multi", False) if args else False
+
     def _select_profile_and_role(self, args, role):
         profile = getattr(args, "profile", None) if args is not None else None
         role_arg = getattr(args, "role", None) if args is not None else None
@@ -213,6 +216,11 @@ class ChatSession:
             f"[green]Working Dir:[/green] {cwd_display}  |  {priv_status}"
         )
 
+        if self.multi_line_mode:
+            self.console.print(
+                "[blue]Multi-line input mode enabled (Esc+Enter or Ctrl+D to submit)[/blue]"
+            )
+
         from janito.cli.chat_mode.shell.commands._priv_check import (
             user_has_any_privileges,
         )
@@ -305,6 +313,7 @@ class ChatSession:
             bottom_toolbar=lambda: get_toolbar_func(
                 self.performance_collector, 0, self.shell_state
             )(),
+            multiline=self.multi_line_mode,
         )
 
     def _handle_input(self, session):

janito/cli/core/model_guesser.py

@@ -0,0 +1,51 @@
+"""
+Module for guessing the provider based on model names.
+"""
+
+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'):
+                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":
+                try:
+                    from janito.providers.moonshotai.model_info import MOONSHOTAI_MODEL_SPECS
+                    for spec_model_name in MOONSHOTAI_MODEL_SPECS.keys():
+                        if spec_model_name.lower() == model_name:
+                            return "moonshotai"
+                except ImportError:
+                    pass
+                    
+        except Exception:
+            # Skip providers that have issues accessing model specs
+            continue
+    
+    return None

janito/cli/core/runner.py

@@ -2,6 +2,7 @@
 
 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.verbose_output import print_verbose_info
 
 
@@ -14,6 +15,17 @@ def _choose_provider(args):
                 "Default provider", provider, style="magenta", align_content=True
             )
         elif provider is None:
+            # Try to guess provider based on model name if -m is provided
+            model = getattr(args, "model", None)
+            if model:
+                guessed_provider = _guess_provider_from_model(model)
+                if guessed_provider:
+                    if getattr(args, "verbose", False):
+                        print_verbose_info(
+                            "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."
             )
@@ -191,4 +203,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/main_cli.py

@@ -21,6 +21,13 @@ definition = [
             "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
         },
     ),
+    (
+        ["--multi"],
+        {
+            "action": "store_true",
+            "help": "Start chat mode with multi-line input as default (no need for /multi command)",
+        },
+    ),
     (
         ["--profile"],
         {
@@ -214,7 +221,7 @@ 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 openai -m gpt-3.5-turbo 'Your prompt here'\n\n"
+            "\n\nExample usage: janito -p moonshotai -m kimi-k1-8k 'Your prompt here'\n\n"
             "Use -m or --model to set the model for the session."
         )
         self._define_args()

janito/docs/GETTING_STARTED.md

@@ -0,0 +1,117 @@
+# Getting Started with Janito
+
+This guide will help you set up Janito CLI quickly and start using it with MoonshotAI as your default provider.
+
+## Quick Setup (2 minutes)
+
+### 1. Install Janito
+```bash
+pip install janito
+```
+
+### 2. Get Your MoonshotAI API Key
+
+1. Go to [Moonshot AI Platform](https://platform.moonshot.cn/)
+2. Sign up for an account
+3. Navigate to API Keys section
+4. Create a new API key
+
+### 3. Configure Janito
+```bash
+# Set MoonshotAI as your default provider
+janito --set-api-key YOUR_API_KEY -p moonshotai
+
+# Verify it's working
+janito "Hello, can you introduce yourself?"
+```
+
+## Your First Commands
+
+### Basic Usage
+```bash
+# Simple prompt
+janito "Create a Python script to calculate fibonacci numbers"
+
+# With specific model
+janito -m kimi-k1-8k "Explain machine learning in simple terms"
+
+# Interactive chat mode
+janito --chat
+```
+
+### Working with Files
+```bash
+# Analyze a file
+janito "Analyze the performance of my_app.py" < my_app.py
+
+# Generate code in a specific directory
+janito -W ./my_project "Create a REST API with FastAPI"
+```
+
+## Configuration Options
+
+### Set as Default Provider
+```bash
+# Make MoonshotAI your permanent default
+janito --set provider=moonshotai
+janito --set model=kimi-k1-8k
+```
+
+### Environment Variables
+You can also use environment variables:
+```bash
+export MOONSHOTAI_API_KEY=your_key_here
+export JANITO_PROVIDER=moonshotai
+export JANITO_MODEL=kimi-k1-8k
+```
+
+## MoonshotAI Models
+
+Janito supports these MoonshotAI 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
+- **kimi-k2-turbo-preview**: Latest model with enhanced capabilities
+- **kimi-k2-turbo-preview**: Turbo version of the advanced reasoning model
+
+## Next Steps
+
+1. **Explore tools**: Run `janito --list-tools` to see available tools
+2. **Try chat mode**: Run `janito --chat` for interactive sessions
+3. **Check examples**: Look at the main README.md for more usage examples
+4. **Join community**: Get help and share tips with other users
+
+## Troubleshooting
+
+### Common Issues
+
+**"Provider not found" error**
+```bash
+# Check available providers
+janito --list-providers
+
+# Re-register MoonshotAI
+janito --set-api-key YOUR_KEY -p moonshotai
+```
+
+**"Model not available" error**
+```bash
+# List available MoonshotAI models
+janito -p moonshotai --list-models
+```
+
+**API key issues**
+```bash
+# Check current configuration
+janito --show-config
+
+# Reset API key
+janito --set-api-key NEW_KEY -p moonshotai
+```
+
+### Getting Help
+
+- Check the main README.md for comprehensive documentation
+- Use `janito --help` for command-line options
+- Visit our GitHub repository for issues and discussions

janito/drivers/azure_openai/driver.py

@@ -63,6 +63,13 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
 
     def _instantiate_openai_client(self, config):
         try:
+            if not config.api_key:
+                provider_name = getattr(self, 'provider_name', 'Azure OpenAI')
+                print(f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:")
+                print(f"  janito --set-api-key YOUR_API_KEY -p azure-openai")
+                print(f"Or set the AZURE_OPENAI_API_KEY environment variable.")
+                raise ValueError(f"API key is required for provider '{provider_name}'")
+
             from openai import AzureOpenAI
 
             api_key_display = str(config.api_key)

janito/drivers/openai/driver.py

@@ -44,9 +44,10 @@ class OpenAIModelDriver(LLMDriver):
 
                 tool_classes = self.tools_adapter.get_tool_classes()
                 tool_schemas = generate_tool_schemas(tool_classes)
-                api_kwargs["tools"] = tool_schemas
+                if tool_schemas:  # Only add tools if we have actual schemas
+                    api_kwargs["tools"] = tool_schemas
             except Exception as e:
-                api_kwargs["tools"] = []
+                # Don't add empty tools array - some providers reject it
                 if hasattr(config, "verbose_api") and config.verbose_api:
                     print(f"[OpenAIModelDriver] Tool schema generation failed: {e}")
         # OpenAI-specific parameters
@@ -246,6 +247,13 @@ class OpenAIModelDriver(LLMDriver):
 
     def _instantiate_openai_client(self, config):
         try:
+            if not config.api_key:
+                provider_name = getattr(self, 'provider_name', 'OpenAI-compatible')
+                print(f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:")
+                print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name.lower()}")
+                print(f"Or set the {provider_name.upper()}_API_KEY environment variable.")
+                raise ValueError(f"API key is required for provider '{provider_name}'")
+
             api_key_display = str(config.api_key)
             if api_key_display and len(api_key_display) > 8:
                 api_key_display = api_key_display[:4] + "..." + api_key_display[-4:]

janito/drivers/zai/__init__.py

@@ -0,0 +1 @@
+# Z.AI driver package