ctxsync 0.8.0__py3-none-any.whl

ctxsync/configmanager/base_config_manager.py

@@ -0,0 +1,255 @@
+from abc import ABC, abstractmethod
+import copy
+
+
+class BaseConfigManager(ABC):
+    """
+    Abstract base class for managing configuration settings.
+
+    This class defines the interface for configuration management and includes
+    common functionality that can be shared across different implementations,
+    such as file-based and in-memory configurations.
+    """
+
+    def __init__(self):
+        """
+        Initializes the configuration manager with empty global and local configurations.
+
+        - `global_config`: A dictionary to store global configuration settings that apply
+          universally across all environments.
+        - `local_config`: A dictionary to store local configuration settings specific to
+          the current environment or project.
+        """
+        self.global_config = {}
+        self.local_config = {}
+
+    def _get_default_config(self):
+        """
+        Returns the default configuration dictionary.
+
+        This method centralizes the default configuration settings, making it easier to manage and update defaults.
+
+        Returns:
+            dict: The default configuration settings.
+        """
+        return {
+            "log_level": "INFO",
+            "upload_delay": 0.5,
+            "max_file_size": 32 * 1024,
+            "two_way_sync": False,
+            "prune_remote_files": True,
+            "claude_api_url": "https://claude.ai/api",
+            "compression_algorithm": "none",
+            "submodule_detect_filenames": [
+                "pom.xml",
+                "build.gradle",
+                "package.json",
+                "setup.py",
+                "Cargo.toml",
+                "go.mod",
+            ],
+            "file_categories": {
+                "all_files": {
+                    "description": "All files not ignored",
+                    "patterns": ["*"],
+                },
+                "all_source_code": {
+                    "description": "All source code files",
+                    "patterns": [
+                        "*.java",
+                        "*.py",
+                        "*.js",
+                        "*.ts",
+                        "*.c",
+                        "*.cpp",
+                        "*.h",
+                        "*.hpp",
+                        "*.go",
+                        "*.rs",
+                    ],
+                },
+                "production_code": {
+                    "description": "Production source code",
+                    "patterns": [
+                        "**/src/**/*.java",
+                        "**/*.py",
+                        "**/*.js",
+                        "**/*.ts",
+                        "**/*.vue",
+                    ],
+                },
+                "test_code": {
+                    "description": "Test source code",
+                    "patterns": [
+                        "**/test/**/*.java",
+                        "**/tests/**/*.py",
+                        "**/test_*.py",
+                        "**/*Test.java",
+                    ],
+                },
+                "build_config": {
+                    "description": "Build configuration files",
+                    "patterns": [
+                        "**/pom.xml",
+                        "**/build.gradle",
+                        "**/package.json",
+                        "**/setup.py",
+                        "**/Cargo.toml",
+                        "**/go.mod",
+                        "**/pyproject.toml",
+                        "**/requirements.txt",
+                        "**/*.tf",
+                        "**/*.yaml",
+                        "**/*.yml",
+                        "**/*.properties",
+                    ],
+                },
+                "uberproject_java": {
+                    "description": "Uberproject Java + Javascript",
+                    "patterns": [
+                        "**/src/**/*.java",
+                        "**/*.py",
+                        "**/*.js",
+                        "**/*.ts",
+                        "**/*.vue",
+                        "**/pom.xml",
+                        "**/build.gradle",
+                        "**/package.json",
+                        "**/setup.py",
+                        "**/Cargo.toml",
+                        "**/go.mod",
+                        "**/pyproject.toml",
+                        "**/requirements.txt",
+                        "**/*.tf",
+                        "**/*.yaml",
+                        "**/*.yml",
+                        "**/*.properties",
+                    ],
+                },
+            },
+        }
+
+    @abstractmethod
+    def _load_global_config(self):
+        """
+        Loads the global configuration settings.
+
+        This method should be implemented by subclasses to load the global configuration
+        from the appropriate source (e.g., a file or an in-memory structure).
+        """
+        pass
+
+    @abstractmethod
+    def _load_local_config(self):
+        """
+        Loads the local configuration settings.
+
+        This method should be implemented by subclasses to load the local configuration
+        from the appropriate source (e.g., a file or an in-memory structure).
+        """
+        pass
+
+    @abstractmethod
+    def _save_global_config(self):
+        """
+        Saves the global configuration settings.
+
+        This method should be implemented by subclasses to save the global configuration
+        to the appropriate destination (e.g., a file or an in-memory structure).
+        """
+        pass
+
+    @abstractmethod
+    def _save_local_config(self):
+        """
+        Saves the local configuration settings.
+
+        This method should be implemented by subclasses to save the local configuration
+        to the appropriate destination (e.g., a file or an in-memory structure).
+        """
+        pass
+
+    @abstractmethod
+    def set(self, key, value, local=False):
+        """
+        Sets a configuration value.
+
+        Args:
+            key (str): The key of the configuration setting to set.
+            value: The value to associate with the given key.
+            local (bool): Whether to set the configuration in the local context.
+                          If False, the setting is stored in the global context.
+                          Default is False.
+
+        This method should be implemented by subclasses to handle the setting of
+        configuration values, either globally or locally.
+        """
+        pass
+
+    @abstractmethod
+    def get(self, key, default=None):
+        """
+        Retrieves a configuration value.
+
+        Args:
+            key (str): The key of the configuration setting to retrieve.
+            default: The default value to return if the key is not found.
+                     Default is None.
+
+        Returns:
+            The value associated with the given key, or the default value if the key
+            does not exist.
+
+        This method should be implemented by subclasses to retrieve configuration
+        values, checking the local context first, then the global context.
+        """
+        pass
+
+    @abstractmethod
+    def _find_local_config_dir(self):
+        """
+        Finds the local configuration directory.
+
+        Returns:
+            Path: The path to the local configuration directory, or None if no
+            directory is found.
+
+        This method should be implemented by subclasses to locate the directory where
+        local configuration files are stored.
+        """
+        pass
+
+    # Common methods that are shared between implementations
+    def get_default_category(self):
+        """
+        Retrieves the default synchronization category.
+
+        Returns:
+            str: The default synchronization category, as specified in the configuration.
+        """
+        return self.get("default_sync_category")
+
+    def set_default_category(self, category):
+        """
+        Sets the default synchronization category.
+
+        Args:
+            category (str): The category to set as the default for synchronization.
+        """
+        self.set("default_sync_category", category, local=True)
+
+    def copy(self):
+        """
+        Creates a deep copy of the configuration manager.
+
+        Returns:
+            BaseConfigManager: A new instance of the configuration manager with
+                               a deep copy of the global and local configurations.
+
+        This method is useful when you need to duplicate the current state of the
+        configuration manager, preserving the settings in a new instance.
+        """
+        new_instance = self.__class__()
+        new_instance.global_config = copy.deepcopy(self.global_config)
+        new_instance.local_config = copy.deepcopy(self.local_config)
+        return new_instance

