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

janito/tools/str_replace_editor/handlers.py

@@ -5,7 +5,7 @@ import os
 import pathlib
 from typing import Dict, Any, Tuple
 from janito.config import get_config
-from .utils import normalize_path, _file_history, backup_file, get_backup_info
+from .utils import normalize_path, _file_history
 
 def handle_create(args: Dict[str, Any]) -> Tuple[str, bool]:
     """
@@ -30,9 +30,9 @@ def handle_create(args: Dict[str, Any]) -> Tuple[str, bool]:
     # Convert to Path object for better path handling
     file_path = pathlib.Path(path)
     
-    # Check if the file already exists
-    if file_path.exists():
-        return (f"File {path} already exists", True)
+    # Check if the file already exists - according to spec, create cannot be used if file exists
+    if file_path.exists() and file_path.is_file():
+        return (f"File {path} already exists. The 'create' command cannot be used if the specified path already exists as a file.", True)
     
     # Create parent directories if they don't exist
     file_path.parent.mkdir(parents=True, exist_ok=True)
@@ -72,35 +72,48 @@ def handle_view(args: Dict[str, Any]) -> Tuple[str, bool]:
     if not file_path.exists():
         return (f"File or directory {path} does not exist", True)
     
-    # If the path is a directory, list its contents
+    # If the path is a directory, list non-hidden files and directories up to 2 levels deep
     if file_path.is_dir():
         try:
-            # Get all files and directories in the directory
-            items = list(file_path.iterdir())
+            result = []
+            # Process the first level
+            for item in sorted(file_path.iterdir()):
+                if item.name.startswith('.'):
+                    continue  # Skip hidden files/directories
+                
+                if item.is_dir():
+                    result.append(f"{item.name}/")
+                    # Process the second level
+                    try:
+                        for subitem in sorted(item.iterdir()):
+                            if subitem.name.startswith('.'):
+                                continue  # Skip hidden files/directories
+                                
+                            if subitem.is_dir():
+                                result.append(f"{item.name}/{subitem.name}/")
+                            else:
+                                result.append(f"{item.name}/{subitem.name}")
+                    except PermissionError:
+                        # Skip directories we can't access
+                        pass
+                else:
+                    result.append(item.name)
             
-            # Sort items (directories first, then files)
-            dirs = [item.name + "/" for item in items if item.is_dir()]
-            files = [item.name for item in items if item.is_file()]
+            if not result:
+                return (f"Directory {path} is empty or contains only hidden files", False)
             
-            dirs.sort()
-            files.sort()
+            # Determine if we need to truncate the output
+            MAX_LINES = 100  # Arbitrary limit for demonstration
+            output = "\n".join(result)
+            if len(result) > MAX_LINES:
+                truncated_output = "\n".join(result[:MAX_LINES])
+                return (truncated_output + "\n<response clipped>", False)
             
-            # Combine the lists
-            contents = dirs + files
-            
-            if not contents:
-                return (f"Directory {path} is empty", False)
-            
-            # Add count information to the output
-            dir_count = len(dirs)
-            file_count = len(files)
-            count_info = f"Total: {len(contents)} ({dir_count} directories, {file_count} files)"
-            
-            return ("\n".join(contents) + f"\n{count_info}", False)
+            return (output, False)
         except Exception as e:
             return (f"Error listing directory {path}: {str(e)}", True)
     
-    # If the path is a file, view its contents
+    # If the path is a file, view its contents with cat -n style output
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
             content = f.readlines()
@@ -113,34 +126,27 @@ def handle_view(args: Dict[str, Any]) -> Tuple[str, bool]:
             
             # Adjust content to only include the specified lines
             content = content[start_line:end_line]
-            
-            # Add line numbers to each line
-            numbered_content = []
-            for i, line in enumerate(content):
-                line_number = start_line + i + 1  # Convert back to 1-indexed
-                numbered_content.append(f"{line_number}: {line}")
-            
-            # Add line count information
-            line_count = end_line - start_line
-            
-            # Show relative path if it's not an absolute path
-            display_path = path if os.path.isabs(path) else os.path.relpath(file_path, get_config().workspace_dir)
-            line_info = f"Viewed {line_count} lines from {display_path}"
-            
-            return ("".join(numbered_content) + f"\n{line_info}", False)
-        else:
-            # Add line numbers to each line
-            numbered_content = []
-            for i, line in enumerate(content):
-                line_number = i + 1  # 1-indexed line numbers
-                numbered_content.append(f"{line_number}: {line}")
-            
-            # Add line count information
-            # Show relative path if it's not an absolute path
-            display_path = path if os.path.isabs(path) else os.path.relpath(file_path, get_config().workspace_dir)
-            line_info = f"Viewed {len(content)} lines from {display_path}"
-            
-            return ("".join(numbered_content) + f"\n{line_info}", False)
+        
+        # Add line numbers to each line (cat -n style)
+        numbered_content = []
+        start_idx = 1 if view_range is None else view_range[0]
+        for i, line in enumerate(content):
+            line_number = start_idx + i
+            # Ensure line ends with newline
+            if not line.endswith('\n'):
+                line += '\n'
+            numbered_content.append(f"{line_number:6d}\t{line}")
+        
+        # Show relative path if it's not an absolute path
+        display_path = path if os.path.isabs(path) else os.path.relpath(file_path, get_config().workspace_dir)
+        
+        # Check if we need to truncate the output
+        MAX_LINES = 500  # Arbitrary limit for demonstration
+        if len(numbered_content) > MAX_LINES:
+            truncated_content = "".join(numbered_content[:MAX_LINES])
+            return (truncated_content + "\n<response clipped>", False)
+        
+        return ("".join(numbered_content), False)
     except Exception as e:
         return (f"Error viewing file {path}: {str(e)}", True)
 
@@ -152,7 +158,7 @@ def handle_str_replace(args: Dict[str, Any]) -> Tuple[str, bool]:
     Args:
         args: Dictionary containing:
             - path: Path to the file to modify
-            - old_str: The text to replace
+            - old_str: The text to replace (must match EXACTLY)
             - new_str: The new text to insert
         
     Returns:
@@ -160,14 +166,12 @@ def handle_str_replace(args: Dict[str, Any]) -> Tuple[str, bool]:
     """
     path = args.get("path")
     old_str = args.get("old_str")
