sxn 0.3.0 → 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

@@ -329,10 +329,7 @@ module Sxn
 
             @ui.progress_done
 
-            # Apply project's default rules first
-            apply_project_rules(project_name, session_name)
-
-            # Apply template-specific rule overrides if defined (in addition to project defaults)
+            # Apply project-specific rule overrides if defined
             apply_template_rules(session_name, project_name, worktree[:path], project_config["rules"]) if project_config["rules"]
           end
 

data/lib/sxn/commands/templates.rb

@@ -62,11 +62,7 @@ module Sxn
         else
           projects.each do |project_config|
             project_name = project_config["name"]
-            project = begin
-              @project_manager.get_project(project_name)
-            rescue Sxn::ProjectNotFoundError
-              nil
-            end
+            project = @project_manager.get_project(project_name)
             status = project ? "✓" : "✗ (not found)"
 
             details = []

data/lib/sxn/commands.rb

@@ -6,6 +6,7 @@ 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

data/lib/sxn/mcp/prompts/workflow_prompts.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Prompts
+      # Guided new session creation workflow
+      class NewSession < ::MCP::Prompt
+        prompt_name "new-session"
+        description "Guided workflow for creating a new development session"
+
+        arguments [
+          ::MCP::Prompt::Argument.new(
+            name: "task_description",
+            description: "Brief description of what you're working on",
+            required: false
+          ),
+          ::MCP::Prompt::Argument.new(
+            name: "projects",
+            description: "Comma-separated list of projects to include",
+            required: false
+          )
+        ]
+
+        class << self
+          def template(args = {}, _server_context: nil)
+            # Handle both string and symbol keys
+            task_description = args["task_description"] || args[:task_description]
+            projects = args["projects"] || args[:projects]
+            project_list = projects ? projects.split(",").map(&:strip).join(", ") : "Not specified"
+
+            <<~PROMPT
+              # Create a New Development Session
+
+              Help me create a new sxn development session.
+
+              ## Task Information
+              - Description: #{task_description || "Not provided"}
+              - Requested projects: #{project_list}
+
+              ## Steps to Complete
+
+              1. **Generate session name** based on the task description
+              2. **Create the session** using sxn_sessions_create
+              3. **Add worktrees** for each requested project using sxn_worktrees_add
+              4. **Navigate to the session** using sxn_sessions_swap
+
+              ## Guidelines
+              - Session names should be descriptive but concise (e.g., "user-auth", "api-refactor")
+              - Use alphanumeric characters, hyphens, and underscores only
+              - Apply project rules automatically when creating worktrees
+            PROMPT
+          end
+        end
+      end
+
+      # Multi-repo setup workflow
+      class MultiRepoSetup < ::MCP::Prompt
+        prompt_name "multi-repo-setup"
+        description "Set up a multi-repository development environment"
+
+        arguments [
+          ::MCP::Prompt::Argument.new(
+            name: "feature_name",
+            description: "Name of the feature being developed across repos",
+            required: true
+          ),
+          ::MCP::Prompt::Argument.new(
+            name: "repos",
+            description: "Comma-separated list of repository names to include",
+            required: false
+          )
+        ]
+
+        class << self
+          def template(args = {}, _server_context: nil)
+            # Handle both string and symbol keys
+            feature_name = args["feature_name"] || args[:feature_name]
+            repos = args["repos"] || args[:repos]
+            repo_list = repos ? repos.split(",").map(&:strip) : []
+
+            <<~PROMPT
+              # Multi-Repository Development Setup
+
+              Set up a coordinated development environment for: **#{feature_name}**
+
+              ## Repositories to Include
+              #{repo_list.empty? ? "- (Will use sxn_projects_list to find available projects)" : repo_list.map { |r| "- #{r}" }.join("\n")}
+
+              ## Setup Process
+
+              1. **Check registered projects** with sxn_projects_list
+              2. **Create the session** with sxn_sessions_create
+                 - Name: #{feature_name.downcase.gsub(/\s+/, "-")}
+              3. **Add worktrees** for each repository with sxn_worktrees_add
+              4. **Apply rules** with sxn_rules_apply for each project
+              5. **Navigate** using sxn_sessions_swap
+
+              ## Best Practices
+              - Use the same branch name across all repos
+              - Apply rules to copy environment files
+            PROMPT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sxn/mcp/resources/session_resources.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Resources
+      # Factory methods for creating MCP Resource objects
+      module SessionResources
+        class << self
+          # Build all resources for the server
+          def build_all(server_context)
+            [
+              build_current_session(server_context),
+              build_all_sessions(server_context),
+              build_all_projects(server_context)
+            ].compact
+          end
+
+          private
+
+          def build_current_session(server_context)
+            return nil unless server_context[:config_manager]
+
+            ::MCP::Resource.new(
+              uri: "sxn://session/current",
+              name: "Current Session",
+              description: "Information about the currently active sxn session",
+              mime_type: "application/json"
+            )
+          end
+
+          def build_all_sessions(server_context)
+            return nil unless server_context[:config_manager]
+
+            ::MCP::Resource.new(
+              uri: "sxn://sessions",
+              name: "All Sessions",
+              description: "Summary of all sxn sessions",
+              mime_type: "application/json"
+            )
+          end
+
+          def build_all_projects(server_context)
+            return nil unless server_context[:config_manager]
+
+            ::MCP::Resource.new(
+              uri: "sxn://projects",
+              name: "Registered Projects",
+              description: "All registered projects in the sxn workspace",
+              mime_type: "application/json"
+            )
+          end
+        end
+      end
+
+      # Resource content readers
+      module ResourceContentReader
+        class << self
+          def read_content(uri, server_context)
+            case uri
+            when "sxn://session/current"
+              read_current_session(server_context)
+            when "sxn://sessions"
+              read_all_sessions(server_context)
+            when "sxn://projects"
+              read_all_projects(server_context)
+            else
+              JSON.generate({ error: "Unknown resource: #{uri}" })
+            end
+          end
+
+          private
+
+          def read_current_session(server_context)
+            config_manager = server_context[:config_manager]
+            return JSON.generate({ error: "sxn not initialized" }) unless config_manager
+
+            session_manager = server_context[:session_manager]
+            session = session_manager.current_session
+
+            unless session
+              return JSON.generate({
+                                     current_session: nil,
+                                     message: "No active session"
+                                   })
+            end
+
+            JSON.generate({
+                            name: session[:name],
+                            status: session[:status],
+                            path: session[:path],
+                            created_at: session[:created_at],
+                            default_branch: session[:default_branch],
+                            worktrees: session[:worktrees],
+                            projects: session[:projects]
+                          })
+          rescue StandardError => e
+            JSON.generate({ error: e.message })
+          end
+
+          def read_all_sessions(server_context)
+            config_manager = server_context[:config_manager]
+            return JSON.generate({ error: "sxn not initialized" }) unless config_manager
+
+            session_manager = server_context[:session_manager]
+            sessions = session_manager.list_sessions
+
+            JSON.generate({
+                            total: sessions.length,
+                            sessions: sessions.map do |s|
+                              {
+                                name: s[:name],
+                                status: s[:status],
+                                worktree_count: s[:worktrees].keys.length
+                              }
+                            end
+                          })
+          rescue StandardError => e
+            JSON.generate({ error: e.message })
+          end
+
+          def read_all_projects(server_context)
+            config_manager = server_context[:config_manager]
+            return JSON.generate({ error: "sxn not initialized" }) unless config_manager
+
+            project_manager = server_context[:project_manager]
+            projects = project_manager.list_projects
+
+            JSON.generate({
+                            total: projects.length,
+                            projects: projects.map do |p|
+                              {
+                                name: p[:name],
+                                type: p[:type],
+                                path: p[:path]
+                              }
+                            end
+                          })
+          rescue StandardError => e
+            JSON.generate({ error: e.message })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sxn/mcp/server.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    # Main MCP server class that orchestrates tools, resources, and prompts
+    class Server
+      attr_reader :workspace_path, :config_manager
+
+      def initialize(workspace_path: nil)
+        @workspace_path = workspace_path || ENV["SXN_WORKSPACE"] || discover_workspace
+        @config_manager = initialize_config_manager
+        @server = build_mcp_server
+      end
+
+      # Run the server with STDIO transport (for Claude Code integration)
+      def run_stdio
+        transport = ::MCP::Server::Transports::StdioTransport.new(@server)
+        transport.open
+      end
+
+      # Run the server with HTTP transport (for web-based integrations)
+      def run_http(port: 3000)
+        transport = ::MCP::Server::Transports::StreamableHTTPTransport.new(@server)
+        transport.run(port: port)
+      end
+
+      private
+
+      def discover_workspace
+        # Try to find .sxn directory in current or parent directories
+        current = Dir.pwd
+        loop do
+          sxn_path = File.join(current, ".sxn")
+          return current if File.directory?(sxn_path)
+
+          parent = File.dirname(current)
+          break if parent == current
+
+          current = parent
+        end
+
+        # Fall back to current directory
+        Dir.pwd
+      end
+
+      def initialize_config_manager
+        Sxn::Core::ConfigManager.new(@workspace_path)
+      rescue Sxn::ConfigurationError
+        # Allow server to start even if sxn isn't initialized
+        # Tools will return appropriate errors
+        nil
+      end
+
+      def build_mcp_server
+        context = build_context
+
+        server = ::MCP::Server.new(
+          name: "sxn",
+          version: Sxn::VERSION,
+          tools: registered_tools,
+          resources: registered_resources(context),
+          prompts: registered_prompts,
+          server_context: context
+        )
+
+        # Set up resource read handler
+        server.resources_read_handler do |params|
+          uri = params[:uri]
+          content = Resources::ResourceContentReader.read_content(uri, context)
+          [{ uri: uri, text: content, mimeType: "application/json" }]
+        end
+
+        server
+      end
+
+      def build_context
+        {
+          config_manager: @config_manager,
+          session_manager: @config_manager && Sxn::Core::SessionManager.new(@config_manager),
+          project_manager: @config_manager && Sxn::Core::ProjectManager.new(@config_manager),
+          worktree_manager: @config_manager && Sxn::Core::WorktreeManager.new(@config_manager),
+          template_manager: @config_manager && Sxn::Core::TemplateManager.new(@config_manager),
+          rules_manager: @config_manager && Sxn::Core::RulesManager.new(@config_manager),
+          workspace_path: @workspace_path
+        }
+      end
+
+      def registered_tools
+        [
+          # Session tools
+          Tools::Sessions::ListSessions,
+          Tools::Sessions::CreateSession,
+          Tools::Sessions::GetSession,
+          Tools::Sessions::DeleteSession,
+          Tools::Sessions::ArchiveSession,
+          Tools::Sessions::ActivateSession,
+          Tools::Sessions::SwapSession,
+          # Worktree tools
+          Tools::Worktrees::ListWorktrees,
+          Tools::Worktrees::AddWorktree,
+          Tools::Worktrees::RemoveWorktree,
+          # Project tools
+          Tools::Projects::ListProjects,
+          Tools::Projects::AddProject,
+          Tools::Projects::GetProject,
+          # Template tools
+          Tools::Templates::ListTemplates,
+          Tools::Templates::ApplyTemplate,
+          # Rules tools
+          Tools::Rules::ListRules,
+          Tools::Rules::ApplyRules
+        ]
+      end
+
+      def registered_resources(context)
+        Resources::SessionResources.build_all(context)
+      end
+
+      def registered_prompts
+        [
+          Prompts::NewSession,
+          Prompts::MultiRepoSetup
+        ]
+      end
+    end
+  end
+end