sxn 0.2.5 → 0.4.0

data/lib/sxn/commands/mcp.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+require "English"
+
+module Sxn
+  module Commands
+    # Manage MCP server for Claude Code integration
+    class MCP < Thor
+      include Thor::Actions
+
+      def initialize(args = ARGV, local_options = {}, config = {})
+        super
+        @ui = Sxn::UI::Output.new
+      end
+
+      desc "install", "Install sxn MCP server to Claude Code"
+      option :project, type: :boolean, aliases: "-p", desc: "Install to project .mcp.json instead of user config"
+      def install
+        sxn_mcp_path = find_sxn_mcp_executable
+
+        if sxn_mcp_path.nil?
+          @ui.error("Could not find sxn-mcp executable")
+          @ui.recovery_suggestion("Ensure the sxn gem is properly installed")
+          exit(1)
+        end
+
+        if options[:project]
+          install_to_project(sxn_mcp_path)
+        else
+          install_to_claude_code(sxn_mcp_path)
+        end
+      end
+
+      desc "uninstall", "Remove sxn MCP server from Claude Code"
+      option :project, type: :boolean, aliases: "-p", desc: "Remove from project .mcp.json"
+      def uninstall
+        if options[:project]
+          uninstall_from_project
+        else
+          uninstall_from_claude_code
+        end
+      end
+
+      desc "status", "Check if sxn MCP server is installed"
+      def status
+        @ui.section("MCP Server Status")
+
+        claude_installed = check_claude_installation
+        project_installed = check_project_installation
+
+        @ui.newline
+        @ui.key_value("Claude Code (user)", claude_installed ? "Installed" : "Not installed")
+        @ui.key_value("Project (.mcp.json)", project_installed ? "Installed" : "Not installed")
+
+        sxn_mcp_path = find_sxn_mcp_executable
+        @ui.newline
+        if sxn_mcp_path
+          @ui.key_value("Executable", sxn_mcp_path)
+        else
+          @ui.warning("sxn-mcp executable not found in PATH")
+        end
+
+        @ui.newline
+        display_install_commands unless claude_installed || project_installed
+      end
+
+      desc "server", "Run the MCP server directly (for testing)"
+      option :transport, type: :string, default: "stdio", enum: %w[stdio http], desc: "Transport type"
+      option :port, type: :numeric, default: 3000, desc: "Port for HTTP transport"
+      def server
+        require "sxn/mcp"
+
+        mcp_server = Sxn::MCP::Server.new
+
+        case options[:transport]
+        when "stdio"
+          @ui.info("Starting MCP server with STDIO transport...")
+          mcp_server.run_stdio
+        when "http"
+          @ui.info("Starting MCP server on port #{options[:port]}...")
+          mcp_server.run_http(port: options[:port])
+        end
+      end
+
+      private
+
+      def find_sxn_mcp_executable
+        # Check if sxn-mcp is in PATH
+        path = `which sxn-mcp 2>/dev/null`.strip
+        return path unless path.empty?
+
+        # Check relative to this gem's installation
+        gem_bin_path = File.expand_path("../../../bin/sxn-mcp", __dir__)
+        return gem_bin_path if File.exist?(gem_bin_path)
+
+        nil
+      end
+
+      def install_to_claude_code(sxn_mcp_path)
+        unless claude_cli_available?
+          @ui.error("Claude CLI not found")
+          @ui.recovery_suggestion("Install Claude Code CLI first: https://claude.ai/code")
+          exit(1)
+        end
+
+        @ui.progress_start("Installing sxn MCP server to Claude Code")
+
+        # claude mcp add --transport stdio sxn -- /path/to/sxn-mcp
+        success = system("claude", "mcp", "add", "--transport", "stdio", "sxn", "--", sxn_mcp_path)
+
+        if success
+          @ui.progress_done
+          @ui.success("sxn MCP server installed to Claude Code")
+          @ui.info("Restart Claude Code to use the new server")
+        else
+          @ui.progress_failed
+          @ui.error("Failed to install MCP server")
+          @ui.recovery_suggestion("Try running manually: claude mcp add --transport stdio sxn -- #{sxn_mcp_path}")
+          exit(1)
+        end
+      end
+
+      def install_to_project(sxn_mcp_path)
+        mcp_json_path = File.join(Dir.pwd, ".mcp.json")
+
+        mcp_config = if File.exist?(mcp_json_path)
+                       JSON.parse(File.read(mcp_json_path))
+                     else
+                       { "mcpServers" => {} }
+                     end
+
+        mcp_config["mcpServers"] ||= {}
+        mcp_config["mcpServers"]["sxn"] = {
+          "command" => sxn_mcp_path,
+          "args" => [],
+          "env" => { "SXN_WORKSPACE" => "${PWD}" }
+        }
+
+        File.write(mcp_json_path, JSON.pretty_generate(mcp_config))
+
+        @ui.success("Created/updated .mcp.json with sxn MCP server")
+        @ui.info("This file can be version controlled to share with your team")
+      end
+
+      def uninstall_from_claude_code
+        unless claude_cli_available?
+          @ui.error("Claude CLI not found")
+          exit(1)
+        end
+
+        @ui.progress_start("Removing sxn MCP server from Claude Code")
+
+        success = system("claude", "mcp", "remove", "sxn")
+
+        if success
+          @ui.progress_done
+          @ui.success("sxn MCP server removed from Claude Code")
+        else
+          @ui.progress_failed
+          @ui.error("Failed to remove MCP server (it may not be installed)")
+        end
+      end
+
+      def uninstall_from_project
+        mcp_json_path = File.join(Dir.pwd, ".mcp.json")
+
+        unless File.exist?(mcp_json_path)
+          @ui.info("No .mcp.json file found in current directory")
+          return
+        end
+
+        mcp_config = JSON.parse(File.read(mcp_json_path))
+
+        if mcp_config.dig("mcpServers", "sxn")
+          mcp_config["mcpServers"].delete("sxn")
+
+          if mcp_config["mcpServers"].empty?
+            File.delete(mcp_json_path)
+            @ui.success("Removed .mcp.json file (no servers remaining)")
+          else
+            File.write(mcp_json_path, JSON.pretty_generate(mcp_config))
+            @ui.success("Removed sxn from .mcp.json")
+          end
+        else
+          @ui.info("sxn not found in .mcp.json")
+        end
+      end
+
+      def check_claude_installation
+        return false unless claude_cli_available?
+
+        output = `claude mcp get sxn 2>/dev/null`
+        $CHILD_STATUS.success? && !output.strip.empty?
+      end
+
+      def check_project_installation
+        mcp_json_path = File.join(Dir.pwd, ".mcp.json")
+        return false unless File.exist?(mcp_json_path)
+
+        mcp_config = JSON.parse(File.read(mcp_json_path))
+        !mcp_config.dig("mcpServers", "sxn").nil?
+      rescue JSON::ParserError
+        false
+      end
+
+      def claude_cli_available?
+        system("which claude > /dev/null 2>&1")
+      end
+
+      def display_install_commands
+        @ui.subsection("Install Commands")
+        @ui.command_example("sxn mcp install", "Install to Claude Code (user scope)")
+        @ui.command_example("sxn mcp install --project", "Install to project .mcp.json")
+      end
+    end
+  end
+end

