sxn 0.2.0

data/sig/sxn/rules/copy_files_rule.rbs

@@ -0,0 +1,65 @@
+# TypeScript RBS for Sxn::Rules::CopyFilesRule
+
+module Sxn
+  module Rules
+    class CopyFilesRule < BaseRule
+      # Constants
+      VALID_STRATEGIES: Array[String]
+      REQUIRE_ENCRYPTION_PATTERNS: Array[Regexp]
+
+      # Instance variables
+      @file_copier: ::Sxn::Security::SecureFileCopier
+
+      # Initialize the copy files rule
+      def initialize: (untyped arg1, ?untyped arg2, ?untyped arg3, ?untyped arg4, ?dependencies: Array[String]) -> void
+
+      # Validate the rule configuration
+      def validate: () -> bool
+
+      # Apply the file copying operations
+      def apply: () -> bool
+
+      private
+
+      # Validate rule-specific configuration
+      def validate_rule_specific!: () -> void
+
+
+      # Delegate sensitive file detection to the file copier
+      def sensitive_file?: (String file_path) -> bool
+
+      # Validate individual file configuration
+      def validate_file_config!: (Hash[String, untyped] file_config, Integer index) -> void
+
+      # Check if permissions string is valid
+      def valid_permissions?: (untyped permissions) -> bool
+
+      # Convert permissions to integer format
+      def normalize_permissions: (untyped permissions) -> Integer
+
+      # Calculate destination path based on file config (method for tests)
+      def destination_path: (Hash[String, untyped] file_config) -> String
+
+      # Apply a single file operation
+      def apply_file_operation: (Hash[String, untyped] file_config) -> void
+
+      # Apply a copy operation
+      def apply_copy_operation: (String source, String destination, String source_path, String destination_path, Hash[String, untyped] file_config) -> void
+
+      # Apply a symlink operation
+      def apply_symlink_operation: (String source, String destination, String source_path, String destination_path, Hash[String, untyped] file_config) -> void
+
+      # Build options hash for file copying
+      def build_copy_options: (Hash[String, untyped] file_config) -> Hash[Symbol, untyped]
+
+      # Get copy options from file config (alias for build_copy_options)
+      def copy_options: (Hash[String, untyped] file_config) -> Hash[Symbol, untyped]
+
+      # Check if a file should be encrypted based on patterns and configuration
+      def should_encrypt_file?: (String file_path, Hash[String, untyped] file_config) -> bool
+
+      # Convert absolute path to relative path from project root
+      def relative_path: (String absolute_path) -> String
+    end
+  end
+end

data/sig/sxn/rules/errors.rbs

@@ -0,0 +1,33 @@
+# TypeScript RBS for Sxn::Rules errors
+
+module Sxn
+  module Rules
+    # Base error class for all rule-related errors
+    class RuleError < ::Sxn::Error
+    end
+
+    # Raised when rule validation fails
+    class ValidationError < RuleError
+    end
+
+    # Raised when rule application fails
+    class ApplicationError < RuleError
+    end
+
+    # Raised when rule rollback fails
+    class RollbackError < RuleError
+    end
+
+    # Raised when dependency resolution fails
+    class DependencyError < RuleError
+    end
+
+    # Raised when command execution fails
+    class CommandExecutionError < RuleError
+    end
+
+    # Raised when path validation fails
+    class PathValidationError < RuleError
+    end
+  end
+end

data/sig/sxn/rules/project_detector.rbs