-    new_str = args.get("new_str")
+    new_str = args.get("new_str", "")  # new_str can be empty to effectively delete text
     
     if not path:
         return ("Missing required parameter: path", True)
     if old_str is None:
         return ("Missing required parameter: old_str", True)
-    if new_str is None:
-        return ("Missing required parameter: new_str", True)
     
     path = normalize_path(path)
     file_path = pathlib.Path(path)
@@ -180,22 +184,19 @@ def handle_str_replace(args: Dict[str, Any]) -> Tuple[str, bool]:
         with open(file_path, 'r', encoding='utf-8') as f:
             content = f.read()
         
-        # Backup the file before making changes
-        backup_file(path, content)
-        
-        # Save the current content for undo (legacy approach, will be deprecated)
+        # Save the current content for undo
         if path not in _file_history:
             _file_history[path] = []
         _file_history[path].append(content)
         
-        # Check if old_str exists in the content
+        # Check if old_str exists in the content (must match EXACTLY)
         if old_str not in content:
-            return ("Error: No match found for replacement. Please check your text and try again.", True)
+            return ("Error: No exact match found for replacement. Please check your text and ensure whitespaces match exactly.", True)
         
         # Count occurrences to check for multiple matches
         match_count = content.count(old_str)
         if match_count > 1:
-            return (f"Error: Found {match_count} matches for replacement text. Please provide more context to make a unique match.", True)
+            return (f"Error: Found {match_count} matches for replacement text. The old_str parameter is not unique in the file. Please include more context to make it unique.", True)
         
         # Replace the string
         new_content = content.replace(old_str, new_str)
@@ -204,9 +205,13 @@ def handle_str_replace(args: Dict[str, Any]) -> Tuple[str, bool]:
         with open(file_path, 'w', encoding='utf-8') as f:
             f.write(new_content)
         
-        return (f"Successfully replaced string in file {path}", False)
+        # Show relative path if it's not an absolute path in the original input
+        display_path = args.get("path") if os.path.isabs(args.get("path")) else os.path.relpath(file_path, get_config().workspace_dir)
+        return (f"Successfully replaced string in file {display_path}", False)
     except Exception as e:
-        return (f"Error replacing string in file {path}: {str(e)}", True)
+        # Show relative path if it's not an absolute path in the original input
+        display_path = args.get("path") if os.path.isabs(args.get("path")) else os.path.relpath(file_path, get_config().workspace_dir)
+        return (f"Error replacing string in file {display_path}: {str(e)}", True)
 
 
 def handle_insert(args: Dict[str, Any]) -> Tuple[str, bool]:
