sxn 0.2.0

data/sig/sxn/core/session_manager.rbs

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Core
+    # Manages session lifecycle and operations
+    class SessionManager
+      @config_manager: ConfigManager
+      @database: Sxn::Database::SessionDatabase
+
+      def initialize: (?ConfigManager? config_manager) -> void
+
+      def create_session: (String name, ?description: String?, ?linear_task: String?) -> Hash[Symbol, untyped]
+
+      def remove_session: (String name, ?force: bool) -> bool
+
+      def list_sessions: (?status: String?, ?limit: Integer, ?filters: Hash[untyped, untyped]?, **untyped options) -> Array[Hash[Symbol, untyped]]
+
+      def get_session: (String name) -> Hash[Symbol, untyped]?
+
+      def use_session: (String name) -> Hash[Symbol, untyped]
+
+      def current_session: () -> Hash[Symbol, untyped]?
+
+      def session_exists?: (String name) -> bool
+
+      def add_worktree_to_session: (String session_name, String project_name, String worktree_path, String branch) -> void
+
+      def remove_worktree_from_session: (String session_name, String project_name) -> void
+
+      def get_session_worktrees: (String session_name) -> Hash[String, Hash[Symbol, untyped]]
+
+      def archive_session: (String name) -> bool
+
+      def activate_session: (String name) -> bool
+
+      def cleanup_old_sessions: (?Integer days_old) -> Integer
+
+      private
+
+      def initialize_database: () -> Sxn::Database::SessionDatabase
+
+      def validate_session_name!: (String name) -> void
+
+      def ensure_sessions_folder_exists!: () -> void
+
+      def format_session_data: (Hash[Symbol, untyped] db_row) -> Hash[Symbol, untyped]
+
+      def update_session_status: (String session_id, String status, **untyped additional_options) -> void
+
+      def update_session_status_by_name: (String name, String status, **untyped additional_options) -> void
+
+      def find_uncommitted_worktrees: (Hash[Symbol, untyped] session) -> Array[String]
+
+      def remove_session_worktrees: (Hash[Symbol, untyped] session) -> void
+
+      def find_parent_repository: (String worktree_path) -> String?
+    end
+  end
+end

data/sig/sxn/core/worktree_manager.rbs

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sxn
+  module Core
+    # Manages git worktree operations
+    class WorktreeManager
+      @config_manager: ConfigManager
+      @session_manager: SessionManager
+      @project_manager: ProjectManager
+
+      def initialize: (?ConfigManager? config_manager, ?SessionManager? session_manager) -> void
+
+      def add_worktree: (String project_name, ?String? branch, ?session_name: String?) -> Hash[Symbol, untyped]
+
+      def remove_worktree: (String project_name, ?session_name: String?) -> bool
+
+      def list_worktrees: (?session_name: String?) -> Array[Hash[Symbol, untyped]]
+
+      def get_worktree: (String project_name, ?session_name: String?) -> Hash[Symbol, untyped]?
+
+      # Check if a worktree exists for a project
+      def worktree_exists?: (String project_name, ?session_name: String?) -> bool
+
+      # Get the path to a worktree for a project
+      def worktree_path: (String project_name, ?session_name: String?) -> String?
+
+      # Validate worktree name (expected by tests)
+      def validate_worktree_name: (String name) -> bool
+
+      # Execute git command (mock point for tests)
+      def execute_git_command: (*untyped) -> bool
+
+      def validate_worktree: (String project_name, ?session_name: String?) -> Hash[Symbol, untyped]
+
+      private
+
+      def create_git_worktree: (String project_path, String worktree_path, String branch) -> void
+
+      def remove_git_worktree: (String project_path, String worktree_path) -> void
+
+      def remove_git_worktree_by_path: (String worktree_path) -> void
+
+      def get_worktree_status: (String path) -> String
+
+      def valid_git_worktree?: (String path) -> bool
+
+      def check_git_status: (String path) -> Array[String]
+    end
+  end
+end

data/sig/sxn/core.rbs