@@ -0,0 +1,115 @@
+# TypeScript RBS for Sxn::Rules::ProjectDetector
+
+module Sxn
+  module Rules
+    class ProjectDetector
+      # Constants
+      PROJECT_TYPES: Hash[Symbol, Hash[Symbol, untyped]]
+      PACKAGE_MANAGERS: Hash[Symbol, Hash[Symbol, untyped]]
+
+      # Instance variables
+      @project_path: String
+
+      # Attributes
+      attr_reader project_path: String
+
+      # Initialize the project detector
+      def initialize: (String project_path) -> void
+
+      # Detect comprehensive project information
+      def detect_project_info: () -> Hash[Symbol, untyped]
+
+      # Detect project type for a given path (used by ConfigManager)
+      def detect_type: (String path) -> Symbol
+
+      # Legacy method for compatibility with tests
+      # Detect the primary project type
+      def detect_project_type: () -> Symbol
+
+      # Detect the package manager used by the project
+      def detect_package_manager: () -> Symbol
+
+      # Suggest default rules based on detected project characteristics
+      def suggest_default_rules: () -> Hash[String, untyped]
+
+      # Get detailed analysis of the project structure
+      def analyze_project_structure: () -> Hash[Symbol, untyped]
+
+      # Parse dependencies by type for testing
+      def parse_dependencies: (Symbol type) -> Array[String]
+
+      private
+
+      # Validate that the project path exists and is a directory
+      def validate_project_path!: () -> void
+
+      # Calculate confidence score for a project type
+      def calculate_type_confidence: (Symbol type, Hash[Symbol, untyped] criteria) -> Integer
+
+      # Calculate confidence score for a specific project type (test compatibility)
+      def calculate_confidence_score: (Symbol type) -> Integer
+
+      # Check if a file exists in the project (supports glob patterns)
+      def file_exists_in_project?: (String file_pattern) -> bool
+
+      # Detect primary programming language
+      def detect_primary_language: () -> Symbol
+
+      # Detect all languages present in the project
+      def detect_all_languages: () -> Array[Symbol]
+
+      # Detect web framework
+      def detect_framework: () -> Symbol
+
+      # Check if project has Docker configuration
+      def has_docker?: () -> bool
+
+      # Check if project has test configuration
+      def has_tests?: () -> bool
+
+      # Check if project has CI configuration
+      def has_ci_config?: () -> bool
+
+      # Detect database configuration
+      def detect_database: () -> Symbol
+
+      # Detect sensitive files that should be handled carefully
+      def detect_sensitive_files: () -> Array[String]
+
+      # Suggest copy files rules based on project characteristics
+      def suggest_copy_files_rules: (Hash[Symbol, untyped] project_info) -> Hash[String, untyped]
+
+      # Suggest setup commands based on package manager
+      def suggest_setup_commands_rules: (Hash[Symbol, untyped] project_info) -> Hash[String, untyped]
+
+      # Suggest template rules for documentation
+      def suggest_template_rules: (Hash[Symbol, untyped] project_info) -> Hash[String, untyped]
+
+      # Check if project has typical Node.js characteristics
+      def has_nodejs_characteristics?: () -> bool
+
+      # Helper methods for file content checking
+      def gemfile_contains?: (String gem_name) -> bool
+      def package_json_has_dependency?: (String dep_name) -> bool
+      def requirements_contains?: (String package_name) -> bool
+      def package_json_has_script?: (String script_name) -> bool
+      def package_json_has_main_entry?: () -> bool
+      def file_contains?: (String file_path, String content) -> bool
+      def env_contains?: (String env_var, String content) -> bool
+
+      # Analysis methods for detailed project inspection
+      def analyze_important_files: () -> Array[String]
+      def analyze_directory_structure: () -> Array[String]
+      def analyze_dependencies: () -> Hash[Symbol, untyped]
+      def analyze_configuration_files: () -> Array[String]
+      def analyze_scripts: () -> Hash[Symbol, untyped]
+      def analyze_documentation: () -> Array[String]
+
+      # Dependency parsing helpers
+      def parse_gemfile_lock: () -> Array[String]
+      def parse_gemfile: () -> Array[String]
+      def parse_package_json: () -> Array[String]
+      def parse_requirements_txt: () -> Array[String]
+    end
+  end
+end

data/sig/sxn/rules/rules_engine.rbs

