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

janito/config/core/singleton.py

@@ -0,0 +1,282 @@
+"""
+Singleton implementation of the Config class for Janito.
+"""
+import os
+from typing import Dict, Any, Optional, Union
+
+from .properties import ConfigProperties
+from .file_operations import (
+    get_global_config_path,
+    get_local_config_path,
+    load_config_file,
+    save_config_file,
+    merge_configs
+)
+from ..profiles.manager import get_profile
+from ..profiles.definitions import PROFILES
+
+class Config(ConfigProperties):
+    """Singleton configuration class for Janito."""
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(Config, cls).__new__(cls)
+            cls._instance._workspace_dir = os.getcwd()
+            cls._instance._verbose = False
+            cls._instance._ask_mode = False
+            cls._instance._trust_mode = False
+            cls._instance._no_tools = False
+            cls._instance._show_usage_report = True  # Enabled by default
+            
+            # 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
+            # Default max_view_lines will be retrieved from merged_config
+            
+            # Initialize configuration storage
+            cls._instance._global_config = {}
+            cls._instance._local_config = {}
+            cls._instance._merged_config = {}
+            
+            # Load configurations
+            cls._instance._load_config()
+        return cls._instance
+    
+    def _load_config(self) -> None:
+        """Load both global and local configurations and merge them."""
+        # Load global config
+        global_config_path = get_global_config_path()
+        self._global_config = load_config_file(global_config_path)
+        
+        # Load local config
+        local_config_path = get_local_config_path(self._workspace_dir)
+        self._local_config = load_config_file(local_config_path)
+        
+        # Remove runtime-only settings from config files if they exist
+        self._clean_runtime_settings()
+        
+        # Merge configurations (local overrides global)
+        self._merge_configs()
+        
+        # Apply merged configuration to instance variables
+        self._apply_config()
+        
+    def _clean_runtime_settings(self) -> None:
+        """Remove runtime-only settings from configuration files if they exist."""
+        runtime_settings = ["ask_mode"]
+        config_changed = False
+        
+        # Remove from local config
+        for setting in runtime_settings:
+            if setting in self._local_config:
+                del self._local_config[setting]
+                config_changed = True
+                
+        # Remove from global config
+        for setting in runtime_settings:
+            if setting in self._global_config:
+                del self._global_config[setting]
+                config_changed = True
+                
+        # Save changes if needed
+        if config_changed:
+            self._save_local_config()
+            self._save_global_config()
+    
+    def _merge_configs(self) -> None:
+        """Merge global and local configurations with local taking precedence."""
+        self._merged_config = merge_configs(self._global_config, self._local_config)
+    
+    def _apply_config(self) -> None:
+        """Apply the merged configuration to instance variables."""
+        config_data = self._merged_config
+        
+        # Apply configuration values to instance variables
+        if "debug_mode" in config_data:
+            self._verbose = config_data["debug_mode"]
+        if "verbose" in config_data:
+            self._verbose = config_data["verbose"]
+        # ask_mode is a runtime-only setting, not loaded from config
+        if "trust_mode" in config_data:
+            self._trust_mode = config_data["trust_mode"]
+        if "show_usage_report" in config_data:
+            self._show_usage_report = config_data["show_usage_report"]
+        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"]
+        # max_view_lines is accessed directly from merged_config
+    
+    def _save_local_config(self) -> None:
+        """Save local configuration to file."""
+        config_path = get_local_config_path(self._workspace_dir)
+        save_config_file(config_path, self._local_config)
+    
+    def _save_global_config(self) -> None:
+        """Save global configuration to file."""
+        config_path = get_global_config_path()
+        save_config_file(config_path, self._global_config)
+    
+    def _save_config(self) -> None:
+        """Save local configuration to file (for backward compatibility)."""
+        self._save_local_config()
+    
+    def set_profile(self, profile_name: str, config_type: str = "local") -> None:
+        """
+        Set parameter values based on a predefined profile.
+        
+        Args:
+            profile_name: Name of the profile to use (precise, balanced, conversational, creative, technical)
+            config_type: Type of configuration to update ("local" or "global")
+            
+        Raises:
+            ValueError: If the profile name is not recognized or config_type is invalid
+        """
+        if config_type not in ["local", "global"]:
+            raise ValueError(f"Invalid config_type: {config_type}. Must be 'local' or 'global'")
+            
+        profile = get_profile(profile_name)
+        
+        # Update the appropriate configuration
+        if config_type == "local":
+            self.set_local_config("temperature", profile["temperature"])
+            self.set_local_config("profile", profile_name)
+        else:
+            self.set_global_config("temperature", profile["temperature"])
+            self.set_global_config("profile", profile_name)
+    
+    @staticmethod
+    def get_available_profiles() -> Dict[str, Dict[str, Any]]:
+        """Get all available predefined profiles."""
+        from ..profiles.manager import get_available_profiles
+        return get_available_profiles()
+    
+    def set_local_config(self, key: str, value: Any) -> None:
+        """
+        Set a configuration value in the local configuration.
+        
+        Args:
+            key: Configuration key
+            value: Configuration value
+        """
+        self._local_config[key] = value
+        self._save_local_config()
+        
+        # Re-merge and apply configurations
+        self._merge_configs()
+        self._apply_config()
+    
+    def set_global_config(self, key: str, value: Any) -> None:
+        """
+        Set a configuration value in the global configuration.
+        
+        Args:
+            key: Configuration key
+            value: Configuration value
+        """
+        self._global_config[key] = value
+        self._save_global_config()
+        
+        # Re-merge and apply configurations
+        self._merge_configs()
+        self._apply_config()
+    
+    def get_local_config(self) -> Dict[str, Any]:
+        """
+        Get the local configuration.
+        
+        Returns:
+            Dict containing the local configuration
+        """
+        return self._local_config.copy()
+    
+    def get_global_config(self) -> Dict[str, Any]:
+        """
+        Get the global configuration.
+        
+        Returns:
+            Dict containing the global configuration
+        """
+        return self._global_config.copy()
+    
+    def get_merged_config(self) -> Dict[str, Any]:
+        """
+        Get the merged configuration.
+        
+        Returns:
+            Dict containing the merged configuration
+        """
+        return self._merged_config.copy()
+    
+    @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
+        """
+        # Get the singleton instance
+        config = Config()
+        
+        # Set the API key in the global configuration
+        config.set_global_config("api_key", api_key)
+        print(f"API key saved to {get_global_config_path()}")
+    
+    @staticmethod
+    def get_api_key() -> Optional[str]:
+        """
+        Get the API key from the global configuration file.
+        
+        Returns:
+            The API key if found, None otherwise
+        """
+        # Get the singleton instance
+        config = Config()
+        
+        # Get the API key from the merged configuration
+        return config.get_merged_config().get("api_key")
+    
+    def reset_local_config(self) -> bool:
+        """
+        Reset local configuration by removing the local config file.
+        
+        Returns:
+            bool: True if the config file was removed, False if it didn't exist
+        """
+        config_path = get_local_config_path(self._workspace_dir)
+        if config_path.exists():
+            config_path.unlink()
+            # Clear local configuration
+            self._local_config = {}
+            # Re-merge and apply configurations
+            self._merge_configs()
+            self._apply_config()
+            return True
+        return False
+    
+    def reset_global_config(self) -> bool:
+        """
+        Reset global configuration by removing the global config file.
+        
+        Returns:
+            bool: True if the config file was removed, False if it didn't exist
+        """
+        config_path = get_global_config_path()
+        if config_path.exists():
+            config_path.unlink()
+            # Clear global configuration
+            self._global_config = {}
+            # Re-merge and apply configurations
+            self._merge_configs()
+            self._apply_config()
+            return True
+        return False

janito/config/profiles/__init__.py

@@ -0,0 +1,8 @@
+"""
+Profile management for Janito configuration.
+Provides predefined parameter profiles and related functionality.
+"""
+from .definitions import PROFILES
+from .manager import get_profile, get_available_profiles
+
+__all__ = ["PROFILES", "get_profile", "get_available_profiles"]

janito/config/profiles/definitions.py

@@ -0,0 +1,38 @@
+"""
+Predefined parameter profiles for Janito.
+"""
+from typing import Dict, Any
+
+# 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"
+    }
+}

janito/config/profiles/manager.py

@@ -0,0 +1,80 @@
+"""
+Profile management functions for Janito configuration.
+"""
+from typing import Dict, Any
+
+from .definitions import PROFILES
+
+def get_available_profiles() -> Dict[str, Dict[str, Any]]:
+    """
+    Get all available predefined profiles.
+    
+    Returns:
+        Dictionary of profile names to profile settings
+    """
+    return PROFILES
+
+def get_profile(profile_name: str) -> Dict[str, Any]:
+    """
+    Get a specific profile by name.
+    
+    Args:
+        profile_name: Name of the profile to retrieve
+        
+    Returns:
+        Dict containing the profile settings
+        
+    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}")
+    
+    return PROFILES[profile_name]
+
+def create_custom_profile(name: str, temperature: float, description: str = None) -> Dict[str, Any]:
+    """
+    Create a custom profile with the given parameters.
+    
+    Args:
+        name: Name for the custom profile
+        temperature: Temperature value (0.0 to 1.0)
+        description: Optional description for the profile
+        
+    Returns:
+        Dict containing the profile settings
+        
+    Raises:
+        ValueError: If temperature is not between 0.0 and 1.0
+    """
+    if temperature < 0.0 or temperature > 1.0:
+        raise ValueError("Temperature must be between 0.0 and 1.0")
+    
+    # Determine top_p and top_k based on temperature
+    if temperature <= 0.3:
+        top_p = 0.85
+        top_k = 15
+    elif temperature <= 0.6:
+        top_p = 0.9
+        top_k = 40
+    else:
+        top_p = 0.95
+        top_k = 60
+    
+    # Use provided description or generate a default one
+    if description is None:
+        if temperature <= 0.3:
+            description = "Custom precise profile"
+        elif temperature <= 0.6:
+            description = "Custom balanced profile"
+        else:
+            description = "Custom creative profile"
+    
+    return {
+        "temperature": temperature,
+        "top_p": top_p,
+        "top_k": top_k,
+        "description": description
+    }