@@ -0,0 +1,87 @@
+module Sxn
+  module Core
+    class SessionManager
+      @config: Hash[String, untyped]
+      @database: Database::SessionDatabase
+      @worktree_manager: WorktreeManager
+      @rules_manager: RulesManager
+      
+      def initialize: (?config: Hash[String, untyped]?) -> void
+      def create: (String session_name, ?Hash[String, untyped] options) -> Hash[String, untyped]
+      def list: (?status: Symbol?) -> Array[Hash[String, untyped]]
+      def get: (String session_name) -> Hash[String, untyped]?
+      def update: (String session_name, Hash[String, untyped] attributes) -> void
+      def delete: (String session_name) -> void
+      def exists?: (String session_name) -> bool
+      def active_sessions: () -> Array[Hash[String, untyped]]
+      def activate: (String session_name) -> void
+      def deactivate: (String session_name) -> void
+      
+      private
+      def validate_session_name: (String name) -> void
+      def create_session_directory: (String session_name, String project_path) -> String
+      def setup_worktree: (String session_name, String project_path) -> void
+      def apply_rules: (String session_name, Hash[String, untyped] options) -> void
+    end
+    
+    class WorktreeManager
+      @config: Hash[String, untyped]
+      
+      def initialize: (?config: Hash[String, untyped]?) -> void
+      def create: (String name, String source_path, ?String? branch) -> String
+      def list: (String project_path) -> Array[Hash[String, untyped]]
+      def delete: (String name, String project_path) -> void
+      def exists?: (String name, String project_path) -> bool
+      def prune: (String project_path) -> void
+      def get_path: (String name, String project_path) -> String?
+      
+      private
+      def validate_git_repository: (String path) -> void
+      def execute_git_command: (String path, String command) -> String
+      def parse_worktree_list: (String output) -> Array[Hash[String, untyped]]
+    end
+    
+    class ProjectManager
+      @config: Hash[String, untyped]
+      @database: Database::SessionDatabase
+      
+      def initialize: (?config: Hash[String, untyped]?) -> void
+      def add: (String name, String path, ?Hash[String, untyped] options) -> void
+      def remove: (String name) -> void
+      def list: () -> Array[Hash[String, untyped]]
+      def get: (String name) -> Hash[String, untyped]?
+      def update: (String name, Hash[String, untyped] attributes) -> void
+      def exists?: (String name) -> bool
+      def detect_type: (String path) -> Symbol
+      
+      private
+      def validate_project_path: (String path) -> void
+      def detect_project_type: (String path) -> Symbol
+      def load_project_config: (String path) -> Hash[String, untyped]
+    end
+    
+    class RulesManager
+      @config: Hash[String, untyped]
+      @rules: Array[Rules::BaseRule]
+      
+      def initialize: (?config: Hash[String, untyped]?) -> void
+      def add_rule: (Rules::BaseRule rule) -> void
+      def remove_rule: (String rule_name) -> void
+      def apply: (String session_name, Hash[String, untyped] context) -> void
+      def list: () -> Array[Hash[String, untyped]]
+      def get: (String rule_name) -> Rules::BaseRule?
+      def enabled_rules: () -> Array[Rules::BaseRule]
+      def disabled_rules: () -> Array[Rules::BaseRule]
+      
+      private
+      def load_rules: () -> Array[Rules::BaseRule]
+      def execute_rule: (Rules::BaseRule rule, Hash[String, untyped] context) -> void
+      def handle_rule_error: (StandardError error, Rules::BaseRule rule) -> void
+    end
+    
+    class ConfigManager
+      # Alias to Config::ConfigManager
+      include Config
+    end
+  end
+end

data/sig/sxn/database/errors.rbs

