janito 0.10.1__tar.gz → 0.11.0__tar.gz

{janito-0.10.1 → janito-0.11.0}/.gitignore

@@ -107,4 +107,5 @@ venv.bak/
 *.swo
 
 # Janito
-.janito/
+.janito/
+janito-env/

{janito-0.10.1 → janito-0.11.0}/PKG-INFO

@@ -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/janito/__main__.py

@@ -0,0 +1,205 @@
+"""
+Main entry point for Janito.
+"""
+import os
+import sys
+from typing import Optional
+import importlib.resources
+import typer
+from rich.console import Console
+import anthropic
+from janito.config import get_config
+from janito.chat_history import store_conversation, get_chat_history_context
+from janito.callbacks import pre_tool_callback, post_tool_callback, text_callback
+from janito.token_report import generate_token_report
+from janito.tools import str_replace_editor
+from janito.tools.bash import bash_tool
+import claudine
+
+app = typer.Typer()
+
+@app.command()
+def create_tool(name: str = typer.Argument(..., help="Name of the tool to create")):
+    """
+    Create a new tool with the given name.
+    """
+    console = Console()
+    
+    # Ensure workspace is set
+    workspace_dir = get_config().workspace_dir
+    
+    # Create the tools directory if it doesn't exist
+    tools_dir = os.path.join(workspace_dir, "tools")
+    os.makedirs(tools_dir, exist_ok=True)
+    
+    # Create the tool file
+    tool_file = os.path.join(tools_dir, f"{name}.py")
+    
+    # Check if the file already exists
+    if os.path.exists(tool_file):
+        console.print(f"[bold red]Error:[/bold red] Tool file already exists: {tool_file}")
+        return
+    
+    # Create the tool file with a template
+    template = f'''"""
+{name} tool for Janito.
+"""
+
+def {name}(param1: str) -> str:
+    """
+    Description of the {name} tool.
+    
+    Args:
+        param1: Description of param1
+        
+    Returns:
+        str: Description of return value
+    """
+    # TODO: Implement the tool
+    return f"Executed {name} with param1={{param1}}"
+'''
+    
+    with open(tool_file, "w") as f:
+        f.write(template)
+    
+    console.print(f"[bold green]Created tool:[/bold green] {tool_file}")
+
+@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"),
+         verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode with detailed output"),
+         show_tokens: bool = typer.Option(False, "--show-tokens", "-t", help="Show detailed token usage and pricing information"),
+         workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory"),
+         config_str: Optional[str] = typer.Option(None, "--set-config", help="Configuration string in format 'key=value', e.g., 'context=5' for number of history messages to include"),
+         show_config: bool = typer.Option(False, "--show-config", help="Show current configuration")):
+    """
+    Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
+    """    
+    console = Console()
+    
+    # Set verbose mode in config
+    get_config().verbose = verbose
+    
+    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)
+            
+    # Show current configuration if requested
+    if show_config:
+        config = get_config()
+        console.print("[bold blue]Current Configuration:[/bold blue]")
+        console.print(f"[bold]Workspace Directory:[/bold] {config.workspace_dir}")
+        console.print(f"[bold]Verbose Mode:[/bold] {'Enabled' if config.verbose else 'Disabled'}")
+        console.print(f"[bold]Chat History Context Count:[/bold] {config.history_context_count} messages")
+        # Exit if this was the only operation requested
+        if ctx.invoked_subcommand is None and not query:
+            sys.exit(0)
+            
+    # Handle the --set-config parameter
+    if config_str is not None:
+        try:
+            # Parse the config string
+            if "context=" in config_str:
+                context_value = config_str.split("context=")[1].strip()
+                # If there are other configs after context, extract just the number
+                if " " in context_value:
+                    context_value = context_value.split(" ")[0]
+                
+                try:
+                    context_value = int(context_value)
+                    if context_value < 0:
+                        console.print("[bold red]Error:[/bold red] History context count must be a non-negative integer")
+                        return
+                    
+                    get_config().history_context_count = context_value
+                    console.print(f"[bold green]Chat history context count set to {context_value} messages[/bold green]")
+                except ValueError:
+                    console.print(f"[bold red]Error:[/bold red] Invalid context value: {context_value}. Must be an integer.")
+            else:
+                console.print(f"[bold yellow]Warning:[/bold yellow] Unsupported configuration in: {config_str}")
+        except Exception as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+            
+    if ctx.invoked_subcommand is None:
+        # If no query provided in command line, read from stdin
+        if not query:
+            console.print("[bold blue]No query provided in command line. Reading from stdin...[/bold blue]")
+            query = sys.stdin.read().strip()
+            
+        # Only proceed if we have a query (either from command line or stdin)
+        if query:
+            # 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(encoding='utf-8')
+                # Fallback for older Python versions
+                except (ImportError, AttributeError):
+                    instructions = pkg_resources.read_text('janito.data', 'instructions.txt', encoding='utf-8')
+            except Exception as e:
+                console.print(f"[bold red]Error loading instructions:[/bold red] {str(e)}")
+                instructions = "You are Janito, an AI assistant."
+                
+            # Temporarily disable chat history
+            # Get chat history context
+            # chat_history = get_chat_history_context(get_config().history_context_count)
+            # if chat_history:
+            #     console.print("[dim]Loaded chat history from previous sessions.[/dim]")
+            #     # Append chat history to instructions
+            #     instructions = f"{instructions}\n\n{chat_history}"
+                   
+            # Get tools
+            from janito.tools import get_tools
+            tools_list = get_tools()
+            
+            # Initialize the agent with the tools
+            agent = claudine.Agent(
+                api_key=api_key,
+                system_prompt=instructions,
+                callbacks={"pre_tool": pre_tool_callback, "post_tool": post_tool_callback, "text": text_callback},
+                text_editor_tool=str_replace_editor,
+               #bash_tool=bash_tool,
+                tools=tools_list,
+                verbose=verbose
+            )
+            
+            # Send the query to the agent
+            try:
+                agent.query(query)
+                
+                # Temporarily disable storing conversation in chat history
+                # Store the conversation in chat history
+                # store_conversation(query, response, agent)
+                
+                # Print token usage report if show_tokens mode is enabled
+                if show_tokens:
+                    generate_token_report(agent, verbose=True)
+                else:
+                    # Show basic token usage
+                    generate_token_report(agent, verbose=False)
+                    
+            except anthropic.APIError as e:
+                console.print(f"[bold red]Anthropic API Error:[/bold red] {str(e)}")
+                
+            except Exception as e:
+                console.print(f"[bold red]Error:[/bold red] {str(e)}")
+                if verbose:
+                    import traceback
+                    console.print(traceback.format_exc())
+
+if __name__ == "__main__":
+    app()

