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

janito/cli/app.py

@@ -1,178 +0,0 @@
-"""
-Main CLI application for Janito.
-"""
-import sys
-from typing import Optional
-import typer
-from rich.console import Console
-import importlib.metadata
-
-from janito import __version__
-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
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def main(ctx: typer.Context, 
-         query: Optional[str] = typer.Argument(None, help="Query to send to the claudine agent"),
-         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"),
-         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_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"),
-         no_tools: bool = typer.Option(False, "--no-tools", help="Disable all tools for this session (per-session setting, not saved to config)"),
-         temperature: float = typer.Option(0.0, "--temperature", help="Set the temperature for model generation (0.0 to 1.0)"),
-         profile: Optional[str] = typer.Option(None, "--profile", help="Use a predefined parameter profile (precise, balanced, conversational, creative, technical)"),
-         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_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
-    Config().verbose = verbose
-    
-    # Set ask mode in config
-    Config().ask_mode = ask
-    
-    # Set trust mode in config
-    Config().trust_mode = trust
-    
-    # Set no-tools mode in config
-    Config().no_tools = no_tools
-    
-    # Show a message if ask mode is enabled
-    if ask:
-        console.print("[bold yellow]⚠️ Ask Mode enabled:[/bold yellow] 🔒 Tools that perform changes are disabled")
-        
-    # Show a message if trust mode is enabled
-    if trust:
-        console.print("[bold blue]⚡ Trust Mode enabled:[/bold blue] Tool outputs are suppressed for concise execution")
-        
-    # Show a message if no-tools mode is enabled
-    if no_tools:
-        console.print("[bold magenta]🚫 No-Tools Mode enabled:[/bold magenta] All tools are disabled for this session")
-    
-    # Show version and exit if requested
-    if version:
-        console.print(f"🚀 Janito version: {__version__}")
-        sys.exit(0)
-    
-    # Validate temperature
-    validate_parameters(temperature)
-    
-    # Process continue flags before handling other options
-    continue_conversation = None
-    
-    # First, parse continue_flag and continue_id from original sys.argv to avoid typer issues
-    # This is necessary because typer has trouble with quotes in some edge cases
-    try:
-        # Check if --continue or -c is in sys.argv
-        args = sys.argv
-        
-        # Handle the --history flag with optional count parameter
-        history_count_override = None
-        if "--history" in args:
-            history_idx = args.index("--history")
-            history_flag = True
-            
-            # Check if there's a number after --history and it's not another flag
-            if history_idx + 1 < len(args) and not args[history_idx + 1].startswith("-"):
-                try:
-                    # Try to convert to int - if successful, it's a count
-                    history_count_override = int(args[history_idx + 1])
-                except ValueError:
-                    # Not a number, ignore it
-                    pass
-        
-        if "--continue" in args or "-c" in args:
-            continue_idx = args.index("--continue") if "--continue" in args else args.index("-c")
-            
-            # Check if there's at least one argument after --continue
-            if continue_idx + 1 < len(args) and not args[continue_idx + 1].startswith("-"):
-                # If next arg doesn't start with "-", it's our continue value
-                continue_value = args[continue_idx + 1]
-                
-                # Check if continue_value is a numeric ID or a query
-                if continue_value.isdigit():
-                    # It's an ID
-                    continue_conversation = continue_value
-                    
-                    # Check if there's a query after the ID
-                    if continue_idx + 2 < len(args) and not args[continue_idx + 2].startswith("-"):
-                        query = args[continue_idx + 2]
-                else:
-                    # It's a query string for the most recent conversation
-                    continue_conversation = ""  # Empty string means continue most recent
-                    query = continue_value
-                    
-                    if verbose:
-                        console.print(f"[bold blue]🔄 Continuing most recent conversation[/bold blue]")
-                        console.print(f"[dim]📝 Query: {query}[/dim]")
-            else:
-                # --continue with no args means continue most recent conversation
-                continue_conversation = ""
-        
-        # --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 flag option (processed by typer)
-        if continue_flag is not None:
-            if continue_flag == "":
-                continue_conversation = ""  # Empty string means continue most recent
-            elif continue_flag.isdigit():
-                continue_conversation = continue_flag
-            else:
-                continue_conversation = ""  # Empty string means continue most recent
-                query = continue_flag  # Use the continue_flag as the query
-    
-    # Handle configuration-related commands
-    exit_after_config = handle_config_commands(
-        ctx, 
-        False,  # reset_config is removed, passing False for backward compatibility
-        reset_local_config,
-        reset_global_config,
-        workspace, 
-        show_config, 
-        profile, 
-        role, 
-        set_api_key,
-        set_local_config,
-        set_global_config,
-        query,
-        continue_flag,
-        history_flag,
-        history_count_override
-    )
-    
-    if exit_after_config:
-        sys.exit(0)
-    
-    # Handle query if no subcommand was invoked
-    if ctx.invoked_subcommand is None:
-        # If no query provided in command line, read from stdin
-        # Only prompt for stdin if query is still None after processing --continue flag
-        if not query:
-            console.print("[bold blue]📝 No query provided in command line. Reading from stdin...[/bold blue]")
-            console.print(get_stdin_termination_hint())
-            query = sys.stdin.read().strip()
-            
-        # Only proceed if we have a query (either from command line or stdin)
-        if query:
-            handle_query(query, temperature, verbose, show_tokens, continue_conversation, system)

janito/cli/commands/__init__.py

@@ -1,12 +0,0 @@
-"""
-Command handling logic for Janito CLI.
-"""
-from janito.cli.commands.config import handle_config_commands
-from janito.cli.commands.validation import validate_parameters
-from janito.cli.commands.history import handle_history
-
-__all__ = [
-    "handle_config_commands",
-    "validate_parameters",
-    "handle_history",
-]

janito/cli/commands/config.py

@@ -1,30 +0,0 @@
-"""
-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 typer
-from typing import Optional
-
-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/history.py

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

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

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

@@ -1,31 +0,0 @@
-"""
-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,12 +0,0 @@
-"""
-Command handling logic for Janito CLI.
-This module serves as a compatibility layer for the reorganized commands module.
-"""
-# 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",
-]