@@ -0,0 +1,37 @@
+# TypeScript RBS for Sxn::Database errors
+
+module Sxn
+  module Database
+    # Base error class for all database-related errors
+    class Error < ::Sxn::Error
+    end
+
+    # Raised when trying to create a session with a name that already exists
+    class DuplicateSessionError < Error
+    end
+
+    # Raised when trying to access a session that doesn't exist
+    class SessionNotFoundError < Error
+    end
+
+    # Raised when concurrent updates conflict (optimistic locking)
+    class ConflictError < Error
+    end
+
+    # Raised when database schema migration fails
+    class MigrationError < Error
+    end
+
+    # Raised when database integrity checks fail
+    class IntegrityError < Error
+    end
+
+    # Raised when database connection fails
+    class ConnectionError < Error
+    end
+
+    # Raised when transaction rollback occurs
+    class TransactionError < Error
+    end
+  end
+end

data/sig/sxn/database/session_database.rbs

@@ -0,0 +1,151 @@
+# TypeScript RBS for Sxn::Database::SessionDatabase
+
+module Sxn
+  module Database
+    class SessionDatabase
+      # Constants
+      SCHEMA_VERSION: Integer
+      DEFAULT_DB_PATH: String
+      VALID_STATUSES: Array[String]
+
+      # Instance variables
+      @db_path: Pathname
+      @config: Hash[Symbol, untyped]
+      @prepared_statements: Hash[Symbol, untyped]
+      @connection: untyped
+
+      # Attributes
+      attr_reader db_path: Pathname
+      attr_reader connection: untyped
+      attr_reader config: Hash[Symbol, untyped]
+
+      # Initialize database connection and ensure schema is current
+      #
+      # @param db_path [String, Pathname, nil] Path to SQLite database file
+      # @param config [Hash] Database configuration options
+      def initialize: (?String? db_path, ?Hash[Symbol, untyped] config) -> void
+
+      # Create a new session with validation and conflict detection
+      def create_session: (Hash[Symbol, untyped] session_data) -> String
+
+      # List sessions with filtering, sorting, and pagination
+      def list_sessions: (?filters: Hash[Symbol, untyped], ?sort: Hash[Symbol, untyped], ?limit: Integer, ?offset: Integer) -> Array[Hash[Symbol, untyped]]
+
+      # Update session data with optimistic locking
+      def update_session: (String session_id, ?Hash[Symbol, untyped] updates, ?expected_version: String?) -> bool
+
+      # Delete session with cascade options
+      def delete_session: (String session_id, ?cascade: bool) -> bool
+
+      # Search sessions with full-text search and filters
+      def search_sessions: (String query, ?filters: Hash[Symbol, untyped], ?limit: Integer) -> Array[Hash[Symbol, untyped]]
+
+      # Get single session by ID
+      def get_session: (String session_id) -> Hash[Symbol, untyped]
+
+      # Get session by name
+      def get_session_by_name: (String name) -> Hash[Symbol, untyped]?
+
+      # Alias for get_session for compatibility
+      alias get_session_by_id get_session
+
+      # Get session statistics
+      def statistics: () -> Hash[Symbol, untyped]
+
+      # Execute database maintenance tasks
+      def maintenance: (?Array[Symbol] tasks) -> Hash[Symbol, untyped]
+
+      # Close database connection and cleanup prepared statements
+      def close: () -> void
+
+      # Update session status
+      def update_session_status: (String name, String status) -> bool
+
+      # Public method to create database tables (expected by tests)
+      def create_tables: () -> void
+
+      private
+
+      # Default database configuration
+      def default_config: () -> Hash[Symbol, untyped]
+
+      # Resolve database path, creating parent directories if needed
+      def resolve_db_path: (String? path) -> Pathname
+
+      # Ensure parent directory exists for database file
+      def ensure_directory_exists: () -> void
+
+      # Initialize SQLite connection with optimized settings
+      def initialize_connection: () -> void
+
+      # Configure SQLite PRAGMA settings for performance and safety
+      def configure_sqlite_pragmas: () -> void
+
+      # Setup database schema and run migrations
+      def setup_database: () -> void
+
+      # Get current schema version from database
+      def get_schema_version: () -> Integer
+
+      # Set schema version in database
+      def set_schema_version: (Integer version) -> void
+
+      # Create initial database schema with optimized indexes
+      def create_initial_schema: () -> void
+
+      # Run database migrations from old version to current
+      def run_migrations: (Integer from_version) -> void
+
+      # Generate secure, unique session ID
+      def generate_session_id: () -> String
+
+      # Validate session data before creation
+      def validate_session_data!: (Hash[Symbol, untyped] data) -> void
+
+      # Validate session update data
+      def validate_session_updates!: (Hash[Symbol, untyped] updates) -> void
+
+      # Serialize tags array to JSON string
+      def serialize_tags: (Array[String]? tags) -> String?
+
+      # Serialize metadata hash to JSON string
+      def serialize_metadata: (Hash[untyped, untyped]? metadata) -> String?
+
+      # Deserialize session row from database
+      def deserialize_session_row: (Hash[String, untyped] row) -> Hash[Symbol, untyped]
+
+      # Get session directory path
+      def session_directory_path: (String session_name) -> String
+
+      # Build WHERE conditions for filtering
+      def build_where_conditions: (Hash[Symbol, untyped] filters, Array[untyped] params) -> Array[String]
+
+      # Execute query with parameters and return results
+      def execute_query: (String sql, ?Array[untyped] params) -> Array[Hash[String, untyped]]
+
+      # Transaction wrapper with rollback support
+      def with_transaction: [T] () { () -> T } -> T
+
+      # Prepare and cache SQL statements for performance
+      def prepare_statement: (Symbol name, String sql) -> untyped
+
+      # Count total sessions
+      def count_sessions: () -> Integer
+
+      # Count sessions by status
+      def count_sessions_by_status: () -> Hash[String, Integer]
+
+      # Get recent session activity (last 7 days)
+      def recent_session_activity: () -> Integer
+
+      # Get database file size in MB
+      def database_size_mb: () -> Float
+
+      # Delete session worktrees (for cascade deletion)
+      def delete_session_worktrees: (String session_id) -> void
+
+      # Delete session files (for cascade deletion)
+      def delete_session_files: (String session_id) -> void
+    end
+  end
+end

