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

janito/__init__.py

@@ -2,4 +2,4 @@
 Janito package.
 """
 
-__version__ = "0.14.0"
+__version__ = "0.15.0"

janito/cli/agent/initialization.py

@@ -20,21 +20,17 @@ console = Console()
 
 def get_api_key() -> str:
     """
-    Get the API key from global config, environment variable, or user input.
+    Get the API key from global config or user input.
     
     Returns:
         str: The API key
     """
-    # Get API key from global config, environment variable, or ask the user
+    # Get API key from global config or ask the user
     api_key = Config.get_api_key()
-    
-    # If not found in global config, try environment variable
-    if not api_key:
-        api_key = os.environ.get("ANTHROPIC_API_KEY")
         
-    # If still not found, prompt the user
+    # If not found, prompt the user
     if not api_key:
-        console.print("[bold yellow]⚠️ Warning:[/bold yellow] API key not found in global config or ANTHROPIC_API_KEY environment variable.")
+        console.print("[bold yellow]⚠️ Warning:[/bold yellow] API key not found in global config.")
         console.print("🔑 Please set it using --set-api-key or provide your API key now:")
         api_key = typer.prompt("Anthropic API Key", hide_input=True)
     

janito/cli/agent/query.py

@@ -11,6 +11,7 @@ from janito.token_report import generate_token_report
 from janito.tools import print_usage_stats
 from janito.cli.agent.initialization import initialize_agent
 from janito.cli.agent.conversation import load_messages, save_messages
+from janito.config import Config
 
 console = Console()
 
@@ -60,15 +61,17 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
         # Save messages after successful query and get the message ID
         message_id = save_messages(agent)
         
-        # Print token usage report
-        if show_tokens:
-            generate_token_report(agent, verbose=True, interrupted=False)
-        else:
-            # Show basic token usage
-            generate_token_report(agent, verbose=False, interrupted=False)
-        
-        # Print tool usage statistics
-        print_usage_stats()
+        # Check if usage reports should be shown
+        if Config().show_usage_report:
+            # Print token usage report
+            if show_tokens:
+                generate_token_report(agent, verbose=True, interrupted=False)
+            else:
+                # Show basic token usage
+                generate_token_report(agent, verbose=False, interrupted=False)
+            
+            # Print tool usage statistics
+            print_usage_stats()
         
 
             
@@ -79,22 +82,23 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
         # Save messages even if interrupted
         message_id = save_messages(agent)
         
-        # Print token usage report (even if interrupted)
-        try:
-            if show_tokens:
-                generate_token_report(agent, verbose=True, interrupted=True)
-            else:
-                # Show basic token usage
-                generate_token_report(agent, verbose=False, interrupted=True)
-            
-            # Print tool usage statistics
-            print_usage_stats()
-            
-
-        except Exception as e:
-            console.print(f"[bold red]❌ Error generating usage report:[/bold red] {str(e)}")
-            if verbose:
-                console.print(traceback.format_exc())
+        # Check if usage reports should be shown
+        if Config().show_usage_report:
+            # Print token usage report (even if interrupted)
+            try:
+                if show_tokens:
+                    generate_token_report(agent, verbose=True, interrupted=True)
+                else:
+                    # Show basic token usage
+                    generate_token_report(agent, verbose=False, interrupted=True)
+                
+                # Print tool usage statistics
+                print_usage_stats()
+                
+            except Exception as e:
+                console.print(f"[bold red]❌ Error generating usage report:[/bold red] {str(e)}")
+                if verbose:
+                    console.print(traceback.format_exc())
         
         # Exit with non-zero status to indicate interruption
         sys.exit(130)  # 130 is the standard exit code for SIGINT

janito/cli/app.py

@@ -8,7 +8,7 @@ from rich.console import Console
 import importlib.metadata
 
 from janito import __version__
-from janito.config import get_config
+from janito.config import Config
 from janito.cli.commands import handle_config_commands, validate_parameters
 from janito.cli.agent import handle_query
 from janito.cli.utils import get_stdin_termination_hint
@@ -22,9 +22,11 @@ def main(ctx: typer.Context,
          verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode with detailed output"),
          show_tokens: bool = typer.Option(False, "--show-tokens", "--tokens", help="Show detailed token usage and pricing information"),
          workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory"),
-         config_str: Optional[str] = typer.Option(None, "--set-config", help="Configuration string in format 'key=value', e.g., 'temperature=0.7' or 'profile=technical'"),
+         set_local_config: Optional[str] = typer.Option(None, "--set-local-config", help="Set a local configuration value in format 'key=value' (overrides global config)"),
+         set_global_config: Optional[str] = typer.Option(None, "--set-global-config", help="Set a global configuration value in format 'key=value' (used as default)"),
          show_config: bool = typer.Option(False, "--show-config", help="Show current configuration"),
-         reset_config: bool = typer.Option(False, "--reset-config", help="Reset configuration by removing the config file"),
+         reset_local_config: bool = typer.Option(False, "--reset-local-config", help="Reset local configuration by removing the local config file"),
+         reset_global_config: bool = typer.Option(False, "--reset-global-config", help="Reset global configuration by removing the global config file"),
          set_api_key: Optional[str] = typer.Option(None, "--set-api-key", help="Set the Anthropic API key globally in the user's home directory"),
          ask: bool = typer.Option(False, "--ask", help="Enable ask mode which disables tools that perform changes"),
          trust: bool = typer.Option(False, "--trust", "-t", help="Enable trust mode which suppresses tool outputs for a more concise execution"),
@@ -34,23 +36,22 @@ def main(ctx: typer.Context,
          role: Optional[str] = typer.Option(None, "--role", help="Set the assistant's role (default: 'software engineer')"),
          system: Optional[str] = typer.Option(None, "--system", "-s", help="Provide custom system instructions, bypassing the default file load method"),
          version: bool = typer.Option(False, "--version", help="Show the version and exit"),
-         continue_id: Optional[str] = typer.Option(None, "--continue-id", help="Continue a specific conversation with the given ID"),
          continue_flag: Optional[str] = typer.Option(None, "--continue", "-c", help="Continue a conversation. Can be used as: 1) --continue (to continue most recent), 2) --continue 123 (to continue conversation with ID 123), or 3) --continue \"query\" (to continue most recent with new query)"),
          history_flag: bool = typer.Option(False, "--history", help="Show a summary of conversations. Use --history for default (20) or --history n to specify count")):
     """
     Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
     """    
     # Set verbose mode in config
-    get_config().verbose = verbose
+    Config().verbose = verbose
     
     # Set ask mode in config
-    get_config().ask_mode = ask
+    Config().ask_mode = ask
     
     # Set trust mode in config
-    get_config().trust_mode = trust
+    Config().trust_mode = trust
     
     # Set no-tools mode in config
-    get_config().no_tools = no_tools
+    Config().no_tools = no_tools
     
     # Show a message if ask mode is enabled
     if ask:
@@ -124,22 +125,15 @@ def main(ctx: typer.Context,
                 # --continue with no args means continue most recent conversation
                 continue_conversation = ""
         
-        # Handle explicit --continue-id if specified (this takes precedence)
-        if "--continue-id" in args:
-            continue_id_idx = args.index("--continue-id")
-            if continue_id_idx + 1 < len(args) and not args[continue_id_idx + 1].startswith("-"):
-                continue_conversation = args[continue_id_idx + 1]
+        # --continue-id has been removed in favor of --continue
     except Exception as e:
         if verbose:
             console.print(f"[bold yellow]⚠️ Error parsing continue arguments: {str(e)}[/bold yellow]")
     
     # Fall back to typer-processed args if our parsing failed
     if continue_conversation is None:
-        # Handle the --continue-id option
-        if continue_id is not None:
-            continue_conversation = continue_id
         # Handle the --continue flag option (processed by typer)
-        elif continue_flag is not None:
+        if continue_flag is not None:
             if continue_flag == "":
                 continue_conversation = ""  # Empty string means continue most recent
             elif continue_flag.isdigit():
@@ -151,15 +145,17 @@ def main(ctx: typer.Context,
     # Handle configuration-related commands
     exit_after_config = handle_config_commands(
         ctx, 
-        reset_config, 
+        False,  # reset_config is removed, passing False for backward compatibility
+        reset_local_config,
+        reset_global_config,
         workspace, 
         show_config, 
         profile, 
         role, 
-        set_api_key, 
-        config_str, 
+        set_api_key,
+        set_local_config,
+        set_global_config,
         query,
-        continue_id,
         continue_flag,
         history_flag,
         history_count_override

janito/cli/commands/config.py

@@ -1,242 +1,30 @@
 """
 Configuration management functions for Janito CLI.
