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

janito/cli/commands.py

@@ -1,329 +1,12 @@
 """
 Command handling logic for Janito CLI.
+This module serves as a compatibility layer for the reorganized commands module.
 """
-import sys
-import os
-from typing import Optional, Tuple, Any
-from pathlib import Path
-import typer
-from rich.console import Console
-
-from janito.config import get_config, Config
-
-console = Console()
-
-def validate_parameters(temperature: float) -> None:
-    """
-    Validate temperature parameter.
-    
-    Args:
-        temperature: Temperature value for model generation
-    """
-    try:
-        if temperature < 0.0 or temperature > 1.0:
-            raise ValueError("Temperature must be between 0.0 and 1.0")
-            
-        # We'll use this value directly in the agent initialization but we don't save it to config
-        # Temperature display is hidden
-    except ValueError as e:
-        console.print(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
-
-def handle_reset_config(reset_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --reset-config parameter.
-    
-    Args:
-        reset_config: Whether to reset the configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if reset_config:
-        try:
-            config_path = Path(get_config().workspace_dir) / ".janito" / "config.json"
-            if get_config().reset_config():
-                console.print(f"[bold green]✅ Configuration file removed: {config_path}[/bold green]")
-            else:
-                console.print(f"[bold yellow]⚠️ Configuration file does not exist: {config_path}[/bold yellow]")
-        except Exception as e:
-            console.print(f"[bold red]Error removing configuration file:[/bold red] {str(e)}")
-        
-        # Exit after resetting config if no other operation is requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_workspace(workspace: Optional[str]) -> bool:
-    """
-    Handle the --workspace parameter.
-    
-    Args:
-        workspace: Workspace directory path
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if workspace:
-        try:
-            console.print(f"[bold]📂 Setting workspace directory to: {workspace}[/bold]")
-            get_config().workspace_dir = workspace
-            console.print(f"[bold green]✅ Workspace directory set to: {get_config().workspace_dir}[/bold green]")
-        except ValueError as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def handle_show_config(show_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --show-config parameter.
-    
-    Args:
-        show_config: Whether to show the configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if show_config:
-        config = get_config()
-        console.print("[bold blue]⚙️  Current Configuration:[/bold blue]")
-        console.print(f"[bold]📁 Local Configuration File:[/bold] .janito/config.json")
-        console.print(f"[bold]🏠 Global Configuration File:[/bold] {Path.home() / '.janito' / 'config.json'}")
-        
-        # Show API key status
-        api_key_global = Config.get_api_key()
-        api_key_env = os.environ.get("ANTHROPIC_API_KEY")
-        if api_key_global:
-            console.print(f"[bold]🔑 API Key:[/bold] [green]Set in global config[/green]")
-        elif api_key_env:
-            console.print(f"[bold]🔑 API Key:[/bold] [yellow]Set in environment variable[/yellow]")
-        else:
-            console.print(f"[bold]🔑 API Key:[/bold] [red]Not set[/red]")
-            
-        console.print(f"[bold]🔊 Verbose Mode:[/bold] {'Enabled' if config.verbose else 'Disabled'}")
-        console.print(f"[bold]❓ Ask Mode:[/bold] {'Enabled' if config.ask_mode else 'Disabled'}")
-
-        console.print(f"[bold]👤 Role:[/bold] {config.role}")
-        
-        # Show profile information if one is set
-        if config.profile:
-            profile_data = config.get_available_profiles()[config.profile]
-            console.print(f"[bold]📋 Active Profile:[/bold] {config.profile} - {profile_data['description']}")
-        
-        # Show available profiles
-        profiles = config.get_available_profiles()
-        if profiles:
-            console.print("\n[bold blue]📋 Available Parameter Profiles:[/bold blue]")
-            for name, data in profiles.items():
-                console.print(f"[bold]🔹 {name}[/bold] - {data['description']}")
-            
-        # Exit if this was the only operation requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_profile(profile: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --profile parameter.
-    
-    Args:
-        profile: Profile name
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if profile is not None:
-        try:
-            # Apply profile without saving to config
-            config = get_config()
-            profile_data = config.get_available_profiles()[profile.lower()]
-            
-            # Set values directly without saving
-            config._temperature = profile_data["temperature"]
-            config._profile = profile.lower()
-            
-            console.print(f"[bold green]✅ Profile '{profile.lower()}' applied for this session only[/bold green]")
-            console.print(f"[dim]📝 Description: {profile_data['description']}[/dim]")
-            
-            # Exit after applying profile if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except ValueError as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def handle_role(role: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --role parameter.
-    
-    Args:
-        role: Role name
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if role is not None:
-        try:
-            # Set role directly without saving to config
-            config = get_config()
-            config._role = role
-            
-            console.print(f"[bold green]✅ Role '{role}' applied for this session only[/bold green]")
-            
-            # Exit after applying role if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def handle_set_api_key(set_api_key: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-api-key parameter.
-    
-    Args:
-        set_api_key: API key
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if set_api_key is not None:
-        try:
-            Config.set_api_key(set_api_key)
-            console.print(f"[bold green]✅ API key saved to global configuration[/bold green]")
-            console.print(f"[dim]📁 Location: {Path.home() / '.janito' / 'config.json'}[/dim]")
-            
-            # Exit after setting API key if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def handle_set_config(config_str: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-config parameter.
-    
-    Args:
-        config_str: Configuration string in format 'key=value'
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if config_str is not None:
-        try:
-            # Parse the config string
-            config_parts = config_str.split("=", 1)
-            if len(config_parts) != 2:
-                console.print(f"[bold red]Error:[/bold red] Invalid configuration format. Use 'key=value' format.")
-                return ctx.invoked_subcommand is None and not query
-                
-            key = config_parts[0].strip()
-            value = config_parts[1].strip()
-            
-            # Remove quotes if present
-            if (value.startswith("'") and value.endswith("'")) or \
-               (value.startswith('"') and value.endswith('"')):
-                value = value[1:-1]
-                
-            if key == "profile":
-                try:
-                    get_config().set_profile(value)
-                    profile_data = get_config().get_available_profiles()[value.lower()]
-                    console.print(f"[bold green]✅ Profile set to '{value.lower()}'[/bold green]")
-                    console.print(f"[dim]📝 Description: {profile_data['description']}[/dim]")
-                except ValueError as e:
-                    console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            elif key == "temperature":
-                try:
-                    temp_value = float(value)
-                    if temp_value < 0.0 or temp_value > 1.0:
-                        console.print("[bold red]Error:[/bold red] Temperature must be between 0.0 and 1.0")
-                        return ctx.invoked_subcommand is None and not query
-                    
-                    get_config().temperature = temp_value
-                    console.print(f"[bold green]✅ Temperature set to {temp_value} and saved to configuration[/bold green]")
-                except ValueError:
-                    console.print(f"[bold red]Error:[/bold red] Invalid temperature value: {value}. Must be a float between 0.0 and 1.0.")
-            # top_k and top_p are now only accessible through profiles
-            elif key == "role":
-                get_config().role = value
-                console.print(f"[bold green]✅ Role set to '{value}' and saved to configuration[/bold green]")
-            else:
-                console.print(f"[bold yellow]Warning:[/bold yellow] Unsupported configuration key: {key}")
-            
-            # Exit after applying config changes if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            
-    return False
-
-def handle_config_commands(
-    ctx: typer.Context,
-    reset_config: bool,
-    workspace: Optional[str],
-    show_config: bool,
-    profile: Optional[str],
-    role: Optional[str],
-    set_api_key: Optional[str],
-    config_str: Optional[str],
-    query: Optional[str],
-    continue_conversation: bool = False
-) -> bool:
-    """
-    Handle all configuration-related commands.
-    
-    Args:
-        ctx: Typer context
-        reset_config: Whether to reset the configuration
-        workspace: Workspace directory path
-        show_config: Whether to show the configuration
-        profile: Profile name
-        role: Role name
-        set_api_key: API key
-        config_str: Configuration string in format 'key=value'
-        query: Query string
-        continue_conversation: Whether to continue the previous conversation
-        
-    Returns:
-        bool: True if the program should exit after these operations
-    """
-    # Handle each command and check if we should exit after it
-    if handle_reset_config(reset_config, ctx, query):
-        return True
-        
-    handle_workspace(workspace)
-    
-    if handle_show_config(show_config, ctx, query):
-        return True
-        
-    if handle_profile(profile, ctx, query):
-        return True
-        
-    if handle_role(role, ctx, query):
-        return True
-        
-    if handle_set_api_key(set_api_key, ctx, query):
-        return True
-        
-    if handle_set_config(config_str, ctx, query):
-        return True
-        
-    return False
+# 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/config.py

@@ -53,6 +53,8 @@ class Config:
             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"]
@@ -74,6 +76,8 @@ class Config:
                         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:
@@ -95,6 +99,7 @@ class Config:
             # 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
         }
@@ -265,6 +270,36 @@ class Config:
         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."""
@@ -323,6 +358,8 @@ class Config:
             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"]

janito/data/instructions_template.txt

@@ -1,27 +1,31 @@
 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  "." .
+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 (.janito/docs/STRUCTURE.md)
-Always start exploring the project by viewing for the file .janito/docs/STRUCTURE.md.
+# 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 tool user_prompt when:
+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/tools/__init__.py

@@ -10,11 +10,12 @@ 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", "get_tools", 
+           "prompt_user", "move_file", "fetch_webpage", "think", "get_tools", 
            "get_tracker", "reset_tracker", "print_usage_stats"]
 
 def get_tools():
@@ -23,10 +24,15 @@ def get_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]
+    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]

janito/tools/bash/bash.py

@@ -34,7 +34,9 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
     # Import console for printing output in real-time
     from janito.tools.rich_console import console, print_info
     
-    print_info(f"{command}", "Bash Run")
+    # Only print command if not in trust mode
+    if not get_config().trust_mode:
+        print_info(f"{command}", "Bash Run")
     global _bash_session
     
     # Check if in ask mode and if the command might modify files