data/sig/sxn/database.rbs

@@ -0,0 +1,83 @@
+module Sxn
+  module Database
+    # High-performance SQLite-based session storage
+    class SessionDatabase
+      type config_hash = Hash[Symbol, untyped]
+      type session_data_hash = Hash[Symbol, untyped]
+      type statistics_hash = Hash[Symbol, untyped]
+      type filters_hash = Hash[Symbol, untyped]
+      type sort_hash = Hash[Symbol, untyped]
+
+      attr_reader db_path: Pathname
+      attr_reader connection: SQLite3::Database?
+      attr_reader config: config_hash
+
+      def initialize: (?String? db_path, ?config_hash config) -> void
+      def create_session: (session_data_hash session_data) -> String
+      def list_sessions: (?filters: filters_hash, ?sort: sort_hash, ?limit: Integer, ?offset: Integer) -> Array[Hash[Symbol, untyped]]
+      def update_session: (String session_id, ?session_data_hash updates, ?expected_version: String?) -> bool
+      def delete_session: (String session_id, ?cascade: bool) -> bool
+      def search_sessions: (String query, ?filters: filters_hash, ?limit: Integer) -> Array[Hash[Symbol, untyped]]
+      def get_session: (String session_id) -> Hash[Symbol, untyped]
+      def get_session_by_name: (String name) -> Hash[Symbol, untyped]?
+      def statistics: () -> statistics_hash
+      def maintenance: (?Array[Symbol] tasks) -> Hash[Symbol, String]
+      def close: () -> void
+      def create_tables: () -> void
+      def update_session_status: (String name, String status) -> bool
+      
+      def default_config: () -> config_hash
+      def resolve_db_path: (String? path) -> Pathname
+      def ensure_directory_exists: () -> void
+      def initialize_connection: () -> void
+      def configure_sqlite_pragmas: () -> void
+      def setup_database: () -> void
+      def get_schema_version: () -> Integer
+      def set_schema_version: (Integer version) -> void
+      def create_initial_schema: () -> void
+      def run_migrations: (Integer from_version) -> void
+      def generate_session_id: () -> String
+      def validate_session_data!: (session_data_hash data) -> void
+      def validate_session_updates!: (session_data_hash updates) -> void
+      def serialize_tags: (Array[String]? tags) -> String?
+      def serialize_metadata: (Hash[untyped, untyped]? metadata) -> String?
+      def deserialize_session_row: (Hash[String, untyped] row) -> Hash[Symbol, untyped]
+      def session_directory_path: (String session_name) -> String
+      def build_where_conditions: (filters_hash filters, Array[untyped] params) -> Array[String]
+      def execute_query: (String sql, ?Array[untyped] params) -> Array[Hash[String, untyped]]
+      def with_transaction: [T] () { () -> T } -> T
+      def prepare_statement: (Symbol name, String sql) -> SQLite3::Statement
+      def count_sessions: () -> Integer
+      def count_sessions_by_status: () -> Hash[String, Integer]
+      def recent_session_activity: () -> Integer
+      def database_size_mb: () -> Float
+      def delete_session_worktrees: (String session_id) -> void
+      def delete_session_files: (String session_id) -> void
+    end
+    
+    # Database errors
+    class Error < Sxn::Error
+    end
+    
+    class DuplicateSessionError < Error
+    end
+    
+    class SessionNotFoundError < Error
+    end
+    
+    class ConflictError < Error
+    end
+    
+    class MigrationError < Error
+    end
+    
+    class IntegrityError < Error
+    end
+    
+    class ConnectionError < Error
+    end
+    
+    class TransactionError < Error
+    end
+  end
+end