@@ -0,0 +1,118 @@
+# TypeScript RBS for Sxn::Rules::RulesEngine
+
+module Sxn
+  module Rules
+    class RulesEngine
+      # Execution result for rule application
+      class ExecutionResult
+        @applied_rules: Array[BaseRule]
+        @failed_rules: Array[BaseRule]
+        @skipped_rules: Array[Hash[Symbol, untyped]]
+        @total_duration: Float
+        @errors: Array[Hash[Symbol, untyped]]
+        @start_time: Time?
+        @end_time: Time?
+
+        attr_reader applied_rules: Array[BaseRule]
+        attr_reader failed_rules: Array[BaseRule]
+        attr_reader total_duration: Float
+        attr_reader errors: Array[Hash[Symbol, untyped]]
+
+        def skipped_rules: () -> Array[BaseRule]
+
+        def initialize: () -> void
+        def start!: () -> void
+        def finish!: () -> void
+        def add_applied_rule: (BaseRule rule) -> void
+        def add_failed_rule: (BaseRule rule, StandardError error) -> void
+        def add_skipped_rule: (BaseRule rule, String reason) -> void
+        def add_engine_error: (StandardError error) -> void
+        def success?: () -> bool
+        def total_rules: () -> Integer
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+
+      # Constants
+      RULE_TYPES: Hash[String, untyped]
+
+      # Instance variables
+      @project_path: String
+      @session_path: String
+      @logger: untyped
+      @applied_rules: Array[BaseRule]
+
+      # Attributes
+      attr_reader project_path: String
+      attr_reader session_path: String
+      attr_reader logger: untyped
+
+      # Initialize the rules engine
+      def initialize: (String project_path, String session_path, ?logger: untyped) -> void
+
+      # Apply a set of rules with dependency resolution and parallel execution
+      def apply_rules: (Hash[String, untyped] rules_config, ?Hash[Symbol, untyped] options) -> ExecutionResult
+
+      # Rollback all applied rules in reverse order
+      def rollback_rules: () -> bool
+
+      # Validate rules configuration without executing
+      def validate_rules_config: (Hash[String, untyped] rules_config) -> Array[BaseRule]
+
+      # Strict validation that raises errors on any validation failure
+      def validate_rules_strict: (Array[BaseRule] rules) -> void
+
+      # Get available rule types
+      def available_rule_types: () -> Array[String]
+
+      private
+
+      # Default execution options
+      def default_options: () -> Hash[Symbol, untyped]
+
+      # Validate that paths exist and are accessible
+      def validate_paths!: () -> void
+
+      # Load rules from configuration
+      def load_rules: (Hash[String, untyped] rules_config) -> Array[BaseRule]
+
+      # Load a single rule from specification
+      def load_single_rule: (String rule_name, Hash[String, untyped] rule_spec) -> BaseRule
+
+      # Create a rule instance
+      def create_rule: (String rule_name, String rule_type, Hash[String, untyped] config, Array[String] dependencies, String session_path, String project_path) -> BaseRule
+
+      # Get rule class for a given type
+      def get_rule_class: (String rule_type) -> untyped
+
+      # Validate all rules
+      def validate_rules: (Array[BaseRule] rules) -> Array[BaseRule]
+
+      # Validate that all dependencies exist
+      def validate_dependencies: (Array[BaseRule] rules) -> void
+
+      # Check for circular dependencies
+      def check_circular_dependencies: (Array[BaseRule] rules) -> void
+
+      # Detect circular dependencies using DFS
+      def detect_circular_dependencies: (Array[BaseRule] rules) -> void
+
+      # DFS helper for circular dependency detection
+      def has_circular_dependency?: (BaseRule rule, Hash[String, BaseRule] rule_map, Set[String] visited, Set[String] rec_stack) -> bool
+
+      # Resolve execution order based on dependencies (topological sort)
+      def resolve_execution_order: (Array[BaseRule] rules) -> Array[Array[BaseRule]]
+
+      # Execute a phase of rules (potentially in parallel)
+      def execute_phase: (Array[BaseRule] phase_rules, Integer phase_index, ExecutionResult result, Hash[Symbol, untyped] options) -> void
+
+      # Execute rules in a phase sequentially
+      def execute_phase_sequential: (Array[BaseRule] phase_rules, ExecutionResult result, Hash[Symbol, untyped] options) -> void
+
+      # Execute rules in a phase in parallel
+      def execute_phase_parallel: (Array[BaseRule] phase_rules, ExecutionResult result, Hash[Symbol, untyped] options) -> void
+
+      # Execute a single rule
+      def execute_single_rule: (BaseRule rule, ExecutionResult result, Hash[Symbol, untyped] options, ?Mutex? mutex) -> void
+    end
+  end
+end

