janito 2.9.0__tar.gz → 2.12.0__tar.gz

{janito-2.9.0 → janito-2.12.0}/CHANGELOG.md

@@ -3,23 +3,47 @@
 All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
+
+## [2.11.0] - 2025-08-04
+
+### Added
+
+- **Z.AI Provider**: Added complete support for Z.AI with GLM-4.5, GLM-4, and GLM-4V models
+  - GLM-4.5: 128k context with thinking support for advanced reasoning
+  - GLM-4: General-purpose model with 128k context
+  - GLM-4V: Vision model for image understanding with 128k context
+- **Alibaba Cloud Provider**: Added support for Alibaba Cloud's Qwen models
+  - qwen-turbo, qwen-plus, qwen-max, and qwen3-coder-plus models
+- Updated supported providers documentation to include new Z.AI and Alibaba Cloud providers
+
 ### Changed
-- Updated project URLs, author email, and documentation for migration to ikignosis organization.
-- Updated repository links in documentation and configuration files to point to ikignosis GitHub organization.
-- Changed maintainer email in provider modules to janito@ikignosis.org.
-- Updated homepage and repo_url in pyproject.toml and mkdocs.yml to new organization URLs.
 
+- Enhanced provider registry with new visual indicators and improved model listing
+- Updated documentation to reflect new provider additions and model availability
+
+### Removed
+
+- Removed deprecated PROVIDERS.md file from janito/docs (content merged into supported-providers-models.md)
+
+## [2.9.0] - 2025-07-16
 ### Added
-- Added CNAME file for docs.ikignosis.org custom domain.
-- Added CLI command to list available system prompt profiles (`list_profiles.py`).
-- Added privilege status message utility (`_priv_status.py`).
+- Added new `kimi-k2-turbo-preview` model to MoonshotAI provider
+- Added visual indicators for default models in provider registry with star icons
 
-### Style
-- Fixed formatting in CLI command and privilege status modules.
+### Changed
+- Updated default MoonshotAI model from `kimi-k2-0711-preview` to `kimi-k2-turbo-preview`
+- Updated all documentation to reflect new MoonshotAI model names and recommendations
+- Updated project URLs, author email, and documentation for migration to ikignosis organization
+- Updated repository links in documentation and configuration files to point to ikignosis GitHub organization
+- Changed maintainer email in provider modules to janito@ikignosis.org
+- Updated homepage and repo_url in pyproject.toml and mkdocs.yml to new organization URLs
+
+### Fixed
+- Fixed duplicate entries in supported providers documentation
+- Fixed formatting in CLI command and privilege status modules
 
 ## [2.8.0] - 2025-07-16
 ### Added
-- **Groq provider**: New provider with support for moonshotai/kimi-k2-instruct model.
 - **Parallel tool calls**: Enabled for OpenAI provider when tools are available.
 - **No-tools mode**: New CLI option to disable all tool usage.
 - **Disabled tools functionality**: Support for selectively disabling specific tools.

{janito-2.9.0/janito.egg-info → janito-2.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.9.0
+Version: 2.12.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.9.0 → janito-2.12.0}/docs/guides/terminal-shell.md

@@ -32,6 +32,7 @@ You can use these commands at any time (prefix with `/` or just type the name):
 | `/lang <code>`         | Change the interface language (e.g., `/lang pt`, `/lang en`)      |
 | `/clear`               | Clear the terminal screen                                        |
 | `/multi`               | Enter multiline input mode (write multi-line text, Esc+Enter)    |
+| `--multi` (CLI arg)    | Start chat mode with multiline input as default (no need for /multi) |
 | `/config`              | Show or set configuration (see: `/config show`, `/config set local|global key=value`) |
 | `/edit <filename>`     | Open a file in the browser-based editor                          |
 | `/view`                | Print the current LLM conversation history                       |

{janito-2.9.0 → janito-2.12.0}/docs/moonshotai-setup.md

@@ -35,7 +35,8 @@ janito -p moonshotai "Your prompt here"
 
 Janito supports the following MoonshotAI models:
 
-- `kimi-k2-0711-preview` (default) - Advanced reasoning model with 128k context window
+- `kimi-k2-turbo-preview` (default) - Advanced reasoning model with 128k context window
+- `kimi-k2-turbo-preview` - Turbo version of the advanced reasoning model with 128k context window
 - `kimi-k1-8k` - Standard model with 8k context window
 - `kimi-k1-32k` - Standard model with 32k context window
 - `kimi-k1-128k` - Standard model with 128k context window

{janito-2.9.0 → janito-2.12.0}/docs/reference/cli-options.md

@@ -20,6 +20,7 @@ These options are useful for one-off runs, scripting, or experimentation. They t
 | `--verbose-agent` | Print info messages for agent event and message part handling. |
 | `-z`, `--zero` | IDE zero mode: disables system prompt & all tools for raw LLM interaction |
 | `-u`, `--unrestricted-paths` | Disable path security: allow tool arguments to use any file/directory path (DANGEROUS). See [Security](../security.md) for details. |
+| `--multi` | Start chat mode with multiline input as default (no need for /multi command) |
 | `-r`, `--read` | Enable tools that require read permissions (default: off) |
 | `-w`, `--write` | Enable tools that require write permissions (default: off) |
 | `-x`, `--exec` | Enable execution/run tools (allows running code or shell tools from the CLI). (default: off) |
@@ -50,7 +51,7 @@ janito [options] [prompt]
 janito -p openai -m gpt-3.5-turbo "Your prompt here"
 janito -c myproject -p openai "Prompt for my project (uses ~/.janito/configs/myproject.json)"
 janito --list-tools
-janito --web  # Enable clickable file links via web viewer
+janito --multi  # Start chat mode with multiline input as default
 janito -u -x --read --write "Run a tool with unrestricted paths (DANGEROUS)"
 ```
 

{janito-2.9.0 → janito-2.12.0}/docs/supported-providers-models.md

@@ -3,26 +3,46 @@
 This page lists the supported providers and their available models.
 
 ## OpenAI
+
 - GPT-3.5 Turbo
 - GPT-4
 - GPT-4 Turbo
 
 ## Google
+
 - Gemini Pro
 - Gemini 1.5 Pro
 
 ## Anthropic
+
 - Claude 2
 - Claude 3 Opus
 - Claude 3 Sonnet
 - Claude 3 Haiku
 
 ## MoonshotAI
-- Moonshot-v1-8k
-- Moonshot-v1-32k
 
-## Groq
+- kimi-k2-turbo-preview
+- kimi-k2-turbo-preview
+- kimi-k1-8k
+- kimi-k1-32k
+- kimi-k1-128k
+
 - Llama-3-8b-8192
 - Llama-3-70b-8192
 
+## Alibaba
+
+- qwen-turbo
+- qwen-plus
+- qwen-max
+- qwen3-coder-plus
+- qwen3-coder-480b-a35b-instruct
+
+## Z.AI
+
+- glm-4.5
+- glm-4
+- glm-4v
+
 <!-- Removed links to model_info.py files for all providers to avoid broken references. -->

janito-2.12.0/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-2.9.0 → janito-2.12.0}/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-2.9.0 → janito-2.12.0}/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-2.12.0/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-2.9.0 → janito-2.12.0}/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-2.9.0 → janito-2.12.0}/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-2.12.0/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-2.9.0 → janito-2.12.0}/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-2.9.0 → janito-2.12.0}/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-2.12.0/janito/drivers/zai/__init__.py

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