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

janito/cli/commands.py

@@ -1,12 +0,0 @@
-"""
-Command handling logic for Janito CLI.
-This module serves as a compatibility layer for the reorganized commands module.
-"""
-# Re-export the functions from the new module structure
-from janito.cli.commands import handle_config_commands, validate_parameters, handle_history
-
-__all__ = [
-    "handle_config_commands",
-    "validate_parameters",
-    "handle_history",
-]

janito/cli/output.py

@@ -1,29 +0,0 @@
-"""
-Output formatting and display for Janito CLI.
-"""
-from rich.console import Console
-from janito.config import get_config
-
-console = Console()
-
-def display_generation_params(
-    temp_to_use: float, 
-    profile_data: dict = None,
-    temperature: float = 0.0
-) -> None:
-    """
-    Display generation parameters in verbose mode.
-    
-    Args:
-        temp_to_use: The temperature value being used
-        profile_data: The profile data if a profile is being used
-        temperature: The temperature value from command line
-    """
-    # Show profile information if one is active
-    config = get_config()
-    if config.profile:
-        if not profile_data:
-            profile_data = config.get_available_profiles()[config.profile]
-        console.print(f"[dim]👤 Using profile: {config.profile} - {profile_data['description']}[/dim]")
-    
-    # Temperature, top_k, and top_p information is hidden

janito/cli/utils.py

@@ -1,22 +0,0 @@
-"""
-Utility functions for the CLI module.
-"""
-import platform
-from rich.console import Console
-
-console = Console()
-
-def get_stdin_termination_hint():
-    """
-    Returns a user-friendly message about how to terminate stdin input
-    based on the current platform.
-    
-    Returns:
-        str: A message with the key sequence to terminate stdin input
-    """
-    system = platform.system()
-    
-    if system == "Windows":
-        return "[bold yellow]Press Ctrl+Z followed by Enter to terminate input[/bold yellow]"
-    else:  # Unix-like systems (Linux, macOS)
-        return "[bold yellow]Press Ctrl+D to terminate input[/bold yellow]"

janito/config.py

