sxn 0.2.0

data/sig/sxn/commands/rules.rbs

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Commands
+    # Manage project setup rules
+    class Rules < Thor
+      include Thor::Actions
+
+      @ui: Sxn::UI::Output
+      @prompt: Sxn::UI::Prompt
+      @table: Sxn::UI::Table
+      @config_manager: Sxn::Core::ConfigManager
+      @project_manager: Sxn::Core::ProjectManager
+      @rules_manager: Sxn::Core::RulesManager
+
+      # Initialize the command with Thor arguments
+      def initialize: (?Array[String] args, ?Hash[Symbol, untyped] local_options, ?Hash[Symbol, untyped] config) -> void
+
+      # Add a setup rule for project
+      # @param project_name Project name
+      # @param rule_type Type of rule
+      # @param rule_config Rule configuration
+      def add: (?String? project_name, ?String? rule_type, ?String? rule_config) -> void
+
+      # Remove a rule
+      # @param project_name Project name
+      # @param rule_type Rule type
+      # @param rule_index Rule index
+      def remove: (?String? project_name, ?String? rule_type, ?String? rule_index) -> void
+
+      # List all rules or rules for specific project
+      # @param project_name Project name (optional)
+      def list: (?String? project_name) -> void
+
+      # Apply rules to current session
+      # @param project_name Project name (optional)
+      def apply: (?String? project_name) -> void
+
+      # Validate rules for a project
+      # @param project_name Project name
+      def validate: (?String? project_name) -> void
+
+      # Generate rule template
+      # @param rule_type Type of rule
+      # @param project_type Type of project (optional)
+      def template: (?String? rule_type, ?String? project_type) -> void
+
+      # List available rule types
+      def types: () -> void
+
+      private
+
+      # Ensure the project is initialized, exit if not
+      def ensure_initialized!: () -> void
+
+      # Select a project interactively
+      # @param message Prompt message
+      # @return Project name or nil
+      def select_project: (String message) -> String?
+
+      # Prompt for rule configuration based on rule type
+      # @param rule_type Type of rule
+      # @return Configuration hash
+      def prompt_rule_config: (String rule_type) -> Hash[String, untyped]
+
+      # Prompt for copy files rule configuration
+      # @return Configuration hash
+      def prompt_copy_files_config: () -> Hash[String, untyped]
+
+      # Prompt for setup commands rule configuration  
+      # @return Configuration hash
+      def prompt_setup_commands_config: () -> Hash[String, untyped]
+
+      # Prompt for template rule configuration
+      # @return Configuration hash
+      def prompt_template_config: () -> Hash[String, untyped]
+
+      # Display rule information
+      # @param rule Rule configuration
+      def display_rule_info: (Hash[Symbol, untyped]? rule) -> void
+
+      # List rules with validation
+      # @param rules Array of rules
+      # @param project_name Project name (optional)
+      def list_with_validation: (Array[Hash[Symbol, untyped]] rules, String? project_name) -> void
+
+      # Show rules preview for dry run
+      # @param project_name Project name
+      def show_rules_preview: (String project_name) -> void
+
+      # Suggest adding a rule
+      def suggest_add_rule: () -> void
+    end
+  end
+end

