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

janito/cli/commands/history.py

@@ -0,0 +1,119 @@
+"""
+History management functions for Janito CLI.
+"""
+import sys
+import json
+import datetime
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from janito.config import get_config
+
+console = Console()
+
+def handle_history(history_flag: bool, history_count: Optional[int], ctx: typer.Context, query: Optional[str]) -> bool:
+    """
+    Handle the --history parameter to display conversation history.
+    
+    Args:
+        history_flag: Whether to show history (--history flag)
+        history_count: Number of history entries to display (value after --history)
+        ctx: Typer context
+        query: Query string
+        
+    Returns:
+        bool: True if the program should exit after this operation
+    """
+    # Check if --history was used
+    if history_flag:
+        try:
+            # If --history is used with a count value passed from app.py, use that
+            # If no count is specified, default to 20
+            count = 20 if history_count is None else history_count
+            
+            # Get the workspace directory
+            workspace_dir = Path(get_config().workspace_dir)
+            janito_dir = workspace_dir / ".janito"
+            messages_dir = janito_dir / "last_messages"
+            
+            if not messages_dir.exists() or not any(messages_dir.iterdir()):
+                console.print("[bold yellow]⚠️ No conversation history found[/bold yellow]")
+                return True  # Always exit after displaying history
+            
+            # Find all message files and sort by timestamp (newest first)
+            message_files = [f for f in messages_dir.iterdir() if f.is_file() and f.suffix == '.json']
+            message_files.sort(key=lambda x: x.stem, reverse=True)
+            
+            # Limit to the requested number of entries
+            message_files = message_files[:count]
+            
+            # Create a table for the history
+            table = Table(title=f"Conversation History (Last {min(count, len(message_files))} Entries)")
+            table.add_column("ID", style="cyan")
+            table.add_column("Date", style="green")
+            table.add_column("Time", style="green")
+            table.add_column("First Query", style="yellow")
+            
+            # Add rows to the table
+            for file in message_files:
+                try:
+                    with open(file, "r", encoding="utf-8") as f:
+                        message_object = json.load(f)
+                    
+                    # Extract message ID and timestamp
+                    message_id = message_object.get("id", file.stem)
+                    
+                    # Parse timestamp
+                    timestamp_str = message_object.get("timestamp")
+                    if timestamp_str:
+                        timestamp = datetime.datetime.fromisoformat(timestamp_str)
+                        date_str = timestamp.strftime("%Y-%m-%d")
+                        time_str = timestamp.strftime("%H:%M:%S")
+                    else:
+                        # Fallback to file name which is a timestamp
+                        timestamp_str = file.stem
+                        date_str = timestamp_str[:8]  # YYYYMMDD
+                        time_str = timestamp_str[8:]  # HHMMSS
+                        
+                        # Format the date and time
+                        if len(date_str) == 8:
+                            date_str = f"{date_str[:4]}-{date_str[4:6]}-{date_str[6:8]}"
+                        if len(time_str) == 6:
+                            time_str = f"{time_str[:2]}:{time_str[2:4]}:{time_str[4:6]}"
+                    
+                    # Extract the first user message
+                    messages = message_object.get("messages", [])
+                    first_query = "N/A"
+                    for msg in messages:
+                        if msg.get("role") == "user":
+                            first_query = msg.get("content", "N/A")
+                            # Truncate long queries
+                            if len(first_query) > 60:
+                                first_query = first_query[:57] + "..."
+                            break
+                    
+                    table.add_row(message_id, date_str, time_str, first_query)
+                except Exception as e:
+                    table.add_row(file.stem, "Error", "Error", f"Failed to parse: {str(e)}")
+            
+            console.print(table)
+            
+            # Display information about how to continue conversations
+            console.print("\n[bold blue]💡 To continue a conversation:[/bold blue]")
+            script_name = "janito"
+            if sys.argv[0].endswith(('janito', 'janito.exe')):
+                console.print(f"  {script_name} --continue <ID> <request>")
+            else:
+                console.print(f"  python -m janito --continue <ID> <request>")
+            
+            # If --history flag is used, always exit regardless of whether a query is provided
+            return True
+                
+        except Exception as e:
+            console.print(f"[bold red]Error displaying history:[/bold red] {str(e)}")
+            return True  # Exit on error
+            
+    return False

janito/cli/commands/profile.py

@@ -0,0 +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 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

janito/cli/commands/validation.py

@@ -0,0 +1,24 @@
+"""
+Parameter validation functions for Janito CLI.
+"""
+import sys
+from rich.console import Console
+
+console = Console()
+
+def validate_parameters(temperature: float) -> None:
+    """
+    Validate temperature parameter.
+    
+    Args:
+        temperature: Temperature value for model generation
+    """
+    try:
+        if temperature < 0.0 or temperature > 1.0:
+            raise ValueError("Temperature must be between 0.0 and 1.0")
+            
+        # We'll use this value directly in the agent initialization but we don't save it to config
+        # Temperature display is hidden
+    except ValueError as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}")
+        sys.exit(1)

janito/cli/commands/workspace.py

@@ -0,0 +1,31 @@
+"""
+Workspace management functions for Janito CLI.
+"""
+import sys
+from typing import Optional
+from rich.console import Console
+
+from janito.config import Config
+
+console = Console()
+
+def handle_workspace(workspace: Optional[str]) -> bool:
+    """
+    Handle the --workspace parameter.
+    
+    Args:
+        workspace: Workspace directory path
+        
+    Returns:
+        bool: True if the program should exit after this operation
+    """
+    if workspace:
+        try:
+            console.print(f"[bold]📂 Setting workspace directory to: {workspace}[/bold]")
+            Config().workspace_dir = workspace
+            console.print(f"[bold green]✅ Workspace directory set to: {Config().workspace_dir}[/bold green]")
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+            sys.exit(1)
+    
+    return False

janito/cli/commands.py

@@ -1,329 +1,12 @@
 """
 Command handling logic for Janito CLI.
+This module serves as a compatibility layer for the reorganized commands module.
 """
-import sys
-import os
-from typing import Optional, Tuple, Any
-from pathlib import Path
-import typer
-from rich.console import Console
-
-from janito.config import get_config, Config
-
-console = Console()
-
-def validate_parameters(temperature: float) -> None:
-    """
-    Validate temperature parameter.
-    
-    Args:
-        temperature: Temperature value for model generation
-    """
-    try:
-        if temperature < 0.0 or temperature > 1.0:
-            raise ValueError("Temperature must be between 0.0 and 1.0")
-            
-        # We'll use this value directly in the agent initialization but we don't save it to config
-        # Temperature display is hidden
-    except ValueError as e:
-        console.print(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
-
-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_workspace(workspace: Optional[str]) -> bool:
-    """
-    Handle the --workspace parameter.
-    
-    Args:
-        workspace: Workspace directory path
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if workspace:
-        try:
-            console.print(f"[bold]📂 Setting workspace directory to: {workspace}[/bold]")
-            get_config().workspace_dir = workspace
-            console.print(f"[bold green]✅ Workspace directory set to: {get_config().workspace_dir}[/bold green]")
-        except ValueError as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    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_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)
-    
-    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
-
-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_conversation: Optional[str] = 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_conversation: Optional message ID to continue a specific conversation
-        
-    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
-        
-    return False
+# Re-export the functions from the new module structure
+from janito.cli.commands import handle_config_commands, validate_parameters, handle_history
+
+__all__ = [
+    "handle_config_commands",
+    "validate_parameters",
+    "handle_history",
+]