data/sig/sxn/errors.rbs

@@ -0,0 +1,89 @@
+module Sxn
+  # Base error class for all Sxn errors
+  class Error < ::StandardError
+    def initialize: (?String? message, ?cause: Exception?) -> void
+    def detailed_message: () -> String
+    def user_message: () -> String
+    
+    private
+    def format_backtrace: () -> String?
+  end
+  
+  # Configuration related errors
+  class ConfigError < Error
+  end
+  
+  class ConfigNotFoundError < ConfigError
+  end
+  
+  class ConfigValidationError < ConfigError
+    attr_reader errors: Array[String]
+    
+    def initialize: (Array[String] errors, ?String? message) -> void
+  end
+  
+  # Session related errors
+  class SessionError < Error
+  end
+  
+  class SessionNotFoundError < SessionError
+  end
+  
+  class SessionAlreadyExistsError < SessionError
+  end
+  
+  class SessionActiveError < SessionError
+  end
+  
+  # Worktree related errors
+  class WorktreeError < Error
+  end
+  
+  class WorktreeNotFoundError < WorktreeError
+  end
+  
+  class WorktreeAlreadyExistsError < WorktreeError
+  end
+  
+  # Project related errors
+  class ProjectError < Error
+  end
+  
+  class ProjectNotFoundError < ProjectError
+  end
+  
+  class ProjectAlreadyExistsError < ProjectError
+  end
+  
+  # Git related errors
+  class GitError < Error
+  end
+  
+  class NotAGitRepositoryError < GitError
+  end
+  
+  class GitCommandError < GitError
+    attr_reader command: String
+    attr_reader exit_status: Integer
+    
+    def initialize: (String command, Integer exit_status, ?String? message) -> void
+  end
+  
+  # File system errors
+  class FileSystemError < Error
+  end
+  
+  class PathNotFoundError < FileSystemError
+  end
+  
+  class PermissionDeniedError < FileSystemError
+  end
+  
+  # Validation errors
+  class ValidationError < Error
+    attr_reader field: String?
+    attr_reader value: untyped
+    
+    def initialize: (?String? field, ?untyped value, ?String? message) -> void
+  end
+end

data/sig/sxn/rules/base_rule.rbs