janito-0.11.0/janito/callbacks.py

@@ -0,0 +1,132 @@
+"""
+Callback functions for tool execution in janito.
+"""
+
+from typing import Dict, Any, Tuple, Optional, List
+from rich.console import Console
+from rich.markdown import Markdown
+
+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.tools.decorators import format_tool_label
+
+# Note: ConsoleCallback has been removed as we're using pre_tool and post_tool callbacks directly
+
+def pre_tool_callback(tool_name: str, tool_input: Dict[str, Any]) -> Tuple[Dict[str, Any], bool]:
+    """
+    Callback function that runs before a tool is executed.
+    
+    Args:
+        tool_name: Name of the tool being called
+        tool_input: Input parameters for the tool
+        
+    Returns:
+        Tuple of (modified tool input, whether to cancel the tool call)
+    """
+    console = Console()
+    
+    # Add debug counter only when verbose mode is enabled
+    if get_config().verbose:
+        if not hasattr(pre_tool_callback, "counter"):
+            pre_tool_callback.counter = 1
+        console.print(f"[bold green]DEBUG: Starting tool call #{pre_tool_callback.counter}[/bold green]")
+        
+        # Print the tool name and input
+        console.print(f"[bold green]Tool:[/bold green] {tool_name}")
+        console.print(f"[bold green]Input:[/bold green] {tool_input}")
+    else:
+        # For non-debug mode, just print a simple message
+        # Find the tool function
+        tool_func = None
+        if tool_name == "find_files":
+            tool_func = find_files
+        elif tool_name == "str_replace_editor":
+            tool_func = str_replace_editor
+        elif tool_name == "delete_file":
+            tool_func = delete_file
+        elif tool_name == "search_text":
+            tool_func = search_text
+            
+        # Format the input for display
+        display_input = ""
+        if "path" in tool_input:
+            display_input = tool_input["path"]
+        elif "file_path" in tool_input:
+            display_input = tool_input["file_path"]
+        
+        # Print formatted tool label if available
+        formatted_label = format_tool_label(tool_func, tool_input)
+        if formatted_label:
+            console.print("[bold cyan]  Tool:[/bold cyan]", formatted_label, end=" → ")
+        else:
+            console.print("[bold cyan]  Tool:[/bold cyan]", f"{tool_name} {display_input}", end=" → ")
+    
+    return tool_input, True  # Continue with the tool call
+
+def post_tool_callback(tool_name: str, tool_input: Dict[str, Any], result: Any) -> Any:
+    """
+    Callback function that runs after a tool is executed.
+    
+    Args:
+        tool_name: Name of the tool that was called
+        tool_input: Input parameters for the tool
+        result: Result of the tool call
+        
+    Returns:
+        Modified result
+    """
+    console = Console()
+    
+    # Add debug counter only when verbose mode is enabled
+    if get_config().verbose:
+        if not hasattr(post_tool_callback, "counter"):
+            post_tool_callback.counter = 1
+        console.print(f"[bold green]DEBUG: Completed tool call #{post_tool_callback.counter}[/bold green]")
+        post_tool_callback.counter += 1
+    
+    # Show the number of lines in the result content
+    if isinstance(result, tuple) and len(result) >= 1:
+        content, is_error = result
+        # Define prefix icon based on is_error
+        icon_prefix = "❌ " if is_error else "✅ "
+        
+        if isinstance(content, str):
+            # Count the number of lines in the content
+            line_count = content.count('\n') + 1 if content else 0
+            console.print(f"{icon_prefix}{line_count} items")
+        else:
+            console.print(f"{icon_prefix}{content}")
+    else:
+        # If result is not a tuple, convert to string and count lines
+        result_str = str(result)
+        # Default to success icon when no error status is available
+        icon_prefix = "✅ "
+        line_count = result_str.count('\n') + 1 if result_str else 0
+        console.print(f"{icon_prefix}{line_count} lines")
+    
+    return result
+
+def text_callback(text: str) -> None:
+    """
+    Callback function that handles text output from the agent.
+    
+    Args:
+        text: Text output from the agent
+        
+    Returns:
+        None
+    """
+    console = Console()
+    
+    # Add debug counter only when debug mode is enabled
+    if get_config().debug_mode:
+        if not hasattr(text_callback, "counter"):
+            text_callback.counter = 1
+        console.print(f"[bold blue]DEBUG: Text callback #{text_callback.counter}[/bold blue]")
+        text_callback.counter += 1
+    
+    # Print the text with markdown formatting
+    console.print("[bold magenta]Janito:[/bold magenta] ", Markdown(text, code_theme="monokai"), end="")

