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

janito/chat_history.py

@@ -0,0 +1,117 @@
+"""
+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/config.py

@@ -3,8 +3,9 @@ Configuration module for Janito.
 Provides a singleton Config class to access configuration values.
 """
 import os
+import json
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Any, Dict
 import typer
 
 class Config:
@@ -15,8 +16,41 @@ class Config:
         if cls._instance is None:
             cls._instance = super(Config, cls).__new__(cls)
             cls._instance._workspace_dir = os.getcwd()
-            cls._instance._debug_mode = False
+            cls._instance._verbose = False
+            cls._instance._history_context_count = 5
+            cls._instance._load_config()
         return cls._instance
+        
+    def _load_config(self) -> None:
+        """Load configuration from file."""
+        config_path = Path(self._workspace_dir) / ".janito" / "config.json"
+        if config_path.exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    config_data = json.load(f)
+                    if "history_context_count" in config_data:
+                        self._history_context_count = config_data["history_context_count"]
+                    if "debug_mode" in config_data:
+                        self._verbose = config_data["debug_mode"]
+            except Exception as e:
+                print(f"Warning: Failed to load configuration: {str(e)}")
+                
+    def _save_config(self) -> None:
+        """Save configuration to file."""
+        config_dir = Path(self._workspace_dir) / ".janito"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        config_path = config_dir / "config.json"
+        
+        config_data = {
+            "history_context_count": self._history_context_count,
+            "verbose": self._verbose
+        }
+        
+        try:
+            with open(config_path, "w", encoding="utf-8") as f:
+                json.dump(config_data, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Failed to save configuration: {str(e)}")
     
     @property
     def workspace_dir(self) -> str:
@@ -47,15 +81,39 @@ class Config:
         
         self._workspace_dir = path
     
+    @property
+    def verbose(self) -> bool:
+        """Get the verbose mode status."""
+        return self._verbose
+    
+    @verbose.setter
+    def verbose(self, value: bool) -> None:
+        """Set the verbose mode status."""
+        self._verbose = value
+    
+    # For backward compatibility
     @property
     def debug_mode(self) -> bool:
-        """Get the debug mode status."""
-        return self._debug_mode
+        """Get the debug mode status (alias for verbose)."""
+        return self._verbose
     
     @debug_mode.setter
     def debug_mode(self, value: bool) -> None:
-        """Set the debug mode status."""
-        self._debug_mode = value
+        """Set the debug mode status (alias for verbose)."""
+        self._verbose = value
+
+    @property
+    def history_context_count(self) -> int:
+        """Get the number of previous conversations to include in context."""
+        return self._history_context_count
+        
+    @history_context_count.setter
+    def history_context_count(self, count: int) -> None:
+        """Set the number of previous conversations to include in context."""
+        if count < 0:
+            raise ValueError("History context count must be a non-negative integer")
+        self._history_context_count = count
+        self._save_config()
 
 # Convenience function to get the config instance
 def get_config() -> Config:

janito/data/instructions.txt

@@ -1,6 +1,4 @@
-You are a helpful AI assistant, working in a repository.
-Answer the user's questions accurately and concisely. 
-
-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.
+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/token_report.py

@@ -1,73 +1,145 @@
-"""
-Module for generating token usage reports.
-"""
-
-from rich.console import Console
-from claudine.token_tracking import MODEL_PRICING, DEFAULT_MODEL
-
-def generate_token_report(agent, verbose=False):
-    """
-    Generate a token usage report.
-    
-    Args:
-        agent: The Claude agent instance
-        verbose: Whether to show detailed token usage information
-        
-    Returns:
-        None - prints the report to the console
-    """
-    console = Console()
-    usage = agent.get_token_usage()
-    text_usage = usage.text_usage
-    tools_usage = usage.tools_usage
-    
-    if verbose:
-        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)}")
-    else:
-        total_tokens = text_usage.input_tokens + text_usage.output_tokens + tools_usage.input_tokens + tools_usage.output_tokens
-        cost_info = agent.get_cost()
-        console.rule(f"[bold blue]Total tokens: {total_tokens} | Cost: {cost_info.format_total_cost()}[/bold blue]")
+"""
+Module for generating token usage reports.
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+
+def generate_token_report(agent, verbose=False):
+    """
+    Generate a token usage report.
+    
+    Args:
+        agent: The Claude agent instance
+        verbose: Whether to show detailed token usage information
+        
+    Returns:
+        None - prints the report to the console
+    """
+    console = Console()
+    usage = agent.get_tokens()
+    cost = agent.get_token_cost()
+    
+    text_usage = usage.text_usage
+    tools_usage = usage.tools_usage
+    
+    if verbose:
+        total_usage = usage.total_usage
+        
+        # Get costs from the cost object
+        text_input_cost = cost.input_cost
+        text_output_cost = cost.output_cost
+        text_cache_creation_cost = cost.cache_creation_cost
+        text_cache_read_cost = cost.cache_read_cost
+        
+        tools_input_cost = cost.input_cost
+        tools_output_cost = cost.output_cost
+        tools_cache_creation_cost = cost.cache_creation_cost
+        tools_cache_read_cost = cost.cache_read_cost
+        
+        # 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 Cache Creation tokens: {text_usage.cache_creation_input_tokens}")
+        console.print(f"Text Cache Read tokens: {text_usage.cache_read_input_tokens}")
+        console.print(f"Text Total tokens: {text_usage.input_tokens + text_usage.output_tokens + text_usage.cache_creation_input_tokens + text_usage.cache_read_input_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 Cache Creation tokens: {tools_usage.cache_creation_input_tokens}")
+        console.print(f"Tool Cache Read tokens: {tools_usage.cache_read_input_tokens}")
+        console.print(f"Tool Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens + tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens}")
+        
+        console.print(f"Total tokens: {total_usage.input_tokens + total_usage.output_tokens + total_usage.cache_creation_input_tokens + total_usage.cache_read_input_tokens}")
+        
+        console.print("\n[bold blue]Pricing Information:[/bold blue]")
+        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 Cache Creation cost: {format_cost(text_cache_creation_cost)}")
+        console.print(f"Text Cache Read cost: {format_cost(text_cache_read_cost)}")
+        console.print(f"Text Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_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 Cache Creation cost: {format_cost(tools_cache_creation_cost)}")
+        console.print(f"Tool Cache Read cost: {format_cost(tools_cache_read_cost)}")
+        console.print(f"Tool Total cost: {format_cost(tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}")
+        
+        console.print(f"Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost + tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}")
+        
+        # Show cache delta if available
+        if hasattr(cost, 'cache_delta') and cost.cache_delta:
+            cache_delta = cost.cache_delta
+            console.print(f"\n[bold green]Cache Savings:[/bold green] {format_cost(cache_delta)}")
+            
+            # Calculate percentage savings
+            total_cost_without_cache = cost.total_cost + cache_delta
+            if total_cost_without_cache > 0:
+                savings_percentage = (cache_delta / total_cost_without_cache) * 100
+                console.print(f"[bold green]Cache Savings Percentage:[/bold green] {savings_percentage:.2f}%")
+                console.print(f"[bold green]Cost without cache:[/bold green] {format_cost(total_cost_without_cache)}")
+                console.print(f"[bold green]Cost with cache:[/bold green] {format_cost(cost.total_cost)}")
+            
+        # Per-tool breakdown
+        if usage.by_tool:
+            console.print("\n[bold blue]Per-Tool Breakdown:[/bold blue]")
+            try:
+                if hasattr(cost, 'by_tool') and cost.by_tool:
+                    for tool_name, tool_usage in usage.by_tool.items():
+                        tool_input_cost = cost.by_tool[tool_name].input_cost
+                        tool_output_cost = cost.by_tool[tool_name].output_cost
+                        tool_cache_creation_cost = cost.by_tool[tool_name].cache_creation_cost
+                        tool_cache_read_cost = cost.by_tool[tool_name].cache_read_cost
+                        tool_total_cost = tool_input_cost + tool_output_cost + tool_cache_creation_cost + tool_cache_read_cost
+                        
+                        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"  Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
+                        console.print(f"  Cache Read tokens: {tool_usage.cache_read_input_tokens}")
+                        console.print(f"  Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
+                        console.print(f"  Total cost: {format_cost(tool_total_cost)}")
+                else:
+                    # Calculate costs manually for each tool if cost.by_tool is not available
+                    for tool_name, tool_usage in usage.by_tool.items():
+                        # Estimate costs based on overall pricing
+                        total_tokens = tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens
+                        estimated_cost = (total_tokens / (usage.total_usage.total_tokens + usage.total_usage.total_cache_tokens)) * cost.total_cost if usage.total_usage.total_tokens > 0 else 0
+                        
+                        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"  Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
+                        console.print(f"  Cache Read tokens: {tool_usage.cache_read_input_tokens}")
+                        console.print(f"  Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
+                        console.print(f"  Total cost: {format_cost(estimated_cost)}")
+            except Exception as e:
+                console.print(f"Error: {str(e)}")
+    else:
+        total_tokens = (text_usage.input_tokens + text_usage.output_tokens + 
+                       text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens +
+                       tools_usage.input_tokens + tools_usage.output_tokens +
+                       tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens)
+        
+        # Format costs
+        format_cost = lambda cost: f"{cost * 100:.2f}¢" if cost < 1.0 else f"${cost:.6f}"
+        
+        # Prepare summary message
+        summary = f"Total tokens: {total_tokens} | Cost: {format_cost(cost.total_cost)}"
+        
+        # Add cache savings if available
+        if hasattr(cost, 'cache_delta') and cost.cache_delta != 0:
+            cache_delta = cost.cache_delta
+            total_cost_without_cache = cost.total_cost + cache_delta
+            savings_percentage = 0
+            if total_cost_without_cache > 0:
+                savings_percentage = (cache_delta / total_cost_without_cache) * 100
+            
+            summary += f" | Cache savings: {format_cost(cache_delta)} ({savings_percentage:.1f}%)"
+        
+        # Display with a rule
+        console.rule("[blue]Token Usage[/blue]")
+        console.print(f"[blue]{summary}[/blue]", justify="center")

janito/tools/__init__.py

@@ -1,10 +1,21 @@
-"""
-Janito tools package.
-"""
-
-from .str_replace_editor import str_replace_editor
-from .find_files import find_files
-from .delete_file import delete_file
-from .search_text import search_text
-
-__all__ = ["str_replace_editor", "find_files", "delete_file", "search_text"]
+"""
+Janito tools package.
+"""
+
+from .str_replace_editor import str_replace_editor
+from .find_files import find_files
+from .delete_file import delete_file
+from .search_text import search_text
+from .replace_file import replace_file
+from .prompt_user import prompt_user
+
+__all__ = ["str_replace_editor", "find_files", "delete_file", "search_text", "replace_file", "prompt_user", "get_tools"]
+
+def get_tools():
+    """
+    Get a list of all available tools.
+    
+    Returns:
+        List of tool functions (excluding str_replace_editor which is passed separately)
+    """
+    return [find_files, delete_file, search_text, replace_file, prompt_user]

janito/tools/bash.py

@@ -0,0 +1,22 @@
+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