@@ -0,0 +1,137 @@
+# TypeScript RBS for Sxn::Rules::BaseRule
+
+module Sxn
+  module Rules
+    class BaseRule
+      # Rule execution states
+      module States
+        PENDING: Symbol
+        VALIDATING: Symbol
+        VALIDATED: Symbol
+        APPLYING: Symbol
+        APPLIED: Symbol
+        ROLLING_BACK: Symbol
+        ROLLED_BACK: Symbol
+        FAILED: Symbol
+      end
+
+      include States
+
+      # Instance variables
+      @name: String
+      @config: Hash[String, untyped]
+      @project_path: String
+      @session_path: String
+      @dependencies: Array[String]
+      @state: Symbol
+      @changes: Array[RuleChange]
+      @errors: Array[StandardError]
+      @start_time: Time?
+      @end_time: Time?
+      @logger: untyped
+
+      # Attributes
+      attr_reader name: String
+      attr_reader config: Hash[String, untyped]
+      attr_reader project_path: String
+      attr_reader session_path: String
+      attr_reader state: Symbol
+      attr_reader dependencies: Array[String]
+      attr_reader changes: Array[RuleChange]
+      attr_reader errors: Array[StandardError]
+
+      # Initialize a new rule instance
+      def initialize: (untyped arg1, ?untyped arg2, ?untyped arg3, ?untyped arg4, ?dependencies: Array[String]) -> void
+
+      # Validate the rule configuration and dependencies
+      def validate: () -> bool
+
+      # Apply the rule's action
+      def apply: (?Hash[untyped, untyped] context) -> bool
+
+      # Rollback the rule's changes
+      def rollback: () -> bool
+
+      # Check if this rule can be executed (all dependencies are satisfied)
+      def can_execute?: (Array[String] completed_rules) -> bool
+
+      # Get rule execution duration in seconds
+      def duration: () -> Float?
+
+      # Get rule type
+      def type: () -> String
+
+      # Check if rule is required
+      def required?: () -> bool
+
+      # Validate rule configuration (public method expected by tests)
+      def validate_config_hash: (?Hash[String, untyped] config) -> bool
+
+      # Get rule description
+      def description: () -> String
+
+      # Check if rule has been successfully applied
+      def applied?: () -> bool
+
+      # Check if rule has failed
+      def failed?: () -> bool
+
+      # Check if rule can be rolled back
+      def rollbackable?: () -> bool
+
+      # Get a hash representation of the rule for serialization
+      def to_h: () -> Hash[Symbol, untyped]
+
+      private
+
+      # Track a change made by this rule for rollback purposes
+      def track_change: (Symbol type, String target, ?Hash[Symbol, untyped] metadata) -> RuleChange
+
+      # Get the logger instance
+      def logger: () -> untyped
+
+      # Log a message with rule context
+      def log: (Symbol level, String message, ?Hash[Symbol, untyped] metadata) -> void
+
+      private
+
+      # Change the rule state and track timing
+      def change_state!: (Symbol new_state) -> void
+
+      # Validate that required paths exist and are accessible
+      def validate_paths!: () -> void
+
+      # Validate basic rule configuration
+      def validate_config!: () -> void
+
+      # Validate rule dependencies
+      def validate_dependencies!: () -> void
+
+      # Validate rule-specific configuration
+      def validate_rule_specific!: () -> void
+
+      # Rollback all tracked changes in reverse order
+      def rollback_changes!: () -> bool
+
+      # Represents a single change made by a rule
+      class RuleChange
+        @type: Symbol
+        @target: String
+        @metadata: Hash[Symbol, untyped]
+        @timestamp: Time
+
+        attr_reader type: Symbol
+        attr_reader target: String
+        attr_reader metadata: Hash[Symbol, untyped]
+        attr_reader timestamp: Time
+
+        def initialize: (Symbol type, String target, ?Hash[Symbol, untyped] metadata) -> void
+
+        # Rollback this specific change
+        def rollback: () -> void
+
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+    end
+  end
+end