data/sig/sxn/commands/sessions.rbs

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Commands
+    # Manage development sessions
+    class Sessions < Thor
+      include Thor::Actions
+
+      @ui: Sxn::UI::Output
+      @prompt: Sxn::UI::Prompt
+      @table: Sxn::UI::Table
+      @config_manager: Sxn::Core::ConfigManager
+      @session_manager: Sxn::Core::SessionManager
+
+      # Initialize the command with Thor arguments
+      def initialize: (?Array[String] args, ?Hash[Symbol, untyped] local_options, ?Hash[Symbol, untyped] config) -> void
+
+      # Create a new session
+      # @param name Session name
+      def add: (?String? name) -> void
+
+      # Remove a session
+      # @param name Session name
+      def remove: (?String? name) -> void
+
+      # List all sessions
+      def list: () -> void
+
+      # Switch to a session
+      # @param name Session name
+      def use: (?String? name) -> void
+
+      # Show current session
+      def current: () -> void
+
+      # Archive a session
+      # @param name Session name
+      def archive: (?String? name) -> void
+
+      # Activate an archived session
+      # @param name Session name
+      def activate: (?String? name) -> void
+
+      private
+
+      # Ensure the project is initialized, exit if not
+      def ensure_initialized!: () -> void
+
+      # Display session information
+      # @param session Session configuration hash
+      # @param verbose Whether to show verbose information
+      def display_session_info: (Hash[Symbol, untyped]? session, ?verbose: bool) -> void
+
+      # Display available commands for a session
+      # @param session_name Session name
+      def display_session_commands: (String session_name) -> void
+
+      # Suggest creating a session
+      def suggest_create_session: () -> void
+    end
+  end
+end

data/sig/sxn/commands/worktrees.rbs

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Commands
+    # Manage git worktrees
+    class Worktrees < Thor
+      include Thor::Actions
+
+      @ui: Sxn::UI::Output
+      @prompt: Sxn::UI::Prompt
+      @table: Sxn::UI::Table
+      @config_manager: Sxn::Core::ConfigManager
+      @project_manager: Sxn::Core::ProjectManager
+      @session_manager: Sxn::Core::SessionManager
+      @worktree_manager: Sxn::Core::WorktreeManager
+
+      # Initialize the command with Thor arguments
+      def initialize: (?Array[String] args, ?Hash[Symbol, untyped] local_options, ?Hash[Symbol, untyped] config) -> void
+
+      # Add worktree to current session
+      # @param project_name Project name
+      # @param branch Branch name (optional)
+      def add: (?String? project_name, ?String? branch) -> void
+
+      # Remove worktree from current session
+      # @param project_name Project name
+      def remove: (?String? project_name) -> void
+
+      # List worktrees in current session
+      def list: () -> void
+
+      # Validate a worktree
+      # @param project_name Project name
+      def validate: (?String? project_name) -> void
+
+      # Show status of all worktrees in current session
+      def status: () -> void
+
+      private
+
+      # Ensure the project is initialized, exit if not
+      def ensure_initialized!: () -> void
+
+      # Select a project interactively
+      # @param message Prompt message
+      # @return Project name or nil
+      def select_project: (String message) -> String?
+
+      # List worktrees for current session
+      def list_session_worktrees: () -> void
+
+      # List worktrees from all sessions
+      def list_all_worktrees: () -> void
+
+      # List worktrees with validation
+      # @param worktrees Array of worktrees
+      # @param session_name Session name
+      def list_with_validation: (Array[Hash[Symbol, untyped]] worktrees, String session_name) -> void
+
+      # Display worktree information
+      # @param worktree Worktree configuration hash
+      # @param detailed Whether to show detailed information
+      def display_worktree_info: (Hash[Symbol, untyped] worktree, ?detailed: bool) -> void
+
+      # Display available commands for a worktree
+      # @param worktree Worktree configuration hash
+      def display_worktree_commands: (Hash[Symbol, untyped] worktree) -> void
+
+      # Display status summary for worktrees
+      # @param worktrees Array of worktrees
+      def display_worktree_status: (Array[Hash[Symbol, untyped]] worktrees) -> void
+
+      # Apply project rules to a worktree
+      # @param project_name Project name
+      # @param session_name Session name
+      def apply_project_rules: (String project_name, String session_name) -> void
+
+      # Suggest adding a worktree
+      def suggest_add_worktree: () -> void
+    end
+  end
+end

data/sig/sxn/commands.rbs

@@ -0,0 +1,6 @@
+module Sxn
+  module Commands
+    # Commands module contains all CLI command classes
+    # Each command class is defined in its own RBS file under sig/sxn/commands/
+  end
+end

