sxn 0.2.0

data/lib/sxn/core/session_manager.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+require "shellwords"
+
+module Sxn
+  module Core
+    # Manages session lifecycle and operations
+    class SessionManager
+      def initialize(config_manager = nil)
+        @config_manager = config_manager || ConfigManager.new
+        @database = initialize_database
+      end
+
+      def create_session(name, description: nil, linear_task: nil)
+        validate_session_name!(name)
+        ensure_sessions_folder_exists!
+
+        raise Sxn::SessionAlreadyExistsError, "Session '#{name}' already exists" if session_exists?(name)
+
+        session_id = SecureRandom.uuid
+        session_path = File.join(@config_manager.sessions_folder_path, name)
+
+        # Create session directory
+        FileUtils.mkdir_p(session_path)
+
+        # Create session record
+        session_data = {
+          id: session_id,
+          name: name,
+          path: session_path,
+          created_at: Time.now.iso8601,
+          updated_at: Time.now.iso8601,
+          status: "active",
+          description: description,
+          linear_task: linear_task,
+          projects: [],
+          worktrees: {}
+        }
+
+        @database.create_session(session_data)
+        session_data
+      rescue Sxn::Database::DuplicateSessionError => e
+        raise Sxn::SessionAlreadyExistsError, e.message
+      end
+
+      def remove_session(name, force: false)
+        session = get_session(name)
+        raise Sxn::SessionNotFoundError, "Session '#{name}' not found" unless session
+
+        unless force
+          # Check for uncommitted changes in worktrees
+          uncommitted_worktrees = find_uncommitted_worktrees(session)
+          unless uncommitted_worktrees.empty?
+            raise Sxn::SessionHasChangesError,
+                  "Session has uncommitted changes in: #{uncommitted_worktrees.join(", ")}"
+          end
+        end
+
+        # Remove worktrees first
+        remove_session_worktrees(session)
+
+        # Remove session directory
+        FileUtils.rm_rf(session[:path])
+
+        # Remove from database
+        @database.delete_session(session[:id])
+
+        # Clear current session if it was this one
+        @config_manager.update_current_session(nil) if @config_manager.current_session == name
+
+        true
+      end
+
+      def list_sessions(status: nil, limit: 100, filters: nil, **options)
+        # Support both the filters parameter and individual status parameter
+        filter_hash = filters || {}
+        filter_hash[:status] = status if status
+
+        # Merge any other options
+        filter_hash.merge!(options) if options.any?
+
+        sessions = @database.list_sessions(filters: filter_hash, limit: limit)
+        sessions.map { |s| format_session_data(s) }
+      end
+
+      def get_session(name)
+        session = @database.get_session_by_name(name)
+        session ? format_session_data(session) : nil
+      rescue Sxn::Database::SessionNotFoundError
+        nil
+      end
+
+      def use_session(name)
+        session = get_session(name)
+        raise Sxn::SessionNotFoundError, "Session '#{name}' not found" unless session
+
+        @config_manager.update_current_session(name)
+
+        # Update session status to active
+        update_session_status(session[:id], "active")
+
+        session
+      end
+
+      def current_session
+        current_name = @config_manager.current_session
+        return nil unless current_name
+
+        get_session(current_name)
+      end
+
+      def session_exists?(name)
+        !get_session(name).nil?
+      end
+
+      def add_worktree_to_session(session_name, project_name, worktree_path, branch)
+        session = get_session(session_name)
+        raise Sxn::SessionNotFoundError, "Session '#{session_name}' not found" unless session
+
+        # Update session metadata
+        session_data = @database.get_session_by_id(session[:id])
+        worktrees = session_data[:worktrees] || {}
+        worktrees[project_name] = {
+          path: worktree_path,
+          branch: branch,
+          created_at: Time.now.iso8601
+        }
+
+        projects = session_data[:projects] || []
+        projects << project_name unless projects.include?(project_name)
+
+        @database.update_session(session[:id], {
+                                   worktrees: worktrees,
+                                   projects: projects.uniq
+                                 })
+      end
+
+      def remove_worktree_from_session(session_name, project_name)
+        session = get_session(session_name)
+        raise Sxn::SessionNotFoundError, "Session '#{session_name}' not found" unless session
+
+        session_data = @database.get_session_by_id(session[:id])
+        worktrees = session_data[:worktrees] || {}
+        worktrees.delete(project_name)
+
+        projects = session_data[:projects] || []
+        projects.delete(project_name)
+
+        @database.update_session(session[:id], {
+                                   worktrees: worktrees,
+                                   projects: projects
+                                 })
+      end
+
+      def get_session_worktrees(session_name)
+        session = get_session(session_name)
+        return {} unless session
+
+        session_data = @database.get_session_by_id(session[:id])
+        session_data[:worktrees] || {}
+      end
+
+      def archive_session(name)
+        update_session_status_by_name(name, "archived")
+        true
+      end
+
+      def activate_session(name)
+        update_session_status_by_name(name, "active")
+        true
+      end
+
+      def cleanup_old_sessions(days_old = 30)
+        cutoff_date = Time.now.utc - (days_old * 24 * 60 * 60)
+        old_sessions = @database.list_sessions.select do |session|
+          session_time = Time.parse(session[:updated_at]).utc
+          session_time < cutoff_date
+        rescue ArgumentError
+          # If we can't parse the time, err on the side of caution and don't delete
+          false
+        end
+
+        old_sessions.each do |session|
+          remove_session(session[:name], force: true)
+        end
+
+        old_sessions.length
+      end
+
+      private
+
+      def initialize_database
+        raise Sxn::ConfigurationError, "Project not initialized. Run 'sxn init' first." unless @config_manager.initialized?
+
+        db_path = File.join(File.dirname(@config_manager.config_path), "sessions.db")
+        Sxn::Database::SessionDatabase.new(db_path)
+      end
+
+      def validate_session_name!(name)
+        return if name.match?(/\A[a-zA-Z0-9_-]+\z/)
+
+        raise Sxn::InvalidSessionNameError,
+              "Session name must contain only letters, numbers, hyphens, and underscores"
+      end
+
+      def ensure_sessions_folder_exists!
+        sessions_folder = @config_manager.sessions_folder_path
+        raise Sxn::ConfigurationError, "Sessions folder not configured" unless sessions_folder
+
+        FileUtils.mkdir_p(sessions_folder)
+      end
+
+      def format_session_data(db_row)
+        metadata = db_row[:metadata] || {}
+
+        {
+          id: db_row[:id],
+          name: db_row[:name],
+          path: File.join(@config_manager.sessions_folder_path, db_row[:name]),
+          created_at: db_row[:created_at],
+          updated_at: db_row[:updated_at],
+          status: db_row[:status],
+          description: metadata["description"] || db_row[:description],
+          linear_task: metadata["linear_task"] || db_row[:linear_task],
+          # Support both metadata and database columns for backward compatibility
+          projects: db_row[:projects] || metadata["projects"] || [],
+          worktrees: db_row[:worktrees] || metadata["worktrees"] || {}
+        }
+      end
+
+      def update_session_status(session_id, status, **additional_options)
+        updates = { status: status }
+
+        # Put additional options into metadata if provided
+        if additional_options.any?
+          current_session = @database.get_session(session_id)
+          current_metadata = current_session[:metadata] || {}
+          updates[:metadata] = current_metadata.merge(additional_options)
+        end
+
+        @database.update_session(session_id, updates)
+      end
+
+      def update_session_status_by_name(name, status, **additional_options)
+        session = get_session(name)
+        raise Sxn::SessionNotFoundError, "Session '#{name}' not found" unless session
+
+        updates = { status: status }
+
+        # Put additional options into metadata if provided
+        if additional_options.any?
+          current_session = @database.get_session(session[:id])
+          current_metadata = current_session[:metadata] || {}
+          updates[:metadata] = current_metadata.merge(additional_options)
+        end
+
+        @database.update_session(session[:id], updates)
+      end
+
+      def find_uncommitted_worktrees(session)
+        worktrees = session[:worktrees] || {}
+        uncommitted = []
+
+        worktrees.each do |project, worktree_info|
+          path = worktree_info[:path] || worktree_info["path"]
+
+          # If directory doesn't exist, skip it (not uncommitted, just missing)
+          next unless File.directory?(path)
+
+          begin
+            Dir.chdir(path) do
+              # Check for staged changes
+              staged = !system("git diff-index --quiet --cached HEAD", out: File::NULL, err: File::NULL)
+              # Check for unstaged changes
+              unstaged = !system("git diff-files --quiet", out: File::NULL, err: File::NULL)
+              # Check for untracked files
+              untracked_output = `git ls-files --others --exclude-standard 2>/dev/null`
+              untracked = !untracked_output.empty?
+
+              uncommitted << project if staged || unstaged || untracked
+            end
+          rescue StandardError
+            # If we can't check git status, assume it has changes to be safe
+            uncommitted << project
+          end
+        end
+
+        uncommitted
+      end
+
+      def remove_session_worktrees(session)
+        worktrees = session[:worktrees] || {}
+
+        worktrees.each do |project, worktree_info|
+          path = worktree_info[:path] || worktree_info["path"]
+          next unless File.directory?(path)
+
+          begin
+            # Remove git worktree
+            parent_repo = find_parent_repository(path)
+            if parent_repo
+              Dir.chdir(parent_repo) do
+                success = system("git worktree remove #{Shellwords.escape(path)}",
+                                 out: File::NULL, err: File::NULL)
+                warn "Warning: Could not cleanly remove git worktree for #{project}: git command failed" unless success
+              end
+            end
+          rescue StandardError => e
+            # Log error but continue with removal
+            warn "Warning: Could not cleanly remove git worktree for #{project}: #{e.message}"
+          end
+
+          # Remove directory if it still exists
+          FileUtils.rm_rf(path)
+        end
+      end
+
+      def find_parent_repository(worktree_path)
+        # Try to find the parent repository by looking for .git/worktrees reference
+        git_file = File.join(worktree_path, ".git")
+        return nil unless File.exist?(git_file)
+
+        content = File.read(git_file).strip
+        if content.start_with?("gitdir:")
+          git_dir = content.sub(/^gitdir:\s*/, "")
+          # Extract parent repo from worktrees path
+          git_dir.split("/worktrees/").first if git_dir.include?("/worktrees/")
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/sxn/core/worktree_manager.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "English"
+require "shellwords"
+require "fileutils"
+
+module Sxn
+  module Core
+    # Manages git worktree operations
+    class WorktreeManager
+      def initialize(config_manager = nil, session_manager = nil)
+        @config_manager = config_manager || ConfigManager.new
+        @session_manager = session_manager || SessionManager.new(@config_manager)
+        @project_manager = ProjectManager.new(@config_manager)
+      end
+
+      def add_worktree(project_name, branch = nil, session_name: nil)
+        # Use current session if not specified
+        session_name ||= @config_manager.current_session
+        raise Sxn::NoActiveSessionError, "No active session. Use 'sxn use <session>' first." unless session_name
+
+        session = @session_manager.get_session(session_name)
+        raise Sxn::SessionNotFoundError, "Session '#{session_name}' not found" unless session
+
+        project = @project_manager.get_project(project_name)
+        raise Sxn::ProjectNotFoundError, "Project '#{project_name}' not found" unless project
+
+        # Use default branch if not specified
+        branch ||= project[:default_branch] || "master"
+
+        # Check if worktree already exists in this session
+        existing_worktrees = @session_manager.get_session_worktrees(session_name)
+        if existing_worktrees[project_name]
+          raise Sxn::WorktreeExistsError,
+                "Worktree for '#{project_name}' already exists in session '#{session_name}'"
+        end
+
+        # Create worktree path
+        worktree_path = File.join(session[:path], project_name)
+
+        begin
+          # Create the worktree
+          create_git_worktree(project[:path], worktree_path, branch)
+
+          # Register worktree with session
+          @session_manager.add_worktree_to_session(session_name, project_name, worktree_path, branch)
+
+          {
+            project: project_name,
+            branch: branch,
+            path: worktree_path,
+            session: session_name
+          }
+        rescue StandardError => e
+          # Clean up on failure
+          FileUtils.rm_rf(worktree_path)
+          raise Sxn::WorktreeCreationError, "Failed to create worktree: #{e.message}"
+        end
+      end
+
+      def remove_worktree(project_name, session_name: nil)
+        # Use current session if not specified
+        session_name ||= @config_manager.current_session
+        raise Sxn::NoActiveSessionError, "No active session. Use 'sxn use <session>' first." unless session_name
+
+        session = @session_manager.get_session(session_name)
+        raise Sxn::SessionNotFoundError, "Session '#{session_name}' not found" unless session
+
+        worktrees = @session_manager.get_session_worktrees(session_name)
+        worktree_info = worktrees[project_name]
+        unless worktree_info
+          raise Sxn::WorktreeNotFoundError,
+                "Worktree for '#{project_name}' not found in session '#{session_name}'"
+        end
+
+        worktree_path = worktree_info[:path] || worktree_info["path"]
+
+        begin
+          # Remove git worktree
+          project = @project_manager.get_project(project_name)
+          if project
+            remove_git_worktree(project[:path], worktree_path)
+          else
+            # Project might have been removed, try to find parent repo
+            remove_git_worktree_by_path(worktree_path)
+          end
+
+          # Remove from session
+          @session_manager.remove_worktree_from_session(session_name, project_name)
+
+          true
+        rescue StandardError => e
+          raise Sxn::WorktreeRemovalError, "Failed to remove worktree: #{e.message}"
+        end
+      end
+
+      def list_worktrees(session_name: nil)
+        # Use current session if not specified
+        session_name ||= @config_manager.current_session
+        return [] unless session_name
+
+        session = @session_manager.get_session(session_name)
+        return [] unless session
+
+        worktrees_data = @session_manager.get_session_worktrees(session_name)
+
+        worktrees_data.map do |project_name, worktree_info|
+          {
+            project: project_name,
+            branch: worktree_info[:branch] || worktree_info["branch"],
+            path: worktree_info[:path] || worktree_info["path"],
+            created_at: worktree_info[:created_at] || worktree_info["created_at"],
+            exists: File.directory?(worktree_info[:path] || worktree_info["path"]),
+            status: get_worktree_status(worktree_info[:path] || worktree_info["path"])
+          }
+        end
+      end
+
+      def get_worktree(project_name, session_name: nil)
+        worktrees = list_worktrees(session_name: session_name)
+        worktrees.find { |w| w[:project] == project_name }
+      end
+
+      # Check if a worktree exists for a project
+      def worktree_exists?(project_name, session_name: nil)
+        get_worktree(project_name, session_name: session_name) != nil
+      end
+
+      # Get the path to a worktree for a project
+      def worktree_path(project_name, session_name: nil)
+        worktree = get_worktree(project_name, session_name: session_name)
+        worktree&.fetch(:path, nil)
+      end
+
+      # Validate worktree name (expected by tests)
+      def validate_worktree_name(name)
+        return true if name.match?(/\A[a-zA-Z0-9_-]+\z/)
+
+        raise Sxn::WorktreeError, "Invalid worktree name: #{name}"
+      end
+
+      # Execute git command (mock point for tests)
+      def execute_git_command(*)
+        system(*)
+      end
+
+      def validate_worktree(project_name, session_name: nil)
+        worktree = get_worktree(project_name, session_name: session_name)
+        return { valid: false, issues: ["Worktree not found"] } unless worktree
+
+        issues = []
+
+        # Check if directory exists
+        issues << "Worktree directory does not exist: #{worktree[:path]}" unless File.directory?(worktree[:path])
+
+        # Check if it's a valid git worktree
+        issues << "Directory is not a valid git worktree" unless valid_git_worktree?(worktree[:path])
+
+        # Check for git issues
+        git_issues = check_git_status(worktree[:path])
+        issues.concat(git_issues)
+
+        {
+          valid: issues.empty?,
+          issues: issues,
+          worktree: worktree
+        }
+      end
+
+      private
+
+      def create_git_worktree(project_path, worktree_path, branch)
+        Dir.chdir(project_path) do
+          # Check if branch exists
+          branch_exists = system("git show-ref --verify --quiet refs/heads/#{Shellwords.escape(branch)}",
+                                 out: File::NULL, err: File::NULL)
+
+          cmd = if branch_exists
+                  # Branch exists, create worktree from existing branch
+                  ["git", "worktree", "add", worktree_path, branch]
+                else
+                  # Branch doesn't exist, create new branch
+                  ["git", "worktree", "add", "-b", branch, worktree_path]
+                end
+
+          success = system(*cmd, out: File::NULL, err: File::NULL)
+          raise "Git worktree command failed" unless success
+        end
+      end
+
+      def remove_git_worktree(project_path, worktree_path)
+        Dir.chdir(project_path) do
+          # Remove worktree
+          cmd = ["git", "worktree", "remove", "--force", worktree_path]
+          system(*cmd, out: File::NULL, err: File::NULL)
+        end
+
+        # Clean up directory if it still exists
+        FileUtils.rm_rf(worktree_path)
+      end
+
+      def remove_git_worktree_by_path(worktree_path)
+        # Try to find parent repository from .git file
+        git_file = File.join(worktree_path, ".git")
+        if File.exist?(git_file)
+          content = File.read(git_file).strip
+          if content.start_with?("gitdir:")
+            git_dir = content.sub(/^gitdir:\s*/, "")
+            parent_repo = git_dir.split("/worktrees/").first if git_dir.include?("/worktrees/")
+
+            # Ensure parent_repo is a valid absolute path and the directory exists
+            if parent_repo && File.absolute_path?(parent_repo) && File.directory?(parent_repo)
+              begin
+                Dir.chdir(parent_repo) do
+                  cmd = ["git", "worktree", "remove", "--force", worktree_path]
+                  system(*cmd, out: File::NULL, err: File::NULL)
+                end
+              rescue Errno::ENOENT
+                # Directory doesn't exist or can't be accessed, skip git command
+              end
+            end
+          end
+        end
+
+        # Clean up directory
+        FileUtils.rm_rf(worktree_path)
+      end
+
+      def get_worktree_status(path)
+        return "missing" unless File.directory?(path)
+        return "invalid" unless valid_git_worktree?(path)
+
+        Dir.chdir(path) do
+          # Check for staged changes
+          staged = !system("git diff-index --quiet --cached HEAD", out: File::NULL, err: File::NULL)
+          return "staged" if staged
+
+          # Check for unstaged changes
+          unstaged = !system("git diff-files --quiet", out: File::NULL, err: File::NULL)
+          return "modified" if unstaged
+
+          # Check for untracked files
+          untracked = !system("git ls-files --others --exclude-standard --quiet", out: File::NULL, err: File::NULL)
+          return "untracked" if untracked
+
+          "clean"
+        end
+      rescue StandardError
+        "error"
+      end
+
+      def valid_git_worktree?(path)
+        File.exist?(File.join(path, ".git"))
+      end
+
+      def check_git_status(path)
+        return ["Directory does not exist"] unless File.directory?(path)
+        return ["Not a git repository"] unless valid_git_worktree?(path)
+
+        issues = []
+
+        begin
+          Dir.chdir(path) do
+            # Check if we can access git status
+            unless system("git status --porcelain", out: File::NULL, err: File::NULL)
+              issues << "Cannot access git status (possible repository corruption)"
+            end
+
+            # Check for detached HEAD
+            `git symbolic-ref -q HEAD 2>/dev/null`
+            issues << "Repository is in detached HEAD state" if $CHILD_STATUS.exitstatus != 0
+          end
+        rescue StandardError => e
+          issues << "Error checking git status: #{e.message}"
+        end
+
+        issues
+      end
+    end
+  end
+end

data/lib/sxn/core.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "core/config_manager"
+require_relative "core/session_manager"
+require_relative "core/project_manager"
+require_relative "core/worktree_manager"
+require_relative "core/rules_manager"
+
+module Sxn
+  # Core business logic namespace
+  module Core
+  end
+end

data/lib/sxn/database/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+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