ctxsync/configmanager/file_config_manager.py

@@ -0,0 +1,362 @@
+import json
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+import logging
+
+from ctxsync.configmanager.base_config_manager import BaseConfigManager
+from ctxsync.session_key_manager import SessionKeyManager
+
+
+class FileConfigManager(BaseConfigManager):
+    """
+    Manages the configuration for ctxsync, handling both global and local (project-specific) settings.
+
+    This class provides methods to load, save, and access configuration settings from both
+    a global configuration file (~/.ctxsync/config.json) and a local configuration file
+    (.ctxsync/config.local.json) in the project directory. Session keys are stored separately
+    in provider-specific files.
+
+    Configuration created by this tool under its previous name (ClaudeSync) keeps
+    working: ~/.claudesync is migrated to ~/.ctxsync on first run, and existing
+    project-local .claudesync directories are still recognized.
+    """
+
+    LOCAL_DIR_NAME = ".ctxsync"
+    LEGACY_LOCAL_DIR_NAME = ".claudesync"
+
+    def __init__(self):
+        """
+        Initialize the ConfigManager.
+
+        Sets up paths for global and local configuration files and loads both configurations.
+        """
+        super().__init__()
+        self.global_config_dir = Path.home() / ".ctxsync"
+        self._migrate_legacy_global_config()
+        self.global_config_file = self.global_config_dir / "config.json"
+        self.global_config = self._load_global_config()
+        self.local_config = {}
+        self.local_config_dir = None
+        self.local_dir_name = self.LOCAL_DIR_NAME
+        self._load_local_config()
+
+    def _migrate_legacy_global_config(self):
+        """
+        Copies ~/.claudesync (settings and session keys) to ~/.ctxsync the first
+        time the renamed tool runs, so existing users stay authenticated.
+        """
+        legacy_dir = Path.home() / self.LEGACY_LOCAL_DIR_NAME
+        if not self.global_config_dir.exists() and legacy_dir.is_dir():
+            try:
+                shutil.copytree(legacy_dir, self.global_config_dir)
+                logging.info(
+                    f"Migrated configuration from {legacy_dir} to {self.global_config_dir}"
+                )
+            except OSError as e:
+                logging.warning(
+                    f"Could not migrate legacy configuration from {legacy_dir}: {e}"
+                )
+
+    def _load_global_config(self):
+        """
+        Loads the global configuration from the JSON file.
+
+        If the configuration file doesn't exist, it creates the directory (if necessary)
+        and returns the default configuration.
+
+        Returns:
+            dict: The loaded global configuration with default values for missing keys.
+        """
+        if not self.global_config_file.exists():
+            self.global_config_dir.mkdir(parents=True, exist_ok=True)
+            return self._get_default_config()
+
+        with open(self.global_config_file, "r") as f:
+            config = json.load(f)
+            defaults = self._get_default_config()
+            for key, value in defaults.items():
+                if key not in config:
+                    config[key] = value
+            return config
+
+    def _find_local_config_dir(self, max_depth=100):
+        """
+        Finds the nearest directory containing a .ctxsync folder (or a legacy
+        .claudesync folder from before the rename).
+
+        Searches from the current working directory upwards until it finds a config folder
+        or reaches the root directory. Excludes the ~/.ctxsync and ~/.claudesync directories.
+
+        Returns:
+            Path: The path containing the config folder, or None if not found.
+        """
+        current_dir = Path.cwd()
+        root_dir = Path(current_dir.root)
+        home_dir = Path.home()
+        depth = 0
+
+        while current_dir != root_dir:
+            for dir_name in (self.LOCAL_DIR_NAME, self.LEGACY_LOCAL_DIR_NAME):
+                config_dir = current_dir / dir_name
+                if config_dir.is_dir() and config_dir != home_dir / dir_name:
+                    self.local_dir_name = dir_name
+                    return current_dir
+
+            current_dir = current_dir.parent
+            depth += 1
+
+            if depth > max_depth:
+                return None
+
+        return None
+
+    def _load_local_config(self):
+        """
+        Loads the local configuration from the nearest .ctxsync/config.local.json file.
+        Automatically normalizes any Windows-style paths.
+        """
+        self.local_config_dir = self._find_local_config_dir()
+        if self.local_config_dir:
+            local_config_file = (
+                self.local_config_dir / self.local_dir_name / "config.local.json"
+            )
+            if local_config_file.exists():
+                with open(local_config_file, "r") as f:
+                    self.local_config = json.load(f)
+
+                # Check and fix Windows-style paths in submodules
+                if "submodules" in self.local_config:
+                    needs_save = False
+                    for submodule in self.local_config["submodules"]:
+                        if "\\" in submodule["relative_path"]:
+                            submodule["relative_path"] = submodule[
+                                "relative_path"
+                            ].replace("\\", "/")
+                            needs_save = True
+
+                    if needs_save:
+                        self._save_local_config()
+
+    def get_local_path(self):
+        """
+        Retrieves the path of the directory containing the .ctxsync folder.
+
+        Returns:
+            str: The path of the directory containing the .ctxsync folder, or None if not found.
+        """
+        return str(self.local_config_dir) if self.local_config_dir else None
+
+    def get(self, key, default=None):
+        """
+        Retrieves a configuration value.
+
+        Checks the local configuration first, then falls back to the global configuration.
+
+        Args:
+            key (str): The key for the configuration setting to retrieve.
+            default (any, optional): The default value to return if the key is not found. Defaults to None.
+
+        Returns:
+            The value of the configuration setting if found, otherwise the default value.
+        """
+        return self.local_config.get(key) or self.global_config.get(key, default)
+
+    def set(self, key, value, local=False):
+        """
+        Sets a configuration value and saves the configuration.
+
+        Args:
+            key (str): The key for the configuration setting to set.
+            value (any): The value to set for the given key.
+            local (bool): If True, sets the value in the local configuration. Otherwise, sets it in the global configuration.
+        """
+        if local:
+            # Update local_config_dir when setting local_path
+            if key == "local_path":
+                self.local_config_dir = Path(value)
+                # Create .ctxsync directory in the specified path
+                self.local_dir_name = self.LOCAL_DIR_NAME
+                (self.local_config_dir / self.local_dir_name).mkdir(exist_ok=True)
+
+            self.local_config[key] = value
+            self._save_local_config()
+        else:
+            self.global_config[key] = value
+            self._save_global_config()
+
+    def _save_global_config(self):
+        """
+        Saves the current global configuration to the JSON file.
+
+        This method writes the current state of the `global_config` attribute to the configuration file,
+        pretty-printing the JSON for readability.
+        """
+        with open(self.global_config_file, "w") as f:
+            json.dump(self.global_config, f, indent=2)
+
+    def _save_local_config(self):
+        """
+        Saves the current local configuration to the .ctxsync/config.local.json file.
+        """
+        if self.local_config_dir:
+            local_config_file = (
+                self.local_config_dir / self.local_dir_name / "config.local.json"
+            )
+            local_config_file.parent.mkdir(exist_ok=True)
+            with open(local_config_file, "w") as f:
+                json.dump(self.local_config, f, indent=2)
+
+    def set_session_key(self, provider, session_key, expiry):
+        """
+        Sets the session key and its expiry for a specific provider.
+
+        Args:
+            provider (str): The name of the provider.
+            session_key (str): The session key to set.
+            expiry (datetime): The expiry datetime for the session key.
+        """
+        try:
+            session_key_manager = SessionKeyManager(self.get("ssh_key_path"))
+            encrypted_session_key, encryption_method = (
+                session_key_manager.encrypt_session_key(provider, session_key)
+            )
+
+            self.global_config_dir.mkdir(parents=True, exist_ok=True)
+            provider_key_file = self.global_config_dir / f"{provider}.key"
+            with open(provider_key_file, "w") as f:
+                json.dump(
+                    {
+                        "session_key": encrypted_session_key,
+                        "session_key_encryption_method": encryption_method,
+                        "session_key_expiry": expiry.isoformat(),
+                    },
+                    f,
+                )
+        except RuntimeError as e:
+            logging.error(f"Failed to encrypt session key: {str(e)}")
+            raise
+
+    def get_session_key(self, provider):
+        """
+        Retrieves the session key for the specified provider if it's still valid.
+
+        Args:
+            provider (str): The name of the provider.
+
+        Returns:
+            tuple: A tuple containing the session key and expiry if valid, (None, None) otherwise.
+        """
+        provider_key_file = self.global_config_dir / f"{provider}.key"
+        if not provider_key_file.exists():
+            return None, None
+
+        with open(provider_key_file, "r") as f:
+            data = json.load(f)
+
+        encrypted_key = data.get("session_key")
+        encryption_method = data.get("session_key_encryption_method")
+        expiry_str = data.get("session_key_expiry")
+
+        if not encrypted_key or not expiry_str:
+            return None, None
+
+        expiry = datetime.fromisoformat(expiry_str)
+        if datetime.now() > expiry:
+            return None, None
+
+        try:
+            session_key_manager = SessionKeyManager(self.get("ssh_key_path"))
+            session_key = session_key_manager.decrypt_session_key(
+                provider, encryption_method, encrypted_key
+            )
+            return session_key, expiry
+        except RuntimeError as e:
+            logging.error(f"Failed to decrypt session key: {str(e)}")
+            return None, None
+
+    def add_file_category(self, category_name, description, patterns):
+        """
+        Adds a new file category to the global configuration.
+
+        Args:
+            category_name (str): The name of the category to add.
+            description (str): A description of the category.
+            patterns (list): A list of file patterns for the category.
+        """
+        if "file_categories" not in self.global_config:
+            self.global_config["file_categories"] = {}
+        self.global_config["file_categories"][category_name] = {
+            "description": description,
+            "patterns": patterns,
+        }
+        self._save_global_config()
+
+    def remove_file_category(self, category_name):
+        """
+        Removes a file category from the global configuration.
+
+        Args:
+            category_name (str): The name of the category to remove.
+        """
+        if (
+            "file_categories" in self.global_config
+            and category_name in self.global_config["file_categories"]
+        ):
+            del self.global_config["file_categories"][category_name]
+            self._save_global_config()
+
+    def update_file_category(self, category_name, description=None, patterns=None):
+        """
+        Updates an existing file category in the global configuration.
+
+        Args:
+            category_name (str): The name of the category to update.
+            description (str, optional): The new description for the category. If None, the description is not updated.
+            patterns (list, optional): The new list of file patterns for the category. If None, the patterns are not updated.
+        """
+        if (
+            "file_categories" in self.global_config
+            and category_name in self.global_config["file_categories"]
+        ):
+            if description is not None:
+                self.global_config["file_categories"][category_name][
+                    "description"
+                ] = description
+            if patterns is not None:
+                self.global_config["file_categories"][category_name][
+                    "patterns"
+                ] = patterns
+            self._save_global_config()
+
+    def clear_all_session_keys(self):
+        """
+        Removes all stored session keys.
+        """
+        for file in self.global_config_dir.glob("*.key"):
+            os.remove(file)
+
+    def get_active_provider(self):
+        """
+        Retrieves the active provider from the local configuration.
+
+        Returns:
+            str: The name of the active provider, or None if not set.
+        """
+        return self.local_config.get("active_provider")
+
+    def get_providers_with_session_keys(self):
+        """
+        Retrieves a list of providers that have valid session keys.
+
+        Returns:
+            list: A list of provider names with valid session keys.
+        """
+        providers = []
+        for file in self.global_config_dir.glob("*.key"):
+            provider = file.stem
+            session_key, expiry = self.get_session_key(provider)
+            if session_key and expiry > datetime.now():
+                providers.append(provider)
+        return providers