+This file is a thin wrapper around the actual implementation in janito.config.cli.commands
+to maintain backward compatibility.
 """
-import sys
-import os
-from pathlib import Path
-from typing import Optional
 import typer
-from rich.console import Console
-
-from janito.config import get_config, Config
-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
-
-console = Console()
-
-def handle_reset_config(reset_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --reset-config parameter.
-    
-    Args:
-        reset_config: Whether to reset the configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if reset_config:
-        try:
-            config_path = Path(get_config().workspace_dir) / ".janito" / "config.json"
-            if get_config().reset_config():
-                console.print(f"[bold green]✅ Configuration file removed: {config_path}[/bold green]")
-            else:
-                console.print(f"[bold yellow]⚠️ Configuration file does not exist: {config_path}[/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 = get_config()
-        console.print("[bold blue]⚙️  Current Configuration:[/bold blue]")
-        console.print(f"[bold]📁 Local Configuration File:[/bold] .janito/config.json")
-        console.print(f"[bold]🏠 Global Configuration File:[/bold] {Path.home() / '.janito' / 'config.json'}")
-        
-        # Show API key status
-        api_key_global = Config.get_api_key()
-        api_key_env = os.environ.get("ANTHROPIC_API_KEY")
-        if api_key_global:
-            console.print(f"[bold]🔑 API Key:[/bold] [green]Set in global config[/green]")
-        elif api_key_env:
-            console.print(f"[bold]🔑 API Key:[/bold] [yellow]Set in environment variable[/yellow]")
-        else:
-            console.print(f"[bold]🔑 API Key:[/bold] [red]Not set[/red]")
-            
-        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'}")
-
-        console.print(f"[bold]👤 Role:[/bold] {config.role}")
-        
-        # 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 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 to global configuration[/bold green]")
-            console.print(f"[dim]📁 Location: {Path.home() / '.janito' / 'config.json'}[/dim]")
-            
-            # 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_set_config(config_str: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-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:
-        try:
-            # Parse the config string
-            config_parts = config_str.split("=", 1)
-            if len(config_parts) != 2:
-                console.print(f"[bold red]Error:[/bold red] Invalid configuration format. Use 'key=value' format.")
-                return ctx.invoked_subcommand is None and not query
-                
-            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]
-                
-            if key == "profile":
-                try:
-                    get_config().set_profile(value)
-                    profile_data = get_config().get_available_profiles()[value.lower()]
-                    console.print(f"[bold green]✅ Profile set to '{value.lower()}'[/bold green]")
-                    console.print(f"[dim]📝 Description: {profile_data['description']}[/dim]")
-                except ValueError as e:
-                    console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            elif key == "temperature":
-                try:
-                    temp_value = float(value)
-                    if temp_value < 0.0 or temp_value > 1.0:
-                        console.print("[bold red]Error:[/bold red] Temperature must be between 0.0 and 1.0")
-                        return ctx.invoked_subcommand is None and not query
-                    
-                    get_config().temperature = temp_value
-                    console.print(f"[bold green]✅ Temperature set to {temp_value} and saved to configuration[/bold green]")
-                except ValueError:
-                    console.print(f"[bold red]Error:[/bold red] Invalid temperature value: {value}. Must be a float between 0.0 and 1.0.")
-            # top_k and top_p are now only accessible through profiles
-            elif key == "role":
-                get_config().role = value
-                console.print(f"[bold green]✅ Role set to '{value}' and saved to configuration[/bold green]")
-            else:
-                console.print(f"[bold yellow]Warning:[/bold yellow] Unsupported configuration key: {key}")
-            
-            # Exit after applying config changes 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)}")
-            
-    return False
+from typing import Optional
 
-def handle_config_commands(
-    ctx: typer.Context,
-    reset_config: bool,
-    workspace: Optional[str],
-    show_config: bool,
-    profile: Optional[str],
-    role: Optional[str],
-    set_api_key: Optional[str],
-    config_str: Optional[str],
-    query: Optional[str],
-    continue_id: 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: Whether to reset the configuration
-        workspace: Workspace directory path
-        show_config: Whether to show the configuration
-        profile: Profile name
-        role: Role name
-        set_api_key: API key
-        config_str: Configuration string in format 'key=value'
-        query: Query string
-        continue_id: Optional message ID to continue a specific conversation
-        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
-    """
-    # Handle each command and check if we should exit after it
-    if handle_reset_config(reset_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_config(config_str, ctx, query):
-        return True
-    
-    if handle_history(history_flag, history_count, ctx, query):
-        return True
-        
-    return False
+from janito.config.cli.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
+)
+
+# Re-export all functions for backward compatibility
+__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"
+]

