sxn 0.2.0

data/lib/sxn/commands/sessions.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Sxn
+  module Commands
+    # Manage development sessions
+    class Sessions < Thor
+      include Thor::Actions
+
+      def initialize(args = ARGV, local_options = {}, config = {})
+        super
+        @ui = Sxn::UI::Output.new
+        @prompt = Sxn::UI::Prompt.new
+        @table = Sxn::UI::Table.new
+        @config_manager = Sxn::Core::ConfigManager.new
+        @session_manager = Sxn::Core::SessionManager.new(@config_manager)
+      end
+
+      desc "add NAME", "Create a new session"
+      option :description, type: :string, aliases: "-d", desc: "Session description"
+      option :linear_task, type: :string, aliases: "-l", desc: "Linear task ID"
+      option :activate, type: :boolean, default: true, desc: "Activate session after creation"
+
+      def add(name = nil)
+        ensure_initialized!
+
+        # Get session name interactively if not provided
+        if name.nil?
+          existing_sessions = @session_manager.list_sessions.map { |s| s[:name] }
+          name = @prompt.session_name(existing_sessions: existing_sessions)
+        end
+
+        begin
+          @ui.progress_start("Creating session '#{name}'")
+
+          session = @session_manager.create_session(
+            name,
+            description: options[:description],
+            linear_task: options[:linear_task]
+          )
+
+          @ui.progress_done
+          @ui.success("Created session '#{name}'")
+
+          if options[:activate]
+            @session_manager.use_session(name)
+            @ui.success("Activated session '#{name}'")
+          end
+
+          display_session_info(session)
+        rescue Sxn::Error => e
+          @ui.progress_failed
+          @ui.error(e.message)
+          exit(e.exit_code)
+        rescue StandardError => e
+          @ui.progress_failed
+          @ui.error("Unexpected error: #{e.message}")
+          @ui.debug(e.backtrace.join("\n")) if ENV["SXN_DEBUG"]
+          exit(1)
+        end
+      end
+
+      desc "remove NAME", "Remove a session"
+      option :force, type: :boolean, aliases: "-f", desc: "Force removal even with uncommitted changes"
+
+      def remove(name = nil)
+        ensure_initialized!
+
+        # Interactive selection if name not provided
+        if name.nil?
+          sessions = @session_manager.list_sessions
+          if sessions.empty?
+            @ui.empty_state("No sessions found")
+            return
+          end
+
+          choices = sessions.map { |s| { name: s[:name], value: s[:name] } }
+          name = @prompt.select("Select session to remove:", choices)
+        end
+
+        unless @prompt.confirm_deletion(name, "session")
+          @ui.info("Cancelled")
+          return
+        end
+
+        begin
+          @ui.progress_start("Removing session '#{name}'")
+          @session_manager.remove_session(name, force: options[:force])
+          @ui.progress_done
+          @ui.success("Removed session '#{name}'")
+        rescue Sxn::SessionHasChangesError => e
+          @ui.progress_failed
+          @ui.error(e.message)
+          @ui.recovery_suggestion("Use --force to remove anyway, or commit/stash changes first")
+          exit(e.exit_code)
+        rescue Sxn::Error => e
+          @ui.progress_failed
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "list", "List all sessions"
+      option :status, type: :string, enum: %w[active inactive archived], desc: "Filter by status"
+      option :limit, type: :numeric, default: 50, desc: "Maximum number of sessions to show"
+
+      def list
+        ensure_initialized!
+
+        begin
+          sessions = @session_manager.list_sessions(
+            status: options[:status],
+            limit: options[:limit]
+          )
+
+          @ui.section("Sessions")
+
+          if sessions.empty?
+            @ui.empty_state("No sessions found")
+            suggest_create_session
+          else
+            @table.sessions(sessions)
+            @ui.newline
+            @ui.info("Total: #{sessions.size} sessions")
+
+            current = @session_manager.current_session
+            if current
+              @ui.info("Current: #{current[:name]}")
+            else
+              @ui.recovery_suggestion("Use 'sxn use <session>' to activate a session")
+            end
+          end
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "use NAME", "Switch to a session"
+      def use(name = nil)
+        ensure_initialized!
+
+        # Interactive selection if name not provided
+        if name.nil?
+          sessions = @session_manager.list_sessions(status: "active")
+          if sessions.empty?
+            @ui.empty_state("No active sessions found")
+            suggest_create_session
+            return
+          end
+
+          choices = sessions.map do |s|
+            { name: "#{s[:name]} - #{s[:description] || "No description"}", value: s[:name] }
+          end
+          name = @prompt.select("Select session to activate:", choices)
+        end
+
+        begin
+          session = @session_manager.use_session(name)
+          @ui.success("Activated session '#{name}'")
+          display_session_info(session)
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "current", "Show current session"
+      option :verbose, type: :boolean, aliases: "-v", desc: "Show detailed information"
+
+      def current
+        ensure_initialized!
+
+        begin
+          session = @session_manager.current_session
+
+          if session.nil?
+            @ui.info("No active session")
+            suggest_create_session
+            return
+          end
+
+          @ui.section("Current Session")
+          display_session_info(session, verbose: options[:verbose])
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "archive NAME", "Archive a session"
+      def archive(name = nil)
+        ensure_initialized!
+
+        if name.nil?
+          active_sessions = @session_manager.list_sessions(status: "active")
+          if active_sessions.empty?
+            @ui.empty_state("No active sessions to archive")
+            return
+          end
+
+          choices = active_sessions.map { |s| { name: s[:name], value: s[:name] } }
+          name = @prompt.select("Select session to archive:", choices)
+        end
+
+        begin
+          @session_manager.archive_session(name)
+          @ui.success("Archived session '#{name}'")
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "activate NAME", "Activate an archived session"
+      def activate(name = nil)
+        ensure_initialized!
+
+        if name.nil?
+          archived_sessions = @session_manager.list_sessions(status: "archived")
+          if archived_sessions.empty?
+            @ui.empty_state("No archived sessions to activate")
+            return
+          end
+
+          choices = archived_sessions.map { |s| { name: s[:name], value: s[:name] } }
+          name = @prompt.select("Select session to activate:", choices)
+        end
+
+        begin
+          @session_manager.activate_session(name)
+          @ui.success("Activated session '#{name}'")
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      private
+
+      def ensure_initialized!
+        return if @config_manager.initialized?
+
+        @ui.error("Project not initialized")
+        @ui.recovery_suggestion("Run 'sxn init' to initialize sxn in this project")
+        exit(1)
+      end
+
+      def display_session_info(session, verbose: false)
+        return unless session
+
+        @ui.newline
+        @ui.key_value("Name", session[:name] || "Unknown")
+        @ui.key_value("Status", (session[:status] || "unknown").capitalize)
+        @ui.key_value("Path", session[:path] || "Unknown")
+
+        @ui.key_value("Description", session[:description]) if session[:description]
+
+        @ui.key_value("Linear Task", session[:linear_task]) if session[:linear_task]
+
+        @ui.key_value("Created", session[:created_at] || "Unknown")
+        @ui.key_value("Updated", session[:updated_at] || "Unknown")
+
+        if verbose && session[:projects]&.any?
+          @ui.newline
+          @ui.subsection("Projects")
+          session[:projects].each { |project| @ui.list_item(project) }
+        end
+
+        @ui.newline
+        display_session_commands(session[:name]) if session[:name]
+      end
+
+      def display_session_commands(session_name)
+        @ui.subsection("Available Commands")
+
+        @ui.command_example(
+          "sxn worktree add <project> [branch]",
+          "Add a worktree to this session"
+        )
+
+        @ui.command_example(
+          "sxn worktree list",
+          "List worktrees in this session"
+        )
+
+        @ui.command_example(
+          "cd #{@session_manager.get_session(session_name)[:path]}",
+          "Navigate to session directory"
+        )
+      end
+
+      def suggest_create_session
+        @ui.newline
+        @ui.recovery_suggestion("Create your first session with 'sxn add <session-name>'")
+      end
+    end
+  end
+end

