janito 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

janito/__init__.py

@@ -2,4 +2,4 @@
 Janito package.
 """
 
-__version__ = "0.11.0"
+__version__ = "0.12.0"

janito/__main__.py

@@ -1,205 +1,7 @@
-"""
-Main entry point for Janito.
-"""
-import os
-import sys
-from typing import Optional
-import importlib.resources
-import typer
-from rich.console import Console
-import anthropic
-from janito.config import get_config
-from janito.chat_history import store_conversation, get_chat_history_context
-from janito.callbacks import pre_tool_callback, post_tool_callback, text_callback
-from janito.token_report import generate_token_report
-from janito.tools import str_replace_editor
-from janito.tools.bash import bash_tool
-import claudine
-
-app = typer.Typer()
-
-@app.command()
-def create_tool(name: str = typer.Argument(..., help="Name of the tool to create")):
-    """
-    Create a new tool with the given name.
-    """
-    console = Console()
-    
-    # Ensure workspace is set
-    workspace_dir = get_config().workspace_dir
-    
-    # Create the tools directory if it doesn't exist
-    tools_dir = os.path.join(workspace_dir, "tools")
-    os.makedirs(tools_dir, exist_ok=True)
-    
-    # Create the tool file
-    tool_file = os.path.join(tools_dir, f"{name}.py")
-    
-    # Check if the file already exists
-    if os.path.exists(tool_file):
-        console.print(f"[bold red]Error:[/bold red] Tool file already exists: {tool_file}")
-        return
-    
-    # Create the tool file with a template
-    template = f'''"""
-{name} tool for Janito.
-"""
-
-def {name}(param1: str) -> str:
-    """
-    Description of the {name} tool.
-    
-    Args:
-        param1: Description of param1
-        
-    Returns:
-        str: Description of return value
-    """
-    # TODO: Implement the tool
-    return f"Executed {name} with param1={{param1}}"
-'''
-    
-    with open(tool_file, "w") as f:
-        f.write(template)
-    
-    console.print(f"[bold green]Created tool:[/bold green] {tool_file}")
-
-@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", "-t", 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., 'context=5' for number of history messages to include"),
-         show_config: bool = typer.Option(False, "--show-config", help="Show current configuration")):
-    """
-    Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
-    """    
-    console = Console()
-    
-    # Set verbose mode in config
-    get_config().verbose = verbose
-    
-    if workspace:
-        try:
-            print(f"Setting workspace directory to: {workspace}")
-            get_config().workspace_dir = workspace
-            print(f"Workspace directory set to: {get_config().workspace_dir}")
-        except ValueError as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-            
-    # Show current configuration if requested
-    if show_config:
-        config = get_config()
-        console.print("[bold blue]Current Configuration:[/bold blue]")
-        console.print(f"[bold]Workspace Directory:[/bold] {config.workspace_dir}")
-        console.print(f"[bold]Verbose Mode:[/bold] {'Enabled' if config.verbose else 'Disabled'}")
-        console.print(f"[bold]Chat History Context Count:[/bold] {config.history_context_count} messages")
-        # Exit if this was the only operation requested
-        if ctx.invoked_subcommand is None and not query:
-            sys.exit(0)
-            
-    # Handle the --set-config parameter
-    if config_str is not None:
-        try:
-            # Parse the config string
-            if "context=" in config_str:
-                context_value = config_str.split("context=")[1].strip()
-                # If there are other configs after context, extract just the number
-                if " " in context_value:
-                    context_value = context_value.split(" ")[0]
-                
-                try:
-                    context_value = int(context_value)
-                    if context_value < 0:
-                        console.print("[bold red]Error:[/bold red] History context count must be a non-negative integer")
-                        return
-                    
-                    get_config().history_context_count = context_value
-                    console.print(f"[bold green]Chat history context count set to {context_value} messages[/bold green]")
-                except ValueError:
-                    console.print(f"[bold red]Error:[/bold red] Invalid context value: {context_value}. Must be an integer.")
-            else:
-                console.print(f"[bold yellow]Warning:[/bold yellow] Unsupported configuration in: {config_str}")
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            
-    if ctx.invoked_subcommand is None:
-        # If no query provided in command line, read from stdin
-        if not query:
-            console.print("[bold blue]No query provided in command line. Reading from stdin...[/bold blue]")
-            query = sys.stdin.read().strip()
-            
-        # Only proceed if we have a query (either from command line or stdin)
-        if query:
-            # Get API key from environment variable or ask the user
-            api_key = os.environ.get("ANTHROPIC_API_KEY")
-            if not api_key:
-                console.print("[bold yellow]Warning:[/bold yellow] ANTHROPIC_API_KEY environment variable not set.")
-                console.print("Please set it or provide your API key now:")
-                api_key = typer.prompt("Anthropic API Key", hide_input=True)
-        
-            # Load instructions from file
-            import importlib.resources as pkg_resources
-            try:
-                # For Python 3.9+
-                try:
-                    from importlib.resources import files
-                    instructions = files('janito.data').joinpath('instructions.txt').read_text(encoding='utf-8')
-                # Fallback for older Python versions
-                except (ImportError, AttributeError):
-                    instructions = pkg_resources.read_text('janito.data', 'instructions.txt', encoding='utf-8')
-            except Exception as e:
-                console.print(f"[bold red]Error loading instructions:[/bold red] {str(e)}")
-                instructions = "You are Janito, an AI assistant."
-                
-            # Temporarily disable chat history
-            # Get chat history context
-            # chat_history = get_chat_history_context(get_config().history_context_count)
-            # if chat_history:
-            #     console.print("[dim]Loaded chat history from previous sessions.[/dim]")
-            #     # Append chat history to instructions
-            #     instructions = f"{instructions}\n\n{chat_history}"
-                   
-            # Get tools
-            from janito.tools import get_tools
-            tools_list = get_tools()
-            
-            # Initialize the agent with the tools
-            agent = claudine.Agent(
-                api_key=api_key,
-                system_prompt=instructions,
-                callbacks={"pre_tool": pre_tool_callback, "post_tool": post_tool_callback, "text": text_callback},
-                text_editor_tool=str_replace_editor,
-               #bash_tool=bash_tool,
-                tools=tools_list,
-                verbose=verbose
-            )
-            
-            # Send the query to the agent
-            try:
-                agent.query(query)
-                
-                # Temporarily disable storing conversation in chat history
-                # Store the conversation in chat history
-                # store_conversation(query, response, agent)
-                
-                # Print token usage report if show_tokens mode is enabled
-                if show_tokens:
-                    generate_token_report(agent, verbose=True)
-                else:
-                    # Show basic token usage
-                    generate_token_report(agent, verbose=False)
-                    
-            except anthropic.APIError as e:
-                console.print(f"[bold red]Anthropic API Error:[/bold red] {str(e)}")
-                
-            except Exception as e:
-                console.print(f"[bold red]Error:[/bold red] {str(e)}")
-                if verbose:
-                    import traceback
-                    console.print(traceback.format_exc())
-
-if __name__ == "__main__":
+"""
+Main entry point for Janito.
+"""
+from janito.cli import app
+
+if __name__ == "__main__":
     app()

janito/callbacks.py

@@ -1,132 +1,34 @@
-"""
-Callback functions for tool execution in janito.
-"""
-
-from typing import Dict, Any, Tuple, Optional, List
-from rich.console import Console
-from rich.markdown import Markdown
-
-from janito.config import get_config
-from janito.tools import find_files
-from janito.tools.str_replace_editor.editor import str_replace_editor
-from janito.tools.delete_file import delete_file
-from janito.tools.search_text import search_text
-from janito.tools.decorators import format_tool_label
-
-# Note: ConsoleCallback has been removed as we're using pre_tool and post_tool callbacks directly
-
-def pre_tool_callback(tool_name: str, tool_input: Dict[str, Any]) -> Tuple[Dict[str, Any], bool]:
-    """
-    Callback function that runs before a tool is executed.
-    
-    Args:
-        tool_name: Name of the tool being called
-        tool_input: Input parameters for the tool
-        
-    Returns:
-        Tuple of (modified tool input, whether to cancel the tool call)
-    """
-    console = Console()
-    
-    # Add debug counter only when verbose mode is enabled
-    if get_config().verbose:
-        if not hasattr(pre_tool_callback, "counter"):
-            pre_tool_callback.counter = 1
-        console.print(f"[bold green]DEBUG: Starting tool call #{pre_tool_callback.counter}[/bold green]")
-        
-        # Print the tool name and input
-        console.print(f"[bold green]Tool:[/bold green] {tool_name}")
-        console.print(f"[bold green]Input:[/bold green] {tool_input}")
-    else:
-        # For non-debug mode, just print a simple message
-        # Find the tool function
-        tool_func = None
-        if tool_name == "find_files":
-            tool_func = find_files
-        elif tool_name == "str_replace_editor":
-            tool_func = str_replace_editor
-        elif tool_name == "delete_file":
-            tool_func = delete_file
-        elif tool_name == "search_text":
-            tool_func = search_text
-            
-        # Format the input for display
-        display_input = ""
-        if "path" in tool_input:
-            display_input = tool_input["path"]
-        elif "file_path" in tool_input:
-            display_input = tool_input["file_path"]
-        
-        # Print formatted tool label if available
-        formatted_label = format_tool_label(tool_func, tool_input)
-        if formatted_label:
-            console.print("[bold cyan]  Tool:[/bold cyan]", formatted_label, end=" → ")
-        else:
-            console.print("[bold cyan]  Tool:[/bold cyan]", f"{tool_name} {display_input}", end=" → ")
-    
-    return tool_input, True  # Continue with the tool call
-
-def post_tool_callback(tool_name: str, tool_input: Dict[str, Any], result: Any) -> Any:
-    """
-    Callback function that runs after a tool is executed.
-    
-    Args:
-        tool_name: Name of the tool that was called
-        tool_input: Input parameters for the tool
-        result: Result of the tool call
-        
-    Returns:
-        Modified result
-    """
-    console = Console()
-    
-    # Add debug counter only when verbose mode is enabled
-    if get_config().verbose:
-        if not hasattr(post_tool_callback, "counter"):
-            post_tool_callback.counter = 1
-        console.print(f"[bold green]DEBUG: Completed tool call #{post_tool_callback.counter}[/bold green]")
-        post_tool_callback.counter += 1
-    
-    # Show the number of lines in the result content
-    if isinstance(result, tuple) and len(result) >= 1:
-        content, is_error = result
-        # Define prefix icon based on is_error
-        icon_prefix = "❌ " if is_error else "✅ "
-        
-        if isinstance(content, str):
-            # Count the number of lines in the content
-            line_count = content.count('\n') + 1 if content else 0
-            console.print(f"{icon_prefix}{line_count} items")
-        else:
-            console.print(f"{icon_prefix}{content}")
-    else:
-        # If result is not a tuple, convert to string and count lines
-        result_str = str(result)
-        # Default to success icon when no error status is available
-        icon_prefix = "✅ "
-        line_count = result_str.count('\n') + 1 if result_str else 0
-        console.print(f"{icon_prefix}{line_count} lines")
-    
-    return result
-
-def text_callback(text: str) -> None:
-    """
-    Callback function that handles text output from the agent.
-    
-    Args:
-        text: Text output from the agent
-        
-    Returns:
-        None
-    """
-    console = Console()
-    
-    # Add debug counter only when debug mode is enabled
-    if get_config().debug_mode:
-        if not hasattr(text_callback, "counter"):
-            text_callback.counter = 1
-        console.print(f"[bold blue]DEBUG: Text callback #{text_callback.counter}[/bold blue]")
-        text_callback.counter += 1
-    
-    # Print the text with markdown formatting
-    console.print("[bold magenta]Janito:[/bold magenta] ", Markdown(text, code_theme="monokai"), end="")
+"""
+Callback functions for tool execution in janito.
+"""
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+from janito.config import get_config
+
+# Counter for pre-tool callbacks
+pre_tool_callbacks = 0
+
+def text_callback(text: str) -> None:
+    """
+    Callback function that handles text output from the agent.
+    
+    Args:
+        text: Text output from the agent
+        
+    Returns:
+        None
+    """
+    console = Console()
+    
+    # Add debug counter only when debug mode is enabled
+    if get_config().debug_mode:
+        if not hasattr(text_callback, "counter"):
+            text_callback.counter = 1
+        console.print(f"[bold blue]DEBUG: Text callback #{text_callback.counter}[/bold blue]")
+        text_callback.counter += 1
+    
+    # Print the text with markdown formatting
+    console.print(Markdown(text, code_theme="monokai"), end="")
+

janito/cli/__init__.py

@@ -0,0 +1,6 @@
+"""
+CLI module for Janito.
+"""
+from janito.cli.app import app
+
+__all__ = ["app"]

janito/cli/agent.py

@@ -0,0 +1,287 @@
+"""
+Agent initialization and query handling for Janito CLI.
+"""
+import os
+import sys
+import json
+import anthropic
+import claudine
+import typer
+from rich.console import Console
+from pathlib import Path
+from jinja2 import Template
+import importlib.resources as pkg_resources
+
+from janito.config import get_config, Config
+from janito.callbacks import text_callback
+from janito.token_report import generate_token_report
+from janito.tools import str_replace_editor
+from janito.tools.bash.bash import bash_tool
+from janito.cli.output import display_generation_params
+
+console = Console()
+
+def get_api_key() -> str:
+    """
+    Get the API key from global config, environment variable, or user input.
+    
+    Returns:
+        str: The API key
+    """
+    # Get API key from global config, environment variable, 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 api_key:
+        console.print("[bold yellow]⚠️ Warning:[/bold yellow] API key not found in global config or ANTHROPIC_API_KEY environment variable.")
+        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)
+    
+    return api_key
+
+def load_instructions() -> str:
+    """
+    Load instructions template and render it with variables.
+    
+    Returns:
+        str: The rendered instructions
+    """
+    import platform
+    
+    try:
+        # For Python 3.9+
+        try:
+            from importlib.resources import files
+            template_content = files('janito.data').joinpath('instructions_template.txt').read_text(encoding='utf-8')
+        # Fallback for older Python versions
+        except (ImportError, AttributeError):
+            template_content = pkg_resources.read_text('janito.data', 'instructions_template.txt', encoding='utf-8')
+        
+        # Create template variables
+        template_variables = {
+            'platform': platform.system(),
+            'role': get_config().role,
+            # Add any other variables you want to pass to the template here
+        }
+        
+        # Create template and render
+        template = Template(template_content)
+        instructions = template.render(**template_variables)
+        
+    except Exception as e:
+        console.print(f"[bold red]❌ Error loading instructions template:[/bold red] {str(e)}")
+        # Try to fall back to regular instructions.txt
+        try:
+            # For Python 3.9+
+            try:
+                from importlib.resources import files
+                instructions = files('janito.data').joinpath('instructions.txt').read_text(encoding='utf-8')
+            # Fallback for older Python versions
+            except (ImportError, AttributeError):
+                instructions = pkg_resources.read_text('janito.data', 'instructions.txt', encoding='utf-8')
+        except Exception as e2:
+            console.print(f"[bold red]❌ Error loading fallback instructions:[/bold red] {str(e2)}")
+            instructions = "You are Janito, an AI assistant."
+    
+    return instructions
+
+def initialize_agent(temperature: float, verbose: bool) -> claudine.Agent:
+    """
+    Initialize the Claude agent with tools and configuration.
+    
+    Args:
+        temperature: Temperature value for model generation
+        verbose: Whether to enable verbose mode
+        
+    Returns:
+        claudine.Agent: The initialized agent
+    """
+    # Get API key
+    api_key = get_api_key()
+    
+    # Load instructions
+    instructions = load_instructions()
+    
+    # Get tools
+    from janito.tools import get_tools, reset_tracker
+    tools_list = get_tools()
+    
+    # Reset usage tracker before each query
+    reset_tracker()
+    
+    # Use command line parameters if provided (not default values), otherwise use config
+    temp_to_use = temperature if temperature != 0.0 else get_config().temperature
+    
+    # Get profile parameters if a profile is set
+    config = get_config()
+    profile_data = None
+    if config.profile:
+        profile_data = config.get_available_profiles()[config.profile]
+    
+    # Display generation parameters if verbose mode is enabled
+    if verbose:
+        display_generation_params(temp_to_use, profile_data, temperature)
+    
+    # Create config_params dictionary with generation parameters
+    config_params = {
+        "temperature": temp_to_use
+    }
+    
+    # Add top_k and top_p from profile if available
+    if profile_data:
+        if "top_k" in profile_data and profile_data["top_k"] != 0:
+            config_params["top_k"] = profile_data["top_k"]
+        if "top_p" in profile_data and profile_data["top_p"] != 0.0:
+            config_params["top_p"] = profile_data["top_p"]
+    
+    # Initialize the agent
+    agent = claudine.Agent(
+        api_key=api_key,
+        system_prompt=instructions,
+        callbacks={"text": text_callback},
+        text_editor_tool=str_replace_editor,
+        bash_tool=bash_tool,
+        tools=tools_list,
+        verbose=verbose,
+        max_tokens=8126,
+        max_tool_rounds=100,
+        config_params=config_params,
+    )
+    
+    return agent
+
+def save_messages(agent):
+    """
+    Save agent messages to .janito/last_message.json
+    
+    Args:
+        agent: The claudine agent instance
+    """
+    try:
+        # Get the workspace directory
+        workspace_dir = Path(get_config().workspace_dir)
+        
+        # Create .janito directory if it doesn't exist
+        janito_dir = workspace_dir / ".janito"
+        janito_dir.mkdir(exist_ok=True)
+        
+        # Get messages from the agent
+        messages = agent.get_messages()
+        
+        # Save messages to file
+        with open(janito_dir / "last_message.json", "w", encoding="utf-8") as f:
+            json.dump(messages, f, ensure_ascii=False, indent=2)
+            
+        if get_config().verbose:
+            console.print(f"[bold green]✅ Conversation saved to {janito_dir / 'last_message.json'}[/bold green]")
+    except Exception as e:
+        console.print(f"[bold red]❌ Error saving conversation:[/bold red] {str(e)}")
+
+def load_messages():
+    """
+    Load messages from .janito/last_message.json
+    
+    Returns:
+        List of message dictionaries or None if file doesn't exist
+    """
+    try:
+        # Get the workspace directory
+        workspace_dir = Path(get_config().workspace_dir)
+        
+        # Check if file exists
+        messages_file = workspace_dir / ".janito" / "last_message.json"
+        if not messages_file.exists():
+            console.print("[bold yellow]⚠️ No previous conversation found[/bold yellow]")
+            return None
+        
+        # Load messages from file
+        with open(messages_file, "r", encoding="utf-8") as f:
+            messages = json.load(f)
+            
+        if get_config().verbose:
+            console.print(f"[bold green]✅ Loaded previous conversation from {messages_file}[/bold green]")
+            console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
+            
+        return messages
+    except Exception as e:
+        console.print(f"[bold red]❌ Error loading previous conversation:[/bold red] {str(e)}")
+        return None
+
+def handle_query(query: str, temperature: float, verbose: bool, show_tokens: bool, continue_conversation: bool = False) -> None:
+    """
+    Handle a query by initializing the agent and sending the query.
+    
+    Args:
+        query: The query to send to the agent
+        temperature: Temperature value for model generation
+        verbose: Whether to enable verbose mode
+        show_tokens: Whether to show detailed token usage
+        continue_conversation: Whether to continue the previous conversation
+    """
+    # Initialize the agent
+    agent = initialize_agent(temperature, verbose)
+    
+    # Load previous messages if continuing conversation
+    if continue_conversation:
+        messages = load_messages()
+        if messages:
+            agent.set_messages(messages)
+            console.print("[bold blue]🔄 Continuing previous conversation[/bold blue]")
+    
+    # Send the query to the agent
+    try:
+        agent.query(query)
+        
+        # Save messages after successful query
+        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
+        from janito.tools import print_usage_stats
+        print_usage_stats()
+            
+    except KeyboardInterrupt:
+        # Handle Ctrl+C by printing token and tool usage information
+        console.print("\n[bold yellow]⚠️ Query interrupted by user (Ctrl+C)[/bold yellow]")
+        
+        # Save messages even if interrupted
+        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
+            from janito.tools import print_usage_stats
+            print_usage_stats()
+        except Exception as e:
+            console.print(f"[bold red]❌ Error generating usage report:[/bold red] {str(e)}")
+            if verbose:
+                import traceback
+                console.print(traceback.format_exc())
+        
+        # Exit with non-zero status to indicate interruption
+        sys.exit(130)  # 130 is the standard exit code for SIGINT
+            
+    except anthropic.APIError as e:
+        console.print(f"[bold red]❌ Anthropic API Error:[/bold red] {str(e)}")
+        
+    except Exception as e:
+        console.print(f"[bold red]❌ Error:[/bold red] {str(e)}")
+        if verbose:
+            import traceback
+            console.print(traceback.format_exc())