data/sig/sxn/config/config_cache.rbs

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Config
+    # Caches discovered configurations with TTL and file change invalidation
+    class ConfigCache
+      CACHE_DIR: String
+      CACHE_FILE: String
+      DEFAULT_TTL: Integer
+
+      @cache_dir: String
+      @cache_file_path: String
+      @ttl: Integer
+      @write_mutex: Mutex
+
+      attr_reader cache_dir: String
+      attr_reader cache_file_path: String
+      attr_reader ttl: Integer
+
+      def initialize: (?cache_dir: String?, ?ttl: Integer) -> void
+
+      # Get cached configuration or nil if invalid/missing
+      def get: (Array[String] config_files) -> Hash[untyped, untyped]?
+
+      # Store configuration in cache
+      def set: (Hash[untyped, untyped] config, Array[String] config_files) -> bool
+
+      # Invalidate the cache by removing the cache file
+      def invalidate: () -> bool
+
+      # Check if cache is valid without loading the full configuration
+      def valid?: (Array[String] config_files) -> bool
+
+      # Get cache statistics
+      def stats: (?Array[String] config_files) -> Hash[Symbol, untyped]
+
+      private
+
+      # Ensure cache directory exists
+      def ensure_cache_directory: () -> void
+
+      # Check if cache file exists
+      def cache_exists?: () -> bool
+
+      # Load cache data from file
+      def load_cache: () -> Hash[String, untyped]?
+
+      # Save cache data to file atomically
+      def save_cache: (Hash[String, untyped] cache_data) -> bool
+
+      # Check if cache is still valid
+      def cache_valid?: (Hash[String, untyped] cache_data, Array[String] config_files) -> bool
+
+      # Check if cache has expired based on TTL
+      def ttl_expired?: (Hash[String, untyped] cache_data) -> bool
+
+      # Check if any config files have changed
+      def files_changed?: (Hash[String, untyped] cache_data, Array[String] config_files) -> bool
+
+      # Build metadata for config files
+      def build_file_metadata: (Array[String] config_files) -> Hash[String, Hash[String, untyped]]
+
+      # Calculate file checksum for additional validation
+      def file_checksum: (String file_path) -> String
+    end
+  end
+end

data/sig/sxn/config/config_discovery.rbs

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Config
+    # Handles hierarchical configuration discovery and loading
+    class ConfigDiscovery
+      CONFIG_FILE_NAME: String
+      LOCAL_CONFIG_DIR: String
+      WORKSPACE_CONFIG_DIR: String
+      GLOBAL_CONFIG_DIR: String
+      ENV_PREFIX: String
+
+      @start_directory: Pathname
+
+      attr_reader start_directory: Pathname
+
+      def initialize: (?String start_directory) -> void
+
+      # Discover and load configuration from all sources
+      def discover_config: (?Hash[untyped, untyped] cli_options) -> Hash[untyped, untyped]
+
+      # Find all configuration files in the hierarchy
+      def find_config_files: () -> Array[String]
+
+      private
+
+      # Load configurations from all sources
+      def load_all_configs: () -> Hash[Symbol, Hash[untyped, untyped]]
+
+      # Find local project config by walking up directory tree
+      def find_local_config: () -> String?
+
+      # Find workspace config by walking up directory tree
+      def find_workspace_config: () -> String?
+
+      # Find global user config
+      def find_global_config: () -> String?
+
+      # Load system default configuration
+      def load_system_defaults: () -> Hash[String, untyped]
+
+      # Load global user configuration
+      def load_global_config: () -> Hash[untyped, untyped]
+
+      # Load workspace configuration
+      def load_workspace_config: () -> Hash[untyped, untyped]
+
+      # Load local project configuration
+      def load_local_config: () -> Hash[untyped, untyped]
+
+      # Load environment variable configuration
+      def load_env_config: () -> Hash[String, untyped]
+
+      # Load and parse YAML file safely
+      def load_yaml_file: (String file_path) -> Hash[untyped, untyped]
+
+      # Merge configurations with proper precedence
+      def merge_configs: (Hash[Symbol, Hash[untyped, untyped]?] configs, Hash[untyped, untyped] cli_options) -> Hash[untyped, untyped]
+
+      # Deep merge configuration hashes
+      def deep_merge!: (Hash[untyped, untyped] target, Hash[untyped, untyped] source) -> Hash[untyped, untyped]
+    end
+  end
+end