data/lib/sxn/commands/worktrees.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Sxn
+  module Commands
+    # Manage git worktrees
+    class Worktrees < Thor
+      include Thor::Actions
+
+      def initialize(args = ARGV, local_options = {}, config = {})
+        super
+        @ui = Sxn::UI::Output.new
+        @prompt = Sxn::UI::Prompt.new
+        @table = Sxn::UI::Table.new
+        @config_manager = Sxn::Core::ConfigManager.new
+        @project_manager = Sxn::Core::ProjectManager.new(@config_manager)
+        @session_manager = Sxn::Core::SessionManager.new(@config_manager)
+        @worktree_manager = Sxn::Core::WorktreeManager.new(@config_manager, @session_manager)
+      end
+
+      desc "add PROJECT [BRANCH]", "Add worktree to current session"
+      option :session, type: :string, aliases: "-s", desc: "Target session (defaults to current)"
+      option :apply_rules, type: :boolean, default: true, desc: "Apply project rules after creation"
+      option :interactive, type: :boolean, aliases: "-i", desc: "Interactive mode"
+
+      def add(project_name = nil, branch = nil)
+        ensure_initialized!
+
+        # Interactive selection if project not provided
+        if options[:interactive] || project_name.nil?
+          project_name = select_project("Select project for worktree:")
+          return if project_name.nil?
+        end
+
+        # Interactive branch selection if not provided
+        if options[:interactive] && branch.nil?
+          project = @project_manager.get_project(project_name)
+          branch = @prompt.branch_name("Enter branch name:", default: project[:default_branch])
+        end
+
+        session_name = options[:session] || @config_manager.current_session
+        unless session_name
+          @ui.error("No active session")
+          @ui.recovery_suggestion("Use 'sxn use <session>' or specify --session")
+          exit(1)
+        end
+
+        begin
+          @ui.progress_start("Creating worktree for #{project_name}")
+
+          worktree = @worktree_manager.add_worktree(
+            project_name,
+            branch,
+            session_name: session_name
+          )
+
+          @ui.progress_done
+          @ui.success("Created worktree for #{project_name}")
+
+          display_worktree_info(worktree)
+
+          # Apply rules if requested
+          apply_project_rules(project_name, session_name) if options[:apply_rules]
+        rescue Sxn::Error => e
+          @ui.progress_failed
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "remove PROJECT", "Remove worktree from current session"
+      option :session, type: :string, aliases: "-s", desc: "Target session (defaults to current)"
+      option :force, type: :boolean, aliases: "-f", desc: "Force removal even with uncommitted changes"
+
+      def remove(project_name = nil)
+        ensure_initialized!
+
+        session_name = options[:session] || @config_manager.current_session
+        unless session_name
+          @ui.error("No active session")
+          @ui.recovery_suggestion("Use 'sxn use <session>' or specify --session")
+          exit(1)
+        end
+
+        # Interactive selection if project not provided
+        if project_name.nil?
+          worktrees = @worktree_manager.list_worktrees(session_name: session_name)
+          if worktrees.empty?
+            @ui.empty_state("No worktrees in current session")
+            suggest_add_worktree
+            return
+          end
+
+          choices = worktrees.map do |w|
+            { name: "#{w[:project]} (#{w[:branch]})", value: w[:project] }
+          end
+          project_name = @prompt.select("Select worktree to remove:", choices)
+        end
+
+        # Check for uncommitted changes unless forced
+        unless options[:force]
+          worktree = @worktree_manager.get_worktree(project_name, session_name: session_name)
+          if worktree && worktree[:status] != "clean" && !@prompt.ask_yes_no(
+            "Worktree has uncommitted changes. Continue?", default: false
+          )
+            @ui.info("Cancelled")
+            return
+          end
+        end
+
+        unless @prompt.confirm_deletion(project_name, "worktree")
+          @ui.info("Cancelled")
+          return
+        end
+
+        begin
+          @ui.progress_start("Removing worktree for #{project_name}")
+          @worktree_manager.remove_worktree(project_name, session_name: session_name)
+          @ui.progress_done
+          @ui.success("Removed worktree for #{project_name}")
+        rescue Sxn::Error => e
+          @ui.progress_failed
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "list", "List worktrees in current session"
+      option :session, type: :string, aliases: "-s", desc: "Target session (defaults to current)"
+      option :validate, type: :boolean, aliases: "-v", desc: "Validate worktree status"
+      option :all_sessions, type: :boolean, aliases: "-a", desc: "List worktrees from all sessions"
+
+      def list
+        ensure_initialized!
+
+        if options[:all_sessions]
+          list_all_worktrees
+        else
+          list_session_worktrees
+        end
+      end
+
+      desc "validate PROJECT", "Validate a worktree"
+      option :session, type: :string, aliases: "-s", desc: "Target session (defaults to current)"
+
+      def validate(project_name = nil)
+        ensure_initialized!
+
+        session_name = options[:session] || @config_manager.current_session
+        unless session_name
+          @ui.error("No active session")
+          exit(1)
+        end
+
+        # Interactive selection if project not provided
+        if project_name.nil?
+          worktrees = @worktree_manager.list_worktrees(session_name: session_name)
+          if worktrees.empty?
+            @ui.empty_state("No worktrees in current session")
+            return
+          end
+
+          choices = worktrees.map do |w|
+            { name: "#{w[:project]} (#{w[:branch]})", value: w[:project] }
+          end
+          project_name = @prompt.select("Select worktree to validate:", choices)
+        end
+
+        begin
+          result = @worktree_manager.validate_worktree(project_name, session_name: session_name)
+
+          @ui.section("Worktree Validation: #{project_name}")
+
+          if result[:valid]
+            @ui.success("Worktree is valid")
+          else
+            @ui.error("Worktree has issues:")
+            result[:issues].each { |issue| @ui.list_item(issue) }
+          end
+
+          display_worktree_info(result[:worktree], detailed: true) if result[:worktree]
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      desc "status", "Show status of all worktrees in current session"
+      option :session, type: :string, aliases: "-s", desc: "Target session (defaults to current)"
+
+      def status
+        ensure_initialized!
+
+        session_name = options[:session] || @config_manager.current_session
+        unless session_name
+          @ui.error("No active session")
+          exit(1)
+        end
+
+        begin
+          worktrees = @worktree_manager.list_worktrees(session_name: session_name)
+
+          @ui.section("Worktree Status - Session: #{session_name}")
+
+          if worktrees.empty?
+            @ui.empty_state("No worktrees in current session")
+            suggest_add_worktree
+          else
+            display_worktree_status(worktrees)
+          end
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      private
+
+      def ensure_initialized!
+        return if @config_manager.initialized?
+
+        @ui.error("Project not initialized")
+        @ui.recovery_suggestion("Run 'sxn init' to initialize sxn in this project")
+        exit(1)
+      end
+
+      def select_project(message)
+        projects = @project_manager.list_projects
+        if projects.empty?
+          @ui.empty_state("No projects configured")
+          @ui.recovery_suggestion("Add projects with 'sxn projects add <name> <path>'")
+          return nil
+        end
+
+        choices = projects.map do |p|
+          { name: "#{p[:name]} (#{p[:type]}) - #{p[:path]}", value: p[:name] }
+        end
+        @prompt.select(message, choices)
+      end
+
+      def list_session_worktrees
+        session_name = options[:session] || @config_manager.current_session
+        unless session_name
+          @ui.error("No active session")
+          @ui.recovery_suggestion("Use 'sxn use <session>' or specify --session")
+          exit(1)
+        end
+
+        begin
+          worktrees = @worktree_manager.list_worktrees(session_name: session_name)
+
+          @ui.section("Worktrees - Session: #{session_name}")
+
+          if worktrees.empty?
+            @ui.empty_state("No worktrees in current session")
+            suggest_add_worktree
+          elsif options[:validate]
+            list_with_validation(worktrees, session_name)
+          else
+            @table.worktrees(worktrees)
+            @ui.newline
+            @ui.info("Total: #{worktrees.size} worktrees")
+          end
+        rescue Sxn::Error => e
+          @ui.error(e.message)
+          exit(e.exit_code)
+        end
+      end
+
+      def list_all_worktrees
+        sessions = @session_manager.list_sessions(status: "active")
+
+        @ui.section("All Worktrees")
+
+        if sessions.empty?
+          @ui.empty_state("No active sessions")
+          return
+        end
+
+        sessions.each do |session|
+          worktrees = @worktree_manager.list_worktrees(session_name: session[:name])
+          next if worktrees.empty?
+
+          @ui.subsection("Session: #{session[:name]}")
+          @table.worktrees(worktrees)
+          @ui.newline
+        end
+      rescue Sxn::Error => e
+        @ui.error(e.message)
+        exit(e.exit_code)
+      end
+
+      def list_with_validation(worktrees, session_name)
+        @ui.subsection("Worktree Validation")
+
+        Sxn::UI::ProgressBar.with_progress("Validating worktrees", worktrees) do |worktree, progress|
+          validation = @worktree_manager.validate_worktree(
+            worktree[:project],
+            session_name: session_name
+          )
+
+          status = validation[:valid] ? "✅" : "❌"
+          progress.log("#{status} #{worktree[:project]}")
+
+          unless validation[:valid]
+            validation[:issues].each do |issue|
+              progress.log("   - #{issue}")
+            end
+          end
+
+          validation
+        end
+
+        @ui.newline
+        @table.worktrees(worktrees)
+      end
+
+      def display_worktree_info(worktree, detailed: false)
+        @ui.newline
+        @ui.key_value("Project", worktree[:project])
+        @ui.key_value("Branch", worktree[:branch])
+        @ui.key_value("Path", worktree[:path])
+        @ui.key_value("Session", worktree[:session]) if worktree[:session]
+
+        if detailed
+          @ui.key_value("Created", worktree[:created_at]) if worktree[:created_at]
+          @ui.key_value("Exists", worktree[:exists] ? "Yes" : "No")
+          @ui.key_value("Status", worktree[:status]) if worktree[:status]
+        end
+
+        @ui.newline
+        display_worktree_commands(worktree)
+      end
+
+      def display_worktree_commands(worktree)
+        @ui.subsection("Available Commands")
+
+        @ui.command_example(
+          "cd #{worktree[:path]}",
+          "Navigate to worktree directory"
+        )
+
+        if worktree[:project]
+          @ui.command_example(
+            "sxn rules apply #{worktree[:project]}",
+            "Apply project rules to this worktree"
+          )
+        end
+
+        @ui.command_example(
+          "sxn worktree validate #{worktree[:project]}",
+          "Validate this worktree"
+        )
+      end
+
+      def display_worktree_status(worktrees)
+        clean_count = worktrees.count { |w| w[:status] == "clean" }
+        modified_count = worktrees.count { |w| w[:status] == "modified" }
+        missing_count = worktrees.count { |w| !w[:exists] }
+
+        @table.worktrees(worktrees)
+        @ui.newline
+
+        @ui.info("Summary:")
+        @ui.key_value("  Clean", clean_count, indent: 2)
+        @ui.key_value("  Modified", modified_count, indent: 2) if modified_count.positive?
+        @ui.key_value("  Missing", missing_count, indent: 2) if missing_count.positive?
+        @ui.key_value("  Total", worktrees.size, indent: 2)
+
+        if modified_count.positive?
+          @ui.newline
+          @ui.warning("#{modified_count} worktrees have uncommitted changes")
+        end
+
+        return unless missing_count.positive?
+
+        @ui.newline
+        @ui.error("#{missing_count} worktrees are missing from filesystem")
+      end
+
+      def apply_project_rules(project_name, session_name)
+        rules_manager = Sxn::Core::RulesManager.new(@config_manager, @project_manager)
+
+        begin
+          @ui.newline
+          @ui.subsection("Applying Project Rules")
+
+          @ui.progress_start("Applying rules for #{project_name}")
+          results = rules_manager.apply_rules(project_name, session_name)
+          @ui.progress_done
+
+          if results[:success]
+            @ui.success("Applied #{results[:applied_count]} rules successfully")
+          else
+            @ui.warning("Some rules failed to apply")
+            results[:errors].each { |error| @ui.error("  #{error}") }
+          end
+        rescue StandardError => e
+          @ui.warning("Could not apply rules: #{e.message}")
+          @ui.recovery_suggestion("Apply rules manually with 'sxn rules apply #{project_name}'")
+        end
+      end
+
+      def suggest_add_worktree
+        current_session = @config_manager.current_session
+        @ui.newline
+        if current_session
+          @ui.recovery_suggestion("Add worktrees with 'sxn worktree add <project> [branch]'")
+        else
+          @ui.recovery_suggestion("Create and activate a session first with 'sxn add <session>'")
+        end
+      end
+    end
+  end
+end