janito 0.15.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

janito/config/__init__.py

@@ -1,16 +0,0 @@
-"""
-Configuration module for Janito.
-Provides a singleton Config class to access configuration values.
-Supports both local and global configuration with merging functionality.
-"""
-from .core.singleton import Config
-from .profiles.definitions import PROFILES
-from .profiles.manager import get_available_profiles, get_profile
-
-# Convenience function to get the config instance
-def get_config() -> Config:
-    """Get the singleton Config instance."""
-    return Config()
-
-# Re-export the Config class for backward compatibility
-__all__ = ["Config", "PROFILES", "get_config", "get_available_profiles", "get_profile"]

janito/config/cli/__init__.py

@@ -1,28 +0,0 @@
-"""
-CLI integration for Janito configuration.
-Provides command handling and validation for configuration-related CLI commands.
-"""
-from .commands import (
-    handle_reset_config,
-    handle_reset_local_config,
-    handle_reset_global_config,
-    handle_show_config,
-    handle_set_api_key,
-    handle_set_local_config,
-    handle_set_global_config,
-    handle_config_commands
-)
-from .validators import validate_temperature, validate_boolean_value
-
-__all__ = [
-    "handle_reset_config",
-    "handle_reset_local_config",
-    "handle_reset_global_config",
-    "handle_show_config",
-    "handle_set_api_key",
-    "handle_set_local_config",
-    "handle_set_global_config",
-    "handle_config_commands",
-    "validate_temperature",
-    "validate_boolean_value"
-]

janito/config/cli/commands.py