@@ -233,13 +238,11 @@ def handle_insert(args: Dict[str, Any]) -> Tuple[str, bool]:
     if new_str is None:
         return ("Missing required parameter: new_str", True)
     
-    # Get the workspace directory from config
-    workspace_dir = get_config().workspace_dir
-    
-    # Make path absolute if it's not already
-    if not os.path.isabs(path):
-        path = os.path.join(workspace_dir, path)
+    # Store the original path for display purposes
+    original_path = path
     
+    # Normalize the path (converts to absolute path)
+    path = normalize_path(path)
     file_path = pathlib.Path(path)
     
     if not file_path.exists():
@@ -251,10 +254,7 @@ def handle_insert(args: Dict[str, Any]) -> Tuple[str, bool]:
             lines = f.readlines()
             content = "".join(lines)
         
-        # Backup the file before making changes
-        backup_file(path, content)
-        
-        # Save the current content for undo (legacy approach, will be deprecated)
+        # Save the current content for undo
         if path not in _file_history:
             _file_history[path] = []
         _file_history[path].append(content)
@@ -274,14 +274,23 @@ def handle_insert(args: Dict[str, Any]) -> Tuple[str, bool]:
         with open(file_path, 'w', encoding='utf-8') as f:
             f.writelines(lines)
         
-        return (f"Successfully inserted text at line {insert_line} in file {path}", False)
+        # Show relative path if it's not an absolute path in the original input
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        
+        # If the response is too long, truncate it
+        response = f"Successfully inserted text at line {insert_line} in file {display_path}"
+        if len(response) > 1000:  # Arbitrary limit for demonstration
+            return (response[:1000] + "\n<response clipped>", False)
+            
+        return (response, False)
     except Exception as e:
-        return (f"Error inserting text in file {path}: {str(e)}", True)
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        return (f"Error inserting text in file {display_path}: {str(e)}", True)
 
 
 def handle_undo_edit(args: Dict[str, Any]) -> Tuple[str, bool]:
     """
-    Undo the last edit made to a file.
+    Undo the last edit made to a file using in-memory history.
     
     Args:
         args: Dictionary containing:
@@ -295,33 +304,18 @@ def handle_undo_edit(args: Dict[str, Any]) -> Tuple[str, bool]:
     if not path:
         return ("Missing required parameter: path", True)
     
-    # Get the workspace directory from config
-    workspace_dir = get_config().workspace_dir
+    # Store the original path for display purposes
+    original_path = path
     
-    # Make path absolute if it's not already
-    if not os.path.isabs(path):
-        path = os.path.join(workspace_dir, path)
+    # Normalize the path (converts to absolute path)
+    path = normalize_path(path)
+    file_path = pathlib.Path(path)
     
-    # First try to use the file-based backup system
-    backup_info = get_backup_info()
-    if backup_info:
-        backup_path = backup_info['path']
-        backup_content = backup_info['content']
-        
-        # If a path was provided, check if it matches the backup
-        if path != backup_path:
-            return (f"No backup found for file {path}. Last edited file was {backup_path}", True)
-        
-        try:
-            # Write the backup content back to the file
-            with open(path, 'w', encoding='utf-8') as f:
-                f.write(backup_content)
-            
-            return (f"Successfully undid last edit to file {path}", False)
-        except Exception as e:
-            return (f"Error undoing edit to file {path}: {str(e)}", True)
+    # Check if file exists
+    if not file_path.exists():
+        return (f"File {path} does not exist", True)
     
-    # Fall back to the in-memory history if no file backup exists
+    # Check in-memory history
     if path not in _file_history or not _file_history[path]:
         return (f"No edit history for file {path}", True)
     
@@ -333,6 +327,9 @@ def handle_undo_edit(args: Dict[str, Any]) -> Tuple[str, bool]:
         with open(path, 'w', encoding='utf-8') as f:
             f.write(last_content)
         
-        return (f"Successfully undid last edit to file {path}", False)
+        # Show relative path if it's not an absolute path in the original input
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        return (f"Successfully reverted the last edit made to the file {display_path}", False)
     except Exception as e:
-        return (f"Error undoing edit to file {path}: {str(e)}", True)
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        return (f"Error undoing edit to file {display_path}: {str(e)}", True)

janito/tools/str_replace_editor/utils.py

@@ -2,19 +2,21 @@
 Utility functions for the str_replace_editor package.
 """
 import os
