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

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.13.0.dist-info/METADATA

@@ -0,0 +1,300 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 0.13.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
+- 💬 Conversation history with ability to resume previous conversations
+- 🔇 Trust mode for concise output without tool details
+
+## 🛠️ 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"
+
+# Use trust mode for concise output without tool details
+janito --trust "Optimize the HTML code"
+# Or use the short alias
+janito -t "Optimize the HTML code"
+
+# Continue the most recent conversation
+janito --continue "Please add one more line"
+
+# Continue a specific conversation using its message ID
+# (Janito displays the message ID after each conversation)
+janito --continue abc123def "Let's refine that code"
+
+# 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
+# Even interrupted conversations can be continued with --continue
+```
+
+## 🔧 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` 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"
+
+# Use trust mode for concise output without tool details
+janito --trust "Create a simple Python script"
+# Or use the short alias
+janito -t "Create a simple Python script"
+```
+
+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
+```
+
+## 🔇 Trust Mode
+
+Janito offers a trust mode that suppresses tool outputs for a more concise execution experience:
+
+### How It Works
+
+- When enabled with `--trust` or `-t`, Janito suppresses informational and success messages from tools
+- Only essential output and error messages are displayed
+- The final result from Claude is still shown in full
+- Trust mode is a per-session setting and not saved to your configuration
+
+### Using Trust Mode
+
+```bash
+# Enable trust mode with the full flag
+janito --trust "Create a Python script that reads a CSV file"
+
+# Or use the short alias
+janito -t "Create a Python script that reads a CSV file"
+```
+
+This feature is particularly useful for:
+- Experienced users who don't need to see every step of the process
+- Batch processing or scripting where concise output is preferred
+- Focusing on results rather than the process
+- Creating cleaner output for documentation or sharing
+
+## 💬 Conversation History
+
+Janito automatically saves your conversation history, allowing you to continue previous discussions:
+
+### How It Works
+
+- Each conversation is saved with a unique message ID in `.janito/last_messages/`
+- The most recent conversation is also saved as `.janito/last_message.json` for backward compatibility
+- After each conversation, Janito displays the command to continue that specific conversation
+
+### Using the Continue Feature
+
+```bash
+# Continue the most recent conversation
+janito --continue "Add more details to your previous response"
+
+# Continue a specific conversation using its ID
+janito --continue abc123def "Let's modify that code you suggested"
+```
+
+The `--continue` flag (or `-c` for short) allows you to:
+- Resume the most recent conversation when used without an ID
+- Resume a specific conversation when provided with a message ID
+- Maintain context across multiple interactions for complex tasks
+
+This feature is particularly useful for:
+- Multi-step development tasks
+- Iterative code improvements
+- Continuing discussions after system interruptions
+- Maintaining context when working on complex problems
+
+## ⚙️ 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
+
+## 🛠️ Command-Line Options
+
+Janito offers a variety of command-line options to customize its behavior:
+
+```
+--verbose, -v                 Enable verbose mode with detailed output
+--show-tokens                 Show detailed token usage and pricing information
+--workspace, -w TEXT          Set the workspace directory
+--set-config TEXT             Configuration string in format 'key=value', e.g., 'temperature=0.7'
+--show-config                 Show current configuration
+--reset-config                Reset configuration by removing the config file
+--set-api-key TEXT            Set the Anthropic API key globally in the user's home directory
+--ask                         Enable ask mode which disables tools that perform changes
+--trust, -t                   Enable trust mode which suppresses tool outputs for concise execution
+--temperature FLOAT           Set the temperature for model generation (0.0 to 1.0)
+--profile TEXT                Use a predefined parameter profile (precise, balanced, conversational, creative, technical)
+--role TEXT                   Set the assistant's role (default: 'software engineer')
+--version                     Show the version and exit
+--continue, -c TEXT           Continue a previous conversation, optionally with a specific message ID
+--help                        Show the help message and exit
+```
+
+## 🔑 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.13.0.dist-info/RECORD

