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

janito/config/core/properties.py

@@ -1,316 +0,0 @@
-"""
-Property getters and setters for the Config class.
-"""
-import os
-import typer
-from typing import Optional, Any, Union, Tuple, Tuple
-
-class ConfigProperties:
-    """
-    Mixin class containing property getters and setters for the Config class.
-    This class is not meant to be instantiated directly.
-    """
-    
-    @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.
-        
-        Args:
-            path: Path to set as workspace directory
-            
-        Raises:
-            ValueError: If the directory doesn't exist and can't be created
-        """
-        # 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
-        # This is a runtime setting, not persisted
-    
-    # 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
-        # This is a runtime setting, not persisted
-        
-    @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.
-        
-        Args:
-            value: Boolean value to set
-            
-        Note: This setting is not persisted to config file
-        as it's meant to be a per-session setting.
-        """
-        # Convert tuple to boolean if needed (for backward compatibility)
-        if isinstance(value, tuple) and len(value) == 2:
-            bool_value, _ = value
-            self._ask_mode = bool_value
-        else:
-            self._ask_mode = value
-        # Don't save to config file - this is a runtime setting only
-    
-    @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: Union[float, Tuple[float, str]]) -> None:
-        """
-        Set the temperature value for model generation.
-        
-        Args:
-            value: Temperature value (0.0 to 1.0), or a tuple of (value, config_type)
-            
-        Example:
-            config.temperature = 0.7  # Set runtime value only
-            config.temperature = (0.7, "local")  # Set in local config
-            config.temperature = (0.7, "global")  # Set in global config
-            
-        Raises:
-            ValueError: If temperature is not between 0.0 and 1.0
-        """
-        if isinstance(value, tuple) and len(value) == 2:
-            temp_value, config_type = value
-            if temp_value < 0.0 or temp_value > 1.0:
-                raise ValueError("Temperature must be between 0.0 and 1.0")
-                
-            self._temperature = temp_value
-            
-            if config_type == "local":
-                self.set_local_config("temperature", temp_value)
-            else:
-                self.set_global_config("temperature", temp_value)
-        else:
-            if value < 0.0 or value > 1.0:
-                raise ValueError("Temperature must be between 0.0 and 1.0")
-                
-            self._temperature = value
-            # Don't save to config file - this is a runtime setting
-    
-    # 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: Union[str, Tuple[str, str]]) -> None:
-        """
-        Set the role for the assistant.
-        
-        Args:
-            value: Role string, or a tuple of (value, config_type)
-            
-        Example:
-            config.role = "software engineer"  # Set runtime value only
-            config.role = ("software engineer", "local")  # Set in local config
-            config.role = ("software engineer", "global")  # Set in global config
-        """
-        if isinstance(value, tuple) and len(value) == 2:
-            role_value, config_type = value
-            self._role = role_value
-            
-            if config_type == "local":
-                self.set_local_config("role", role_value)
-            else:
-                self.set_global_config("role", role_value)
-        else:
-            self._role = value
-            # Don't save to config file - this is a runtime setting
-    
-    @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: Union[Optional[str], Tuple[Optional[str], str]]) -> None:
-        """
-        Set the path to the GitBash executable.
-        
-        Args:
-            value: Path to the GitBash executable, or None to use auto-detection,
-                  or a tuple of (value, config_type)
-            
-        Example:
-            config.gitbash_path = "C:/Program Files/Git/bin/bash.exe"  # Set runtime value only
-            config.gitbash_path = ("C:/Program Files/Git/bin/bash.exe", "local")  # Set in local config
-            config.gitbash_path = ("C:/Program Files/Git/bin/bash.exe", "global")  # Set in global config
-            
-        Raises:
-            ValueError: If the provided path doesn't exist
-        """
-        if isinstance(value, tuple) and len(value) == 2:
-            path_value, config_type = value
-            # If a path is provided, verify it exists
-            if path_value is not None and not os.path.exists(path_value):
-                raise ValueError(f"GitBash executable not found at: {path_value}")
-            
-            self._gitbash_path = path_value
-            
-            if config_type == "local":
-                self.set_local_config("gitbash_path", path_value)
-            else:
-                self.set_global_config("gitbash_path", path_value)
-        else:
-            # 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
-            # Don't save to config file - this is a runtime setting
-    
-    @property
-    def profile(self) -> Optional[str]:
-        """Get the current profile name."""
-        return self._profile
-        
-    @property
-    def max_view_lines(self) -> int:
-        """Get the maximum number of lines to display before showing a warning."""
-        return self._merged_config.get("max_view_lines", 500)
-        
-    @max_view_lines.setter
-    def max_view_lines(self, value: Union[int, Tuple[int, str]]) -> None:
-        """
-        Set the maximum number of lines to display before showing a warning.
-        
-        Args:
-            value: Maximum number of lines (must be positive), or a tuple of (value, config_type)
-            
-        Example:
-            config.max_view_lines = 1000  # Set runtime value only
-            config.max_view_lines = (1000, "local")  # Set in local config
-            config.max_view_lines = (1000, "global")  # Set in global config
-            
-        Raises:
-            ValueError: If the value is not a positive integer
-        """
-        if isinstance(value, tuple) and len(value) == 2:
-            lines_value, config_type = value
-            if not isinstance(lines_value, int) or lines_value <= 0:
-                raise ValueError("max_view_lines must be a positive integer")
-                
-            if config_type == "local":
-                self.set_local_config("max_view_lines", lines_value)
-            else:
-                self.set_global_config("max_view_lines", lines_value)
-        else:
-            if not isinstance(value, int) or value <= 0:
-                raise ValueError("max_view_lines must be a positive integer")
-                
-            # This is a special case - we don't have a dedicated instance variable
-            # for max_view_lines, it's accessed directly from merged_config
-            # So we need to update the merged_config directly
-            self._merged_config["max_view_lines"] = value
-            # Don't save to config file - this is a runtime setting
-            
-    @property
-    def show_usage_report(self) -> bool:
-        """Get the show usage report status."""
-        return self._show_usage_report
-        
-    @show_usage_report.setter
-    def show_usage_report(self, value: Union[bool, Tuple[bool, str]]) -> None:
-        """
-        Set the show usage report status.
-        
-        Args:
-            value: Boolean value to set, or a tuple of (value, config_type)
-            
-        Example:
-            config.show_usage_report = True  # Set runtime value only
-            config.show_usage_report = (True, "local")  # Set in local config
-            config.show_usage_report = (True, "global")  # Set in global config
-        """
-        if isinstance(value, tuple) and len(value) == 2:
-            bool_value, config_type = value
-            self._show_usage_report = bool_value
-            
-            if config_type == "local":
-                self.set_local_config("show_usage_report", bool_value)
-            else:
-                self.set_global_config("show_usage_report", bool_value)
-        else:
-            self._show_usage_report = value
-            # Don't save to config file - this is a runtime setting

janito/config/core/singleton.py

@@ -1,282 +0,0 @@
-"""
-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

@@ -1,8 +0,0 @@
-"""
-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

@@ -1,38 +0,0 @@
-"""
-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"
-    }
-}