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

janito/tools/str_replace_editor/utils.py

@@ -2,19 +2,20 @@
 Utility functions for the str_replace_editor package.
 """
 import os
-import pathlib
-from typing import Dict, Any, Optional
 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 +25,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/tools/usage_tracker.py

@@ -0,0 +1,136 @@
+"""
+Tool usage tracking module for Janito.
+
+This module provides functionality to track tool usage statistics
+such as files modified, created, deleted, and lines replaced.
+"""
+
+from functools import wraps
+from typing import Dict, Any, Callable
+import threading
+
+# Global tracker instance
+_tracker = None
+_tracker_lock = threading.Lock()
+
+class ToolUsageTracker:
+    """Tracks usage statistics for Janito tools."""
+    
+    def __init__(self):
+        self.reset()
+    
+    def reset(self):
+        """Reset all counters to zero."""
+        self.files_modified = 0
+        self.files_created = 0
+        self.files_deleted = 0
+        self.files_moved = 0
+        self.lines_replaced = 0
+        self.lines_delta = 0  # Track the net change in number of lines
+        self.web_requests = 0
+        self.bash_commands = 0
+        self.user_prompts = 0
+        self.search_operations = 0
+        self.file_views = 0
+        self.partial_file_views = 0
+    
+    def increment(self, counter_name: str, value: int = 1):
+        """Increment a specific counter by the given value."""
+        if hasattr(self, counter_name):
+            setattr(self, counter_name, getattr(self, counter_name) + value)
+    
+    def get_stats(self) -> Dict[str, int]:
+        """Get all non-zero statistics as a dictionary."""
+        stats = {}
+        for attr_name in dir(self):
+            if not attr_name.startswith('_') and not callable(getattr(self, attr_name)):
+                value = getattr(self, attr_name)
+                if value > 0:
+                    # Convert attribute_name to "Attribute Name" format
+                    display_name = ' '.join(word.capitalize() for word in attr_name.split('_'))
+                    stats[display_name] = value
+        return stats
+
+
+def get_tracker() -> ToolUsageTracker:
+    """Get the global tracker instance."""
+    global _tracker
+    with _tracker_lock:
+        if _tracker is None:
+            _tracker = ToolUsageTracker()
+    return _tracker
+
+
+def reset_tracker():
+    """Reset the global tracker."""
+    get_tracker().reset()
+
+
+def track_usage(counter_name: str, increment_value: int = 1):
+    """
+    Decorator to track tool usage.
+    
+    Args:
+        counter_name: The name of the counter to increment
+        increment_value: Value to increment the counter by (default: 1)
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            # Only track successful operations
+            if isinstance(result, tuple) and len(result) >= 2:
+                message, is_error = result[0], result[1]
+                if not is_error:
+                    get_tracker().increment(counter_name, increment_value)
+            return result
+        return wrapper
+    return decorator
+
+
+def count_lines_in_string(old_str: str, new_str: str) -> tuple[int, int]:
+    """
+    Count the number of lines that differ between old_str and new_str.
+    
+    Args:
+        old_str: Original string
+        new_str: New string
+        
+    Returns:
+        Tuple of (number of lines that differ, line delta)
+    """
+    old_lines = old_str.splitlines()
+    new_lines = new_str.splitlines()
+    
+    # Calculate the line delta (positive for added lines, negative for removed lines)
+    line_delta = len(new_lines) - len(old_lines)
+    
+    # Simple approach: count the total number of lines changed
+    # For tracking purposes, we'll use the max to ensure we don't undercount
+    return max(len(old_lines), len(new_lines)), line_delta
+
+
+def print_usage_stats():
+    """Print the current usage statistics if any values are non-zero."""
+    stats = get_tracker().get_stats()
+    if stats:
+        from rich.console import Console
+        
+        console = Console()
+        
+        # Create a single-line summary of tool usage
+        summary_parts = []
+        for name, value in stats.items():
+            # Format lines delta with a sign
+            if name == "Lines Delta":
+                sign = "+" if value > 0 else "" if value == 0 else "-"
+                formatted_value = f"{sign}{abs(value)}"
+                summary_parts.append(f"{name}: {formatted_value}")
+            else:
+                summary_parts.append(f"{name}: {value}")
+        
+        summary = " | ".join(summary_parts)
+        
+        # Display with a rule similar to token usage
+        console.rule("[blue]Tool Usage[/blue]")
+        console.print(f"[blue]{summary}[/blue]", justify="center")

