janito 2.9.0__tar.gz → 2.10.0__tar.gz

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

@@ -3,23 +3,26 @@
 All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
-### 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.
 
+## [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
+
+### 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
 
-### Style
-- Fixed formatting in CLI command and privilege status modules.
+### 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.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.9.0
+Version: 2.10.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.10.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.10.0}/docs/supported-providers-models.md

@@ -18,11 +18,19 @@ This page lists the supported providers and their available models.
 - Claude 3 Haiku
 
 ## MoonshotAI
-- Moonshot-v1-8k
-- Moonshot-v1-32k
+- kimi-k2-turbo-preview
+- kimi-k2-turbo-preview
+- kimi-k1-8k
+- kimi-k1-32k
+- kimi-k1-128k
 
-## Groq
 - Llama-3-8b-8192
 - Llama-3-70b-8192
 
+## Alibaba
+- qwen-turbo
+- qwen-plus
+- qwen-max
+- qwen3-coder-plus
+
 <!-- Removed links to model_info.py files for all providers to avoid broken references. -->

janito-2.10.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.10.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.10.0}/janito/cli/main_cli.py

@@ -214,7 +214,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.10.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.10.0/janito/docs/PROVIDERS.md

@@ -0,0 +1,224 @@
+# Provider Configuration Guide
+
+This guide covers how to configure and use different LLM providers with Janito.
+
+## MoonshotAI (Recommended)
+
+**MoonshotAI** is the recommended default provider for Janito, offering excellent performance and competitive pricing.
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p moonshotai
+
+# Set as default provider
+janito --set provider=moonshotai
+janito --set model=kimi-k1-8k
+```
+
+### Available Models
+
+- **kimi-k1-8k**: Fast, general-purpose model (8k context)
+- **kimi-k1-32k**: Extended context model (32k context)
+- **kimi-k1-128k**: Long context model (128k context)
+- **kimi-k2-turbo-preview**: Latest enhanced model
+
+### Environment Variables
+```bash
+export MOONSHOTAI_API_KEY=your_key_here
+```
+
+## OpenAI
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p openai
+
+# Use specific model
+janito -p openai -m gpt-4 "Your prompt"
+```
+
+### Available Models
+
+- **gpt-4**: Most capable model
+- **gpt-4-turbo**: Faster, more efficient
+- **gpt-3.5-turbo**: Cost-effective option
+
+### Environment Variables
+```bash
+export OPENAI_API_KEY=your_key_here
+```
+
+## Anthropic
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p anthropic
+
+# Use Claude models
+janito -p anthropic -m claude-3-5-sonnet-20241022 "Your prompt"
+```
+
+### Available Models
+
+- **claude-3-5-sonnet-20241022**: Most capable
+- **claude-3-opus-20240229**: High performance
+- **claude-3-haiku-20240307**: Fast and cost-effective
+
+### Environment Variables
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+```
+
+## Google
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p google
+
+# Use Gemini models
+janito -p google -m gemini-2.0-flash-exp "Your prompt"
+```
+
+### Available Models
+
+- **gemini-2.0-flash-exp**: Latest experimental model
+- **gemini-1.5-pro**: Production-ready
+- **gemini-1.5-flash**: Fast and efficient
+
+### Environment Variables
+```bash
+export GOOGLE_API_KEY=your_key_here
+```
+
+## Azure OpenAI
+
+### Setup
+```bash
+# Set configuration
+janito --set-api-key YOUR_API_KEY -p azure-openai
+janito --set azure_deployment_name=your_deployment_name -p azure-openai
+```
+
+### Configuration
+
+Requires both API key and deployment name:
+
+- **API Key**: Your Azure OpenAI key
+- **Deployment Name**: Your Azure deployment name
+- **Base URL**: Your Azure endpoint URL
+
+### Environment Variables
+```bash
+export AZURE_OPENAI_API_KEY=your_key_here
+export AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
+```
+
+## Other Providers
+
+Janito also supports these providers through OpenAI-compatible APIs:
+
+### Alibaba Cloud
+```bash
+janito --set-api-key YOUR_KEY -p alibaba
+```
+
+### DeepSeek
+```bash
+janito --set-api-key YOUR_KEY -p deepseek
+```
+
+### Groq
+```bash
+janito --set-api-key YOUR_KEY -p groq
+```
+
+### Mistral
+```bash
+janito --set-api-key YOUR_KEY -p mistral
+```
+
+## Configuration Management
+
+### Check Current Configuration
+```bash
+janito --show-config
+```
+
+### List All Providers
+```bash
+janito --list-providers
+```
+
+### List Models for a Provider
+```bash
+janito -p moonshotai --list-models
+janito -p openai --list-models
+```
+
+### Switch Providers
+```bash
+# Temporarily for one command
+janito -p openai -m gpt-4 "Your prompt"
+
+# Permanently as default
+janito --set provider=openai
+janito --set model=gpt-4
+```
+
+## Advanced Configuration
+
+### Custom Base URLs
+For OpenAI-compatible providers, you can set custom base URLs:
+
+```bash
+janito --set base_url=https://your-custom-endpoint.com -p openai
+```
+
+### Provider-Specific Settings
+Each provider can have custom settings:
+
+```bash
+# Set temperature for a specific provider/model
+janito --set temperature=0.7 -p moonshotai -m kimi-k1-8k
+
+# Set max tokens
+janito --set max_tokens=2000 -p openai -m gpt-4
+```
+
+## Troubleshooting
+
+### Provider Not Found
+```bash
+# Check if provider is registered
+janito --list-providers
+
+# Re-register provider
+janito --set-api-key YOUR_KEY -p PROVIDER_NAME
+```
+
+### API Key Issues
+```bash
+# Check current API key
+janito --show-config
+
+# Reset API key
+janito --set-api-key NEW_KEY -p PROVIDER_NAME
+```
+
+### Model Not Available
+```bash
+# List available models for provider
+janito -p PROVIDER_NAME --list-models
+```
+
+## Best Practices
+
+1. **Start with MoonshotAI**: It's the recommended default for good reason
+2. **Use environment variables**: For CI/CD and containerized environments
+3. **Test different models**: Each has different strengths and pricing
+4. **Monitor usage**: Keep track of API costs and rate limits
+5. **Use profiles**: Set up different configurations for different use cases

{janito-2.9.0 → janito-2.10.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.10.0}/janito/drivers/openai/driver.py

@@ -246,6 +246,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.10.0/janito/mkdocs.yml

@@ -0,0 +1,40 @@
+site_name: Janito CLI Documentation
+site_description: A powerful command-line tool for running LLM-powered workflows
+site_url: https://janito.readthedocs.io/
+
+nav:
+  - Home: README.md
+  - Getting Started: docs/GETTING_STARTED.md
+  - Providers: docs/PROVIDERS.md
+  - Tools: docs/TOOLS_REFERENCE.md
+
+markdown_extensions:
+  - admonition
+  - codehilite
+  - toc:
+      permalink: true
+  - pymdownx.superfences
+  - pymdownx.tabbed:
+      alternate_style: true
+
+theme:
+  name: material
+  palette:
+    - scheme: default
+      primary: blue
+      accent: blue
+  features:
+    - navigation.tabs
+    - navigation.sections
+    - navigation.expand
+    - search.highlight
+    - search.share
+
+repo_url: https://github.com/ikignosis/janito
+repo_name: ikignosis/janito
+edit_uri: edit/main/docs/
+
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/ikignosis/janito

{janito-2.9.0 → janito-2.10.0}/janito/provider_registry.py

@@ -93,11 +93,21 @@ class ProviderRegistry:
                 model_specs = model_info_mod.MODEL_SPECS
             elif hasattr(model_info_mod, "MOONSHOTAI_MODEL_SPECS"):
                 model_specs = model_info_mod.MOONSHOTAI_MODEL_SPECS
-
-            if provider_name == "groq":
-                return "<any> (must be provided)"
+            
             if model_specs:
-                return ", ".join(model_specs.keys())
+                default_model = getattr(provider_class, "DEFAULT_MODEL", None)
+                model_names = []
+                
+                for model_key in model_specs.keys():
+                    if model_key == default_model:
+                        # Highlight the default model with color and star icon
+                        model_names.append(f"[bold green]⭐ {model_key}[/bold green]")
+                    else:
+                        model_names.append(model_key)
+                
+                if provider_name == "moonshotai":
+                    return ", ".join(model_names)
+                return ", ".join(model_names)
             return "-"
         except Exception as e:
             return "-"

{janito-2.9.0 → janito-2.10.0}/janito/providers/__init__.py

@@ -5,4 +5,4 @@ import janito.providers.azure_openai.provider
 import janito.providers.anthropic.provider
 import janito.providers.deepseek.provider
 import janito.providers.moonshotai.provider
-import janito.providers.groq.provider
+import janito.providers.alibaba.provider