janito-0.11.0/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-0.11.0/janito/config.py

@@ -0,0 +1,121 @@
+"""
+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, Any, Dict
+import typer
+
+class Config:
+    """Singleton configuration class for Janito."""
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(Config, cls).__new__(cls)
+            cls._instance._workspace_dir = os.getcwd()
+            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:
+        """Get the current workspace directory."""
+        return self._workspace_dir
+    
+    @workspace_dir.setter
+    def workspace_dir(self, path: str) -> None:
+        """Set the workspace directory."""
+        # Convert to absolute path if not already
+        if not os.path.isabs(path):
+            path = os.path.normpath(os.path.abspath(path))
+        else:
+            # Ensure Windows paths are properly formatted
+            path = os.path.normpath(path)
+        
+        # Check if the directory exists
+        if not os.path.isdir(path):
+            create_dir = typer.confirm(f"Workspace directory does not exist: {path}\nDo you want to create it?")
+            if create_dir:
+                try:
+                    os.makedirs(path, exist_ok=True)
+                    print(f"Created workspace directory: {path}")
+                except Exception as e:
+                    raise ValueError(f"Failed to create workspace directory: {str(e)}")
+            else:
+                raise ValueError(f"Workspace directory does not exist: {path}")
+        
+        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 (alias for verbose)."""
+        return self._verbose
+    
+    @debug_mode.setter
+    def debug_mode(self, value: bool) -> None:
+        """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:
+    """Get the singleton Config instance."""
+    return Config()

{janito-0.10.1 → janito-0.11.0}/janito/data/instructions.txt

@@ -1,4 +1,4 @@
-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.
+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.