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

janito/cli/agent.py

@@ -1,287 +1,12 @@
 """
 Agent initialization and query handling for Janito CLI.
-"""
-import os
-import sys
-import json
-import anthropic
-import claudine
-import typer
-from rich.console import Console
-from pathlib import Path
-from jinja2 import Template
-import importlib.resources as pkg_resources
-
-from janito.config import get_config, Config
-from janito.callbacks import text_callback
-from janito.token_report import generate_token_report
-from janito.tools import str_replace_editor
-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
-    """
-    import platform
-    
-    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) -> claudine.Agent:
-    """
-    Initialize the Claude agent with tools and configuration.
-    
-    Args:
-        temperature: Temperature value for model generation
-        verbose: Whether to enable verbose mode
-        
-    Returns:
-        claudine.Agent: The initialized agent
-    """
-    # Get API key
-    api_key = get_api_key()
-    
-    # Load instructions
-    instructions = load_instructions()
-    
-    # Get tools
-    from janito.tools import get_tools, reset_tracker
-    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
-    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
-
-def save_messages(agent):
-    """
-    Save agent messages to .janito/last_message.json
-    
-    Args:
-        agent: The claudine agent instance
-    """
-    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)
-        
-        # Get messages from the agent
-        messages = agent.get_messages()
-        
-        # Save messages to file
-        with open(janito_dir / "last_message.json", "w", encoding="utf-8") as f:
-            json.dump(messages, f, ensure_ascii=False, indent=2)
-            
-        if get_config().verbose:
-            console.print(f"[bold green]✅ Conversation saved to {janito_dir / 'last_message.json'}[/bold green]")
-    except Exception as e:
-        console.print(f"[bold red]❌ Error saving conversation:[/bold red] {str(e)}")
+This file is a compatibility layer that imports from the new module structure.
+"""
 
-def load_messages():
-    """
-    Load messages from .janito/last_message.json
-    
-    Returns:
-        List of message dictionaries or None if file doesn't exist
-    """
-    try:
-        # Get the workspace directory
-        workspace_dir = Path(get_config().workspace_dir)
-        
-        # Check if file exists
-        messages_file = workspace_dir / ".janito" / "last_message.json"
-        if not messages_file.exists():
-            console.print("[bold yellow]⚠️ No previous conversation found[/bold yellow]")
-            return None
-        
-        # Load messages from file
-        with open(messages_file, "r", encoding="utf-8") as f:
-            messages = json.load(f)
-            
-        if get_config().verbose:
-            console.print(f"[bold green]✅ Loaded previous conversation from {messages_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 previous conversation:[/bold red] {str(e)}")
-        return None
+# Import the public API from the new module structure
+from janito.cli.agent.query import handle_query
+from janito.cli.agent.conversation import load_messages, save_messages
 
-def handle_query(query: str, temperature: float, verbose: bool, show_tokens: bool, continue_conversation: bool = False) -> None:
-    """
-    Handle a query by initializing the agent and sending the query.
-    
-    Args:
-        query: The query to send to the agent
-        temperature: Temperature value for model generation
-        verbose: Whether to enable verbose mode
-        show_tokens: Whether to show detailed token usage
-        continue_conversation: Whether to continue the previous conversation
-    """
-    # Initialize the agent
-    agent = initialize_agent(temperature, verbose)
-    
-    # Load previous messages if continuing conversation
-    if continue_conversation:
-        messages = load_messages()
-        if messages:
-            agent.set_messages(messages)
-            console.print("[bold blue]🔄 Continuing previous conversation[/bold blue]")
-    
-    # Send the query to the agent
-    try:
-        agent.query(query)
-        
-        # Save messages after successful query
-        save_messages(agent)
-        
-        # Print token usage report
-        if show_tokens:
-            generate_token_report(agent, verbose=True, interrupted=False)
-        else:
-            # Show basic token usage
-            generate_token_report(agent, verbose=False, interrupted=False)
-        
-        # Print tool usage statistics
-        from janito.tools import print_usage_stats
-        print_usage_stats()
-            
-    except KeyboardInterrupt:
-        # Handle Ctrl+C by printing token and tool usage information
-        console.print("\n[bold yellow]⚠️ Query interrupted by user (Ctrl+C)[/bold yellow]")
-        
-        # Save messages even if interrupted
-        save_messages(agent)
-        
-        # Print token usage report (even if interrupted)
-        try:
-            if show_tokens:
-                generate_token_report(agent, verbose=True, interrupted=True)
-            else:
-                # Show basic token usage
-                generate_token_report(agent, verbose=False, interrupted=True)
-            
-            # Print tool usage statistics
-            from janito.tools import print_usage_stats
-            print_usage_stats()
-        except Exception as e:
-            console.print(f"[bold red]❌ Error generating usage report:[/bold red] {str(e)}")
-            if verbose:
-                import traceback
-                console.print(traceback.format_exc())
-        
-        # Exit with non-zero status to indicate interruption
-        sys.exit(130)  # 130 is the standard exit code for SIGINT
-            
-    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())
+# Export the public API
+__all__ = ["handle_query", "load_messages", "save_messages"]