@@ -0,0 +1,47 @@
+janito/__init__.py,sha256=5Cnu7sPJURDSY1cnxtGvzs0MpwHUsh5zYZRNQ2LkM8k,53
+janito/__main__.py,sha256=Oy-Nc1tZkpyvTKuq1R8oHSuJTkvptN6H93kIHBu7DKY,107
+janito/callbacks.py,sha256=E1FPXYHZUgiEGMabYuf999PSf_Su4ByHOWlc1-hMqWE,915
+janito/config.py,sha256=MHfloii_OnOVcV4pbunfdnAv8uJzxu_ytDK34Rj8yZ8,13221
+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=iFwzbZupkpXQVO0YrQmCGKKQGcqCRdAY3JLg6tZaJiQ,15940
+janito/cli/app.py,sha256=czgOEWCsWlKeLWMHxPv6fxOStoL2wcC8_QZs6mMtTp8,4643
+janito/cli/commands.py,sha256=pgassnKENr0DGcZT3tFXtz8MCVuEZwHgxiBktgAik6g,12682
+janito/cli/output.py,sha256=mo3hUokhrD4SWexUjCbLGGQeCDUf0369DA_i9BW7HjU,933
+janito/cli/utils.py,sha256=gO4NtCNwtEzYDsQesrFlqB5FtYuw87yGwo4iG3nINgw,661
+janito/data/instructions_template.txt,sha256=FlyGpNjl2LRBjPWLTK40oKOSH6sveHp5ud35nf_lfs8,1716
+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=0zWYRF8qk4N-upuwswUSEfYFAfkEYDYeCgxst-czWtY,6044
+janito/tools/search_text.py,sha256=RxbnNeZ3ErCvevwbl60fQAe55QYtU-D9n13iixeDcqQ,9822
+janito/tools/usage_tracker.py,sha256=IE7GVBDYsX2EDLjsVaVqTeAnT2SAYfcOJvBaH__wHdU,4613
+janito/tools/bash/bash.py,sha256=AFm0w_z-yyYRWxuR744OFpm5iCZaZpE-pWbnKbgajp4,3665
+janito/tools/bash/unix_persistent_bash.py,sha256=I59PPQiXHscPJ6Y7ev_83dLFNFWq1hKwAK9kFXdnbBY,7185
+janito/tools/bash/win_persistent_bash.py,sha256=96xm_yijjc6hBYfNluLahbvR2oUuHug_JkoMah7Hy38,12894
+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=RciLTlA7R2PGljeeyluLcBHUAje9c1OCxm-bFE7j6iY,4473
+janito/tools/str_replace_editor/handlers/undo.py,sha256=3OIdAWkpXC2iDe94_sfx_WxEFh3a1cRzoP0NtPXq1Ks,2491
+janito/tools/str_replace_editor/handlers/view.py,sha256=k8F-n64bomHmDjavr5OJKC4cHhfm4_1-aMIFZdMICQo,6809
+janito/data/instructions_template.txt,sha256=FlyGpNjl2LRBjPWLTK40oKOSH6sveHp5ud35nf_lfs8,1716
+janito-0.13.0.dist-info/METADATA,sha256=06Vh36jWdwTcsUOpIyRkHybxssdksSoWNvPVE41y1jM,10584
+janito-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+janito-0.13.0.dist-info/entry_points.txt,sha256=JMbF_1jg-xQddidpAYkzjOKdw70fy_ymJfcmerY2wIY,47
+janito-0.13.0.dist-info/licenses/LICENSE,sha256=6-H8LXExbBIAuT4cyiE-Qy8Bad1K4pagQRVTWr6wkhk,1096
+janito-0.13.0.dist-info/RECORD,,

janito/chat_history.py