data/lib/sxn/commands/sessions.rb

@@ -19,12 +19,14 @@ module Sxn
         @session_manager = Sxn::Core::SessionManager.new(@config_manager)
         @project_manager = Sxn::Core::ProjectManager.new(@config_manager)
         @worktree_manager = Sxn::Core::WorktreeManager.new(@config_manager, @session_manager)
+        @template_manager = Sxn::Core::TemplateManager.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 :branch, type: :string, aliases: "-b", desc: "Default branch for worktrees"
+      option :template, type: :string, aliases: "-t", desc: "Template to use for worktree creation"
       option :activate, type: :boolean, default: true, desc: "Activate session after creation"
       option :skip_worktree, type: :boolean, default: false, desc: "Skip worktree creation wizard"
 
@@ -37,9 +39,29 @@ module Sxn
           name = @prompt.session_name(existing_sessions: existing_sessions)
         end
 
+        template_id = options[:template]
+
+        # Validate template if specified
+        if template_id
+          begin
+            @template_manager.validate_template(template_id)
+          rescue Sxn::SessionTemplateNotFoundError, Sxn::SessionTemplateValidationError => e
+            @ui.error(e.message)
+            exit(1)
+          end
+        end
+
         # Get default branch - use provided option, or prompt interactively
+        # Branch is required when using a template
         default_branch = options[:branch]
