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

janito-1.0.1.dist-info/RECORD

@@ -0,0 +1,51 @@
+janito/__init__.py,sha256=j9q3lYMZra0QrErNnn9E5GNXxWLOlDgeOkmX8oXa7ro,23
+janito/__main__.py,sha256=CBScR30Tm-vuhIJM8o5HXKr0q-smICiwSVyuU68BP8U,78
+janito/render_prompt.py,sha256=HrMUELV4tI3PWqv6RM6teiVvnUejdehBcnHUFzit3Bo,445
+janito/agent/__init__.py,sha256=CByAH5Yk-yH64zo0RU7Z3nsn_7Vmandphqk0JNlpyj8,21
+janito/agent/agent.py,sha256=qGjkGajNjroz1kU-iV--0DD_2FwmwjAM1Y9Z5foxwoE,3590
+janito/agent/config.py,sha256=6WQbjrK-UwkG9Yb5e5ljfBIvQs3Y_Wgd3Py8FbO0RiI,3565
+janito/agent/config_defaults.py,sha256=cR4kFkjg6BFccE0psy4khBiKjnj60VCQhmqLvLbjcJM,373
+janito/agent/conversation.py,sha256=5UtWgDsRh205p0Dq8tEtqEPT0avL8KFs3xmwJomaYEk,4664
+janito/agent/queued_tool_handler.py,sha256=THPymKXnpoXfN49EhW5b4hrwpWZZup73JKFDJ_U03tI,540
+janito/agent/runtime_config.py,sha256=gigcKUwaXs_qSdXdC5InUTPmdXUbOA-tRUx2ZJ5zzI0,906
+janito/agent/tool_handler.py,sha256=f3iOWi78bKn0B6twMlayedmE0OMeQ1do32yZl4DMzaE,4399
+janito/agent/tools/__init__.py,sha256=7-RjFK1YXacifjSrXT4EdMXG_kyKVl7TCjrcHkklaCQ,414
+janito/agent/tools/ask_user.py,sha256=MHKHyBTD4iyCM-z9_ZUbe7AMn-pz7cr6FIAB0SdESH4,1895
+janito/agent/tools/bash_exec.py,sha256=1HkjvTlXunjZ7xvxqzdayG8JWtrioC0MYOfdid_6uiY,2486
+janito/agent/tools/create_directory.py,sha256=qnP8bFeAYr3fnstbIIp6EOqur1o0xAVv1k21Y9LOAHs,698
+janito/agent/tools/create_file.py,sha256=pauO9YYnPDeO61U2tcTHgC1VPJ7yhWQOrIHhCKuLk8E,1782
+janito/agent/tools/fetch_url.py,sha256=ZPasbnPxM-lcVlpRUwviGmhiqm-MoVFA1_1K99h8I94,1926
+janito/agent/tools/file_str_replace.py,sha256=9ooaDVEHT4WDdSbFZuz_QHkQpG9s8OtP1g99_GbechA,2012
+janito/agent/tools/find_files.py,sha256=KgvnAAa7YbU59ASYcUI6XsGpxB7ouPde7E1h8e8Vf4E,1608
+janito/agent/tools/gitignore_utils.py,sha256=zXiqx4HetZ7iKkV5qXyHyZ5yrrVex4G17WHBWToFo3Y,1158
+janito/agent/tools/move_file.py,sha256=aIbZ0Jxt0JI8fHqW5SPkNMiFFs40s_wYXoHT8ooPHzs,1679
+janito/agent/tools/remove_file.py,sha256=sWvdDIP5lrQh4rhBcQEEa1hQ6AJDCuFovsBZkirk3mU,658
+janito/agent/tools/rich_live.py,sha256=cuZ3-ZxpuHxR1TvIcp0bi9F3QM1M6Ms0XiOMd8If8gU,1161
+janito/agent/tools/rich_utils.py,sha256=aQMqeaq3hIpzZ5EHQBNTKS5dNsojQp9MDfJSoqOQe0k,837
+janito/agent/tools/search_text.py,sha256=TdTpaomLt4oZpX_0zz9W_bXhI5vvQLu0IjA7mCRCJYU,2020
+janito/agent/tools/view_file.py,sha256=i4IBpn_Waw_4sgHUOaPIYPcMNmmvzM9ECoR5O5fldfU,1535
+janito/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+janito/cli/_print_config.py,sha256=gsdVgG8uGHoWZHUSzgvB-FIrlvAawF0HjXtiQZAloPk,3116
+janito/cli/_utils.py,sha256=Q_OCFZmbr78qW4hSSUUhjondVc0ao7-iUHE7Ig8IP1g,289
+janito/cli/arg_parser.py,sha256=6Y_gBJSPk7tdHKSAsi1fQdr4pnCp8dcSGFrlu7s8KiI,2498
+janito/cli/config_commands.py,sha256=Ovk2LszVrHcKSqXjlH-fvJYhT3axZomlh9_wpNQfSYI,5675
+janito/cli/logging_setup.py,sha256=dWQ0wFf4YuF5lxZlhpN6lis7G56LeFYUwQdh9nA5NmA,1141
+janito/cli/main.py,sha256=ONmn_lIPu8_Rd57j3YfWEx46fWj8gAkONPLdctABwy0,1333
+janito/cli/runner.py,sha256=K_xpygfg4MpyLuI6hx3s1I6-leEd80w08l3F6PIO4so,5362
+janito/cli_chat_shell/__init__.py,sha256=PDGl7xK_vgkROoXvUxGZqVQFfuL9U4TjdexpP8E2JKg,41
+janito/cli_chat_shell/chat_loop.py,sha256=KjnmhOYU0zblBzV5Q80BCqgvKSi_rPpE3TykzzDoexk,5259
+janito/cli_chat_shell/commands.py,sha256=Tvhw8azybchGS1qi2yJEn3FKho-FDYOK1ZT865GYwhM,7615
+janito/cli_chat_shell/config_shell.py,sha256=s59PCt_TmBPqQJ_C8nkKo4kCcW9aq3Jhpe9RlRCa0-s,3265
+janito/cli_chat_shell/load_prompt.py,sha256=EuUlHg317T8f5VqEMaJxFgzWBl51zC2sND0eeYr6pJ4,612
+janito/cli_chat_shell/session_manager.py,sha256=Gax0pC0ediDsExLUwPEg_nD8MdSrznaHoer53zxLYuE,1966
+janito/cli_chat_shell/ui.py,sha256=7O36dWaXDQ5r-GGD6a57iHSiDpN2pkdav3HxSdf6CIc,5279
+janito/templates/system_instructions.j2,sha256=f-hRp0ZliGac8vg6HJiYkU0TketpFoSbUunh9TOQrtE,1795
+janito/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+janito/web/__main__.py,sha256=oPXNF332aCeI7aUWr7_8M57oOKugw422VrEubxFp0P4,354
+janito/web/app.py,sha256=bZse9S_F9hFSYRTJxoel5RjrtoAmvJ_lYkPfKRmBI1o,4125
+janito-1.0.1.dist-info/licenses/LICENSE,sha256=sHBqv0bvtrb29H7WRR-Z603YHm9pLtJIo3nHU_9cmgE,1091
+janito-1.0.1.dist-info/METADATA,sha256=NcSx21pY78wR4NzupbiIuEc0srPMn9nToBpLFbKZQjM,5103
+janito-1.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+janito-1.0.1.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-1.0.1.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
+janito-1.0.1.dist-info/RECORD,,