@@ -1,117 +0,0 @@
-"""
-Chat history module for Janito.
-Handles storing and loading chat history.
-"""
-import os
-import json
-import datetime
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-from janito.config import get_config
-
-def ensure_chat_history_dir() -> Path:
-    """
-    Ensure the chat history directory exists.
-    
-    Returns:
-        Path: Path to the chat history directory
-    """
-    workspace_dir = get_config().workspace_dir
-    chat_history_dir = Path(workspace_dir) / ".janito" / "chat_history"
-    chat_history_dir.mkdir(parents=True, exist_ok=True)
-    return chat_history_dir
-
-
-
-def store_conversation(query: str, response: str, agent=None) -> None:
-    """
-    Store a conversation in the chat history.
-    
-    Args:
-        query: The user's query
-        response: The agent's response
-        agent: Optional agent instance for using get_messages method
-    """
-    chat_history_dir = ensure_chat_history_dir()
-    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"{timestamp}.json"
-    
-    # Create the conversation data
-    conversation = {
-        "timestamp": timestamp,
-        "query": query,
-        "response": response
-    }
-    
-    # Write to file
-    with open(chat_history_dir / filename, "w", encoding="utf-8") as f:
-        json.dump(conversation, f, ensure_ascii=False, indent=2)
-
-def load_recent_conversations(count: int = 5) -> List[Dict[str, str]]:
-    """
-    Load the most recent conversations from the chat history.
-    
-    Args:
-        count: Number of conversations to load
-        
-    Returns:
-        List[Dict[str, str]]: List of conversations
-    """
-    chat_history_dir = ensure_chat_history_dir()
-    
-    # Get all JSON files in the chat history directory
-    history_files = list(chat_history_dir.glob("*.json"))
-    
-    # Sort by filename (which includes timestamp)
-    history_files.sort(reverse=True)
-    
-    # Load the most recent conversations
-    conversations = []
-    for file_path in history_files[:count]:
-        try:
-            with open(file_path, "r", encoding="utf-8") as f:
-                conversation = json.load(f)
-                conversations.append(conversation)
-        except Exception as e:
-            print(f"Error loading chat history file {file_path}: {e}")
-    
-    return conversations
-
-def format_conversation_for_context(conversation: Dict[str, str]) -> str:
-    """
-    Format a conversation for inclusion in the context.
-    
-    Args:
-        conversation: The conversation to format
-        
-    Returns:
-        str: The formatted conversation
-    """
-    timestamp = conversation.get("timestamp", "Unknown time")
-    query = conversation.get("query", "")
-    response = conversation.get("response", "")
-    
-    formatted_time = datetime.datetime.strptime(timestamp, "%Y%m%d_%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
-    
-    return f"--- Conversation from {formatted_time} ---\nUser: {query}\n\nAssistant: {response}\n\n"
-
-def get_chat_history_context(count: int = 5) -> str:
-    """
-    Get the chat history formatted for inclusion in the agent's context.
-    
-    Args:
-        count: Number of conversations to include
-        
-    Returns:
-        str: The formatted chat history
-    """
-    conversations = load_recent_conversations(count)
-    
-    if not conversations:
-        return ""
-    
-    context = "# Previous conversations:\n\n"
-    for conversation in conversations:
-        context += format_conversation_for_context(conversation)
-    
-    return context

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 "." .
-
-If creating or editing files with a large number of lines, organize them into smaller files.

janito/tools/bash.py

@@ -1,22 +0,0 @@
-from typing import Optional
-from typing import Tuple
-
-
-def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]:
-    """
-    A simple bash tool implementation that just prints the command and restart flag.
-    
-    Args:
-        command: The bash command to execute
-        restart: Whether to restart the process
-        
-    Returns:
-        A tuple containing (output message, is_error flag)
-    """
-    # In a real implementation, this would execute the command
-    # Here we just print what would be executed
-    output = f"Would execute bash command: '{command}'\n"
-    output += f"Restart flag is set to: {restart}"
-
-    # Return the output with is_error=False
-    return output, False