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

janito/config/profiles/manager.py

@@ -1,80 +0,0 @@
-"""
-Profile management functions for Janito configuration.
-"""
-from typing import Dict, Any
-
-from .definitions import PROFILES
-
-def get_available_profiles() -> Dict[str, Dict[str, Any]]:
-    """
-    Get all available predefined profiles.
-    
-    Returns:
-        Dictionary of profile names to profile settings
-    """
-    return PROFILES
-
-def get_profile(profile_name: str) -> Dict[str, Any]:
-    """
-    Get a specific profile by name.
-    
-    Args:
-        profile_name: Name of the profile to retrieve
-        
-    Returns:
-        Dict containing the profile settings
-        
-    Raises:
-        ValueError: If the profile name is not recognized
-    """
-    profile_name = profile_name.lower()
-    if profile_name not in PROFILES:
-        valid_profiles = ", ".join(PROFILES.keys())
-        raise ValueError(f"Unknown profile: {profile_name}. Valid profiles are: {valid_profiles}")
-    
-    return PROFILES[profile_name]
-
-def create_custom_profile(name: str, temperature: float, description: str = None) -> Dict[str, Any]:
-    """
-    Create a custom profile with the given parameters.
-    
-    Args:
-        name: Name for the custom profile
-        temperature: Temperature value (0.0 to 1.0)
-        description: Optional description for the profile
-        
-    Returns:
-        Dict containing the profile settings
-        
-    Raises:
-        ValueError: If temperature is not between 0.0 and 1.0
-    """
-    if temperature < 0.0 or temperature > 1.0:
-        raise ValueError("Temperature must be between 0.0 and 1.0")
-    
-    # Determine top_p and top_k based on temperature
-    if temperature <= 0.3:
-        top_p = 0.85
-        top_k = 15
-    elif temperature <= 0.6:
-        top_p = 0.9
-        top_k = 40
-    else:
-        top_p = 0.95
-        top_k = 60
-    
-    # Use provided description or generate a default one
-    if description is None:
-        if temperature <= 0.3:
-            description = "Custom precise profile"
-        elif temperature <= 0.6:
-            description = "Custom balanced profile"
-        else:
-            description = "Custom creative profile"
-    
-    return {
-        "temperature": temperature,
-        "top_p": top_p,
-        "top_k": top_k,
-        "description": description
-    }

janito/data/instructions_template.txt

@@ -1,34 +0,0 @@
-You are a {{ role }}, using the name Janito .
-You will be assisting an user using a computer system on a {{ platform }} platform.
-You can find more about the current project using the tools in the workspace directory.
-If the question is related to the project, use the tools using the relative path, ./filename instead of /filename.
-
-If creating or editing files with a large number of lines, organize them into smaller files.
-If creating or editing files in an existing directory check surrounding files for the used patterns.
-
-# Structure Discovery (docs/STRUCTURE.md from current directory)
-Always start exploring the project by viewing for the file docs/STRUCTURE.md.
-Do not track files or directories wich are in .gitignore in the structure.
-At the end of responding to the user, update the structure file based on the files and directories you have interacted with,
-be precise focusing on the most important files and directories, avoid adding extra information like architecture or design patterns.
-
-# Tools
-The bash tool does not support commands which will require user input.
-Use the bash tool to get the current date or time when needed.
-Prefer the str_replace_editor tool to view directories and file contents.
-
-<IMPORTANT>
-Call the user_prompt tool when:
-- There are multiple options to apply a certain change
-- The next operation risk is moderated or high
-- The implementation plan is complex, requiring a review
-Proceed according to the user answer.
-</IMPORTANT>
-
-When changing code in Python files, be mindful about the need to review the imports specially when new type hints are used (eg. Optional, Tuple, List, Dict, etc).
-After performing changes to a project in interfaces which are exposed to the user, respond to the user with a short summary on how to verify the changes. eg. "run cmd xpto", prefer to provide a command to run instead of a description.
-When displaying commands in instructions to the user, consider their platform.
-When creating html pages which refer to images that should be manually placed by the user, instead of broken links provide a frame with a placeholder image.
-
-If STRUCTURE.md was updated add it to the list of files to be committed.
-After significant changes, run git commit with a message describing the changes made.