janito/cli/commands/profile.py

@@ -1,72 +1,93 @@
-"""
-Profile and role management functions for Janito CLI.
-"""
-import sys
-from typing import Optional
-import typer
-from rich.console import Console
-
-from janito.config import get_config
-
-console = Console()
-
-def handle_profile(profile: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --profile parameter.
-    
-    Args:
-        profile: Profile name
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if profile is not None:
-        try:
-            # Apply profile without saving to config
-            config = get_config()
-            profile_data = config.get_available_profiles()[profile.lower()]
-            
-            # Set values directly without saving
-            config._temperature = profile_data["temperature"]
-            config._profile = profile.lower()
-            
-            console.print(f"[bold green]✅ Profile '{profile.lower()}' applied for this session only[/bold green]")
-            console.print(f"[dim]📝 Description: {profile_data['description']}[/dim]")
-            
-            # Exit after applying profile if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except ValueError as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def handle_role(role: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --role parameter.
-    
-    Args:
-        role: Role name
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if role is not None:
-        try:
-            # Set role directly without saving to config
-            config = get_config()
-            config._role = role
-            
-            console.print(f"[bold green]✅ Role '{role}' applied for this session only[/bold green]")
-            
-            # Exit after applying role 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)
-    
+"""
+Profile and role management functions for Janito CLI.
+"""
+import sys
+from typing import Optional
+import typer
+from rich.console import Console
+
+from janito.config import Config
+
+console = Console()
+
+def handle_profile(profile: Optional[str], ctx: typer.Context, query: Optional[str], config_type: str = "session") -> bool:
+    """
+    Handle the --profile parameter.
+    
+    Args:
+        profile: Profile name
+        ctx: Typer context
+        query: Query string
+        config_type: Type of configuration to update ("session", "local", or "global")
+        
+    Returns:
+        bool: True if the program should exit after this operation
+    """
+    if profile is not None:
+        try:
+            # Apply profile
+            config = Config()
+            profile_data = config.get_available_profiles()[profile.lower()]
+            
+            if config_type == "session":
+                # Set values directly without saving
+                config._temperature = profile_data["temperature"]
+                config._profile = profile.lower()
+                console.print(f"[bold green]✅ Profile '{profile.lower()}' applied for this session only[/bold green]")
+            elif config_type in ["local", "global"]:
+                # Set profile in the specified configuration
+                config.set_profile(profile.lower(), config_type)
+                console.print(f"[bold green]✅ Profile '{profile.lower()}' set in {config_type} configuration[/bold green]")
+            else:
+                console.print(f"[bold red]Error:[/bold red] Invalid config_type: {config_type}")
+                return ctx.invoked_subcommand is None and not query
+            
+            console.print(f"[dim]📝 Description: {profile_data['description']}[/dim]")
+            
+            # Exit after applying profile if no other operation is requested
+            return ctx.invoked_subcommand is None and not query
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+            sys.exit(1)
+    
+    return False
+
+def handle_role(role: Optional[str], ctx: typer.Context, query: Optional[str], config_type: str = "session") -> bool:
+    """
+    Handle the --role parameter.
+    
+    Args:
+        role: Role name
+        ctx: Typer context
+        query: Query string
+        config_type: Type of configuration to update ("session", "local", or "global")
+        
+    Returns:
+        bool: True if the program should exit after this operation
+    """
+    if role is not None:
+        try:
+            config = Config()
+            
+            if config_type == "session":
+                # Set role directly without saving
+                config._role = role
+                console.print(f"[bold green]✅ Role '{role}' applied for this session only[/bold green]")
+            elif config_type in ["local", "global"]:
+                # Set role in the specified configuration
+                if config_type == "local":
+                    config.role = role, "local"
+                else:
+                    config.role = role, "global"
+                console.print(f"[bold green]✅ Role '{role}' set in {config_type} configuration[/bold green]")
+            else:
+                console.print(f"[bold red]Error:[/bold red] Invalid config_type: {config_type}")
+                return ctx.invoked_subcommand is None and not query
+            
+            # Exit after applying role 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