-        default_branch ||= @prompt.default_branch(session_name: name)
+        if default_branch.nil?
+          if template_id
+            @ui.error("Branch is required when using a template. Use -b/--branch to specify.")
+            exit(1)
+          else
+            default_branch = @prompt.default_branch(session_name: name)
+          end
+        end
 
         begin
           @ui.progress_start("Creating session '#{name}'")
@@ -48,7 +70,8 @@ module Sxn
             name,
             description: options[:description],
             linear_task: options[:linear_task],
-            default_branch: default_branch
+            default_branch: default_branch,
+            template_id: template_id
           )
 
           @ui.progress_done
@@ -60,8 +83,13 @@ module Sxn
 
           display_session_info(session)
 
-          # Offer to add a worktree unless skipped
-          offer_worktree_wizard(name) unless options[:skip_worktree]
+          # Apply template if specified (with atomic rollback on failure)
+          if template_id
+            apply_template_to_session(name, template_id, default_branch)
+          elsif !options[:skip_worktree]
+            # Offer to add a worktree unless skipped or template was used
+            offer_worktree_wizard(name)
+          end
         rescue Sxn::Error => e
           @ui.progress_failed
           @ui.error(e.message)
@@ -275,6 +303,85 @@ module Sxn
 
       private
 
+      def apply_template_to_session(session_name, template_id, default_branch)
+        template = @template_manager.get_template(template_id)
+        projects = template["projects"] || []
+        created_worktrees = []
+
+        @ui.newline
+        @ui.section("Applying Template '#{template_id}'")
+        @ui.info("Creating #{projects.size} worktree(s)...")
+
+        begin
+          projects.each_with_index do |project_config, index|
+            project_name = project_config["name"]
+            # Use project-specific branch override, or fall back to session default
+            branch = project_config["branch"] || default_branch
+
+            @ui.progress_start("Creating worktree #{index + 1}/#{projects.size}: #{project_name}")
+
+            worktree = @worktree_manager.add_worktree(
+              project_name,
+              branch,
+              session_name: session_name
+            )
+            created_worktrees << worktree
+
+            @ui.progress_done
+
+            # Apply project-specific rule overrides if defined
+            apply_template_rules(session_name, project_name, worktree[:path], project_config["rules"]) if project_config["rules"]
+          end
+
+          @ui.newline
+          @ui.success("Template applied: #{created_worktrees.size} worktree(s) created")
+
+          # Display created worktrees
+          @ui.newline
+          @ui.subsection("Created Worktrees")
+          created_worktrees.each do |wt|
+            @ui.list_item("#{wt[:project]} (#{wt[:branch]}) → #{wt[:path]}")
+          end
+        rescue StandardError => e
+          # ATOMIC ROLLBACK: Remove all created worktrees and the session
+          @ui.progress_failed
+          @ui.newline
+          @ui.warning("Template application failed, rolling back...")
+
+          rollback_template_application(session_name, created_worktrees)
+
+          raise Sxn::SessionTemplateApplicationError.new(template_id, e.message)
+        end
+      end
+
+      def rollback_template_application(session_name, created_worktrees)
+        # Remove created worktrees
+        created_worktrees.each do |wt|
+          @worktree_manager.remove_worktree(wt[:project], session_name: session_name)
+        rescue StandardError
+          # Best effort cleanup, continue with rollback
+          nil
+        end
+
+        # Remove the session
+        @session_manager.remove_session(session_name, force: true)
+        @ui.info("Session '#{session_name}' has been rolled back")
+      rescue StandardError => e
+        @ui.warning("Rollback encountered errors: #{e.message}")
+      end
+
+      def apply_template_rules(_session_name, project_name, worktree_path, rules)
+        return unless rules.is_a?(Hash)
+
+        rules_manager = Sxn::Core::RulesManager.new(@config_manager, worktree_path)
+
+        rules_manager.apply_copy_files_rules(rules["copy_files"]) if rules["copy_files"]
+
+        rules_manager.apply_setup_commands(rules["setup_commands"]) if rules["setup_commands"]
+      rescue StandardError => e
+        @ui.warning("Failed to apply rules for #{project_name}: #{e.message}")
+      end
+
       def ensure_initialized!
         return if @config_manager.initialized?
 