{janito-0.15.0.dist-info → janito-1.0.1.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

janito-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+janito = janito.__main__:main

{janito-0.15.0.dist-info → janito-1.0.1.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [year] [copyright holder]
+Copyright (c) [year] [Full Name]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

janito-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+janito

janito/callbacks.py

@@ -1,34 +0,0 @@
-"""
-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/agent/__init__.py

@@ -1,7 +0,0 @@
-"""
-Agent initialization and query handling for Janito CLI.
-"""
-from janito.cli.agent.query import handle_query
-from janito.cli.agent.conversation import load_messages, save_messages
-
-__all__ = ["handle_query", "load_messages", "save_messages"]

janito/cli/agent/conversation.py

@@ -1,149 +0,0 @@
-"""
-Conversation management functionality for Janito CLI.
-"""
-import json
-import datetime
-import sys
-from typing import Optional, List, Dict, Any
-from rich.console import Console
-from pathlib import Path
-import claudine
-
-from janito.config import get_config
-
-console = Console()
-
-def generate_message_id() -> str:
-    """
-    Generate a message ID based on timestamp with seconds granularity
-    
-    Returns:
-        str: A timestamp-based message ID
-    """
-    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
-    return timestamp
-
-def save_messages(agent: claudine.Agent) -> Optional[str]:
-    """
-    Save agent messages to .janito/last_messages/{message_id}.json
-    
-    Args:
-        agent: The claudine agent instance
-        
-    Returns:
-        str: The message ID used for saving, or None if saving failed
-    """
-    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)
-        
-        # Create last_messages directory if it doesn't exist
-        messages_dir = janito_dir / "last_messages"
-        messages_dir.mkdir(exist_ok=True)
-        
-        # Generate a unique message ID
-        message_id = generate_message_id()
-        
-        # Get messages from the agent
-        messages = agent.get_messages()
-        
-        # Create a message object with metadata
-        message_object = {
-            "id": message_id,
-            "timestamp": datetime.datetime.now().isoformat(),
-            "messages": messages
-        }
-        
-        # Save messages to file
-        message_file = messages_dir / f"{message_id}.json"
-        with open(message_file, "w", encoding="utf-8") as f:
-            json.dump(message_object, f, ensure_ascii=False, indent=2)
-            
-        if get_config().verbose:
-            console.print(f"[bold green]✅ Conversation saved to {message_file}[/bold green]")
-            
-        return message_id
-    except Exception as e:
-        console.print(f"[bold red]❌ Error saving conversation:[/bold red] {str(e)}")
-        return None
-
-def load_messages(message_id: Optional[str] = None) -> Optional[List[Dict[str, Any]]]:
-    """
-    Load messages from .janito/last_messages/{message_id}.json or the latest message file
-    
-    Args:
-        message_id: Optional message ID to load specific conversation
-        
-    Returns:
-        List of message dictionaries or None if file doesn't exist
-    """
-    try:
-        # Get the workspace directory
-        workspace_dir = Path(get_config().workspace_dir)
-        janito_dir = workspace_dir / ".janito"
-        messages_dir = janito_dir / "last_messages"
-        
-        # If message_id is provided, try to load that specific conversation
-        if message_id:
-            # Check if the message ID is a file name or just the ID
-            if message_id.endswith('.json'):
-                message_file = messages_dir / message_id
-            else:
-                message_file = messages_dir / f"{message_id}.json"
-                
-            if not message_file.exists():
-                console.print(f"[bold yellow]⚠️ No conversation found with ID {message_id}[/bold yellow]")
-                return None
-                
-            # Load messages from file
-            with open(message_file, "r", encoding="utf-8") as f:
-                message_object = json.load(f)
-                
-            # Extract messages from the message object
-            if isinstance(message_object, dict) and "messages" in message_object:
-                messages = message_object["messages"]
-            else:
-                # Handle legacy format
-                messages = message_object
-                
-            if get_config().verbose:
-                console.print(f"[bold green]✅ Loaded conversation from {message_file}[/bold green]")
-                console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
-                
-            return messages
-        
-        # If no message_id is provided, try to load the latest message from last_messages directory
-        if not messages_dir.exists() or not any(messages_dir.iterdir()):
-            console.print("[bold yellow]⚠️ No previous conversation found[/bold yellow]")
-            return None
-        
-        # Find the latest message file (based on filename which is a timestamp)
-        latest_file = max(
-            [f for f in messages_dir.iterdir() if f.is_file() and f.suffix == '.json'],
-            key=lambda x: x.stem
-        )
-        
-        # Load messages from the latest file
-        with open(latest_file, "r", encoding="utf-8") as f:
-            message_object = json.load(f)
-            
-        # Extract messages from the message object
-        if isinstance(message_object, dict) and "messages" in message_object:
-            messages = message_object["messages"]
-        else:
-            # Handle legacy format
-            messages = message_object
-            
-        if get_config().verbose:
-            console.print(f"[bold green]✅ Loaded latest conversation from {latest_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 conversation:[/bold red] {str(e)}")
-        return None
-

janito/cli/agent/initialization.py

@@ -1,168 +0,0 @@
-"""
-Agent initialization functionality for Janito CLI.
-"""
-import os
-import platform
-import typer
-from typing import Optional, Dict, Any
-from rich.console import Console
-from jinja2 import Template
-import importlib.resources as pkg_resources
-import claudine
-
-from janito.config import get_config, Config
-from janito.callbacks import text_callback
-from janito.tools import str_replace_editor, get_tools, reset_tracker
-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 or user input.
-    
-    Returns:
-        str: The API key
-    """
-    # Get API key from global config or ask the user
-    api_key = Config.get_api_key()
-        
-    # If not found, prompt the user
-    if not api_key:
-        console.print("[bold yellow]⚠️ Warning:[/bold yellow] API key not found in global config.")
-        console.print("🔑 Please set it using --set-api-key or provide your API key now:")
-        api_key = typer.prompt("Anthropic API Key", hide_input=True)
-    
-    return api_key
-
-def load_instructions() -> str:
-    """
-    Load instructions template and render it with variables.
-    
-    Returns:
-        str: The rendered instructions
-    """
-    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, system_instructions: Optional[str] = None) -> claudine.Agent:
-    """
-    Initialize the Claude agent with tools and configuration.
-    
-    Args:
-        temperature: Temperature value for model generation
-        verbose: Whether to enable verbose mode
-        system_instructions: Optional custom system instructions to use instead of loading from file
-        
-    Returns:
-        claudine.Agent: The initialized agent
-    """
-    # Get API key
-    api_key = get_api_key()
-    
-    # Load instructions or use provided system instructions
-    if system_instructions:
-        instructions = system_instructions
-        if verbose:
-            console.print("[bold blue]🔄 Using custom system instructions provided via --system parameter[/bold blue]")
-            # Print the first 50 characters of the instructions for verification
-            preview = system_instructions[:50] + "..." if len(system_instructions) > 50 else system_instructions
-            console.print(f"[dim]System instructions preview: {preview}[/dim]")
-    else:
-        instructions = load_instructions()
-    
-    # Get tools
-    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
-    if get_config().no_tools:
-        # If no_tools mode is enabled, don't pass any tools to the agent
-        agent = claudine.Agent(
-            api_key=api_key,
-            system_prompt=instructions,
-            callbacks={"text": text_callback},
-            verbose=verbose,
-            max_tokens=8126,
-            max_tool_rounds=100,
-            config_params=config_params,
-            # Don't pass any tools, including text_editor_tool and bash_tool
-        )
-    else:
-        # Normal mode with tools
-        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

janito/cli/agent/query.py

@@ -1,112 +0,0 @@
-"""
-Query handling functionality for Janito CLI.
-"""
-import sys
-import traceback
-from typing import Optional
-from rich.console import Console
-import anthropic
-
-from janito.token_report import generate_token_report
-from janito.tools import print_usage_stats
-from janito.cli.agent.initialization import initialize_agent
-from janito.cli.agent.conversation import load_messages, save_messages
-from janito.config import Config
-
-console = Console()
-
-def handle_query(query: str, temperature: float, verbose: bool, show_tokens: bool, continue_conversation: Optional[str] = None, system_instructions: Optional[str] = None) -> 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: Optional message ID to continue a specific conversation
-        system_instructions: Optional custom system instructions to use instead of loading from file
-    """
-    # Initialize the agent
-    agent = initialize_agent(temperature, verbose, system_instructions)
-    
-    # Load previous messages if continuing conversation
-    if continue_conversation is not None:
-        # If continue_conversation is an empty string (from flag with no value), use default behavior
-        message_id = None if continue_conversation == "" else continue_conversation
-        messages = load_messages(message_id)
-        if messages:
-            agent.set_messages(messages)
-            if message_id:
-                console.print(f"[bold blue]🔄 Continuing conversation with ID: {message_id}[/bold blue]")
-            else:
-                console.print("[bold blue]🔄 Continuing most recent conversation[/bold blue]")
-                
-            # Provide information about the conversation being continued
-            if verbose and len(messages) > 0:
-                # Get the number of messages
-                num_messages = len(messages)
-                # Get the last user message if available
-                last_user_message = next((msg.get("content", "") for msg in reversed(messages) 
-                                         if msg.get("role") == "user"), "")
-                if last_user_message:
-                    console.print(f"[dim]📝 Last query: \"{last_user_message[:60]}{'...' if len(last_user_message) > 60 else ''}\"[/dim]")
-        else:
-            console.print("[bold yellow]⚠️ No previous conversation found to continue[/bold yellow]")
-    
-    # Send the query to the agent
-    try:
-        agent.query(query)
-        
-        # Save messages after successful query and get the message ID
-        message_id = save_messages(agent)
-        
-        # Check if usage reports should be shown
-        if Config().show_usage_report:
-            # Print token usage report
-            if show_tokens:
-                generate_token_report(agent, verbose=True, interrupted=False)
-            else:
-                # Show basic token usage
-                generate_token_report(agent, verbose=False, interrupted=False)
-            
-            # Print tool usage statistics
-            print_usage_stats()
-        
-
-            
-    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
-        message_id = save_messages(agent)
-        
-        # Check if usage reports should be shown
-        if Config().show_usage_report:
-            # Print token usage report (even if interrupted)
-            try:
-                if show_tokens:
-                    generate_token_report(agent, verbose=True, interrupted=True)
-                else:
-                    # Show basic token usage
-                    generate_token_report(agent, verbose=False, interrupted=True)
-                
-                # Print tool usage statistics
-                print_usage_stats()
-                
-            except Exception as e:
-                console.print(f"[bold red]❌ Error generating usage report:[/bold red] {str(e)}")
-                if verbose:
-                    console.print(traceback.format_exc())
-        
-        # Exit with non-zero status to indicate interruption
-        sys.exit(130)  # 130 is the standard exit code for SIGINT
-            
-    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:
-            console.print(traceback.format_exc())

janito/cli/agent.py

@@ -1,12 +0,0 @@
-"""
-Agent initialization and query handling for Janito CLI.
-
-This file is a compatibility layer that imports from the new module structure.
-"""
-
-# Import the public API from the new module structure
-from janito.cli.agent.query import handle_query
-from janito.cli.agent.conversation import load_messages, save_messages
-
-# Export the public API
-__all__ = ["handle_query", "load_messages", "save_messages"]