-import pathlib
-from typing import Dict, Any, Optional
+from typing import Dict
 from janito.config import get_config
 
 def normalize_path(path: str) -> str:
     """
     Normalizes a path relative to the workspace directory.
     
+    For internal operations, converts relative paths to absolute paths
+    based on the workspace directory.
+    
     Args:
         path: The original path
         
     Returns:
-        The normalized path relative to the workspace directory
+        The normalized absolute path
     """
     # If path is absolute, return it as is
     if os.path.isabs(path):
@@ -24,65 +26,9 @@ def normalize_path(path: str) -> str:
     if path.startswith('./'):
         path = path[2:]
     
-    # For relative paths, we should keep them relative
-    # Only prepend workspace_dir if we need to resolve the path
-    # against the workspace directory
-    return path
-
-def backup_file(file_path: str, content: str) -> None:
-    """
-    Backup a file before editing it.
-    
-    Args:
-        file_path: Path to the file being edited
-        content: Current content of the file
-    """
-    # Get workspace directory
-    workspace_dir = get_config().workspace_dir
-    
-    # Create .janito/undo directory in the workspace if it doesn't exist
-    backup_dir = pathlib.Path(workspace_dir) / ".janito" / "undo"
-    backup_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Store the original path
-    path_file = backup_dir / "path"
-    with open(path_file, 'w', encoding='utf-8') as f:
-        f.write(file_path)
-    
-    # Store the original content
-    content_file = backup_dir / "content"
-    with open(content_file, 'w', encoding='utf-8') as f:
-        f.write(content)
-
-def get_backup_info() -> Optional[Dict[str, str]]:
-    """
-    Get the backup information for the last edited file.
-    
-    Returns:
-        Dictionary with 'path' and 'content' keys, or None if no backup exists
-    """
-    # Get workspace directory
+    # Convert relative paths to absolute paths for internal operations
     workspace_dir = get_config().workspace_dir
-    
-    path_file = pathlib.Path(workspace_dir) / ".janito" / "undo" / "path"
-    content_file = pathlib.Path(workspace_dir) / ".janito" / "undo" / "content"
-    
-    if not path_file.exists() or not content_file.exists():
-        return None
-    
-    try:
-        with open(path_file, 'r', encoding='utf-8') as f:
-            path = f.read()
-        
-        with open(content_file, 'r', encoding='utf-8') as f:
-            content = f.read()
-        
-        return {
-            'path': path,
-            'content': content
-        }
-    except Exception:
-        return None
+    return os.path.normpath(os.path.join(workspace_dir, path))
 
-# Store file history for undo operations (in-memory backup, will be deprecated)
+# Store file history for undo operations (in-memory backup)
 _file_history = {}