data/lib/sxn/commands/templates.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Sxn
+  module Commands
+    # Manage session templates
+    class Templates < 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
+        @template_manager = Sxn::Core::TemplateManager.new(@config_manager)
+        @project_manager = Sxn::Core::ProjectManager.new(@config_manager)
+      end
+
+      desc "list", "List available session templates"
+
+      def list
+        ensure_initialized!
+
+        templates = @template_manager.list_templates
+
+        @ui.section("Session Templates")
+
+        if templates.empty?
+          @ui.empty_state("No templates defined")
+          @ui.newline
+          @ui.recovery_suggestion("Create a template with 'sxn templates create'")
+          @ui.recovery_suggestion("Or manually edit .sxn/templates.yml")
+        else
+          display_templates_table(templates)
+          @ui.newline
+          @ui.info("Total: #{templates.size} template(s)")
+        end
+      rescue Sxn::Error => e
+        @ui.error(e.message)
+        exit(e.exit_code)
+      end
+
+      desc "show NAME", "Show details of a session template"
+
+      def show(name)
+        ensure_initialized!
+
+        template = @template_manager.get_template(name)
+
+        @ui.section("Template: #{name}")
+        @ui.key_value("Description", template["description"] || "(none)")
+        @ui.key_value("Projects", (template["projects"] || []).size.to_s)
+
+        @ui.newline
+        @ui.subsection("Projects")
+
+        projects = template["projects"] || []
+        if projects.empty?
+          @ui.empty_state("No projects in this template")
+        else
+          projects.each do |project_config|
+            project_name = project_config["name"]
+            project = @project_manager.get_project(project_name)
+            status = project ? "✓" : "✗ (not found)"
+
+            details = []
+            details << "branch: #{project_config["branch"]}" if project_config["branch"]
+            details << "has custom rules" if project_config["rules"]
+
+            if details.any?
+              @ui.list_item("#{project_name} #{status} (#{details.join(", ")})")
+            else
+              @ui.list_item("#{project_name} #{status}")
+            end
+          end
+        end
+
+        @ui.newline
+        @ui.subsection("Usage")
+        @ui.command_example(
+          "sxn add my-session -t #{name} -b my-branch",
+          "Create session with this template"
+        )
+      rescue Sxn::SessionTemplateNotFoundError => e
+        @ui.error(e.message)
+        exit(1)
+      rescue Sxn::Error => e
+        @ui.error(e.message)
+        exit(e.exit_code)
+      end
+
+      desc "create", "Create a new session template"
+      option :name, type: :string, aliases: "-n", desc: "Template name"
+      option :description, type: :string, aliases: "-d", desc: "Template description"
+
+      def create
+        ensure_initialized!
+
+        # Get template name
+        name = options[:name]
+        if name.nil?
+          name = @prompt.ask("Template name:")
+          if name.nil? || name.strip.empty?
+            @ui.error("Template name is required")
+            exit(1)
+          end
+        end
+
+        # Check if template already exists
+        if @template_manager.template_exists?(name)
+          @ui.error("Template '#{name}' already exists")
+          @ui.recovery_suggestion("Use a different name or remove existing template with 'sxn templates remove #{name}'")
+          exit(1)
+        end
+
+        # Get description
+        description = options[:description]
+        description ||= @prompt.ask("Description (optional):")
+
+        # Select projects
+        projects = @project_manager.list_projects
+        if projects.empty?
+          @ui.error("No projects configured")
+          @ui.recovery_suggestion("Add projects with 'sxn projects add <name> <path>' first")
+          exit(1)
+        end
+
+        @ui.newline
+        @ui.info("Select projects to include in the template:")
+        @ui.info("(Use space to select, enter to confirm)")
+        @ui.newline
+
+        project_choices = projects.map do |p|
+          { name: "#{p[:name]} (#{p[:type] || "unknown"})", value: p[:name] }
+        end
+
+        selected_projects = @prompt.multi_select("Projects:", project_choices)
+
+        if selected_projects.empty?
+          @ui.error("At least one project must be selected")
+          exit(1)
+        end
+
+        # Create the template
+        @ui.progress_start("Creating template '#{name}'")
+
+        @template_manager.create_template(
+          name,
+          description: description,
+          projects: selected_projects
+        )
+
+        @ui.progress_done
+        @ui.success("Template '#{name}' created with #{selected_projects.size} project(s)")
+
+        @ui.newline
+        @ui.subsection("Usage")
+        @ui.command_example(
+          "sxn add my-session -t #{name} -b my-branch",
+          "Create session with this template"
+        )
+      rescue Sxn::SessionTemplateValidationError => e
+        @ui.progress_failed
+        @ui.error(e.message)
+        exit(1)
+      rescue Sxn::Error => e
+        @ui.progress_failed
+        @ui.error(e.message)
+        exit(e.exit_code)
+      end
+
+      desc "remove NAME", "Remove a session template"
+      option :force, type: :boolean, aliases: "-f", desc: "Skip confirmation"
+
+      def remove(name = nil)
+        ensure_initialized!
+
+        # Interactive selection if name not provided
+        if name.nil?
+          templates = @template_manager.list_templates
+          if templates.empty?
+            @ui.empty_state("No templates to remove")
+            return
+          end
+
+          choices = templates.map { |t| { name: "#{t[:name]} - #{t[:description] || "(no description)"}", value: t[:name] } }
+          name = @prompt.select("Select template to remove:", choices)
+        end
+
+        # Verify template exists
+        @template_manager.get_template(name)
+
+        # Confirm deletion unless force flag is used
+        return if !options[:force] && !@prompt.confirm_deletion(name, "template")
+
+        @ui.progress_start("Removing template '#{name}'")
+        @template_manager.remove_template(name)
+        @ui.progress_done
+        @ui.success("Template '#{name}' removed")
+      rescue Sxn::SessionTemplateNotFoundError => e
+        @ui.error(e.message)
+        exit(1)
+      rescue Sxn::Error => e
+        @ui.progress_failed
+        @ui.error(e.message)
+        exit(e.exit_code)
+      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_templates_table(templates)
+        @table.templates(templates)
+      end
+    end
+  end
+end

data/lib/sxn/commands.rb

@@ -5,6 +5,8 @@ require_relative "commands/sessions"
 require_relative "commands/projects"
 require_relative "commands/worktrees"
 require_relative "commands/rules"
+require_relative "commands/templates"
+require_relative "commands/mcp"
 
 module Sxn
   # Commands namespace for all CLI command implementations