janito-0.12.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 0.12.0
+Summary: Janito CLI tool
+Project-URL: Homepage, https://github.com/joaompinto/janito
+Author-email: João Pinto <lamego.pinto@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: anthropic>=0.5.0
+Requires-Dist: beautifulsoup4>=4.13.0
+Requires-Dist: claudine>=0.1.0
+Requires-Dist: jinja2>=3.0.0
+Requires-Dist: lxml-html-clean>=0.4.1
+Requires-Dist: newspaper3k>=0.2.8
+Requires-Dist: requests>=2.32.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: trafilatura>=1.6.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+# 🤖 Janito
+
+Janito is a powerful AI-assisted command-line interface (CLI) tool built with Python, leveraging Anthropic's Claude for intelligent code and file management.
+
+[![GitHub Repository](https://img.shields.io/badge/GitHub-Repository-blue?logo=github)](https://github.com/joaompinto/janito)
+
+## ✨ Features
+
+- 🧠 Intelligent AI assistant powered by Claude
+- 📁 File management capabilities with real-time output
+- 🔍 Smart code search and editing
+- 💻 Interactive terminal interface with rich formatting
+- 📊 Detailed token usage tracking and cost reporting with cache savings analysis
+- 🛑 Token and tool usage reporting even when interrupted with Ctrl+C
+- 🌐 Web page fetching with content extraction capabilities
+- 🔄 Parameter profiles for optimizing Claude's behavior for different tasks
+- 📋 Line delta tracking to monitor net changes in files
+
+## 🛠️ System Requirements
+
+- **Python 3.8+** - Janito requires Python 3.8 or higher
+- **Operating Systems**:
+  - Linux/macOS: Native support
+  - Windows: Requires Git Bash for proper operation of CLI tools
+- **Anthropic API Key** - Required for Claude AI integration
+
+## 🛠️ Installation
+
+```bash
+# Install directly from PyPI
+pip install janito
+```
+
+### Setting up your API Key
+
+Janito requires an Anthropic API key to function. You can:
+1. Set the API key: `janito --set-api-key your_api_key`
+
+For development or installation from source, please see [README_DEV.md](README_DEV.md).
+
+## 🚀 Usage Tutorial
+
+After installation, you can start using Janito right away. Let's walk through a simple tutorial:
+
+### Getting Started
+
+First, let's check that everything is working:
+
+```bash
+# Get help and see available commands
+janito --help
+```
+
+### Tutorial: Creating a Simple Project
+
+Let's create a simple HTML project with Janito's help:
+
+After installing Janito, using your prefered editor and/or terminal, go to a new empty folder.
+
+Use the janito command to create a new project.
+
+```bash
+# Step 1: Create a new project structure
+janito "Create a simple HTML page with a calculator and 3 columns with text for the 3 main activities of the Kazakh culture"
+```
+Browse the resulting html page.
+
+### Tutorial: Adding Features
+
+Now, let's enhance our example
+
+```bash
+# Step 2: Add multiplication and division features
+janito "Add some svg icons and remove the calculator"
+
+```
+
+Refresh the page
+
+### Exploring More Features
+
+Janito offers many more capabilities:
+
+```bash
+# Show detailed token usage and cost information
+janito --show-tokens "Explain what is in the project"
+
+# Use a specific parameter profile for creative tasks
+janito --profile creative "Write a fun description for our project"
+
+# Continue previous conversation
+janito --continue "Plese add one more line"
+
+# Show current configuration and available profiles
+janito --show-config
+
+# You can press Ctrl+C at any time to interrupt a query
+# Janito will still display token and tool usage information
+```
+
+## 🔧 Available Tools
+
+Janito comes with several built-in tools:
+- 📄 `str_replace_editor` - View, create, and edit files
+- 🔎 `find_files` - Find files matching patterns
+- 🗑️ `delete_file` - Delete files
+- 🔍 `search_text` - Search for text patterns in files
+- 🌐 `fetch_webpage` - Fetch and extract content from web pages
+- 📋 `move_file` - Move files from one location to another
+- 💻 `bash` - Execute bash commands with real-time output display
+
+## 📊 Usage Tracking
+
+Janito includes a comprehensive token usage tracking system that helps you monitor API costs:
+
+- **Basic tracking**: By default, Janito displays a summary of token usage and cost after each query
+- **Detailed reporting**: Use the `--show-tokens` or `-t` flag to see detailed breakdowns including:
+  - Input and output token counts
+  - Per-tool token usage statistics
+  - Precise cost calculations
+  - Cache performance metrics with savings analysis
+  - Line delta tracking for file modifications
+
+```bash
+# Show detailed token usage and cost information
+janito --show-tokens "Write a Python function to sort a list"
+
+# Basic usage (shows simplified token usage summary)
+janito "Explain Docker containers"
+```
+
+The usage tracker automatically calculates cache savings, showing you how much you're saving by reusing previous responses.
+
+## 📋 Parameter Profiles
+
+Janito offers predefined parameter profiles to optimize Claude's behavior for different tasks:
+
+- **precise**: Factual answers, documentation, structured data (temperature: 0.2)
+- **balanced**: Professional writing, summarization, everyday tasks (temperature: 0.5)
+- **conversational**: Natural dialogue, educational content (temperature: 0.7)
+- **creative**: Storytelling, brainstorming, marketing copy (temperature: 0.9)
+- **technical**: Code generation, debugging, technical problem-solving (temperature: 0.3)
+
+```bash
+# Use a specific profile
+janito --profile creative "Write a poem about coding"
+
+# View available profiles
+janito --show-config
+```
+
+## ⚙️ Dependencies
+
+Janito automatically installs the following dependencies:
+- typer (>=0.9.0) - For CLI interface
+- rich (>=13.0.0) - For rich text formatting
+- claudine - For Claude AI integration
+- Additional packages for file handling and web content extraction
+
+## 🔑 API Key Configuration
+
+You can configure your Anthropic API key in several ways:
+
+```bash
+# Option 1: Set as environment variable
+export ANTHROPIC_API_KEY=your_api_key
+
+# Option 2: Configure globally within Janito
+janito --set-api-key your_api_key
+
+# Option 3: Let Janito prompt you on first use
+janito "Hello, I'm new to Janito!"
+```
+
+Your API key is securely stored and used for all future sessions.
+
+## 💻 Development
+
+For development instructions, please refer to [README_DEV.md](README_DEV.md).
+
+## 📜 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

janito-0.12.0.dist-info/RECORD

@@ -0,0 +1,47 @@
+janito/__init__.py,sha256=UhMcaPInS2sBvYxOLldeLu7sKy-ZZxndtrf6NPqQBgI,53
+janito/__main__.py,sha256=Oy-Nc1tZkpyvTKuq1R8oHSuJTkvptN6H93kIHBu7DKY,107
+janito/callbacks.py,sha256=E1FPXYHZUgiEGMabYuf999PSf_Su4ByHOWlc1-hMqWE,915
+janito/config.py,sha256=haIErp8tVL6e_5h4fsgLqFib2aCAZZ3sIXa8wStn_yo,12424
+janito/test_file.py,sha256=c6GWGdTYG3z-Y5XBao9Tmhmq3G-v0L37OfwLgBo8zIU,126
+janito/token_report.py,sha256=Mks7o2yTxPChgQyBJNoQ5eMmrhSgEM4LKCKi2tHJbVo,9580
+janito/cli/__init__.py,sha256=dVi9l3E86YyukjxQ-XSUnMZkghnNasXex-X5XAOBiwk,85
+janito/cli/agent.py,sha256=AYJhSqPbz1Ywz_RBzHxfXIK6x-aZrqA8-C2QzmxZ3J8,10533
+janito/cli/app.py,sha256=RghsHSmvnECGWzoAeQOJdxHTZM_Xcw6Y4jgbJ5I6-5M,4131
+janito/cli/commands.py,sha256=c1EHJ_VZR_3aA3zRvCLaBn9yfdj5emQpTI0Z_bXcIyc,12664
+janito/cli/output.py,sha256=mo3hUokhrD4SWexUjCbLGGQeCDUf0369DA_i9BW7HjU,933
+janito/cli/utils.py,sha256=gO4NtCNwtEzYDsQesrFlqB5FtYuw87yGwo4iG3nINgw,661
+janito/data/instructions_template.txt,sha256=oXmjVEajwLuTjcyXyD123CGSjNG1QLbfzbw9iEq-w5w,1411
+janito/tools/__init__.py,sha256=hio75FRkxLSQB13We-SCCM7Qa9lMqWCfWhEonHlTr8M,1405
+janito/tools/decorators.py,sha256=Tp48n5y4LKsjyV3HeOA9wk2dV413RrEG-23kRyQVlKs,2522
+janito/tools/delete_file.py,sha256=UrZ5q59SIxWfuJcqgol6yPBqL-RhO9lFCF4MqAc6o00,2252
+janito/tools/find_files.py,sha256=c_N9ETcRPprQeuZYanwFnl-9E05ZqUYhNVoCRS5uqQg,8300
+janito/tools/move_file.py,sha256=FCs1ghalfHlXmcbAA_IlLcUll9hTOU1MMFGrTWopXvM,2741
+janito/tools/prompt_user.py,sha256=OnTiWVBCbL_2MYu7oThlKr8X_pnYdG-dzxXSOgJF41c,1942
+janito/tools/replace_file.py,sha256=i4GoLtS14eKSU5lYI18mJ96S0_ekeHMwlQfazg-fxrM,2296
+janito/tools/rich_console.py,sha256=VyLStA7fCgMGp9KZ0TYHAC3FOOAWKKHx1XTWWWF2ISI,4560
+janito/tools/search_text.py,sha256=hZLgKlF_cC5JRQ2XsussndSZMmptwr8d0tTKCyCXFwg,9755
+janito/tools/usage_tracker.py,sha256=IE7GVBDYsX2EDLjsVaVqTeAnT2SAYfcOJvBaH__wHdU,4613
+janito/tools/bash/bash.py,sha256=gOYhp2CexuEjSSpHGhVQLr-Ooc67Etl7Br1TbRtY6vc,3577
+janito/tools/bash/unix_persistent_bash.py,sha256=tFFhbG9rk1KcONmG0j6SZHrqYxCXELhzobRSTEHPFm0,6868
+janito/tools/bash/win_persistent_bash.py,sha256=mMgAdRi7jlznq7ssNmgiSMEqzEI-rIV0kgYpndcum6U,12758
+janito/tools/fetch_webpage/__init__.py,sha256=0RG0ev-yrfo8gPzt-36WMpVdY2qtMhk2Z-mVpq-7m1o,1076
+janito/tools/fetch_webpage/chunking.py,sha256=mMtrZeirZ_GnKOOzeG8BijLVpSUI0-TA5Ioqi2HKb1A,2971
+janito/tools/fetch_webpage/core.py,sha256=3XDvYnC_UbQUNumwWw32hfJhjJUEaPzzoF2yhxhwxos,7764
+janito/tools/fetch_webpage/extractors.py,sha256=-jrLDRWfWyF2SNOATdRWrqETqnnDLbe2JUWtuyHKFOU,12043
+janito/tools/fetch_webpage/news.py,sha256=Hp0uNTnRzTa-4hyegQbHSmLeSbkiSpx4cP2oP_hKLEQ,5378
+janito/tools/fetch_webpage/utils.py,sha256=mkfwefD7U9HOktIwo1eP63v7dpVY-q06COUjaqnTT5M,3412
+janito/tools/str_replace_editor/__init__.py,sha256=kYmscmQgft3Jzt3oCNz7k2FiRbJvku6OFDDC3Q_zoAA,144
+janito/tools/str_replace_editor/editor.py,sha256=BckYfiMRUYDfDrbu871qMt2AfZexth_02QhwYYOd53g,2489
+janito/tools/str_replace_editor/utils.py,sha256=akiPqCHjky_RwL9OitHJJ7uQ-3fNaA8wt_K_YO1EP6I,954
+janito/tools/str_replace_editor/handlers/__init__.py,sha256=RP6JCeDRIL4R-lTpGowIoOAi64gg6VxZvJGp8Q2UOVU,373
+janito/tools/str_replace_editor/handlers/create.py,sha256=s8RQE04kDAL7OLZA8WxJkDqTmJlGmCNiit4tIHnmNMo,2470
+janito/tools/str_replace_editor/handlers/insert.py,sha256=eKHodm2ozKUlRMxWMLAsu9ca6unUo1jfXWwHSld-pSU,4061
+janito/tools/str_replace_editor/handlers/str_replace.py,sha256=quHQ1vOqvXCPaC14W5iub01kKB4XNMqwh1odnXnhhxY,4459
+janito/tools/str_replace_editor/handlers/undo.py,sha256=3OIdAWkpXC2iDe94_sfx_WxEFh3a1cRzoP0NtPXq1Ks,2491
+janito/tools/str_replace_editor/handlers/view.py,sha256=ZWcx7r5VwxWG3ImQxK2lzONL9xlqctM-hy2kMF-huT0,6616
+janito/data/instructions_template.txt,sha256=oXmjVEajwLuTjcyXyD123CGSjNG1QLbfzbw9iEq-w5w,1411
+janito-0.12.0.dist-info/METADATA,sha256=oR3nvTukvj3uPVcZ2LbAA4lx46W08elLhWphDWXpAAs,6458
+janito-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+janito-0.12.0.dist-info/entry_points.txt,sha256=JMbF_1jg-xQddidpAYkzjOKdw70fy_ymJfcmerY2wIY,47
+janito-0.12.0.dist-info/licenses/LICENSE,sha256=6-H8LXExbBIAuT4cyiE-Qy8Bad1K4pagQRVTWr6wkhk,1096
+janito-0.12.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)

janito/data/instructions.txt

@@ -1,4 +0,0 @@
-You are an expert software engineer, working in a project.
-When using str_replace_editor be aware that our files starting path is "." .
-
-Before performing any action, always check the structure of the project for paths that might be related to the request.