janito/token_report.py

@@ -1,154 +0,0 @@
-"""
-Module for generating token usage reports.
-"""
-
-from rich.console import Console
-
-def generate_token_report(agent, verbose=False, interrupted=False):
-    """
-    Generate a token usage report.
-    
-    Args:
-        agent: The Claude agent instance
-        verbose: Whether to show detailed token usage information
-        interrupted: Whether the request was interrupted
-        
-    Returns:
-        None - prints the report to the console
-    """
-    console = Console()
-    usage = agent.get_tokens()
-    cost = agent.get_token_cost()
-    
-    text_usage = usage.text_usage
-    tools_usage = usage.tools_usage
-    
-    if verbose:
-        total_usage = usage.total_usage
-        
-        # Get costs from the cost object
-        text_input_cost = cost.input_cost
-        text_output_cost = cost.output_cost
-        text_cache_creation_cost = cost.cache_creation_cost
-        text_cache_read_cost = cost.cache_read_cost
-        
-        tools_input_cost = cost.input_cost
-        tools_output_cost = cost.output_cost
-        tools_cache_creation_cost = cost.cache_creation_cost
-        tools_cache_read_cost = cost.cache_read_cost
-        
-        # Format costs
-        def format_cost(cost):
-            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
-        
-        console.print("\n[bold blue]📊 Detailed Token Usage:[/bold blue]")
-        console.print(f"📝 Text Input tokens: {text_usage.input_tokens}")
-        console.print(f"📤 Text Output tokens: {text_usage.output_tokens}")
-        console.print(f"💾 Text Cache Creation tokens: {text_usage.cache_creation_input_tokens}")
-        console.print(f"📖 Text Cache Read tokens: {text_usage.cache_read_input_tokens}")
-        console.print(f"📋 Text Total tokens: {text_usage.input_tokens + text_usage.output_tokens + text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens}")
-        
-        console.print(f"🔧 Tool Input tokens: {tools_usage.input_tokens}")
-        console.print(f"🔨 Tool Output tokens: {tools_usage.output_tokens}")
-        console.print(f"💾 Tool Cache Creation tokens: {tools_usage.cache_creation_input_tokens}")
-        console.print(f"📖 Tool Cache Read tokens: {tools_usage.cache_read_input_tokens}")
-        console.print(f"🧰 Tool Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens + tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens}")
-        
-        console.print(f"🔢 Total tokens: {total_usage.input_tokens + total_usage.output_tokens + total_usage.cache_creation_input_tokens + total_usage.cache_read_input_tokens}")
-        
-        console.print("\n[bold blue]💰 Pricing Information:[/bold blue]")
-        console.print(f"📝 Text Input cost: {format_cost(text_input_cost)}")
-        console.print(f"📤 Text Output cost: {format_cost(text_output_cost)}")
-        console.print(f"💾 Text Cache Creation cost: {format_cost(text_cache_creation_cost)}")
-        console.print(f"📖 Text Cache Read cost: {format_cost(text_cache_read_cost)}")
-        console.print(f"📋 Text Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost)}")
-        
-        console.print(f"🔧 Tool Input cost: {format_cost(tools_input_cost)}")
-        console.print(f"🔨 Tool Output cost: {format_cost(tools_output_cost)}")
-        console.print(f"💾 Tool Cache Creation cost: {format_cost(tools_cache_creation_cost)}")
-        console.print(f"📖 Tool Cache Read cost: {format_cost(tools_cache_read_cost)}")
-        console.print(f"🧰 Tool Total cost: {format_cost(tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}")
-        
-        total_cost_text = f"💵 Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost + tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}"
-        if interrupted:
-            total_cost_text += " (interrupted request not accounted)"
-        console.print(total_cost_text)
-        
-        # Show cache delta if available
-        if hasattr(cost, 'cache_delta') and cost.cache_delta:
-            cache_delta = cost.cache_delta
-            console.print(f"\n[bold green]💰 Cache Savings:[/bold green] {format_cost(cache_delta)}")
-            
-            # Calculate percentage savings
-            total_cost_without_cache = cost.total_cost + cache_delta
-            if total_cost_without_cache > 0:
-                savings_percentage = (cache_delta / total_cost_without_cache) * 100
-                console.print(f"[bold green]📊 Cache Savings Percentage:[/bold green] {savings_percentage:.2f}%")
-                console.print(f"[bold green]💸 Cost without cache:[/bold green] {format_cost(total_cost_without_cache)}")
-                console.print(f"[bold green]💲 Cost with cache:[/bold green] {format_cost(cost.total_cost)}")
-            
-        # Per-tool breakdown
-        if usage.by_tool:
-            console.print("\n[bold blue]🔧 Per-Tool Breakdown:[/bold blue]")
-            try:
-                if hasattr(cost, 'by_tool') and cost.by_tool:
-                    for tool_name, tool_usage in usage.by_tool.items():
-                        tool_input_cost = cost.by_tool[tool_name].input_cost
-                        tool_output_cost = cost.by_tool[tool_name].output_cost
-                        tool_cache_creation_cost = cost.by_tool[tool_name].cache_creation_cost
-                        tool_cache_read_cost = cost.by_tool[tool_name].cache_read_cost
-                        tool_total_cost = tool_input_cost + tool_output_cost + tool_cache_creation_cost + tool_cache_read_cost
-                        
-                        console.print(f"   🔧 Tool: {tool_name}")
-                        console.print(f"  📥 Input tokens: {tool_usage.input_tokens}")
-                        console.print(f"  📤 Output tokens: {tool_usage.output_tokens}")
-                        console.print(f"  💾 Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
-                        console.print(f"  📖 Cache Read tokens: {tool_usage.cache_read_input_tokens}")
-                        console.print(f"  🔢 Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
-                        console.print(f"  💵 Total cost: {format_cost(tool_total_cost)}")
-                else:
-                    # Calculate costs manually for each tool if cost.by_tool is not available
-                    for tool_name, tool_usage in usage.by_tool.items():
-                        # Estimate costs based on overall pricing
-                        total_tokens = tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens
-                        estimated_cost = (total_tokens / (usage.total_usage.total_tokens + usage.total_usage.total_cache_tokens)) * cost.total_cost if usage.total_usage.total_tokens > 0 else 0
-                        
-                        console.print(f"   🔧 Tool: {tool_name}")
-                        console.print(f"  📥 Input tokens: {tool_usage.input_tokens}")
-                        console.print(f"  📤 Output tokens: {tool_usage.output_tokens}")
-                        console.print(f"  💾 Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
-                        console.print(f"  📖 Cache Read tokens: {tool_usage.cache_read_input_tokens}")
-                        console.print(f"  🔢 Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
-                        console.print(f"  💵 Total cost: {format_cost(estimated_cost)}")
-            except Exception as e:
-                console.print(f"❌ Error: {str(e)}")
-    else:
-        total_tokens = (text_usage.input_tokens + text_usage.output_tokens + 
-                       text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens +
-                       tools_usage.input_tokens + tools_usage.output_tokens +
-                       tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens)
-        
-        # Format costs
-        def format_cost(cost):
-            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
-        
-        # Prepare summary message
-        cost_text = f"Cost: {format_cost(cost.total_cost)}"
-        if interrupted:
-            cost_text += " (interrupted request not accounted)"
-            
-        summary = f"Total tokens: {total_tokens} | {cost_text}"
-        
-        # Add cache savings if available
-        if hasattr(cost, 'cache_delta') and cost.cache_delta != 0:
-            cache_delta = cost.cache_delta
-            total_cost_without_cache = cost.total_cost + cache_delta
-            savings_percentage = 0
-            if total_cost_without_cache > 0:
-                savings_percentage = (cache_delta / total_cost_without_cache) * 100
-            
-            summary += f" | Cache savings: {format_cost(cache_delta)} ({savings_percentage:.1f}%)"
-        
-        # Display with a rule
-        console.rule("[blue]Token Usage[/blue]")
-        console.print(f"[blue]{summary}[/blue]", justify="center")

janito/tools/__init__.py

@@ -1,44 +0,0 @@
-"""
-Janito tools package.
-"""
-
-from .str_replace_editor import str_replace_editor
-from .find_files import find_files
-from .delete_file import delete_file
-from .search_text import search_text
-from .replace_file import replace_file
-from .prompt_user import prompt_user
-from .move_file import move_file
-from janito.tools.fetch_webpage import fetch_webpage
-from .think import think
-from .usage_tracker import get_tracker, reset_tracker, print_usage_stats
-from janito.config import get_config
-
-__all__ = ["str_replace_editor", "find_files", "delete_file", "search_text", "replace_file", 
-           "prompt_user", "move_file", "fetch_webpage", "think", "get_tools", 
-           "get_tracker", "reset_tracker", "print_usage_stats"]
-
-def get_tools():
-    """
-    Get a list of all available tools.
-    
-    Returns:
-        List of tool functions (excluding str_replace_editor which is passed separately)
-        If no_tools mode is enabled, returns an empty list
-        If ask_mode is enabled, only returns tools that don't perform changes
-    """
-    # If no_tools mode is enabled, return an empty list
-    if get_config().no_tools:
-        return []
-        
-    # Tools that only read or view but don't modify anything
-    read_only_tools = [find_files, search_text, prompt_user, fetch_webpage, think]
-    
-    # Tools that modify the filesystem
-    write_tools = [delete_file, replace_file, move_file]
-    
-    # If ask_mode is enabled, only return read-only tools
-    if get_config().ask_mode:
-        return read_only_tools
-    else:
-        return read_only_tools + write_tools

janito/tools/bash/bash.py

@@ -1,157 +0,0 @@
-from typing import Optional
-from typing import Tuple
-import threading
-import platform
-import re
-import queue
-import signal
-import time
-from janito.config import get_config
-from janito.tools.usage_tracker import get_tracker
-from janito.tools.rich_console import console, print_info
-
-# Import the appropriate implementation based on the platform
-if platform.system() == "Windows":
-    from janito.tools.bash.win_persistent_bash import PersistentBash
-else:
-    from janito.tools.bash.unix_persistent_bash import PersistentBash
-
-# Global instance of PersistentBash to maintain state between calls
-_bash_session = None
-_session_lock = threading.RLock()  # Use RLock to allow reentrant locking
-_current_bash_thread = None
-_command_interrupted = False
-
-def _execute_bash_command(command, result_queue):
-    """
-    Execute a bash command in a separate thread.
-    
-    Args:
-        command: The bash command to execute
-        result_queue: Queue to store the result
-    """
-    global _bash_session, _command_interrupted
-    
-    try:
-        # Execute the command - output will be printed to console in real-time
-        output = _bash_session.execute(command)
-        
-        # Put the result in the queue if the command wasn't interrupted
-        if not _command_interrupted:
-            result_queue.put((output, False))
-    except Exception as e:
-        # Handle any exceptions that might occur
-        error_message = f"Error executing bash command: {str(e)}"
-        console.print(error_message, style="red bold")
-        result_queue.put((error_message, True))
-
-def _keyboard_interrupt_handler(signum, frame):
-    """
-    Handle keyboard interrupt (Ctrl+C) by setting the interrupt flag.
-    """
-    global _command_interrupted
-    _command_interrupted = True
-    console.print("\n[bold red]Command interrupted by user (Ctrl+C)[/bold red]")
-    
-    # Restore the default signal handler
-    signal.signal(signal.SIGINT, original_sigint_handler)
-
-def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]:
-    """
-    Execute a bash command using a persistent Bash session.
-    The appropriate implementation (Windows or Unix) is selected based on the detected platform.
-    When in ask mode, only read-only commands are allowed.
-    Output is printed to the console in real-time as it's received.
-    Command runs in a background thread, allowing Ctrl+C to interrupt just the command.
-    
-    Args:
-        command: The bash command to execute
-        restart: Whether to restart the bash session
-        
-    Returns:
-        A tuple containing (output message, is_error flag)
-    """
-    # Import console for printing output in real-time
-    from janito.tools.rich_console import console, print_info
-    
-    # Only print command if not in trust mode
-    if not get_config().trust_mode:
-        print_info(f"{command}", "Bash Run")
-    
-    global _bash_session, _current_bash_thread, _command_interrupted, original_sigint_handler
-    _command_interrupted = False
-    
-    # Check if in ask mode and if the command might modify files
-    if get_config().ask_mode:
-        # List of potentially modifying commands
-        modifying_patterns = [
-            r'\brm\b', r'\bmkdir\b', r'\btouch\b', r'\becho\b.*[>\|]', r'\bmv\b', r'\bcp\b',
-            r'\bchmod\b', r'\bchown\b', r'\bsed\b.*-i', r'\bawk\b.*[>\|]', r'\bcat\b.*[>\|]',
-            r'\bwrite\b', r'\binstall\b', r'\bapt\b', r'\byum\b', r'\bpip\b.*install',
-            r'\bnpm\b.*install', r'\bdocker\b', r'\bkubectl\b.*apply', r'\bgit\b.*commit',
-            r'\bgit\b.*push', r'\bgit\b.*merge', r'\bdd\b'
-        ]
-        
-        # Check if command matches any modifying pattern
-        for pattern in modifying_patterns:
-            if re.search(pattern, command, re.IGNORECASE):
-                return ("Cannot execute potentially modifying commands in ask mode. Use --ask option to disable modifications.", True)
-    
-    with _session_lock:
-        # Initialize or restart the session if needed
-        if _bash_session is None or restart:
-            if _bash_session is not None:
-                _bash_session.close()
-            # Get GitBash path from config (None means auto-detect)
-            gitbash_path = get_config().gitbash_path
-            _bash_session = PersistentBash(bash_path=gitbash_path)
-        
-        try:
-            # Create a queue to get the result from the thread
-            result_queue = queue.Queue()
-            
-            # Save the original SIGINT handler
-            original_sigint_handler = signal.getsignal(signal.SIGINT)
-            
-            # Set our custom SIGINT handler
-            signal.signal(signal.SIGINT, _keyboard_interrupt_handler)
-            
-            # Create and start the thread
-            _current_bash_thread = threading.Thread(
-                target=_execute_bash_command,
-                args=(command, result_queue)
-            )
-            _current_bash_thread.daemon = True
-            _current_bash_thread.start()
-            
-            # Wait for the thread to complete or for an interrupt
-            while _current_bash_thread.is_alive() and not _command_interrupted:
-                _current_bash_thread.join(0.1)  # Check every 100ms
-            
-            # If the command was interrupted, return a message
-            if _command_interrupted:
-                # Restore the original signal handler
-                signal.signal(signal.SIGINT, original_sigint_handler)
-                return ("Command was interrupted by Ctrl+C", True)
-            
-            # Get the result from the queue
-            output, is_error = result_queue.get(timeout=1)
-            
-            # Restore the original signal handler
-            signal.signal(signal.SIGINT, original_sigint_handler)
-            
-            # Track bash command execution
-            get_tracker().increment('bash_commands')
-            
-            # Return the output
-            return output, is_error
-            
-        except Exception as e:
-            # Handle any exceptions that might occur
-            error_message = f"Error executing bash command: {str(e)}"
-            console.print(error_message, style="red bold")
-            
-            # Restore the original signal handler
-            signal.signal(signal.SIGINT, original_sigint_handler)
-            
-            return error_message, True