janito 0.13.0__tar.gz → 0.14.0__tar.gz

{janito-0.13.0 → janito-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 0.13.0
+Version: 0.14.0
 Summary: Janito CLI tool
 Project-URL: Homepage, https://github.com/joaompinto/janito
 Author-email: João Pinto <lamego.pinto@gmail.com>
@@ -31,12 +31,13 @@ Janito is a powerful AI-assisted command-line interface (CLI) tool built with Py
 - 🔍 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
+- 💬 Enhanced conversation history with browsing and management
 - 🔇 Trust mode for concise output without tool details
+- 🚫 No-tools mode for pure AI interactions without file system access
+- 📝 Custom system instructions for specialized assistant behavior
 
 ## 🛠️ System Requirements
 
@@ -115,19 +116,35 @@ janito --trust "Optimize the HTML code"
 # Or use the short alias
 janito -t "Optimize the HTML code"
 
+# Disable all tools for pure AI interaction
+janito --no-tools "Explain how HTML works"
+
+# View your conversation history
+janito --history
+
+# View a specific number of recent conversations
+janito --history 10
+
 # 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"
+janito --continue 'abc123def' 'Let's refine that code'
+
+# Alternative way to continue a specific conversation
+janito --continue-id abc123def "Let's refine that code"
+
+# Provide custom system instructions
+janito --system "You are a poetry expert who speaks in rhymes" "Write about coding"
+# Or use the short alias
+janito -s "You are a poetry expert who speaks in rhymes" "Write about coding"
 
 # 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
+# Interrupted conversations can be continued with --continue
 ```
 
 ## 🔧 Available Tools
@@ -213,9 +230,58 @@ This feature is particularly useful for:
 - Focusing on results rather than the process
 - Creating cleaner output for documentation or sharing
 
+## 🚫 No-Tools Mode
+
+Janito provides a no-tools mode that disables all file system and external tools for pure AI interactions:
+
+### How It Works
+
+- When enabled with `--no-tools`, Janito disables all tools for the current session
+- Claude will respond based purely on its knowledge without accessing or modifying files
+- This mode is a per-session setting and not saved to your configuration
+
+### Using No-Tools Mode
+
+```bash
+# Enable no-tools mode
+janito --no-tools "Explain how Docker containers work"
+```
+
+This feature is particularly useful for:
+- Getting general information or explanations without file system access
+- Brainstorming sessions where you don't need file operations
+- Safer operation in sensitive environments
+- Faster responses for queries that don't require tools
+
+## 📝 Custom System Instructions
+
+Janito allows you to provide custom system instructions to change Claude's behavior:
+
+### How It Works
+
+- When provided with `--system` or `-s`, Janito uses your custom instructions instead of the default
+- This allows you to create specialized assistant personalities or behaviors
+- Custom instructions are a per-session setting and not saved to your configuration
+
+### Using Custom System Instructions
+
+```bash
+# Provide custom system instructions
+janito --system "You are a poetry expert who speaks in rhymes" "Write about coding"
+
+# Or use the short alias
+janito -s "You are a cybersecurity expert" "Review this authentication code"
+```
+
+This feature is particularly useful for:
+- Creating specialized assistant personalities
+- Focusing Claude on specific domains or expertise
+- Setting up specific response formats or styles
+- Educational scenarios where you need different expert perspectives
+
 ## 💬 Conversation History
 
-Janito automatically saves your conversation history, allowing you to continue previous discussions:
+Janito automatically saves your conversation history, allowing you to browse, manage, and continue previous discussions:
 
 ### How It Works
 
@@ -223,6 +289,23 @@ Janito automatically saves your conversation history, allowing you to continue p
 - 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
 
+### Browsing Your History
+
+You can view your conversation history with the `--history` flag:
+
+```bash
+# Show the 20 most recent conversations (default)
+janito --history
+
+# Show a specific number of recent conversations
+janito --history 10
+```
+
+This displays a table with:
+- Conversation ID
+- Date and time
+- First query from each conversation
+
 ### Using the Continue Feature
 
 ```bash
@@ -231,6 +314,13 @@ 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"
+
+# Just use --continue without arguments to continue the most recent conversation
+# and be prompted for your next query
+janito --continue
+
+# Alternative way to continue a specific conversation
+janito --continue-id abc123def "Let's modify that code you suggested"
 ```
 
 The `--continue` flag (or `-c` for short) allows you to:
@@ -266,11 +356,17 @@ Janito offers a variety of command-line options to customize its behavior:
 --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
+--no-tools                    Disable all tools for this session (pure AI interaction)
 --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')
+--system, -s TEXT             Provide custom system instructions, bypassing the default file load method
 --version                     Show the version and exit
---continue, -c TEXT           Continue a previous conversation, optionally with a specific message ID
+--continue, -c TEXT           Continue a conversation. Can be used as: 1) --continue (to continue most recent), 
+                              2) --continue 123 (to continue conversation with ID 123), or 
+                              3) --continue "query" (to continue most recent with new query)
+--continue-id TEXT            Continue a specific conversation with the given ID
+--history                     Show a summary of conversations. Use --history for default (20) or --history n to specify count
 --help                        Show the help message and exit
 ```
 

{janito-0.13.0 → janito-0.14.0}/README.md

@@ -11,12 +11,13 @@ Janito is a powerful AI-assisted command-line interface (CLI) tool built with Py
 - 🔍 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
+- 💬 Enhanced conversation history with browsing and management
 - 🔇 Trust mode for concise output without tool details
+- 🚫 No-tools mode for pure AI interactions without file system access
+- 📝 Custom system instructions for specialized assistant behavior
 
 ## 🛠️ System Requirements
 
@@ -95,19 +96,35 @@ janito --trust "Optimize the HTML code"
 # Or use the short alias
 janito -t "Optimize the HTML code"
 
+# Disable all tools for pure AI interaction
+janito --no-tools "Explain how HTML works"
+
+# View your conversation history
+janito --history
+
+# View a specific number of recent conversations
+janito --history 10
+
 # 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"
+janito --continue 'abc123def' 'Let's refine that code'
+
+# Alternative way to continue a specific conversation
+janito --continue-id abc123def "Let's refine that code"
+
+# Provide custom system instructions
+janito --system "You are a poetry expert who speaks in rhymes" "Write about coding"
+# Or use the short alias
+janito -s "You are a poetry expert who speaks in rhymes" "Write about coding"
 
 # 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
+# Interrupted conversations can be continued with --continue
 ```
 
 ## 🔧 Available Tools
@@ -193,9 +210,58 @@ This feature is particularly useful for:
 - Focusing on results rather than the process
 - Creating cleaner output for documentation or sharing
 
+## 🚫 No-Tools Mode
+
+Janito provides a no-tools mode that disables all file system and external tools for pure AI interactions:
+
+### How It Works
+
+- When enabled with `--no-tools`, Janito disables all tools for the current session
+- Claude will respond based purely on its knowledge without accessing or modifying files
+- This mode is a per-session setting and not saved to your configuration
+
+### Using No-Tools Mode
+
+```bash
+# Enable no-tools mode
+janito --no-tools "Explain how Docker containers work"
+```
+
+This feature is particularly useful for:
+- Getting general information or explanations without file system access
+- Brainstorming sessions where you don't need file operations
+- Safer operation in sensitive environments
+- Faster responses for queries that don't require tools
+
+## 📝 Custom System Instructions
+
+Janito allows you to provide custom system instructions to change Claude's behavior:
+
+### How It Works
+
+- When provided with `--system` or `-s`, Janito uses your custom instructions instead of the default
+- This allows you to create specialized assistant personalities or behaviors
+- Custom instructions are a per-session setting and not saved to your configuration
+
+### Using Custom System Instructions
+
+```bash
+# Provide custom system instructions
+janito --system "You are a poetry expert who speaks in rhymes" "Write about coding"
+
+# Or use the short alias
+janito -s "You are a cybersecurity expert" "Review this authentication code"
+```
+
+This feature is particularly useful for:
+- Creating specialized assistant personalities
+- Focusing Claude on specific domains or expertise
+- Setting up specific response formats or styles
+- Educational scenarios where you need different expert perspectives
+
 ## 💬 Conversation History
 
-Janito automatically saves your conversation history, allowing you to continue previous discussions:
+Janito automatically saves your conversation history, allowing you to browse, manage, and continue previous discussions:
 
 ### How It Works
 
@@ -203,6 +269,23 @@ Janito automatically saves your conversation history, allowing you to continue p
 - 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
 
+### Browsing Your History
+
+You can view your conversation history with the `--history` flag:
+
+```bash
+# Show the 20 most recent conversations (default)
+janito --history
+
+# Show a specific number of recent conversations
+janito --history 10
+```
+
+This displays a table with:
+- Conversation ID
+- Date and time
+- First query from each conversation
+
 ### Using the Continue Feature
 
 ```bash
@@ -211,6 +294,13 @@ 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"
+
+# Just use --continue without arguments to continue the most recent conversation
+# and be prompted for your next query
+janito --continue
+
+# Alternative way to continue a specific conversation
+janito --continue-id abc123def "Let's modify that code you suggested"
 ```
 
 The `--continue` flag (or `-c` for short) allows you to:
@@ -246,11 +336,17 @@ Janito offers a variety of command-line options to customize its behavior:
 --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
+--no-tools                    Disable all tools for this session (pure AI interaction)
 --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')
+--system, -s TEXT             Provide custom system instructions, bypassing the default file load method
 --version                     Show the version and exit
---continue, -c TEXT           Continue a previous conversation, optionally with a specific message ID
+--continue, -c TEXT           Continue a conversation. Can be used as: 1) --continue (to continue most recent), 
+                              2) --continue 123 (to continue conversation with ID 123), or 
+                              3) --continue "query" (to continue most recent with new query)
+--continue-id TEXT            Continue a specific conversation with the given ID
+--history                     Show a summary of conversations. Use --history for default (20) or --history n to specify count
 --help                        Show the help message and exit
 ```
 

janito-0.14.0/janito/__init__.py

@@ -0,0 +1,5 @@
+"""
+Janito package.
+"""
+
+__version__ = "0.14.0"

janito-0.14.0/janito/cli/agent/__init__.py

@@ -0,0 +1,7 @@
+"""
+Agent initialization and query handling for Janito CLI.
+"""
+from janito.cli.agent.query import handle_query
+from janito.cli.agent.conversation import load_messages, save_messages
+
+__all__ = ["handle_query", "load_messages", "save_messages"]

janito-0.14.0/janito/cli/agent/conversation.py

@@ -0,0 +1,149 @@
+"""
+Conversation management functionality for Janito CLI.
+"""
+import json
+import datetime
+import sys
+from typing import Optional, List, Dict, Any
+from rich.console import Console
+from pathlib import Path
+import claudine
+
+from janito.config import get_config
+
+console = Console()
+
+def generate_message_id() -> str:
+    """
+    Generate a message ID based on timestamp with seconds granularity
+    
+    Returns:
+        str: A timestamp-based message ID
+    """
+    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+    return timestamp
+
+def save_messages(agent: claudine.Agent) -> Optional[str]:
+    """
+    Save agent messages to .janito/last_messages/{message_id}.json
+    
+    Args:
+        agent: The claudine agent instance
+        
+    Returns:
+        str: The message ID used for saving, or None if saving failed
+    """
+    try:
+        # Get the workspace directory
+        workspace_dir = Path(get_config().workspace_dir)
+        
+        # Create .janito directory if it doesn't exist
+        janito_dir = workspace_dir / ".janito"
+        janito_dir.mkdir(exist_ok=True)
+        
+        # Create last_messages directory if it doesn't exist
+        messages_dir = janito_dir / "last_messages"
+        messages_dir.mkdir(exist_ok=True)
+        
+        # Generate a unique message ID
+        message_id = generate_message_id()
+        
+        # Get messages from the agent
+        messages = agent.get_messages()
+        
+        # Create a message object with metadata
+        message_object = {
+            "id": message_id,
+            "timestamp": datetime.datetime.now().isoformat(),
+            "messages": messages
+        }
+        
+        # Save messages to file
+        message_file = messages_dir / f"{message_id}.json"
+        with open(message_file, "w", encoding="utf-8") as f:
+            json.dump(message_object, f, ensure_ascii=False, indent=2)
+            
+        if get_config().verbose:
+            console.print(f"[bold green]✅ Conversation saved to {message_file}[/bold green]")
+            
+        return message_id
+    except Exception as e:
+        console.print(f"[bold red]❌ Error saving conversation:[/bold red] {str(e)}")
+        return None
+
+def load_messages(message_id: Optional[str] = None) -> Optional[List[Dict[str, Any]]]:
+    """
+    Load messages from .janito/last_messages/{message_id}.json or the latest message file
+    
+    Args:
+        message_id: Optional message ID to load specific conversation
+        
+    Returns:
+        List of message dictionaries or None if file doesn't exist
+    """
+    try:
+        # Get the workspace directory
+        workspace_dir = Path(get_config().workspace_dir)
+        janito_dir = workspace_dir / ".janito"
+        messages_dir = janito_dir / "last_messages"
+        
+        # If message_id is provided, try to load that specific conversation
+        if message_id:
+            # Check if the message ID is a file name or just the ID
+            if message_id.endswith('.json'):
+                message_file = messages_dir / message_id
+            else:
+                message_file = messages_dir / f"{message_id}.json"
+                
+            if not message_file.exists():
+                console.print(f"[bold yellow]⚠️ No conversation found with ID {message_id}[/bold yellow]")
+                return None
+                
+            # Load messages from file
+            with open(message_file, "r", encoding="utf-8") as f:
+                message_object = json.load(f)
+                
+            # Extract messages from the message object
+            if isinstance(message_object, dict) and "messages" in message_object:
+                messages = message_object["messages"]
+            else:
+                # Handle legacy format
+                messages = message_object
+                
+            if get_config().verbose:
+                console.print(f"[bold green]✅ Loaded conversation from {message_file}[/bold green]")
+                console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
+                
+            return messages
+        
+        # If no message_id is provided, try to load the latest message from last_messages directory
+        if not messages_dir.exists() or not any(messages_dir.iterdir()):
+            console.print("[bold yellow]⚠️ No previous conversation found[/bold yellow]")
+            return None
+        
+        # Find the latest message file (based on filename which is a timestamp)
+        latest_file = max(
+            [f for f in messages_dir.iterdir() if f.is_file() and f.suffix == '.json'],
+            key=lambda x: x.stem
+        )
+        
+        # Load messages from the latest file
+        with open(latest_file, "r", encoding="utf-8") as f:
+            message_object = json.load(f)
+            
+        # Extract messages from the message object
+        if isinstance(message_object, dict) and "messages" in message_object:
+            messages = message_object["messages"]
+        else:
+            # Handle legacy format
+            messages = message_object
+            
+        if get_config().verbose:
+            console.print(f"[bold green]✅ Loaded latest conversation from {latest_file}[/bold green]")
+            console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
+            
+        return messages
+    except Exception as e:
+        console.print(f"[bold red]❌ Error loading conversation:[/bold red] {str(e)}")
+        return None
+

janito-0.14.0/janito/cli/agent/initialization.py

@@ -0,0 +1,172 @@
+"""
+Agent initialization functionality for Janito CLI.
+"""
+import os
+import platform
+import typer
+from typing import Optional, Dict, Any
+from rich.console import Console
+from jinja2 import Template
+import importlib.resources as pkg_resources
+import claudine
+
+from janito.config import get_config, Config
+from janito.callbacks import text_callback
+from janito.tools import str_replace_editor, get_tools, reset_tracker
+from janito.tools.bash.bash import bash_tool
+from janito.cli.output import display_generation_params
+
+console = Console()
+
+def get_api_key() -> str:
+    """
+    Get the API key from global config, environment variable, or user input.
+    
+    Returns:
+        str: The API key
+    """
+    # Get API key from global config, environment variable, or ask the user
+    api_key = Config.get_api_key()
+    
+    # If not found in global config, try environment variable
+    if not api_key:
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        
+    # If still not found, prompt the user
+    if not api_key:
+        console.print("[bold yellow]⚠️ Warning:[/bold yellow] API key not found in global config or ANTHROPIC_API_KEY environment variable.")
+        console.print("🔑 Please set it using --set-api-key or provide your API key now:")
+        api_key = typer.prompt("Anthropic API Key", hide_input=True)
+    
+    return api_key
+
+def load_instructions() -> str:
+    """
+    Load instructions template and render it with variables.
+    
+    Returns:
+        str: The rendered instructions
+    """
+    try:
+        # For Python 3.9+
+        try:
+            from importlib.resources import files
+            template_content = files('janito.data').joinpath('instructions_template.txt').read_text(encoding='utf-8')
+        # Fallback for older Python versions
+        except (ImportError, AttributeError):
+            template_content = pkg_resources.read_text('janito.data', 'instructions_template.txt', encoding='utf-8')
+        
+        # Create template variables
+        template_variables = {
+            'platform': platform.system(),
+            'role': get_config().role,
+            # Add any other variables you want to pass to the template here
+        }
+        
+        # Create template and render
+        template = Template(template_content)
+        instructions = template.render(**template_variables)
+        
+    except Exception as e:
+        console.print(f"[bold red]❌ Error loading instructions template:[/bold red] {str(e)}")
+        # Try to fall back to regular instructions.txt
+        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 e2:
+            console.print(f"[bold red]❌ Error loading fallback instructions:[/bold red] {str(e2)}")
+            instructions = "You are Janito, an AI assistant."
+    
+    return instructions
+
+def initialize_agent(temperature: float, verbose: bool, system_instructions: Optional[str] = None) -> claudine.Agent:
+    """
+    Initialize the Claude agent with tools and configuration.
+    
+    Args:
+        temperature: Temperature value for model generation
+        verbose: Whether to enable verbose mode
+        system_instructions: Optional custom system instructions to use instead of loading from file
+        
+    Returns:
+        claudine.Agent: The initialized agent
+    """
+    # Get API key
+    api_key = get_api_key()
+    
+    # Load instructions or use provided system instructions
+    if system_instructions:
+        instructions = system_instructions
+        if verbose:
+            console.print("[bold blue]🔄 Using custom system instructions provided via --system parameter[/bold blue]")
+            # Print the first 50 characters of the instructions for verification
+            preview = system_instructions[:50] + "..." if len(system_instructions) > 50 else system_instructions
+            console.print(f"[dim]System instructions preview: {preview}[/dim]")
+    else:
+        instructions = load_instructions()
+    
+    # Get tools
+    tools_list = get_tools()
+    
+    # Reset usage tracker before each query
+    reset_tracker()
+    
+    # Use command line parameters if provided (not default values), otherwise use config
+    temp_to_use = temperature if temperature != 0.0 else get_config().temperature
+    
+    # Get profile parameters if a profile is set
+    config = get_config()
+    profile_data = None
+    if config.profile:
+        profile_data = config.get_available_profiles()[config.profile]
+    
+    # Display generation parameters if verbose mode is enabled
+    if verbose:
+        display_generation_params(temp_to_use, profile_data, temperature)
+    
+    # Create config_params dictionary with generation parameters
+    config_params = {
+        "temperature": temp_to_use
+    }
+    
+    # Add top_k and top_p from profile if available
+    if profile_data:
+        if "top_k" in profile_data and profile_data["top_k"] != 0:
+            config_params["top_k"] = profile_data["top_k"]
+        if "top_p" in profile_data and profile_data["top_p"] != 0.0:
+            config_params["top_p"] = profile_data["top_p"]
+    
+    # Initialize the agent
+    if get_config().no_tools:
+        # If no_tools mode is enabled, don't pass any tools to the agent
+        agent = claudine.Agent(
+            api_key=api_key,
+            system_prompt=instructions,
+            callbacks={"text": text_callback},
+            verbose=verbose,
+            max_tokens=8126,
+            max_tool_rounds=100,
+            config_params=config_params,
+            # Don't pass any tools, including text_editor_tool and bash_tool
+        )
+    else:
+        # Normal mode with tools
+        agent = claudine.Agent(
+            api_key=api_key,
+            system_prompt=instructions,
+            callbacks={"text": text_callback},
+            text_editor_tool=str_replace_editor,
+            bash_tool=bash_tool,
+            tools=tools_list,
+            verbose=verbose,
+            max_tokens=8126,
+            max_tool_rounds=100,
+            config_params=config_params,
+        )
+    
+    return agent