janito/data/instructions_template.txt

@@ -1,7 +1,7 @@
 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 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.
@@ -17,15 +17,18 @@ 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>
+<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/>
+</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.
+
+If STRUCTURE.md was updated add it to the list of files to be committed.
+After significant changes, run git commit with a message describing the changes made.

janito/tools/bash/bash.py

@@ -3,6 +3,9 @@ from typing import Tuple
 import threading
 import platform
 import re
+import queue
+import signal
+import time
 from janito.config import get_config
 from janito.tools.usage_tracker import get_tracker
 from janito.tools.rich_console import console, print_info
@@ -16,6 +19,42 @@ else:
 # Global instance of PersistentBash to maintain state between calls
 _bash_session = None
 _session_lock = threading.RLock()  # Use RLock to allow reentrant locking
+_current_bash_thread = None
+_command_interrupted = False
+
+def _execute_bash_command(command, result_queue):
+    """
+    Execute a bash command in a separate thread.
+    
+    Args:
+        command: The bash command to execute
+        result_queue: Queue to store the result
+    """
+    global _bash_session, _command_interrupted
+    
+    try:
+        # Execute the command - output will be printed to console in real-time
+        output = _bash_session.execute(command)
+        
+        # Put the result in the queue if the command wasn't interrupted
+        if not _command_interrupted:
+            result_queue.put((output, False))
+    except Exception as e:
+        # Handle any exceptions that might occur
+        error_message = f"Error executing bash command: {str(e)}"
+        console.print(error_message, style="red bold")
+        result_queue.put((error_message, True))
+
+def _keyboard_interrupt_handler(signum, frame):
+    """
+    Handle keyboard interrupt (Ctrl+C) by setting the interrupt flag.
+    """
+    global _command_interrupted
+    _command_interrupted = True
+    console.print("\n[bold red]Command interrupted by user (Ctrl+C)[/bold red]")
+    
+    # Restore the default signal handler
+    signal.signal(signal.SIGINT, original_sigint_handler)
 
 def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]:
     """
@@ -23,6 +62,7 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
     The appropriate implementation (Windows or Unix) is selected based on the detected platform.
     When in ask mode, only read-only commands are allowed.
     Output is printed to the console in real-time as it's received.
+    Command runs in a background thread, allowing Ctrl+C to interrupt just the command.
     
     Args:
         command: The bash command to execute
@@ -37,7 +77,9 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
     # Only print command if not in trust mode
     if not get_config().trust_mode:
         print_info(f"{command}", "Bash Run")
-    global _bash_session
+    
+    global _bash_session, _current_bash_thread, _command_interrupted, original_sigint_handler
+    _command_interrupted = False
     
     # Check if in ask mode and if the command might modify files
     if get_config().ask_mode:
@@ -65,20 +107,51 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
             _bash_session = PersistentBash(bash_path=gitbash_path)
         
         try:
-            # Execute the command - output will be printed to console in real-time
-            output = _bash_session.execute(command)
+            # Create a queue to get the result from the thread
+            result_queue = queue.Queue()
+            
+            # Save the original SIGINT handler
+            original_sigint_handler = signal.getsignal(signal.SIGINT)
+            
+            # Set our custom SIGINT handler
+            signal.signal(signal.SIGINT, _keyboard_interrupt_handler)
+            
+            # Create and start the thread
+            _current_bash_thread = threading.Thread(
+                target=_execute_bash_command,
+                args=(command, result_queue)
+            )
+            _current_bash_thread.daemon = True
+            _current_bash_thread.start()
+            
+            # Wait for the thread to complete or for an interrupt
+            while _current_bash_thread.is_alive() and not _command_interrupted:
+                _current_bash_thread.join(0.1)  # Check every 100ms
+            
+            # If the command was interrupted, return a message
+            if _command_interrupted:
+                # Restore the original signal handler
+                signal.signal(signal.SIGINT, original_sigint_handler)
+                return ("Command was interrupted by Ctrl+C", True)
+            
+            # Get the result from the queue
+            output, is_error = result_queue.get(timeout=1)
+            
+            # Restore the original signal handler
+            signal.signal(signal.SIGINT, original_sigint_handler)
             
             # Track bash command execution
             get_tracker().increment('bash_commands')
             
-            # Always assume execution was successful
-            is_error = False
-            
-            # Return the output as a string (even though it was already printed in real-time)
+            # Return the output
             return output, is_error
             
         except Exception as e:
             # Handle any exceptions that might occur
             error_message = f"Error executing bash command: {str(e)}"
             console.print(error_message, style="red bold")
+            
+            # Restore the original signal handler
+            signal.signal(signal.SIGINT, original_sigint_handler)
+            
             return error_message, True

janito/tools/bash/unix_persistent_bash.py

@@ -132,7 +132,38 @@ class PersistentBash:
         start_time = time.time()
         max_wait = timeout if timeout is not None else 3600  # Default to 1 hour if no timeout
         
+        # Check if we're being run from the main bash_tool function
+        # which will handle interruption
+        try:
+            from janito.tools.bash.bash import _command_interrupted
+        except ImportError:
+            _command_interrupted = False
+        
         while time.time() - start_time < max_wait + 5:  # Add buffer time
+            # Check if we've been interrupted
+            if '_command_interrupted' in globals() and _command_interrupted:
+                # Send Ctrl+C to the running process
+                if self.process and self.process.poll() is None:
+                    try:
+                        # Send interrupt signal to the process group
+                        import os
+                        import signal
+                        pgid = os.getpgid(self.process.pid)
+                        os.killpg(pgid, signal.SIGINT)
+                    except:
+                        pass
+                
+                # Add message to output
+                interrupt_msg = "Command interrupted by user (Ctrl+C)"
+                console.print(f"[bold red]{interrupt_msg}[/bold red]")
+                output_lines.append(interrupt_msg)
+                
+                # Reset the bash session
+                self.close()
+                self.start_process()
+                
+                break
+                
             try:
                 line = self.process.stdout.readline().rstrip('\r\n')
                 if end_marker in line:
@@ -152,7 +183,7 @@ class PersistentBash:
                 continue
             
         # Check for timeout
-        if time.time() - start_time >= max_wait + 5:
+        if time.time() - start_time >= max_wait + 5 and not _command_interrupted:
             timeout_msg = f"Error: Command timed out after {max_wait} seconds"
             console.print(timeout_msg, style="red bold")
             output_lines.append(timeout_msg)

janito/tools/bash/win_persistent_bash.py

@@ -216,7 +216,40 @@ class PersistentBash:
         start_time = time.time()
         max_wait = timeout if timeout is not None else 3600  # Default to 1 hour if no timeout
         
+        # Check if we're being run from the main bash_tool function
+        # which will handle interruption
+        try:
+            from janito.tools.bash.bash import _command_interrupted
+        except ImportError:
+            _command_interrupted = False
+        
         while time.time() - start_time < max_wait + 5:  # Add buffer time
+            # Check if we've been interrupted
+            if '_command_interrupted' in globals() and _command_interrupted:
+                # Send Ctrl+C to the running process
+                if self.process and self.process.poll() is None:
+                    try:
+                        # On Windows, we need to use CTRL_C_EVENT
+                        import signal
+                        self.process.send_signal(signal.CTRL_C_EVENT)
+                    except:
+                        # If that fails, try to terminate the process
+                        try:
+                            self.process.terminate()
+                        except:
+                            pass
+                
+                # Add message to output
+                interrupt_msg = "Command interrupted by user (Ctrl+C)"
+                console.print(f"[bold red]{interrupt_msg}[/bold red]")
+                output_lines.append(interrupt_msg)
+                
+                # Reset the bash session
+                self.close()
+                self.start_process()
+                
+                break
+                
             try:
                 line = self.stdout.readline().rstrip('\r\n')
                 if end_marker in line:
@@ -243,7 +276,7 @@ class PersistentBash:
                 continue
             
         # Check for timeout
-        if time.time() - start_time >= max_wait + 5:
+        if time.time() - start_time >= max_wait + 5 and not _command_interrupted:
             timeout_msg = f"Error: Command timed out after {max_wait} seconds"
             console.print(timeout_msg, style="red bold")
             output_lines.append(timeout_msg)

janito/tools/move_file.py

@@ -64,7 +64,7 @@ def move_file(
     try:
         shutil.move(str(source_obj), str(destination_obj))
         success_msg = f"Successfully moved file from {original_source} to {original_destination}"
-        print_success(success_msg, "Success")
+        print_success("", "Success")
         return (success_msg, False)
     except Exception as e:
         error_msg = f"Error moving file from {original_source} to {original_destination}: {str(e)}"