data/sig/sxn/rules/setup_commands_rule.rbs

@@ -0,0 +1,60 @@
+# TypeScript RBS for Sxn::Rules::SetupCommandsRule
+
+module Sxn
+  module Rules
+    class SetupCommandsRule < BaseRule
+      # Constants
+      CONDITION_TYPES: Hash[String, Symbol]
+      DEFAULT_TIMEOUT: Integer
+      MAX_TIMEOUT: Integer
+
+      # Instance variables
+      @command_executor: ::Sxn::Security::SecureCommandExecutor
+      @executed_commands: Array[Hash[Symbol, untyped]]
+
+      # Initialize the setup commands rule
+      def initialize: (untyped arg1, ?untyped arg2, ?untyped arg3, ?untyped arg4, ?dependencies: Array[String]) -> void
+
+      # Validate the rule configuration
+      def validate: () -> bool
+
+      # Apply the command execution operations
+      def apply: (?Hash[untyped, untyped] context) -> bool
+
+      # Get summary of executed commands
+      def execution_summary: () -> Array[Hash[Symbol, untyped]]
+
+      private
+
+      # Validate rule-specific configuration
+      def validate_rule_specific!: () -> void
+
+      # Validate individual command configuration
+      def validate_command_config!: (Hash[String, untyped] command_config, Integer index) -> void
+
+      # Check if condition format is valid
+      def valid_condition?: (untyped condition) -> bool
+
+      # Apply a single command operation
+      def apply_command: (Hash[String, untyped] command_config, Integer index, bool continue_on_failure) -> void
+
+      # Execute a command with the security layer
+      def execute_command_safely: (Hash[String, untyped] command_config) -> untyped
+
+      # Determine the working directory for command execution
+      def determine_working_directory: (Hash[String, untyped] command_config) -> String
+
+      # Check if command should be executed based on its condition
+      def should_execute_command?: (Hash[String, untyped] command_config) -> bool
+
+      # Condition evaluation methods
+      def file_exists?: (String path) -> bool
+      def file_missing?: (String path) -> bool
+      def directory_exists?: (String path) -> bool
+      def directory_missing?: (String path) -> bool
+      def command_available?: (String command_name) -> bool
+      def env_var_set?: (String var_name) -> bool
+      def always_true: (?untyped arg) -> bool
+    end
+  end
+end

data/sig/sxn/rules/template_rule.rbs

@@ -0,0 +1,44 @@
+# TypeScript RBS for Sxn::Rules::TemplateRule
+
+module Sxn
+  module Rules
+    class TemplateRule < BaseRule
+      # Constants
+      SUPPORTED_ENGINES: Array[String]
+
+      # Instance variables
+      @template_processor: ::Sxn::Templates::TemplateProcessor
+      @template_variables: ::Sxn::Templates::TemplateVariables
+
+      # Initialize the template rule
+      def initialize: (untyped arg1, ?untyped arg2, ?untyped arg3, ?untyped arg4, ?dependencies: Array[String]) -> void
+
+      # Validate the rule configuration
+      def validate: () -> bool
+
+      # Apply the template processing operations
+      def apply: () -> bool
+
+      private
+
+      # Validate rule-specific configuration
+      def validate_rule_specific!: () -> void
+
+
+      # Validate individual template configuration
+      def validate_template_config!: (Hash[String, untyped] template_config, Integer index) -> void
+
+      # Apply a single template operation
+      def apply_template: (Hash[String, untyped] template_config, Integer index) -> void
+
+      # Build variables hash for template processing
+      def build_template_variables: (Hash[String, untyped] template_config) -> Hash[Symbol, untyped]
+
+      # Deep merge two hashes, with the second hash taking precedence
+      def deep_merge: (Hash[untyped, untyped] hash1, Hash[untyped, untyped] hash2) -> Hash[untyped, untyped]
+
+      # Extract variable names used in a template
+      def extract_used_variables: (String template_content) -> Array[String]
+    end
+  end
+end