data/sig/sxn/config/config_validator.rbs

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Config
+    # Validates configuration structure and values
+    class ConfigValidator
+      # Current schema version
+      CURRENT_VERSION: Integer
+
+      # Configuration schema definition
+      SCHEMA: Hash[String, Hash[Symbol, untyped]]
+
+      @errors: Array[String]
+
+      attr_reader errors: Array[String]
+
+      def initialize: () -> void
+
+      # Validate configuration against schema
+      def valid?: (untyped config) -> bool
+
+      # Validate and migrate configuration if needed
+      def validate_and_migrate: (Hash[untyped, untyped] config) -> Hash[untyped, untyped]
+
+      # Get formatted error messages
+      def format_errors: () -> String
+
+      # Migrate configuration from older versions
+      def migrate_config: (Hash[untyped, untyped] config) -> Hash[untyped, untyped]
+
+      private
+
+      # Check if config needs v0 to v1 migration based on structure
+      def needs_v0_to_v1_migration?: (Hash[untyped, untyped] config) -> bool
+
+      # Validate configuration against schema recursively
+      def validate_against_schema: (Hash[untyped, untyped] config, Hash[String, Hash[Symbol, untyped]] schema, String path) -> void
+
+      # Check if value has the correct type according to schema
+      def value_has_correct_type?: (untyped value, Hash[Symbol, untyped] schema) -> bool
+
+      # Validate field type
+      def validate_field_type: (untyped value, Hash[Symbol, untyped] schema, String path) -> void
+
+      # Validate field constraints
+      def validate_field_constraints: (untyped value, Hash[Symbol, untyped] schema, String path) -> void
+
+      # Validate nested schemas
+      def validate_nested_schema: (untyped value, Hash[Symbol, untyped] schema, String path) -> void
+
+      # Apply default values to configuration
+      def apply_defaults: (Hash[untyped, untyped] config) -> Hash[untyped, untyped]
+
+      # Apply defaults recursively
+      def apply_defaults_recursive: (Hash[untyped, untyped] config, Hash[String, Hash[Symbol, untyped]] schema, Hash[untyped, untyped] root_config) -> Hash[untyped, untyped]
+
+      # Migrate from version 0 (unversioned) to version 1
+      def migrate_v0_to_v1: (Hash[untyped, untyped] config) -> Hash[untyped, untyped]
+
+      # Migrate rules from version 0 to version 1
+      def migrate_rules_v0_to_v1: (Hash[untyped, untyped]? rules) -> void
+    end
+  end
+end

data/sig/sxn/config.rbs