@@ -1,375 +0,0 @@
-"""
-Configuration module for Janito.
-Provides a singleton Config class to access configuration values.
-"""
-import os
-import json
-from pathlib import Path
-import typer
-from typing import Dict, Any, Optional
-
-# Predefined parameter profiles
-PROFILES = {
-    "precise": {
-        "temperature": 0.2,
-        "top_p": 0.85,
-        "top_k": 20,
-        "description": "Factual answers, documentation, structured data, avoiding hallucinations"
-    },
-    "balanced": {
-        "temperature": 0.5,
-        "top_p": 0.9,
-        "top_k": 40,
-        "description": "Professional writing, summarization, everyday tasks with moderate creativity"
-    },
-    "conversational": {
-        "temperature": 0.7,
-        "top_p": 0.9,
-        "top_k": 45,
-        "description": "Natural dialogue, educational content, support conversations"
-    },
-    "creative": {
-        "temperature": 0.9,
-        "top_p": 0.95,
-        "top_k": 70,
-        "description": "Storytelling, brainstorming, marketing copy, poetry"
-    },
-    "technical": {
-        "temperature": 0.3,
-        "top_p": 0.95,
-        "top_k": 15,
-        "description": "Code generation, debugging, decision analysis, technical problem-solving"
-    }
-}
-
-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
-            # Chat history context feature has been removed
-            cls._instance._ask_mode = False
-            cls._instance._trust_mode = False  # New trust mode setting
-            cls._instance._no_tools = False  # New no-tools mode setting
-            # Set technical profile as default
-            profile_data = PROFILES["technical"]
-            cls._instance._temperature = profile_data["temperature"]
-            cls._instance._profile = "technical"
-            cls._instance._role = "software engineer"
-            cls._instance._gitbash_path = None  # Default to None for auto-detection
-            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)
-                    # Chat history context feature has been removed
-                    if "debug_mode" in config_data:
-                        self._verbose = config_data["debug_mode"]
-                    if "ask_mode" in config_data:
-                        self._ask_mode = config_data["ask_mode"]
-                    if "trust_mode" in config_data:
-                        self._trust_mode = config_data["trust_mode"]
-                    if "temperature" in config_data:
-                        self._temperature = config_data["temperature"]
-                    if "profile" in config_data:
-                        self._profile = config_data["profile"]
-                    if "role" in config_data:
-                        self._role = config_data["role"]
-                    if "gitbash_path" in config_data:
-                        self._gitbash_path = config_data["gitbash_path"]
-            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 = {
-            # Chat history context feature has been removed
-            "verbose": self._verbose,
-            "ask_mode": self._ask_mode,
-            # trust_mode is not saved as it's a per-session setting
-            "temperature": self._temperature,
-            "role": self._role
-        }
-        
-        # Save profile name if one is set
-        if self._profile:
-            config_data["profile"] = self._profile
-            
-        # Save GitBash path if one is set
-        if self._gitbash_path:
-            config_data["gitbash_path"] = self._gitbash_path
-        
-        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)}")
-            
-    def set_profile(self, profile_name: str) -> None:
-        """Set parameter values based on a predefined profile.
-        
-        Args:
-            profile_name: Name of the profile to use (precise, balanced, conversational, creative, technical)
-            
-        Raises:
-            ValueError: If the profile name is not recognized
-        """
-        profile_name = profile_name.lower()
-        if profile_name not in PROFILES:
-            valid_profiles = ", ".join(PROFILES.keys())
-            raise ValueError(f"Unknown profile: {profile_name}. Valid profiles are: {valid_profiles}")
-            
-        profile = PROFILES[profile_name]
-        self._temperature = profile["temperature"]
-        self._profile = profile_name
-        self._save_config()
-        
-    @property
-    def profile(self) -> Optional[str]:
-        """Get the current profile name."""
-        return self._profile
-        
-    @staticmethod
-    def get_available_profiles() -> Dict[str, Dict[str, Any]]:
-        """Get all available predefined profiles."""
-        return PROFILES
-        
-    @staticmethod
-    def set_api_key(api_key: str) -> None:
-        """Set the API key in the global configuration file.
-        
-        Args:
-            api_key: The Anthropic API key to store
-            
-        Returns:
-            None
-        """
-        # Create .janito directory in user's home directory if it doesn't exist
-        home_dir = Path.home()
-        config_dir = home_dir / ".janito"
-        config_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Create or update the config.json file
-        config_path = config_dir / "config.json"
-        
-        # Load existing config if it exists
-        config_data = {}
-        if config_path.exists():
-            try:
-                with open(config_path, "r", encoding="utf-8") as f:
-                    config_data = json.load(f)
-            except Exception as e:
-                print(f"Warning: Failed to load global configuration: {str(e)}")
-        
-        # Update the API key
-        config_data["api_key"] = api_key
-        
-        # Save the updated config
-        try:
-            with open(config_path, "w", encoding="utf-8") as f:
-                json.dump(config_data, f, indent=2)
-            print(f"API key saved to {config_path}")
-        except Exception as e:
-            raise ValueError(f"Failed to save API key: {str(e)}")
-            
-    @staticmethod
-    def get_api_key() -> Optional[str]:
-        """Get the API key from the global configuration file.
-        
-        Returns:
-            The API key if found, None otherwise
-        """
-        # Look for config.json in user's home directory
-        home_dir = Path.home()
-        config_path = home_dir / ".janito" / "config.json"
-        
-        if config_path.exists():
-            try:
-                with open(config_path, "r", encoding="utf-8") as f:
-                    config_data = json.load(f)
-                    return config_data.get("api_key")
-            except Exception:
-                # Silently fail and return None
-                pass
-                
-        return None
-    
-    @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)}") from 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
-
-    # Chat history context feature has been removed
-        
-    @property
-    def ask_mode(self) -> bool:
-        """Get the ask mode status."""
-        return self._ask_mode
-        
-    @ask_mode.setter
-    def ask_mode(self, value: bool) -> None:
-        """Set the ask mode status."""
-        self._ask_mode = value
-        self._save_config()
-        
-    @property
-    def trust_mode(self) -> bool:
-        """Get the trust mode status."""
-        return self._trust_mode
-        
-    @trust_mode.setter
-    def trust_mode(self, value: bool) -> None:
-        """Set the trust mode status.
-        
-        Note: This setting is not persisted to config file
-        as it's meant to be a per-session setting.
-        """
-        self._trust_mode = value
-        # Don't save to config file - this is a per-session setting
-        
-    @property
-    def no_tools(self) -> bool:
-        """Get the no-tools mode status."""
-        return self._no_tools
-        
-    @no_tools.setter
-    def no_tools(self, value: bool) -> None:
-        """Set the no-tools mode status.
-        
-        Note: This setting is not persisted to config file
-        as it's meant to be a per-session setting.
-        """
-        self._no_tools = value
-        # Don't save to config file - this is a per-session setting
-        
-    @property
-    def temperature(self) -> float:
-        """Get the temperature value for model generation."""
-        return self._temperature
-        
-    @temperature.setter
-    def temperature(self, value: float) -> None:
-        """Set the temperature value for model generation."""
-        if value < 0.0 or value > 1.0:
-            raise ValueError("Temperature must be between 0.0 and 1.0")
-        self._temperature = value
-        self._save_config()
-        
-    # top_k and top_p are now only accessible through profiles
-        
-    @property
-    def role(self) -> str:
-        """Get the role for the assistant."""
-        return self._role
-        
-    @role.setter
-    def role(self, value: str) -> None:
-        """Set the role for the assistant."""
-        self._role = value
-        self._save_config()
-        
-    @property
-    def gitbash_path(self) -> Optional[str]:
-        """Get the path to the GitBash executable."""
-        return self._gitbash_path
-        
-    @gitbash_path.setter
-    def gitbash_path(self, value: Optional[str]) -> None:
-        """Set the path to the GitBash executable.
-        
-        Args:
-            value: Path to the GitBash executable, or None to use auto-detection
-        """
-        # If a path is provided, verify it exists
-        if value is not None and not os.path.exists(value):
-            raise ValueError(f"GitBash executable not found at: {value}")
-        
-        self._gitbash_path = value
-        self._save_config()
-        
-    def reset_config(self) -> bool:
-        """Reset configuration by removing the config file.
-        
-        Returns:
-            bool: True if the config file was removed, False if it didn't exist
-        """
-        config_path = Path(self._workspace_dir) / ".janito" / "config.json"
-        if config_path.exists():
-            config_path.unlink()
-            # Reset instance variables to defaults
-            self._verbose = False
-            # Chat history context feature has been removed
-            self._ask_mode = False
-            self._trust_mode = False
-            self._no_tools = False
-            # Set technical profile as default
-            profile_data = PROFILES["technical"]
-            self._temperature = profile_data["temperature"]
-            self._profile = "technical"
-            self._role = "software engineer"
-            self._gitbash_path = None  # Reset to auto-detection
-            return True
-        return False
-
-# Convenience function to get the config instance
-def get_config() -> Config:
-    """Get the singleton Config instance."""
-    return Config()

