janito 2.8.0__py3-none-any.whl → 2.10.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

@@ -72,11 +72,13 @@ class ChatSession:
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
 
-        profile, role, profile_system_prompt, no_tools_mode = self._select_profile_and_role(args, role)
+        profile, role, profile_system_prompt, no_tools_mode = (
+            self._select_profile_and_role(args, role)
+        )
         # Propagate no_tools_mode flag to downstream components via args
-        if args is not None and not hasattr(args, 'no_tools_mode'):
+        if args is not None and not hasattr(args, "no_tools_mode"):
             try:
-                setattr(args, 'no_tools_mode', no_tools_mode)
+                setattr(args, "no_tools_mode", no_tools_mode)
             except Exception:
                 pass
         conversation_history = self._create_conversation_history()
@@ -126,7 +128,9 @@ class ChatSession:
                     profile = "Developer with Python Tools"
                 else:
                     profile = (
-                        "Developer with Python Tools" if result == "Developer" else result
+                        "Developer with Python Tools"
+                        if result == "Developer"
+                        else result
                     )
             except ImportError:
                 profile = "Raw Model Session (no tools, no context)"
@@ -200,13 +204,27 @@ class ChatSession:
             cwd_display = "~" + cwd[len(home) :]
         else:
             cwd_display = cwd
-        self.console.print(f"[green]Working Dir:[/green] {cwd_display}")
+        from janito.cli.chat_mode.shell.commands._priv_status import (
+            get_privilege_status_message,
+        )
+
+        priv_status = get_privilege_status_message()
+        self.console.print(
+            f"[green]Working Dir:[/green] {cwd_display}  |  {priv_status}"
+        )
 
         from janito.cli.chat_mode.shell.commands._priv_check import (
             user_has_any_privileges,
         )
 
-        if not user_has_any_privileges():
+        perms = __import__(
+            "janito.tools.permissions", fromlist=["get_global_allowed_permissions"]
+        ).get_global_allowed_permissions()
+        if perms.execute:
+            self.console.print(
+                "[bold red]Commands/Code execution is enabled -  Be cautious[/bold red]"
+            )
+        if not (perms.read or perms.write or perms.execute):
             self.console.print(
                 "[yellow]Note: You currently have no privileges enabled. If you need to interact with files or the system, enable permissions using /read on, /write on, or /execute on.[/yellow]"
             )

janito/cli/chat_mode/shell/commands/_priv_status.py

@@ -0,0 +1,13 @@
+from janito.tools.permissions import get_global_allowed_permissions
+
+
+def get_privilege_status_message():
+    perms = get_global_allowed_permissions()
+    if perms.read and perms.write:
+        return "[cyan]Read-Write tools enabled[/cyan]"
+    elif perms.read:
+        return "[cyan]Read-Only tools enabled[/cyan]"
+    elif perms.write:
+        return "[cyan]Write-Only tools enabled[/cyan]"
+    else:
+        return "[yellow]No tool permissions enabled[/yellow]"

janito/cli/cli_commands/list_config.py

@@ -0,0 +1,31 @@
+from rich.console import Console
+from pathlib import Path
+import os
+
+
+def handle_list_config(args=None):
+    console = Console()
+    home = Path.home()
+    default_config = home / ".janito" / "config.json"
+    custom_dir = home / ".janito" / "configs"
+    console.print("[bold green]Janito configuration files:[/bold green]")
+    if default_config.exists():
+        console.print(f"[bold yellow]Default config:[/bold yellow] {default_config}")
+    else:
+        console.print(
+            f"[bold yellow]Default config:[/bold yellow] {default_config} [red](not found)"
+        )
+    if custom_dir.exists() and custom_dir.is_dir():
+        files = sorted(
+            f for f in custom_dir.iterdir() if f.is_file() and f.suffix == ".json"
+        )
+        if files:
+            console.print("[bold yellow]Custom configs:[/bold yellow]")
+            for f in files:
+                console.print(f"  - {f}")
+        else:
+            console.print("[bold yellow]Custom configs:[/bold yellow] (none found)")
+    else:
+        console.print(
+            f"[bold yellow]Custom configs:[/bold yellow] {custom_dir} [red](directory not found)"
+        )

janito/cli/cli_commands/list_profiles.py