@@ -0,0 +1,74 @@
+module Sxn
+  module Config
+    DEFAULT_CONFIG_FILENAME: String
+    
+    class ConfigManager
+      @config_path: Pathname
+      @config: Hash[String, untyped]
+      @discovery: ConfigDiscovery
+      @validator: ConfigValidator
+      @cache: ConfigCache
+      
+      def initialize: (?config_path: String?) -> void
+      def load: () -> Hash[String, untyped]
+      def save: (Hash[String, untyped] config) -> void
+      def get: (String key, ?untyped default) -> untyped
+      def set: (String key, untyped value) -> void
+      def delete: (String key) -> void
+      def exists?: () -> bool
+      def reload: () -> Hash[String, untyped]
+      def validate!: () -> void
+      def backup: () -> String
+      def restore: (String backup_path) -> void
+      
+      private
+      def load_config_file: () -> Hash[String, untyped]
+      def save_config_file: (Hash[String, untyped] config) -> void
+      def deep_get: (Hash[String, untyped] hash, String key) -> untyped
+      def deep_set: (Hash[String, untyped] hash, String key, untyped value) -> void
+      def deep_delete: (Hash[String, untyped] hash, String key) -> void
+    end
+    
+    class ConfigDiscovery
+      DEFAULT_SEARCH_PATHS: Array[String]
+      
+      def find_config: (?from: String?) -> Pathname?
+      def search_paths: (String from) -> Array[Pathname]
+      def config_in_directory?: (Pathname dir) -> bool
+      
+      private
+      def expand_search_paths: (Pathname from) -> Array[Pathname]
+      def check_directory: (Pathname dir) -> Pathname?
+    end
+    
+    class ConfigValidator
+      REQUIRED_KEYS: Array[String]
+      VALID_LOG_LEVELS: Array[Symbol]
+      
+      def validate: (Hash[String, untyped] config) -> bool
+      def validate!: (Hash[String, untyped] config) -> void
+      def errors: () -> Array[String]
+      
+      private
+      def validate_required_keys: (Hash[String, untyped] config) -> void
+      def validate_types: (Hash[String, untyped] config) -> void
+      def validate_values: (Hash[String, untyped] config) -> void
+    end
+    
+    class ConfigCache
+      @cache: Hash[String, untyped]
+      @ttl: Integer
+      @timestamps: Hash[String, Time]
+      
+      def initialize: (?ttl: Integer) -> void
+      def get: (String key) -> untyped
+      def set: (String key, untyped value) -> void
+      def delete: (String key) -> void
+      def clear: () -> void
+      def expired?: (String key) -> bool
+      
+      private
+      def cleanup_expired: () -> void
+    end
+  end
+end

data/sig/sxn/core/config_manager.rbs

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Core
+    # Manages configuration initialization and access
+    class ConfigManager
+      @base_path: String
+      @config_path: String
+      @sessions_folder: String?
+
+      attr_reader config_path: String
+      attr_reader sessions_folder: String?
+
+      def initialize: (?String base_path) -> void
+
+      def initialized?: () -> bool
+
+      def initialize_project: (String sessions_folder, ?force: bool) -> String
+
+      def get_config: () -> Hash[untyped, untyped]
+
+      def update_current_session: (String? session_name) -> void
+
+      def current_session: () -> String?
+
+      def sessions_folder_path: () -> String?
+
+      def add_project: (String name, String path, ?type: String?, ?default_branch: String?) -> void
+
+      def remove_project: (String name) -> void
+
+      def list_projects: () -> Array[Hash[Symbol, untyped]]
+
+      def get_project: (String name) -> Hash[Symbol, untyped]?
+
+      def update_project: (String name, Hash[Symbol, untyped] updates) -> bool
+
+      def update_project_config: (String name, Hash[Symbol, untyped] updates) -> bool
+
+      def detect_projects: () -> Array[Hash[Symbol, String]]
+
+      # Updates .gitignore to include SXN-related entries if not already present
+      def update_gitignore: () -> bool
+
+      # Public method to save configuration (expected by tests)
+      def save_config: () -> bool
+
+      private
+
+      def sessions_folder_relative_path: () -> String
+
+      def has_gitignore_entry?: (Array[String] lines, String entry) -> bool
+
+      def load_config: () -> void
+
+      def load_config_file: () -> Hash[untyped, untyped]
+
+      def save_config_file: (Hash[untyped, untyped] config) -> void
+
+      def create_directories: () -> void
+
+      def create_config_file: () -> void
+
+      def setup_database: () -> Sxn::Database::SessionDatabase
+    end
+  end
+end