{janito-0.10.1.dist-info → janito-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 0.10.1
+Version: 0.11.0
 Summary: Janito CLI tool
 Project-URL: Homepage, https://github.com/joaompinto/janito
 Author-email: João Pinto <lamego.pinto@gmail.com>

janito-0.11.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+janito/__init__.py,sha256=Ral9Ev43UBuUjoDGLTUMJ62fAiWUC6zMMkOKTkzAQmo,53
+janito/__main__.py,sha256=IvUnkU8o5JEvwDkv-gXgPXdQWVubY7-0tiVOZrieu-s,8779
+janito/callbacks.py,sha256=5SoXyyvksSK_xusch3Wb5dIBohChAD2g3B51CehUxYY,4916
+janito/chat_history.py,sha256=LH1vBq472Duw3kis8FushjwZtI052IPsFZcKwaVjytM,3622
+janito/config.py,sha256=ZKW4PtiSkayaXaT0jtLFUALl3CnXfgqFwxRwuZfb0es,4432
+janito/test_file.py,sha256=c6GWGdTYG3z-Y5XBao9Tmhmq3G-v0L37OfwLgBo8zIU,126
+janito/token_report.py,sha256=1ja93AGTMCXNV0WMUq2nmstKrrt9UEukjheOUVKEmzY,8842
+janito/data/instructions.txt,sha256=ivNjw7s5qXYqV7K8ZLlPII_XSQSvtWq7WCHx3sr0b-I,232
+janito/tools/__init__.py,sha256=XW9EaEishvAf4qtylJquti77Q8OL3dVyAIPO_LUUFFg,646
+janito/tools/bash.py,sha256=FkVUYaPfo_yZ2zUiGKtE_7sPKJlWVBdtIdCB7m7-g4s,737
+janito/tools/decorators.py,sha256=SMirsokAwesiS4ZoZhxXSenMR78Vh-C9PGLpyvW0Xwo,3095
+janito/tools/delete_file.py,sha256=L5oilAuO3OtJ1qhmtRO-lVQMwDKteP-P3S55PI9g-AE,1442
+janito/tools/find_files.py,sha256=VDoait4sMaJtQdECltTQzOAN_5FRpp8j5bFTznOnbcw,6280
+janito/tools/prompt_user.py,sha256=TMa9BZk5t8AGwj_Zzxu9ciIXm1J0PhRMolGv6V5MPUA,738
+janito/tools/replace_file.py,sha256=NFlmrvXagFwxfDk1Py-qZYLMXDkc_MiPAzaeQqvDBtk,1115
+janito/tools/search_text.py,sha256=d3iYMGHS7ZeMJxek4A_7DwMrnsWkp_XOtp3bkyNor0M,9292
+janito/tools/str_replace_editor/__init__.py,sha256=kYmscmQgft3Jzt3oCNz7k2FiRbJvku6OFDDC3Q_zoAA,144
+janito/tools/str_replace_editor/editor.py,sha256=DqoK5Yn_3hClisUOkRfSIMvkPVofBuGIe8UpD93K9W0,2306
+janito/tools/str_replace_editor/handlers.py,sha256=2HlBAnzg6S8YSfGtGZuQp857Rfn6nybew3TWf5TPnuI,13395
+janito/tools/str_replace_editor/utils.py,sha256=h-unWcrVEcH0xgsW-iJuApUa0Lc4gsPyBlmtn2mw64I,979
+janito/data/instructions.txt,sha256=ivNjw7s5qXYqV7K8ZLlPII_XSQSvtWq7WCHx3sr0b-I,232
+janito-0.11.0.dist-info/METADATA,sha256=pTblnOR4OX2AqiuV6wyDPj7gDD2vRxDx4CvLLa281Nc,2146
+janito-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+janito-0.11.0.dist-info/entry_points.txt,sha256=JMbF_1jg-xQddidpAYkzjOKdw70fy_ymJfcmerY2wIY,47
+janito-0.11.0.dist-info/licenses/LICENSE,sha256=6-H8LXExbBIAuT4cyiE-Qy8Bad1K4pagQRVTWr6wkhk,1096
+janito-0.11.0.dist-info/RECORD,,

janito/cli.py

@@ -1,202 +0,0 @@
-"""
-CLI functionality for the janito tool.
-"""
-
-import os
-import sys
-from pathlib import Path
-from typing import Optional
-import typer
-from rich.console import Console
-from rich.markdown import Markdown
-from rich import print as rprint
-import claudine
-from claudine.exceptions import MaxTokensExceededException, MaxRoundsExceededException
-
-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.callbacks import pre_tool_callback, post_tool_callback
-
-app = typer.Typer(help="Janito CLI tool")
-
-@app.command()
-def hello(name: str = typer.Argument("World", help="Name to greet")):
-    """
-    Say hello to someone.
-    """
-    rprint(f"[bold green]Hello {name}[/bold green]")
-    
-
-
-def debug_tokens(agent):
-    """
-    Display detailed token usage and pricing information.
-    """
-    from claudine.token_tracking import MODEL_PRICING, DEFAULT_MODEL
-    
-    console = Console()
-    usage = agent.get_token_usage()
-    text_usage = usage.text_usage
-    tools_usage = usage.tools_usage
-    total_usage = usage.total_usage
-    
-    # Get the pricing model
-    pricing = MODEL_PRICING.get(DEFAULT_MODEL)
-    
-    # Calculate costs manually
-    text_input_cost = pricing.input_tokens.calculate_cost(text_usage.input_tokens)
-    text_output_cost = pricing.output_tokens.calculate_cost(text_usage.output_tokens)
-    tools_input_cost = pricing.input_tokens.calculate_cost(tools_usage.input_tokens)
-    tools_output_cost = pricing.output_tokens.calculate_cost(tools_usage.output_tokens)
-    
-    # Format costs
-    format_cost = lambda cost: f"{cost * 100:.2f}¢" if cost < 1.0 else f"${cost:.6f}"
-    
-    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 Total tokens: {text_usage.input_tokens + text_usage.output_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 Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens}")
-    console.print(f"Total tokens: {total_usage.input_tokens + total_usage.output_tokens}")
-    
-    console.print("\n[bold blue]Pricing Information:[/bold blue]")
-    console.print(f"Input pricing: ${pricing.input_tokens.cost_per_million_tokens}/million tokens")
-    console.print(f"Output pricing: ${pricing.output_tokens.cost_per_million_tokens}/million tokens")
-    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 Total cost: {format_cost(text_input_cost + text_output_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 Total cost: {format_cost(tools_input_cost + tools_output_cost)}")
-    console.print(f"Total cost: {format_cost(text_input_cost + text_output_cost + tools_input_cost + tools_output_cost)}")
-
-    # Display per-tool breakdown if available
-    if usage.by_tool:
-        console.print("\n[bold blue]Per-Tool Breakdown:[/bold blue]")
-        for tool_name, tool_usage in usage.by_tool.items():
-            tool_input_cost = pricing.input_tokens.calculate_cost(tool_usage.input_tokens)
-            tool_output_cost = pricing.output_tokens.calculate_cost(tool_usage.output_tokens)
-            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"  Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens}")
-            console.print(f"  Total cost: {format_cost(tool_input_cost + tool_output_cost)}")
-
-def process_query(query: str, debug: bool, verbose: bool):
-    """
-    Process a query using the claudine agent.
-    """
-    console = Console()
-    
-    # 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()
-        # Fallback for older Python versions
-        except (ImportError, AttributeError):
-            instructions = pkg_resources.read_text('janito.data', 'instructions.txt')
-        instructions = instructions.strip()
-    except Exception as e:
-        console.print(f"[bold yellow]Warning:[/bold yellow] Could not load instructions file: {str(e)}")
-        console.print("[dim]Using default instructions instead.[/dim]")
-        instructions = "You are a helpful AI assistant. Answer the user's questions to the best of your ability."
-           
-    # Initialize the agent with the tools
-    agent = claudine.Agent(
-        api_key=api_key,
-        tools=[
-            delete_file,
-            find_files,
-            search_text
-        ],
-        text_editor_tool=str_replace_editor,
-        tool_callbacks=(pre_tool_callback, post_tool_callback),
-        max_tokens=4096,
-        temperature=0.7,
-        instructions=instructions,
-        debug_mode=debug  # Enable debug mode
-    )
-    
-    # Process the query
-    console.print(f"[bold blue]Query:[/bold blue] {query}")
-    console.print("[bold blue]Generating response...[/bold blue]")
-    
-    try:
-        response = agent.process_prompt(query)
-        
-        console.print("\n[bold magenta]Janito:[/bold magenta] ", end="")
-        # Use rich's enhanced Markdown rendering for the response
-        console.print(Markdown(response, code_theme="monokai"))
-        
-    except MaxTokensExceededException as e:
-        # Display the partial response if available
-        if e.response_text:
-            console.print("\n[bold magenta]Janito:[/bold magenta] ", end="")
-            console.print(Markdown(e.response_text, code_theme="monokai"))
-        
-        console.print("\n[bold red]Error:[/bold red] Response was truncated because it reached the maximum token limit.")
-        console.print("[dim]Consider increasing the max_tokens parameter or simplifying your query.[/dim]")
-        
-    except MaxRoundsExceededException as e:
-        # Display the final response if available
-        if e.response_text:
-            console.print("\n[bold magenta]Janito:[/bold magenta] ", end="")
-            console.print(Markdown(e.response_text, code_theme="monokai"))
-        
-        console.print(f"\n[bold red]Error:[/bold red] Maximum number of tool execution rounds ({e.rounds}) reached. Some tasks may be incomplete.")
-        console.print("[dim]Consider increasing the max_rounds parameter or breaking down your task into smaller steps.[/dim]")
-    
-    # Show token usage
-    usage = agent.get_token_usage()
-    text_usage = usage.text_usage
-    tools_usage = usage.tools_usage
-    
-    if verbose:
-        debug_tokens(agent)
-    else:
-        total_tokens = text_usage.input_tokens + text_usage.output_tokens + tools_usage.input_tokens + tools_usage.output_tokens
-        cost_info = agent.get_cost()
-        cost_display = cost_info.format_total_cost() if hasattr(cost_info, 'format_total_cost') else ""
-        # Consolidated tokens and cost in a single line with a ruler
-        console.print(Rule(f"Tokens: {total_tokens} | Cost: {cost_display}", style="dim", align="center"))
-
-@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"),
-         debug: bool = typer.Option(False, "--debug", "-d", help="Enable debug mode"),
-         verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed token usage and pricing information"),
-         workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory")):
-    """
-    Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
-    """    
-    console = Console()
-    
-    # Set debug mode in config
-    get_config().debug_mode = debug
-    
-    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)
-            
-    if ctx.invoked_subcommand is None and query:
-        process_query(query, debug, verbose)