sxn 0.2.0

data/lib/sxn/commands.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "commands/init"
+require_relative "commands/sessions"
+require_relative "commands/projects"
+require_relative "commands/worktrees"
+require_relative "commands/rules"
+
+module Sxn
+  # Commands namespace for all CLI command implementations
+  module Commands
+  end
+end

data/lib/sxn/config/config_cache.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "digest"
+
+module Sxn
+  module Config
+    # Caches discovered configurations with TTL and file change invalidation
+    #
+    # Features:
+    # - Time-based cache expiration (TTL)
+    # - File modification time checking for cache invalidation
+    # - Atomic cache file operations
+    # - Cache storage in .sxn/.cache/config.json
+    class ConfigCache
+      CACHE_DIR = ".sxn/.cache"
+      CACHE_FILE = "config.json"
+      DEFAULT_TTL = 300 # 5 minutes in seconds
+
+      attr_reader :cache_dir, :cache_file_path, :ttl
+
+      def initialize(cache_dir: nil, ttl: DEFAULT_TTL)
+        @cache_dir = cache_dir || File.join(Dir.pwd, CACHE_DIR)
+        @cache_file_path = File.join(@cache_dir, CACHE_FILE)
+        @ttl = ttl
+        @write_mutex = Mutex.new
+        ensure_cache_directory
+      end
+
+      # Get cached configuration or nil if invalid/missing
+      # @param config_files [Array<String>] List of config file paths to check
+      # @return [Hash, nil] Cached configuration or nil
+      def get(config_files)
+        return nil unless cache_exists?
+
+        cache_data = load_cache
+        return nil unless cache_data
+
+        return nil unless cache_valid?(cache_data, config_files)
+
+        cache_data["config"]
+      rescue StandardError => e
+        warn "Warning: Failed to load cache: #{e.message}"
+        nil
+      end
+
+      # Store configuration in cache
+      # @param config [Hash] Configuration to cache
+      # @param config_files [Array<String>] List of config file paths
+      # @return [Boolean] Success status
+      def set(config, config_files)
+        cache_data = {
+          "config" => config,
+          "cached_at" => Time.now.to_f,
+          "config_files" => build_file_metadata(config_files),
+          "cache_version" => 1
+        }
+
+        save_cache(cache_data)
+        true
+      rescue StandardError => e
+        warn "Warning: Failed to save cache: #{e.message}"
+        false
+      end
+
+      # Invalidate the cache by removing the cache file
+      # @return [Boolean] Success status
+      def invalidate
+        return true unless cache_exists?
+
+        File.delete(cache_file_path)
+        true
+      rescue StandardError => e
+        warn "Warning: Failed to invalidate cache: #{e.message}"
+        false
+      end
+
+      # Check if cache is valid without loading the full configuration
+      # @param config_files [Array<String>] List of config file paths to check
+      # @return [Boolean] True if cache is valid
+      def valid?(config_files)
+        return false unless cache_exists?
+
+        cache_data = load_cache
+        return false unless cache_data
+
+        cache_valid?(cache_data, config_files)
+      rescue StandardError
+        false
+      end
+
+      # Get cache statistics
+      # @param config_files [Array<String>] List of config file paths to check validity against
+      # @return [Hash] Cache statistics
+      def stats(config_files = [])
+        return { exists: false, valid: false } unless cache_exists?
+
+        cache_data = load_cache
+        return { exists: true, valid: false, invalid: true } unless cache_data
+
+        is_valid = cache_valid?(cache_data, config_files || [])
+
+        {
+          exists: true,
+          valid: is_valid,
+          cached_at: Time.at(cache_data["cached_at"]),
+          age_seconds: Time.now.to_f - cache_data["cached_at"],
+          file_count: cache_data["config_files"]&.length || 0,
+          cache_version: cache_data["cache_version"]
+        }
+      rescue StandardError
+        { exists: true, valid: false, invalid: true, error: true }
+      end
+
+      private
+
+      # Ensure cache directory exists
+      def ensure_cache_directory
+        return if Dir.exist?(cache_dir)
+
+        # Thread-safe directory creation
+        FileUtils.mkdir_p(cache_dir)
+      rescue SystemCallError
+        # Directory might have been created by another thread/process
+        # Only re-raise if directory still doesn't exist
+        raise unless Dir.exist?(cache_dir)
+      end
+
+      # Check if cache file exists
+      # @return [Boolean] True if cache file exists
+      def cache_exists?
+        File.exist?(cache_file_path)
+      end
+
+      # Load cache data from file
+      # @return [Hash, nil] Cache data or nil if invalid
+      def load_cache
+        return nil unless cache_exists?
+
+        content = File.read(cache_file_path)
+        JSON.parse(content)
+      rescue JSON::ParserError => e
+        warn "Warning: Invalid cache file JSON: #{e.message}"
+        nil
+      end
+
+      # Save cache data to file atomically
+      # @param cache_data [Hash] Cache data to save
+      def save_cache(cache_data)
+        @write_mutex.synchronize do
+          # Ensure cache directory exists before any file operations
+          ensure_cache_directory
+
+          # Use a more unique temp file name to avoid collisions
+          temp_file = "#{cache_file_path}.#{Process.pid}.#{Thread.current.object_id}.tmp"
+
+          begin
+            File.write(temp_file, JSON.pretty_generate(cache_data))
+          rescue SystemCallError => e
+            # Directory might have been removed, recreate and retry once
+            ensure_cache_directory
+            begin
+              File.write(temp_file, JSON.pretty_generate(cache_data))
+            rescue SystemCallError
+              # If still failing, give up gracefully
+              warn "Warning: Failed to write cache: #{e.message}"
+              return false
+            end
+          end
+
+          # Retry logic for rename operation in case of race conditions
+          retries = 0
+          begin
+            # Ensure the cache directory still exists before rename
+            ensure_cache_directory
+
+            # Use atomic rename with proper error handling
+            File.rename(temp_file, cache_file_path)
+          rescue Errno::ENOENT
+            retries += 1
+            return false unless retries <= 3
+
+            # Directory or temp file might have issues, recreate and retry
+            ensure_cache_directory
+
+            # If temp file is missing, recreate it
+            unless File.exist?(temp_file)
+              begin
+                File.write(temp_file, JSON.pretty_generate(cache_data))
+              rescue SystemCallError
+                # Can't recreate, give up
+                return false
+              end
+            end
+
+            retry
+
+          # Give up after 3 retries, but don't crash - caching is optional
+          # Don't warn here as it's expected in concurrent scenarios
+          rescue SystemCallError
+            # Handle other system errors gracefully - don't warn as it's expected
+            return false
+          ensure
+            # Clean up temp file if it exists
+            FileUtils.rm_f(temp_file) if temp_file && File.exist?(temp_file)
+          end
+
+          true
+        end
+      end
+
+      # Check if cache is still valid
+      # @param cache_data [Hash] Loaded cache data
+      # @param config_files [Array<String>] Current config file paths
+      # @return [Boolean] True if cache is valid
+      def cache_valid?(cache_data, config_files)
+        # Check TTL expiration
+        return false if ttl_expired?(cache_data)
+
+        # Check if any config files have changed
+        return false if files_changed?(cache_data, config_files)
+
+        true
+      end
+
+      # Check if cache has expired based on TTL
+      # @param cache_data [Hash] Cache data
+      # @return [Boolean] True if cache has expired
+      def ttl_expired?(cache_data)
+        cached_at = cache_data["cached_at"]
+        return true unless cached_at
+
+        Time.now.to_f - cached_at > ttl
+      end
+
+      # Check if any config files have changed
+      # @param cache_data [Hash] Cache data
+      # @param config_files [Array<String>] Current config file paths
+      # @return [Boolean] True if files have changed
+      def files_changed?(cache_data, config_files)
+        cached_files = cache_data["config_files"] || {}
+        current_files = build_file_metadata(config_files)
+
+        # Quick check: different number of files
+        return true if cached_files.keys.sort != current_files.keys.sort
+
+        # Check each file's metadata
+        current_files.each do |file_path, metadata|
+          cached_metadata = cached_files[file_path]
+          return true unless cached_metadata
+
+          # Check if mtime or size changed
+          return true if metadata["mtime"] != cached_metadata["mtime"]
+          return true if metadata["size"] != cached_metadata["size"]
+
+          # Always check checksum for content changes (most reliable method)
+          return true if metadata["checksum"] != cached_metadata["checksum"]
+        end
+
+        false
+      end
+
+      # Build metadata for config files
+      # @param config_files [Array<String>] List of config file paths
+      # @return [Hash] File metadata hash
+      def build_file_metadata(config_files)
+        metadata = {}
+
+        config_files.each do |file_path|
+          next unless File.exist?(file_path)
+
+          stat = File.stat(file_path)
+          metadata[file_path] = {
+            "mtime" => stat.mtime.to_f,
+            "size" => stat.size,
+            "checksum" => file_checksum(file_path)
+          }
+        end
+
+        metadata
+      end
+
+      # Calculate file checksum for additional validation
+      # @param file_path [String] Path to file
+      # @return [String] SHA256 checksum
+      def file_checksum(file_path)
+        Digest::SHA256.file(file_path).hexdigest
+      rescue StandardError
+        # If we can't read the file, use a placeholder
+        "unreadable"
+      end
+    end
+  end
+end