@@ -0,0 +1,79 @@
+"""
+CLI Command: List available system prompt profiles (default and user-specific)
+"""
+
+from pathlib import Path
+import importlib.resources as resources
+from rich.console import Console
+from rich.table import Table
+
+
+_PREFIX = "system_prompt_template_"
+_SUFFIX = ".txt.j2"
+
+
+def _extract_profile_name(filename: str) -> str:
+    """Return the human-readable profile name from template file name."""
+    # Remove prefix & suffix and convert underscores back to spaces
+    if filename.startswith(_PREFIX):
+        filename = filename[len(_PREFIX) :]
+    if filename.endswith(_SUFFIX):
+        filename = filename[: -len(_SUFFIX)]
+    return filename.replace("_", " ")
+
+
+def _gather_default_profiles():
+    """Return list of built-in profile names bundled with janito."""
+    profiles = []
+    try:
+        package_files = resources.files("janito.agent.templates.profiles")
+        for path in package_files.iterdir():
+            name = path.name
+            if name.startswith(_PREFIX) and name.endswith(_SUFFIX):
+                profiles.append(_extract_profile_name(name))
+    except Exception:
+        # If for some reason the resources are not available fall back to empty list
+        pass
+    return sorted(profiles, key=str.lower)
+
+
+def _gather_user_profiles():
+    """Return list of user-defined profile names from ~/.janito/profiles directory."""
+    user_dir = Path.home() / ".janito" / "profiles"
+    profiles = []
+    if user_dir.exists() and user_dir.is_dir():
+        for path in user_dir.iterdir():
+            if (
+                path.is_file()
+                and path.name.startswith(_PREFIX)
+                and path.name.endswith(_SUFFIX)
+            ):
+                profiles.append(_extract_profile_name(path.name))
+    return sorted(profiles, key=str.lower)
+
+
+def _print_profiles_table(default_profiles, user_profiles):
+    console = Console()
+    table = Table(title="Available System Prompt Profiles", box=None, show_lines=False)
+    table.add_column("Profile Name", style="cyan", no_wrap=False)
+    table.add_column("Source", style="magenta", no_wrap=True)
+
+    for p in default_profiles:
+        table.add_row(p, "default")
+    for p in user_profiles:
+        table.add_row(p, "user")
+
+    console.print(table)
+
+
+def handle_list_profiles(args=None):
+    """Entry point for the --list-profiles CLI flag."""
+    default_profiles = _gather_default_profiles()
+    user_profiles = _gather_user_profiles()
+
+    if not default_profiles and not user_profiles:
+        print("No profiles found.")
+        return
+
+    _print_profiles_table(default_profiles, user_profiles)
+    return

janito/cli/cli_commands/show_config.py

@@ -34,21 +34,14 @@ def handle_show_config(args):
         provider_names = ProviderRegistry()._get_provider_names()
     except Exception:
         pass
+    from janito.provider_config import get_config_path
+
+    config_path = get_config_path()
     console.print("[bold green]Current configuration:[/bold green]")
+    console.print(f"[bold yellow]Config file:[/bold yellow] {config_path}")
     console.print(f"[bold yellow]Current provider:[/bold yellow] {provider!r}\n")
     if model is not None:
         console.print(f"[bold yellow]Global model:[/bold yellow] {model!r}\n")
-    if provider_names:
-        console.print("[bold cyan]Provider specific default models:[/bold cyan]")
-        for pname in provider_names:
-            eff_model = resolve_effective_model(pname)
-            prov_cfg = config.get_provider_config(pname)
-            prov_model = prov_cfg.get("model") if prov_cfg else None
-            extra = f" (override)" if prov_model else ""
-            sel = "[default]" if pname == provider else ""
-            console.print(
-                f"  [bold]{pname}[/bold]{' '+sel if sel else ''}: model = [magenta]{eff_model}[/magenta]{extra}"
-            )
 
     # Show disabled tools
     from janito.tools.disabled_tools import load_disabled_tools_from_config

janito/cli/core/getters.py

@@ -6,10 +6,18 @@ from janito.cli.cli_commands.list_providers import handle_list_providers
 from janito.cli.cli_commands.list_models import handle_list_models
 from janito.cli.cli_commands.list_tools import handle_list_tools
 from janito.cli.cli_commands.show_config import handle_show_config
+from janito.cli.cli_commands.list_config import handle_list_config
 from functools import partial
 from janito.provider_registry import ProviderRegistry
 
-GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
+GETTER_KEYS = [
+    "show_config",
+    "list_providers",
+    "list_profiles",
+    "list_models",
+    "list_tools",
+    "list_config",
+]
 
 
 def handle_getter(args, config_mgr=None):