janito/cli/output.py

@@ -1,29 +0,0 @@
-"""
-Output formatting and display for Janito CLI.
-"""
-from rich.console import Console
-from janito.config import get_config
-
-console = Console()
-
-def display_generation_params(
-    temp_to_use: float, 
-    profile_data: dict = None,
-    temperature: float = 0.0
-) -> None:
-    """
-    Display generation parameters in verbose mode.
-    
-    Args:
-        temp_to_use: The temperature value being used
-        profile_data: The profile data if a profile is being used
-        temperature: The temperature value from command line
-    """
-    # Show profile information if one is active
-    config = get_config()
-    if config.profile:
-        if not profile_data:
-            profile_data = config.get_available_profiles()[config.profile]
-        console.print(f"[dim]👤 Using profile: {config.profile} - {profile_data['description']}[/dim]")
-    
-    # Temperature, top_k, and top_p information is hidden

janito/cli/utils.py

@@ -1,22 +0,0 @@
-"""
-Utility functions for the CLI module.
-"""
-import platform
-from rich.console import Console
-
-console = Console()
-
-def get_stdin_termination_hint():
-    """
-    Returns a user-friendly message about how to terminate stdin input
-    based on the current platform.
-    
-    Returns:
-        str: A message with the key sequence to terminate stdin input
-    """
-    system = platform.system()
-    
-    if system == "Windows":
-        return "[bold yellow]Press Ctrl+Z followed by Enter to terminate input[/bold yellow]"
-    else:  # Unix-like systems (Linux, macOS)
-        return "[bold yellow]Press Ctrl+D to terminate input[/bold yellow]"

janito/config/README.md

@@ -1,104 +0,0 @@
-# Janito Configuration System
-
-This directory contains the configuration system for Janito. The configuration system is designed to be modular, extensible, and easy to use.
-
-## Directory Structure
-
-```
-janito/config/
-├── __init__.py                 # Re-exports and backward compatibility
-├── README.md                   # This file
-├── core/                       # Core configuration functionality
-│   ├── __init__.py             # Re-exports core components
-│   ├── singleton.py            # Singleton implementation
-│   ├── properties.py           # Property getters and setters
-│   └── file_operations.py      # File I/O operations
-├── profiles/                   # Profile management
-│   ├── __init__.py             # Re-exports profile components
-│   ├── definitions.py          # Profile definitions
-│   └── manager.py              # Profile management functions
-└── cli/                        # CLI integration
-    ├── __init__.py             # Re-exports CLI components
-    ├── commands.py             # Command handling functions
-    └── validators.py           # Input validation functions
-```
-
-## Core Components
-
-The core configuration functionality is implemented in the `core` directory:
-
-- `singleton.py`: Implements the `Config` class as a singleton to ensure only one instance exists
-- `properties.py`: Contains property getters and setters for the `Config` class
-- `file_operations.py`: Handles file I/O operations for loading and saving configuration files
-
-## Profiles
-
-The `profiles` directory contains functionality related to parameter profiles:
-
-- `definitions.py`: Defines predefined parameter profiles (precise, balanced, conversational, creative, technical)
-- `manager.py`: Provides functions for managing profiles, including getting available profiles and creating custom profiles
-
-## CLI Integration
-
-The `cli` directory contains functionality related to CLI integration:
-
-- `commands.py`: Implements command handling functions for configuration-related CLI commands
-- `validators.py`: Provides validation functions for configuration inputs
-
-## Usage
-
-### Basic Usage
-
-```python
-from janito.config import Config
-
-# Get the singleton instance
-config = Config()
-
-# Access configuration properties
-workspace_dir = config.workspace_dir
-temperature = config.temperature
-role = config.role
-
-# Set configuration properties
-config.temperature = 0.7  # Set runtime value only
-config.temperature = (0.7, "local")  # Set in local config
-config.temperature = (0.7, "global")  # Set in global config
-```
-
-### Working with Profiles
-
-```python
-from janito.config import Config, get_available_profiles, get_profile
-
-# Get available profiles
-profiles = get_available_profiles()
-for name, data in profiles.items():
-    print(f"{name}: {data['description']}")
-
-# Get a specific profile
-technical_profile = get_profile("technical")
-print(f"Temperature: {technical_profile['temperature']}")
-
-# Set a profile
-config = Config()
-config.set_profile("creative", "local")
-```
-
-### Configuration Files
-
-The configuration system uses two configuration files:
-
-- Global configuration file: `~/.janito/config.json`
-- Local configuration file: `.janito/config.json` (in the current workspace directory)
-
-Local configuration overrides global configuration when both are present.
-
-## Extending the Configuration System
-
-To add a new configuration property:
-
-1. Add a property getter and setter in `core/properties.py`
-2. Update the `_apply_config` method in `core/singleton.py` to handle the new property
-3. Add validation in `cli/validators.py` if needed
-4. Update the command handling in `cli/commands.py` to support the new property