data/lib/sxn/config/config_discovery.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Sxn
+  module Config
+    # Handles hierarchical configuration discovery and loading
+    #
+    # Configuration precedence (highest to lowest):
+    # 1. Command-line flags
+    # 2. Environment variables (SXN_*)
+    # 3. Local project config (.sxn/config.yml)
+    # 4. Workspace config (.sxn-workspace/config.yml)
+    # 5. Global user config (~/.sxn/config.yml)
+    # 6. System defaults
+    class ConfigDiscovery
+      CONFIG_FILE_NAME = "config.yml"
+      LOCAL_CONFIG_DIR = ".sxn"
+      WORKSPACE_CONFIG_DIR = ".sxn-workspace"
+      GLOBAL_CONFIG_DIR = File.expand_path("~/.sxn")
+      ENV_PREFIX = "SXN_"
+
+      attr_reader :start_directory
+
+      def initialize(start_directory = Dir.pwd)
+        @start_directory = Pathname.new(start_directory).expand_path
+      end
+
+      # Discover and load configuration from all sources
+      # @param cli_options [Hash] Command-line options
+      # @return [Hash] Merged configuration
+      def discover_config(cli_options = {})
+        config_sources = load_all_configs
+        merge_configs(config_sources, cli_options)
+      end
+
+      # Find all configuration files in the hierarchy
+      # @return [Array<String>] Paths to configuration files
+      def find_config_files
+        config_files = []
+
+        # Local project config (.sxn/config.yml)
+        local_config = find_local_config
+        config_files << local_config if local_config
+
+        # Workspace config (.sxn-workspace/config.yml)
+        workspace_config = find_workspace_config
+        config_files << workspace_config if workspace_config
+
+        # Global user config (~/.sxn/config.yml)
+        global_config = find_global_config
+        config_files << global_config if global_config
+
+        config_files
+      end
+
+      private
+
+      # Load configurations from all sources
+      # @return [Hash] Hash of config sources
+      def load_all_configs
+        {
+          system_defaults: load_system_defaults,
+          global_config: load_global_config,
+          workspace_config: load_workspace_config,
+          local_config: load_local_config,
+          env_config: load_env_config
+        }
+      end
+
+      # Find local project config by walking up directory tree
+      # @return [String, nil] Path to local config file
+      def find_local_config
+        current_dir = start_directory
+
+        loop do
+          config_path = current_dir.join(LOCAL_CONFIG_DIR, CONFIG_FILE_NAME)
+          return config_path.to_s if config_path.exist?
+
+          parent = current_dir.parent
+          break if parent == current_dir # Reached filesystem root
+
+          current_dir = parent
+        end
+
+        nil
+      end
+
+      # Find workspace config by walking up directory tree
+      # @return [String, nil] Path to workspace config file
+      def find_workspace_config
+        current_dir = start_directory
+
+        loop do
+          config_path = current_dir.join(WORKSPACE_CONFIG_DIR, CONFIG_FILE_NAME)
+          return config_path.to_s if config_path.exist?
+
+          parent = current_dir.parent
+          break if parent == current_dir # Reached filesystem root
+
+          current_dir = parent
+        end
+
+        nil
+      end
+
+      # Find global user config
+      # @return [String, nil] Path to global config file
+      def find_global_config
+        global_config_path = File.join(GLOBAL_CONFIG_DIR, CONFIG_FILE_NAME)
+        File.exist?(global_config_path) ? global_config_path : nil
+      end
+
+      # Load system default configuration
+      # @return [Hash] Default configuration
+      def load_system_defaults
+        {
+          "version" => 1,
+          "sessions_folder" => ".sessions",
+          "current_session" => nil,
+          "projects" => {},
+          "settings" => {
+            "auto_cleanup" => true,
+            "max_sessions" => 10,
+            "worktree_cleanup_days" => 30,
+            "default_rules" => {
+              "templates" => []
+            }
+          }
+        }
+      end
+
+      # Load global user configuration
+      # @return [Hash] Global configuration
+      def load_global_config
+        config_path = find_global_config
+        return {} unless config_path
+
+        load_yaml_file(config_path)
+      rescue StandardError => e
+        warn "Warning: Failed to load global config #{config_path}: #{e.message}"
+        {}
+      end
+
+      # Load workspace configuration
+      # @return [Hash] Workspace configuration
+      def load_workspace_config
+        config_path = find_workspace_config
+        return {} unless config_path
+
+        load_yaml_file(config_path)
+      rescue StandardError => e
+        warn "Warning: Failed to load workspace config #{config_path}: #{e.message}"
+        {}
+      end
+
+      # Load local project configuration
+      # @return [Hash] Local configuration
+      def load_local_config
+        config_path = find_local_config
+        return {} unless config_path
+
+        load_yaml_file(config_path)
+      rescue StandardError => e
+        warn "Warning: Failed to load local config #{config_path}: #{e.message}"
+        {}
+      end
+
+      # Load environment variable configuration
+      # @return [Hash] Environment configuration
+      def load_env_config
+        env_config = {}
+
+        ENV.each do |key, value|
+          next unless key.start_with?(ENV_PREFIX)
+
+          # Convert SXN_SESSIONS_FOLDER to sessions_folder
+          config_key = key[ENV_PREFIX.length..].downcase
+
+          # Parse boolean values
+          parsed_value = case value.downcase
+                         when "true" then true
+                         when "false" then false
+                         else value
+                         end
+
+          env_config[config_key] = parsed_value
+        end
+
+        env_config
+      end
+
+      # Load and parse YAML file safely
+      # @param file_path [String] Path to YAML file
+      # @return [Hash] Parsed YAML content
+      def load_yaml_file(file_path)
+        content = File.read(file_path)
+        YAML.safe_load(content, permitted_classes: [], permitted_symbols: [], aliases: false) || {}
+      rescue Psych::SyntaxError => e
+        raise ConfigurationError, "Invalid YAML in #{file_path}: #{e.message}"
+      rescue StandardError => e
+        raise ConfigurationError, "Failed to load config file #{file_path}: #{e.message}"
+      end
+
+      # Merge configurations with proper precedence
+      # @param configs [Hash] Hash of configuration sources
+      # @param cli_options [Hash] Command-line options
+      # @return [Hash] Merged configuration
+      def merge_configs(configs, cli_options)
+        # Start with system defaults and merge up the precedence chain
+        result = (configs[:system_defaults] || {}).dup
+
+        # Deep merge each config level, skipping nil values
+        deep_merge!(result, configs[:global_config]) if configs[:global_config]
+        deep_merge!(result, configs[:workspace_config]) if configs[:workspace_config]
+        deep_merge!(result, configs[:local_config]) if configs[:local_config]
+        deep_merge!(result, configs[:env_config]) if configs[:env_config]
+        deep_merge!(result, cli_options)
+
+        result
+      end
+
+      # Deep merge configuration hashes
+      # @param target [Hash] Target hash to merge into
+      # @param source [Hash] Source hash to merge from
+      def deep_merge!(target, source)
+        return target unless source.is_a?(Hash)
+
+        source.each do |key, value|
+          if target[key].is_a?(Hash) && value.is_a?(Hash)
+            deep_merge!(target[key], value)
+          else
+            target[key] = value
+          end
+        end
+
+        target
+      end
+    end
+  end
+end