@@ -24,11 +32,16 @@ def handle_getter(args, config_mgr=None):
             )
             sys.exit(1)
         provider_instance = ProviderRegistry().get_instance(provider)
+    # Lazy import to avoid overhead unless needed
+    from janito.cli.cli_commands.list_profiles import handle_list_profiles
+
     GETTER_DISPATCH = {
         "list_providers": partial(handle_list_providers, args),
         "list_models": partial(handle_list_models, args, provider_instance),
         "list_tools": partial(handle_list_tools, args),
+        "list_profiles": partial(handle_list_profiles, args),
         "show_config": partial(handle_show_config, args),
+        "list_config": partial(handle_list_config, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:

janito/cli/main_cli.py

@@ -98,6 +98,14 @@ definition = [
     (["--version"], {"action": "version", "version": None}),
     (["--list-tools"], {"action": "store_true", "help": "List all registered tools"}),
     (["--show-config"], {"action": "store_true", "help": "Show the current config"}),
+    (
+        ["--list-config"],
+        {"action": "store_true", "help": "List all configuration files"},
+    ),
+    (
+        ["--list-profiles"],
+        {"action": "store_true", "help": "List available system prompt profiles"},
+    ),
     (
         ["--list-providers"],
         {"action": "store_true", "help": "List supported LLM providers"},
@@ -159,6 +167,13 @@ definition = [
             "help": "Print debug info on event subscribe/submit methods",
         },
     ),
+    (
+        ["-c", "--config"],
+        {
+            "metavar": "NAME",
+            "help": "Use custom configuration file ~/.janito/configs/NAME.json instead of default config.json",
+        },
+    ),
 ]
 
 MODIFIER_KEYS = [
@@ -177,7 +192,14 @@ MODIFIER_KEYS = [
     "write",
 ]
 SETTER_KEYS = ["set", "set_provider", "set_api_key", "unset"]
-GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
+GETTER_KEYS = [
+    "show_config",
+    "list_providers",
+    "list_profiles",
+    "list_models",
+    "list_tools",
+    "list_config",
+]
 
 
 class RunMode(enum.Enum):
@@ -192,12 +214,35 @@ 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()
         self.args = self.parser.parse_args()
         self._set_all_arg_defaults()
+        # Support custom config file via -c/--config
+        if getattr(self.args, "config", None):
+            from janito import config as global_config
+            from janito.config_manager import ConfigManager
+            import sys
+            import importlib
+
+            config_name = self.args.config
+            # Re-initialize the global config singleton
+            new_config = ConfigManager(config_name=config_name)
+            # Ensure the config path is updated when the singleton already existed
+            from pathlib import Path
+
+            new_config.config_path = (
+                Path.home() / ".janito" / "configs" / f"{config_name}.json"
+            )
+            # Reload config from the selected file
+            new_config._load_file_config()
+            # Patch the global singleton reference
+            import janito.config as config_module
+
+            config_module.config = new_config
+            sys.modules["janito.config"].config = new_config
         # Support reading prompt from stdin if no user_prompt is given
         import sys
 
@@ -271,7 +316,11 @@ class JanitoCLI:
                 return
         # Special handling: provider is not required for list_providers, list_tools, show_config
         if run_mode == RunMode.GET and (
-            self.args.list_providers or self.args.list_tools or self.args.show_config
+            self.args.list_providers
+            or self.args.list_tools
+            or self.args.list_profiles
+            or self.args.show_config
+            or self.args.list_config
         ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)

janito/config.py

@@ -2,4 +2,5 @@
 from janito.config_manager import ConfigManager
 
 # Only one global instance! Used by CLI, provider_config, others:
+# If you want to use a custom config, re-initialize this singleton with config_name or config_path before use.
 config = ConfigManager(config_path=None)

janito/config_manager.py

@@ -20,13 +20,22 @@ class ConfigManager:
                 cls._instance = super(ConfigManager, cls).__new__(cls)
         return cls._instance
 
-    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
+    def __init__(
+        self, config_path=None, defaults=None, runtime_overrides=None, config_name=None
+    ):
         # Lazy single-init
         if hasattr(self, "_initialized") and self._initialized:
             return
         self._initialized = True
 
-        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
+        if config_name:
+            self.config_path = (
+                Path.home() / ".janito" / "configs" / f"{config_name}.json"
+            )
+        else:
+            self.config_path = Path(
+                config_path or Path.home() / ".janito" / "config.json"
+            )
         self.defaults = dict(defaults) if defaults else {}
         self.file_config = {}
         self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}

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