janito/cli/app.py

@@ -7,6 +7,7 @@ import typer
 from rich.console import Console
 import importlib.metadata
 
+from janito import __version__
 from janito.config import get_config
 from janito.cli.commands import handle_config_commands, validate_parameters
 from janito.cli.agent import handle_query
@@ -19,18 +20,23 @@ console = Console()
 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"),
+         show_tokens: bool = typer.Option(False, "--show-tokens", "--tokens", 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., 'temperature=0.7' or 'profile=technical'"),
          show_config: bool = typer.Option(False, "--show-config", help="Show current configuration"),
          reset_config: bool = typer.Option(False, "--reset-config", help="Reset configuration by removing the config file"),
          set_api_key: Optional[str] = typer.Option(None, "--set-api-key", help="Set the Anthropic API key globally in the user's home directory"),
          ask: bool = typer.Option(False, "--ask", help="Enable ask mode which disables tools that perform changes"),
+         trust: bool = typer.Option(False, "--trust", "-t", help="Enable trust mode which suppresses tool outputs for a more concise execution"),
+         no_tools: bool = typer.Option(False, "--no-tools", help="Disable all tools for this session (per-session setting, not saved to config)"),
          temperature: float = typer.Option(0.0, "--temperature", help="Set the temperature for model generation (0.0 to 1.0)"),
          profile: Optional[str] = typer.Option(None, "--profile", help="Use a predefined parameter profile (precise, balanced, conversational, creative, technical)"),
          role: Optional[str] = typer.Option(None, "--role", help="Set the assistant's role (default: 'software engineer')"),
+         system: Optional[str] = typer.Option(None, "--system", "-s", help="Provide custom system instructions, bypassing the default file load method"),
          version: bool = typer.Option(False, "--version", help="Show the version and exit"),
-         continue_conversation: bool = typer.Option(False, "--continue", "-c", help="Continue the previous conversation")):
+         continue_id: Optional[str] = typer.Option(None, "--continue-id", help="Continue a specific conversation with the given ID"),
+         continue_flag: Optional[str] = typer.Option(None, "--continue", "-c", help="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)"),
+         history_flag: bool = typer.Option(False, "--history", help="Show a summary of conversations. Use --history for default (20) or --history n to specify count")):
     """
     Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
     """    