data/sig/sxn/core/project_manager.rbs

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Core
+    # Manages project registration and configuration
+    class ProjectManager
+      @config_manager: ConfigManager
+
+      def initialize: (?ConfigManager? config_manager) -> void
+
+      def add_project: (String name, String path, ?type: String?, ?default_branch: String?) -> Hash[Symbol, untyped]
+
+      def remove_project: (String name) -> bool
+
+      def list_projects: () -> Array[Hash[Symbol, untyped]]
+
+      def get_project: (String name) -> Hash[Symbol, untyped]
+
+      def project_exists?: (String name) -> bool
+
+      def scan_projects: (?String? base_path) -> Array[Hash[Symbol, String]]
+
+      def detect_projects: (?String? base_path) -> Array[Hash[Symbol, String]]
+
+      def detect_project_type: (String path) -> String
+
+      def update_project: (String name, ?Hash[Symbol, untyped] updates) -> Hash[Symbol, untyped]
+
+      def validate_projects: () -> Array[Hash[Symbol, untyped]]
+
+      def auto_register_projects: (Array[Hash[Symbol, String]] detected_projects) -> Array[Hash[Symbol, untyped]]
+
+      def validate_project: (String name) -> Hash[Symbol, untyped]
+
+      def get_project_rules: (String name) -> Hash[String, untyped]
+
+      private
+
+      def validate_project_name!: (String name) -> void
+
+      def validate_project_path!: (String path) -> void
+
+      def detect_default_branch: (String path) -> String
+
+      def git_repository?: (String path) -> bool
+
+      def get_default_rules_for_type: (String type) -> Hash[String, untyped]
+
+      def merge_rules: (Hash[String, untyped] default_rules, Hash[String, untyped] custom_rules) -> Hash[String, untyped]
+    end
+  end
+end

data/sig/sxn/core/rules_manager.rbs

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Core
+    # Manages project rules and their application
+    class RulesManager
+      @config_manager: ConfigManager
+      @project_manager: ProjectManager
+      @rules_engine: Sxn::Rules::RulesEngine
+
+      def initialize: (?ConfigManager? config_manager, ?ProjectManager? project_manager) -> void
+
+      def add_rule: (String project_name, String rule_type, Hash[String, untyped] rule_config) -> Hash[Symbol, untyped]
+
+      def remove_rule: (String project_name, String rule_type, ?Integer? rule_index) -> untyped
+
+      def list_rules: (?String? project_name) -> Array[Hash[Symbol, untyped]]
+
+      def apply_rules: (String project_name, ?String? session_name) -> void
+
+      def validate_rules: (String project_name) -> Array[Hash[Symbol, untyped]]
+
+      def generate_rule_template: (String rule_type, ?String? project_type) -> Array[Hash[String, untyped]]
+
+      def get_available_rule_types: () -> Array[Hash[Symbol, untyped]]
+
+      private
+
+      def validate_rule_type!: (String rule_type) -> void
+
+      def validate_rule_config!: (String rule_type, Hash[String, untyped] rule_config) -> void
+
+      def validate_copy_files_config!: (Hash[String, untyped] config) -> void
+
+      def validate_setup_commands_config!: (Hash[String, untyped] config) -> void
+
+      def validate_template_config!: (Hash[String, untyped] config) -> void
+
+      def list_project_rules: (String project_name) -> Array[Hash[Symbol, untyped]]
+
+      def list_all_rules: () -> Array[Hash[Symbol, untyped]]
+
+      def format_rules_for_display: (String project_name, Hash[String, untyped] rules) -> Array[Hash[Symbol, untyped]]
+
+      def save_project_config: (String project_name, Hash[String, untyped] project_config) -> void
+
+      def generate_copy_files_template: (String? project_type) -> Array[Hash[String, untyped]]
+
+      def generate_setup_commands_template: (String? project_type) -> Array[Hash[String, untyped]]
+
+      def generate_template_rule_template: (String? project_type) -> Array[Hash[String, untyped]]
+    end
+  end
+end