@@ -1,397 +0,0 @@
-"""
-Command handling functions for configuration-related CLI commands.
-"""
-import sys
-import os
-from pathlib import Path
-from typing import Optional, Dict, Any
-import typer
-from rich.console import Console
-
-from ..core.singleton import Config
-from .validators import validate_temperature, validate_boolean_value, validate_config_key_value
-
-console = Console()
-
-def handle_reset_config(reset_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --reset-config parameter (deprecated, kept for backward compatibility).
-    This function now does nothing as --reset-config has been replaced by --reset-local-config and --reset-global-config.
-    
-    Args:
-        reset_config: Whether to reset the configuration (ignored)
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: Always returns False
-    """
-    # This function is kept for backward compatibility but does nothing
-    # Users should use --reset-local-config or --reset-global-config instead
-    return False
-
-def handle_reset_local_config(reset_local_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --reset-local-config parameter.
-    This removes the local configuration file (.janito/config.json) in the current workspace.
-    
-    Args:
-        reset_local_config: Whether to reset the local configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if reset_local_config:
-        try:
-            config_path = Path(Config().workspace_dir) / ".janito" / "config.json"
-            if Config().reset_local_config():
-                console.print(f"[bold green]✅ Local configuration reset[/bold green]")
-            else:
-                console.print(f"[bold yellow]⚠️ No local configuration found[/bold yellow]")
-        except Exception as e:
-            console.print(f"[bold red]Error removing configuration file:[/bold red] {str(e)}")
-        
-        # Exit after resetting config if no other operation is requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_reset_global_config(reset_global_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --reset-global-config parameter.
-    This removes the global configuration file (~/.janito/config.json) in the user's home directory.
-    
-    Args:
-        reset_global_config: Whether to reset the global configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if reset_global_config:
-        try:
-            config_path = Path.home() / ".janito" / "config.json"
-            if Config().reset_global_config():
-                console.print(f"[bold green]✅ Global configuration reset[/bold green]")
-            else:
-                console.print(f"[bold yellow]⚠️ No global configuration found[/bold yellow]")
-        except Exception as e:
-            console.print(f"[bold red]Error removing configuration file:[/bold red] {str(e)}")
-        
-        # Exit after resetting config if no other operation is requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_show_config(show_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --show-config parameter.
-    
-    Args:
-        show_config: Whether to show the configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if show_config:
-        config = Config()
-        console.print("[bold blue]⚙️  Current Configuration:[/bold blue]")
-        
-        # Show configuration file paths
-        local_config_path = Path(config.workspace_dir) / ".janito" / "config.json"
-        global_config_path = Path.home() / ".janito" / "config.json"
-        console.print(f"[bold]📁 Local Configuration File:[/bold] {local_config_path}")
-        console.print(f"[bold]🏠 Global Configuration File:[/bold] {global_config_path}")
-        
-        # Show API key status
-        api_key_global = Config().get_api_key()
-        if api_key_global:
-            console.print(f"[bold]🔑 API Key:[/bold] [green]Set in global config[/green]")
-        else:
-            console.print(f"[bold]🔑 API Key:[/bold] [red]Not set[/red]")
-        
-        # Show merged configuration (effective settings)
-        console.print("\n[bold blue]🔄 Merged Configuration (Effective Settings):[/bold blue]")
-        console.print(f"[bold]🔊 Verbose Mode:[/bold] {'Enabled' if config.verbose else 'Disabled'}")
-        console.print(f"[bold]❓ Ask Mode:[/bold] {'Enabled' if config.ask_mode else 'Disabled'} [dim](runtime-only setting)[/dim]")
-        console.print(f"[bold]📊 Show Usage Report:[/bold] {'Enabled' if config.show_usage_report else 'Disabled'}")
-        console.print(f"[bold]👤 Role:[/bold] [bold white on blue]{config.role}[/bold white on blue]")
-        console.print(f"[bold]🌡️ Temperature:[/bold] {config.temperature}")
-        
-        # Show profile information if one is set
-        if config.profile:
-            profile_data = config.get_available_profiles()[config.profile]
-            console.print(f"[bold]📋 Active Profile:[/bold] {config.profile} - {profile_data['description']}")
-        
-        # Show local configuration
-        local_config = config.get_local_config()
-        if local_config:
-            console.print("\n[bold blue]📁 Local Configuration:[/bold blue]")
-            for key, value in local_config.items():
-                # Don't show API key or runtime-only settings like ask_mode
-                if key != "api_key" and key != "ask_mode":
-                    console.print(f"[bold]🔹 {key}:[/bold] {value}")
-        else:
-            console.print("\n[bold blue]📁 Local Configuration:[/bold blue] [dim]Empty[/dim]")
-        
-        # Show global configuration
-        global_config = config.get_global_config()
-        if global_config:
-            console.print("\n[bold blue]🏠 Global Configuration:[/bold blue]")
-            for key, value in global_config.items():
-                # Don't show API key or runtime-only settings like ask_mode
-                if key != "api_key" and key != "ask_mode":
-                    console.print(f"[bold]🔹 {key}:[/bold] {value}")
-        else:
-            console.print("\n[bold blue]🏠 Global Configuration:[/bold blue] [dim]Empty[/dim]")
-        
-        # Show available profiles
-        profiles = config.get_available_profiles()
-        if profiles:
-            console.print("\n[bold blue]📋 Available Parameter Profiles:[/bold blue]")
-            for name, data in profiles.items():
-                console.print(f"[bold]🔹 {name}[/bold] - {data['description']}")
-            
-        # Exit if this was the only operation requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_set_api_key(set_api_key: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-api-key parameter.
-    
-    Args:
-        set_api_key: API key
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if set_api_key is not None:
-        try:
-            Config().set_api_key(set_api_key)
-            console.print(f"[bold green]✅ API key saved[/bold green]")
-            
-            # Exit after setting API key if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def _handle_config_setting(key: str, value: str, config_type: str = "local") -> bool:
-    """
-    Handle setting a configuration value.
-    
-    Args:
-        key: Configuration key
-        value: Configuration value
-        config_type: Type of configuration to update ("local" or "global")
-        
-    Returns:
-        bool: True if the operation was successful
-    """
-    try:
-        if key == "profile":
-            try:
-                Config().set_profile(value, config_type)
-                profile_data = Config().get_available_profiles()[value.lower()]
-                console.print(f"[bold green]✅ Profile set to '{value.lower()}'[/bold green]")
-                return True
-            except ValueError as e:
-                console.print(f"[bold red]Error:[/bold red] {str(e)}")
-                return False
-        elif key == "temperature":
-            is_valid, result = validate_temperature(value)
-            if not is_valid:
-                console.print(f"[bold red]Error:[/bold red] {result}")
-                return False
-            
-            if config_type == "local":
-                Config().temperature = result, "local"
-            else:
-                Config().temperature = result, "global"
-            console.print(f"[bold green]✅ Temperature set to {result}[/bold green]")
-            return True
-        # top_k and top_p are now only accessible through profiles
-        elif key == "role":
-            if config_type == "local":
-                Config().role = value, "local"
-            else:
-                Config().role = value, "global"
-            console.print(f"[bold green]✅ Role set to '{value}'[/bold green]")
-            return True
-        elif key == "ask_mode":
-            is_valid, result = validate_boolean_value(value)
-            if not is_valid:
-                console.print(f"[bold red]Error:[/bold red] {result}")
-                return False
-            
-            # ask_mode is a runtime-only setting, inform the user
-            console.print(f"[bold yellow]⚠️ Ask mode is a runtime-only setting and cannot be stored in configuration.[/bold yellow]")
-            console.print(f"[bold yellow]Use the --ask flag when running the command instead.[/bold yellow]")
-            return True
-        elif key == "show_usage_report":
-            is_valid, result = validate_boolean_value(value)
-            if not is_valid:
-                console.print(f"[bold red]Error:[/bold red] {result}")
-                return False
-            
-            if config_type == "local":
-                Config().show_usage_report = result, "local"
-            else:
-                Config().show_usage_report = result, "global"
-            console.print(f"[bold green]✅ Show usage report set to {result}[/bold green]")
-            return True
-        else:
-            # For other keys, set them directly in the configuration
-            if config_type == "local":
-                Config().set_local_config(key, value)
-            else:
-                Config().set_global_config(key, value)
-            console.print(f"[bold green]✅ {key} set to '{value}'[/bold green]")
-            return True
-    except Exception as e:
-        console.print(f"[bold red]Error:[/bold red] {str(e)}")
-        return False
-
-
-def handle_set_local_config(config_str: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-local-config parameter.
-    
-    Args:
-        config_str: Configuration string in format 'key=value'
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if config_str is not None:
-        is_valid, result = validate_config_key_value(config_str)
-        if not is_valid:
-            console.print(f"[bold red]Error:[/bold red] {result}")
-            return ctx.invoked_subcommand is None and not query
-        
-        key, value = result
-        _handle_config_setting(key, value, "local")
-        
-        # Exit after applying config changes if no other operation is requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_set_global_config(config_str: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-global-config parameter.
-    
-    Args:
-        config_str: Configuration string in format 'key=value'
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if config_str is not None:
-        is_valid, result = validate_config_key_value(config_str)
-        if not is_valid:
-            console.print(f"[bold red]Error:[/bold red] {result}")
-            return ctx.invoked_subcommand is None and not query
-        
-        key, value = result
-        _handle_config_setting(key, value, "global")
-        
-        # Exit after applying config changes if no other operation is requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_config_commands(
-    ctx: typer.Context,
-    reset_config: bool,
-    reset_local_config: bool = False,
-    reset_global_config: bool = False,
-    workspace: Optional[str] = None,
-    show_config: bool = False,
-    profile: Optional[str] = None,
-    role: Optional[str] = None,
-    set_api_key: Optional[str] = None,
-    set_local_config: Optional[str] = None,
-    set_global_config: Optional[str] = None,
-    query: Optional[str] = None,
-    continue_flag: Optional[str] = None,
-    history_flag: bool = False,
-    history_count: Optional[int] = None
-) -> bool:
-    """
-    Handle all configuration-related commands.
-    
-    Args:
-        ctx: Typer context
-        reset_config: Deprecated parameter kept for backward compatibility
-        reset_local_config: Whether to reset the local configuration
-        reset_global_config: Whether to reset the global configuration
-        workspace: Workspace directory path
-        show_config: Whether to show the configuration
-        profile: Profile name
-        role: Role name
-        set_api_key: API key
-        set_local_config: Configuration string in format 'key=value' for local config
-        set_global_config: Configuration string in format 'key=value' for global config
-        query: Query string
-        continue_flag: Optional string that can be empty (flag only) or contain a chat ID
-        history_flag: Whether to show conversation history (--history flag)
-        history_count: Number of history entries to display (value after --history)
-        
-    Returns:
-        bool: True if the program should exit after these operations
-    """
-    # Import these here to avoid circular imports
-    from janito.cli.commands.workspace import handle_workspace
-    from janito.cli.commands.profile import handle_profile, handle_role
-    from janito.cli.commands.history import handle_history
-    
-    # Handle each command and check if we should exit after it
-    if handle_reset_config(reset_config, ctx, query):
-        return True
-    
-    if handle_reset_local_config(reset_local_config, ctx, query):
-        return True
-    
-    if handle_reset_global_config(reset_global_config, ctx, query):
-        return True
-        
-    handle_workspace(workspace)
-    
-    if handle_show_config(show_config, ctx, query):
-        return True
-        
-    if handle_profile(profile, ctx, query):
-        return True
-        
-    if handle_role(role, ctx, query):
-        return True
-        
-    if handle_set_api_key(set_api_key, ctx, query):
-        return True
-    
-    if handle_set_local_config(set_local_config, ctx, query):
-        return True
-    
-    if handle_set_global_config(set_global_config, ctx, query):
-        return True
-    
-    if handle_history(history_flag, history_count, ctx, query):
-        return True
-        
-    return False

janito/config/cli/validators.py

@@ -1,77 +0,0 @@
-"""
-Validation functions for configuration-related CLI commands.
-"""
-from typing import Tuple, Any, Union, Optional
-
-def validate_temperature(value: str) -> Tuple[bool, Union[float, str]]:
-    """
-    Validate a temperature value from a string input.
-    
-    Args:
-        value: String representation of a temperature value
-        
-    Returns:
-        Tuple of (is_valid, result)
-        If valid, result is the float value
-        If invalid, result is an error message
-    """
-    try:
-        temp_value = float(value)
-        if temp_value < 0.0 or temp_value > 1.0:
-            return False, "Temperature must be between 0.0 and 1.0"
-        return True, temp_value
-    except ValueError:
-        return False, f"Invalid temperature value: {value}. Must be a float between 0.0 and 1.0."
-
-def validate_boolean_value(value: str) -> Tuple[bool, Union[bool, str]]:
-    """
-    Validate a boolean value from a string input.
-    
-    Args:
-        value: String representation of a boolean value
-        
-    Returns:
-        Tuple of (is_valid, result)
-        If valid, result is the boolean value
-        If invalid, result is an error message
-    """
-    try:
-        lower_value = value.lower()
-        if lower_value in ["true", "yes", "1", "on", "y"]:
-            return True, True
-        elif lower_value in ["false", "no", "0", "off", "n"]:
-            return True, False
-        else:
-            return False, f"Invalid boolean value: {value}. Use 'true', 'false', 'yes', 'no', '1', '0', 'on', or 'off'."
-    except Exception:
-        return False, f"Invalid boolean value: {value}. Use 'true', 'false', 'yes', 'no', '1', '0', 'on', or 'off'."
-
-def validate_config_key_value(config_str: str) -> Tuple[bool, Union[Tuple[str, str], str]]:
-    """
-    Validate a configuration key-value pair from a string input.
-    
-    Args:
-        config_str: String in the format 'key=value'
-        
-    Returns:
-        Tuple of (is_valid, result)
-        If valid, result is a tuple of (key, value)
-        If invalid, result is an error message
-    """
-    try:
-        # Parse the config string
-        config_parts = config_str.split("=", 1)
-        if len(config_parts) != 2:
-            return False, "Invalid configuration format. Use 'key=value' format."
-            
-        key = config_parts[0].strip()
-        value = config_parts[1].strip()
-        
-        # Remove quotes if present
-        if (value.startswith("'") and value.endswith("'")) or \
-           (value.startswith('"') and value.endswith('"')):
-            value = value[1:-1]
-        
-        return True, (key, value)
-    except Exception as e:
-        return False, f"Invalid configuration format: {str(e)}"

janito/config/core/__init__.py

@@ -1,23 +0,0 @@
-"""
-Core configuration components for Janito.
-Provides the base Config class and related functionality.
-"""
-from .singleton import Config
-from .properties import ConfigProperties
-from .file_operations import (
-    get_global_config_path,
-    get_local_config_path,
-    load_config_file,
-    save_config_file,
-    merge_configs
-)
-
-__all__ = [
-    "Config", 
-    "ConfigProperties",
-    "get_global_config_path",
-    "get_local_config_path",
-    "load_config_file",
-    "save_config_file",
-    "merge_configs"
-]

janito/config/core/file_operations.py

@@ -1,90 +0,0 @@
-"""
-File operations for configuration management.
-"""
-import json
-from pathlib import Path
-from typing import Dict, Any, Optional
-
-def get_global_config_path() -> Path:
-    """
-    Get the path to the global configuration file.
-    
-    Returns:
-        Path object pointing to the global configuration file (~/.janito/config.json)
-    """
-    return Path.home() / ".janito" / "config.json"
-
-def get_local_config_path(workspace_dir: str) -> Path:
-    """
-    Get the path to the local configuration file.
-    
-    Args:
-        workspace_dir: Current workspace directory
-        
-    Returns:
-        Path object pointing to the local configuration file (.janito/config.json)
-    """
-    return Path(workspace_dir) / ".janito" / "config.json"
-
-def load_config_file(config_path: Path) -> Dict[str, Any]:
-    """
-    Load configuration from a file.
-    
-    Args:
-        config_path: Path to the configuration file
-        
-    Returns:
-        Dict containing the configuration, empty dict if file doesn't exist or error occurs
-    """
-    if not config_path.exists():
-        return {}
-    
-    try:
-        with open(config_path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except Exception as e:
-        print(f"Warning: Failed to load configuration from {config_path}: {str(e)}")
-        return {}
-
-def save_config_file(config_path: Path, config_data: Dict[str, Any]) -> bool:
-    """
-    Save configuration to a file.
-    
-    Args:
-        config_path: Path to the configuration file
-        config_data: Configuration data to save
-        
-    Returns:
-        True if successful, False otherwise
-    """
-    try:
-        # Ensure directory exists
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        # Write configuration to file
-        with open(config_path, "w", encoding="utf-8") as f:
-            json.dump(config_data, f, indent=2)
-        return True
-    except Exception as e:
-        print(f"Warning: Failed to save configuration to {config_path}: {str(e)}")
-        return False
-
-def merge_configs(global_config: Dict[str, Any], local_config: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Merge global and local configurations with local taking precedence.
-    
-    Args:
-        global_config: Global configuration dictionary
-        local_config: Local configuration dictionary
-        
-    Returns:
-        Merged configuration dictionary
-    """
-    # Start with global config
-    merged_config = global_config.copy()
-    
-    # Override with local config
-    for key, value in local_config.items():
-        merged_config[key] = value
-    
-    return merged_config