@@ -40,22 +46,108 @@ def main(ctx: typer.Context,
     # Set ask mode in config
     get_config().ask_mode = ask
     
+    # Set trust mode in config
+    get_config().trust_mode = trust
+    
+    # Set no-tools mode in config
+    get_config().no_tools = no_tools
+    
     # Show a message if ask mode is enabled
     if ask:
         console.print("[bold yellow]⚠️ Ask Mode enabled:[/bold yellow] 🔒 Tools that perform changes are disabled")
+        
+    # Show a message if trust mode is enabled
+    if trust:
+        console.print("[bold blue]⚡ Trust Mode enabled:[/bold blue] Tool outputs are suppressed for concise execution")
+        
+    # Show a message if no-tools mode is enabled
+    if no_tools:
+        console.print("[bold magenta]🚫 No-Tools Mode enabled:[/bold magenta] All tools are disabled for this session")
     
     # Show version and exit if requested
     if version:
-        try:
-            version_str = importlib.metadata.version("janito")
-            console.print(f"🚀 Janito version: {version_str}")
-        except importlib.metadata.PackageNotFoundError:
-            console.print("🚀 Janito version: [italic]development[/italic]")
+        console.print(f"🚀 Janito version: {__version__}")
         sys.exit(0)
     
     # Validate temperature
     validate_parameters(temperature)
     
+    # Process continue flags before handling other options
+    continue_conversation = None
+    
+    # First, parse continue_flag and continue_id from original sys.argv to avoid typer issues
+    # This is necessary because typer has trouble with quotes in some edge cases
+    try:
+        # Check if --continue or -c is in sys.argv
+        args = sys.argv
+        
+        # Handle the --history flag with optional count parameter
+        history_count_override = None
+        if "--history" in args:
+            history_idx = args.index("--history")
+            history_flag = True
+            
+            # Check if there's a number after --history and it's not another flag
+            if history_idx + 1 < len(args) and not args[history_idx + 1].startswith("-"):
+                try:
+                    # Try to convert to int - if successful, it's a count
+                    history_count_override = int(args[history_idx + 1])
+                except ValueError:
+                    # Not a number, ignore it
+                    pass
+        
+        if "--continue" in args or "-c" in args:
+            continue_idx = args.index("--continue") if "--continue" in args else args.index("-c")
+            
+            # Check if there's at least one argument after --continue
+            if continue_idx + 1 < len(args) and not args[continue_idx + 1].startswith("-"):
+                # If next arg doesn't start with "-", it's our continue value
+                continue_value = args[continue_idx + 1]
+                
+                # Check if continue_value is a numeric ID or a query
+                if continue_value.isdigit():
+                    # It's an ID
+                    continue_conversation = continue_value
+                    
+                    # Check if there's a query after the ID
+                    if continue_idx + 2 < len(args) and not args[continue_idx + 2].startswith("-"):
+                        query = args[continue_idx + 2]
+                else:
+                    # It's a query string for the most recent conversation
+                    continue_conversation = ""  # Empty string means continue most recent
+                    query = continue_value
+                    
+                    if verbose:
+                        console.print(f"[bold blue]🔄 Continuing most recent conversation[/bold blue]")
+                        console.print(f"[dim]📝 Query: {query}[/dim]")
+            else:
+                # --continue with no args means continue most recent conversation
+                continue_conversation = ""
+        
+        # Handle explicit --continue-id if specified (this takes precedence)
+        if "--continue-id" in args:
+            continue_id_idx = args.index("--continue-id")
+            if continue_id_idx + 1 < len(args) and not args[continue_id_idx + 1].startswith("-"):
+                continue_conversation = args[continue_id_idx + 1]
+    except Exception as e:
+        if verbose:
+            console.print(f"[bold yellow]⚠️ Error parsing continue arguments: {str(e)}[/bold yellow]")
+    
+    # Fall back to typer-processed args if our parsing failed
+    if continue_conversation is None:
+        # Handle the --continue-id option
+        if continue_id is not None:
+            continue_conversation = continue_id
+        # Handle the --continue flag option (processed by typer)
+        elif continue_flag is not None:
+            if continue_flag == "":
+                continue_conversation = ""  # Empty string means continue most recent
+            elif continue_flag.isdigit():
+                continue_conversation = continue_flag
+            else:
+                continue_conversation = ""  # Empty string means continue most recent
+                query = continue_flag  # Use the continue_flag as the query
+    
     # Handle configuration-related commands
     exit_after_config = handle_config_commands(
         ctx, 
@@ -67,7 +159,10 @@ def main(ctx: typer.Context,
         set_api_key, 
         config_str, 
         query,
-        continue_conversation
+        continue_id,
+        continue_flag,
+        history_flag,
+        history_count_override
     )
     
     if exit_after_config:
@@ -76,6 +171,7 @@ def main(ctx: typer.Context,
     # Handle query if no subcommand was invoked
     if ctx.invoked_subcommand is None:
         # If no query provided in command line, read from stdin
+        # Only prompt for stdin if query is still None after processing --continue flag
         if not query:
             console.print("[bold blue]📝 No query provided in command line. Reading from stdin...[/bold blue]")
             console.print(get_stdin_termination_hint())
@@ -83,4 +179,4 @@ def main(ctx: typer.Context,
             
         # Only proceed if we have a query (either from command line or stdin)
         if query:
-            handle_query(query, temperature, verbose, show_tokens, continue_conversation)
+            handle_query(query, temperature, verbose, show_tokens, continue_conversation, system)

janito/cli/commands/__init__.py

@@ -0,0 +1,12 @@
+"""
+Command handling logic for Janito CLI.
+"""
+from janito.cli.commands.config import handle_config_commands
+from janito.cli.commands.validation import validate_parameters
+from janito.cli.commands.history import handle_history
+
+__all__ = [
+    "handle_config_commands",
+    "validate_parameters",
+    "handle_history",
+]