janito/data/instructions_template.txt

@@ -1,31 +0,0 @@
-You are a {{ role }}, using the name Janito .
-You will be assisting an user using a computer system on a {{ platform }} platform.
-You can find more about the current project using the tools in the workspace directory.
-If the question is related to the project, use the tools using the relative path, filename instead of /filename.
-
-If creating or editing files with a large number of lines, organize them into smaller files.
-If creating or editing files in an existing directory check surrounding files for the used patterns.
-
-# Structure Discovery (docs/STRUCTURE.md from current directory)
-Always start exploring the project by viewing for the file docs/STRUCTURE.md.
-Do not track files or directories wich are in .gitignore in the structure.
-At the end of responding to the user, update the structure file based on the files and directories you have interacted with,
-be precise focusing on the most important files and directories, avoid adding extra information like architecture or design patterns.
-
-# Tools
-The bash tool does not support commands which will require user input.
-Use the bash tool to get the current date or time when needed.
-Prefer the str_replace_editor tool to view directories and file contents.
-
-</IMPORTANT>
-Call the user_prompt tool when:
-- There are multiple options to apply a certain change
-- The next operation risk is moderated or high
-- The implementation plan is complex, requiring a review
-Proceed according to the user answer.
-<IMPORTANT/>
-
-When changing code in Python files, be mindful about the need to review the imports specially when new type hints are used (eg. Optional, Tuple, List, Dict, etc).
-After performing changes to a project in interfaces which are exposed to the user, respond to the user with a short summary on how to verify the changes. eg. "run cmd xpto", prefer to provide a command to run instead of a description.
-When displaying commands in instructions to the user, consider their platform.
-When creating html pages which refer to images that should be manually placed by the user, instead of broken links provide a frame with a placeholder image.

janito/token_report.py

@@ -1,154 +0,0 @@
-"""
-Module for generating token usage reports.
-"""
-
-from rich.console import Console
-
-def generate_token_report(agent, verbose=False, interrupted=False):
-    """
-    Generate a token usage report.
-    
-    Args:
-        agent: The Claude agent instance
-        verbose: Whether to show detailed token usage information
-        interrupted: Whether the request was interrupted
-        
-    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
-        def format_cost(cost):
-            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
-        
-        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)}")
-        
-        total_cost_text = 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)}"
-        if interrupted:
-            total_cost_text += " (interrupted request not accounted)"
-        console.print(total_cost_text)
-        
-        # 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
-        def format_cost(cost):
-            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
-        
-        # Prepare summary message
-        cost_text = f"Cost: {format_cost(cost.total_cost)}"
-        if interrupted:
-            cost_text += " (interrupted request not accounted)"
-            
-        summary = f"Total tokens: {total_tokens} | {cost_text}"
-        
-        # 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,44 +0,0 @@
-"""
-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
-from .move_file import move_file
-from janito.tools.fetch_webpage import fetch_webpage
-from .think import think
-from .usage_tracker import get_tracker, reset_tracker, print_usage_stats
-from janito.config import get_config
-
-__all__ = ["str_replace_editor", "find_files", "delete_file", "search_text", "replace_file", 
-           "prompt_user", "move_file", "fetch_webpage", "think", "get_tools", 
-           "get_tracker", "reset_tracker", "print_usage_stats"]
-
-def get_tools():
-    """
-    Get a list of all available tools.
-    
-    Returns:
-        List of tool functions (excluding str_replace_editor which is passed separately)
-        If no_tools mode is enabled, returns an empty list
-        If ask_mode is enabled, only returns tools that don't perform changes
-    """
-    # If no_tools mode is enabled, return an empty list
-    if get_config().no_tools:
-        return []
-        
-    # Tools that only read or view but don't modify anything
-    read_only_tools = [find_files, search_text, prompt_user, fetch_webpage, think]
-    
-    # Tools that modify the filesystem
-    write_tools = [delete_file, replace_file, move_file]
-    
-    # If ask_mode is enabled, only return read-only tools
-    if get_config().ask_mode:
-        return read_only_tools
-    else:
-        return read_only_tools + write_tools