sxn 0.2.5 → 0.4.0

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

data/lib/sxn/mcp/tools/base_tool.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Tools
+      # Base module for MCP tools with shared error handling
+      module BaseTool
+        # Maps sxn errors to user-friendly messages
+        module ErrorMapping
+          SXN_ERROR_MESSAGES = {
+            # Session errors
+            Sxn::SessionNotFoundError => "Session not found",
+            Sxn::SessionAlreadyExistsError => "Session already exists",
+            Sxn::SessionExistsError => "Session already exists",
+            Sxn::SessionHasChangesError => "Session has uncommitted changes",
+            Sxn::InvalidSessionNameError => "Invalid session name",
+            Sxn::NoActiveSessionError => "No active session",
+            # Project errors
+            Sxn::ProjectNotFoundError => "Project not found",
+            Sxn::ProjectAlreadyExistsError => "Project already exists",
+            Sxn::ProjectExistsError => "Project already exists",
+            Sxn::ProjectInUseError => "Project is in use",
+            Sxn::InvalidProjectNameError => "Invalid project name",
+            Sxn::InvalidProjectPathError => "Invalid project path",
+            # Worktree errors
+            Sxn::WorktreeError => "Worktree error",
+            Sxn::WorktreeExistsError => "Worktree already exists",
+            Sxn::WorktreeNotFoundError => "Worktree not found",
+            Sxn::WorktreeCreationError => "Failed to create worktree",
+            Sxn::WorktreeRemovalError => "Failed to remove worktree",
+            # Template errors
+            Sxn::SessionTemplateNotFoundError => "Template not found",
+            Sxn::SessionTemplateValidationError => "Template validation failed",
+            # Rule errors
+            Sxn::RuleError => "Rule error",
+            Sxn::RuleNotFoundError => "Rule not found",
+            Sxn::InvalidRuleTypeError => "Invalid rule type",
+            Sxn::InvalidRuleConfigError => "Invalid rule configuration",
+            # Configuration errors
+            Sxn::ConfigurationError => "Configuration error",
+            # MCP errors
+            Sxn::MCPError => "MCP error",
+            Sxn::MCPServerError => "MCP server error",
+            Sxn::MCPValidationError => "MCP validation error"
+          }.freeze
+
+          # Wrap a block with error handling that converts sxn errors to error responses
+          def self.wrap
+            yield
+          rescue Sxn::ConfigurationError => e
+            error_response("sxn not initialized: #{e.message}. Run 'sxn init' first.")
+          rescue Sxn::Error => e
+            error_type = SXN_ERROR_MESSAGES[e.class] || "Error"
+            error_response("#{error_type}: #{e.message}")
+          rescue StandardError => e
+            error_response("Unexpected error: #{e.message}")
+          end
+
+          def self.error_response(message)
+            ::MCP::Tool::Response.new([{ type: "text", text: message }], error: true)
+          end
+        end
+
+        # Helper to check if sxn is initialized
+        def self.ensure_initialized!(server_context)
+          return true if server_context[:config_manager]
+
+          false
+        end
+
+        # Helper to return error response for uninitialized sxn
+        def self.not_initialized_response
+          ErrorMapping.error_response("sxn not initialized in this workspace. Run 'sxn init' first.")
+        end
+
+        # Helper to build a successful text response
+        def self.text_response(text)
+          ::MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+
+        # Helper to build a JSON response
+        def self.json_response(data, summary: nil)
+          content = []
+          content << { type: "text", text: summary } if summary
+          content << { type: "text", text: JSON.pretty_generate(data) }
+          ::MCP::Tool::Response.new(content)
+        end
+
+        # Helper to build an error response
+        def self.error_response(message)
+          ErrorMapping.error_response(message)
+        end
+      end
+    end
+  end
+end

data/lib/sxn/mcp/tools/projects.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Tools
+      module Projects
+        # List registered projects
+        class ListProjects < ::MCP::Tool
+          description "List all registered projects in the sxn workspace"
+
+          input_schema(
+            type: "object",
+            properties: {},
+            required: []
+          )
+
+          class << self
+            def call(server_context:)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                project_manager = server_context[:project_manager]
+                projects = project_manager.list_projects
+
+                if projects.empty?
+                  BaseTool.text_response("No projects registered. Use sxn_projects_add to register a project.")
+                else
+                  formatted = projects.map do |p|
+                    "- #{p[:name]} (#{p[:type]})\n  #{p[:path]}\n  Default branch: #{p[:default_branch]}"
+                  end.join("\n")
+
+                  BaseTool.text_response("Registered projects (#{projects.length}):\n#{formatted}")
+                end
+              end
+            end
+          end
+        end
+
+        # Register a new project
+        class AddProject < ::MCP::Tool
+          description "Register a new git repository as a project. " \
+                      "Automatically detects project type and default branch."
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                pattern: "^[a-zA-Z0-9_-]+$",
+                description: "Project name (alphanumeric, hyphens, underscores only)"
+              },
+              path: {
+                type: "string",
+                description: "Path to the git repository (absolute or relative)"
+              },
+              type: {
+                type: "string",
+                description: "Project type (auto-detected if not specified). " \
+                             "Options: rails, ruby, javascript, typescript, react, nextjs, etc."
+              },
+              default_branch: {
+                type: "string",
+                description: "Default branch for worktrees (auto-detected if not specified)"
+              }
+            },
+            required: %w[name path]
+          )
+
+          class << self
+            def call(name:, path:, server_context:, type: nil, default_branch: nil)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                project_manager = server_context[:project_manager]
+
+                result = project_manager.add_project(
+                  name,
+                  path,
+                  type: type,
+                  default_branch: default_branch
+                )
+
+                BaseTool.text_response(
+                  "Project '#{result[:name]}' registered successfully.\n" \
+                  "Type: #{result[:type]}\n" \
+                  "Path: #{result[:path]}\n" \
+                  "Default branch: #{result[:default_branch]}"
+                )
+              end
+            end
+          end
+        end
+
+        # Get project details
+        class GetProject < ::MCP::Tool
+          description "Get detailed information about a registered project"
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Project name to retrieve"
+              }
+            },
+            required: ["name"]
+          )
+
+          class << self
+            def call(name:, server_context:)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                project_manager = server_context[:project_manager]
+                project = project_manager.get_project(name)
+
+                # Validate the project
+                validation = project_manager.validate_project(name)
+
+                # Get project rules
+                rules = project_manager.get_project_rules(name)
+                rules_summary = rules.map { |type, configs| "#{type}: #{Array(configs).length}" }.join(", ")
+
+                output = <<~INFO
+                  Project: #{project[:name]}
+                  Type: #{project[:type]}
+                  Path: #{project[:path]}
+                  Default branch: #{project[:default_branch]}
+
+                  Validation: #{validation[:valid] ? "Valid" : "Invalid"}
+                  #{validation[:issues].map { |i| "  - #{i}" }.join("\n") unless validation[:valid]}
+
+                  Rules: #{rules_summary.empty? ? "(none)" : rules_summary}
+                INFO
+
+                BaseTool.text_response(output.strip)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sxn/mcp/tools/rules.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Tools
+      module Rules
+        # List rules for a project
+        class ListRules < ::MCP::Tool
+          description "List project rules (copy_files, setup_commands, templates)"
+
+          input_schema(
+            type: "object",
+            properties: {
+              project_name: {
+                type: "string",
+                description: "Project name (lists all rules if not specified)"
+              }
+            },
+            required: []
+          )
+
+          class << self
+            def call(server_context:, project_name: nil)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                rules_manager = server_context[:rules_manager]
+                rules = rules_manager.list_rules(project_name)
+
+                if rules.empty?
+                  BaseTool.text_response("No rules defined.")
+                else
+                  # Group by project
+                  by_project = rules.group_by { |r| r[:project] }
+
+                  output = by_project.map do |proj, proj_rules|
+                    proj_output = "#{proj}:\n"
+                    proj_rules.each do |rule|
+                      config_preview = case rule[:type]
+                                       when "copy_files"
+                                         rule[:config]["source"]
+                                       when "setup_commands"
+                                         rule[:config]["command"]&.join(" ")
+                                       when "template"
+                                         "#{rule[:config]["source"]} -> #{rule[:config]["destination"]}"
+                                       else
+                                         rule[:config].to_s
+                                       end
+                      proj_output += "  - [#{rule[:type]}] #{config_preview}\n"
+                    end
+                    proj_output
+                  end.join("\n")
+
+                  BaseTool.text_response("Project rules:\n\n#{output}")
+                end
+              end
+            end
+          end
+        end
+
+        # Apply rules to a worktree
+        class ApplyRules < ::MCP::Tool
+          description "Apply project-specific rules to a worktree (copy files, run setup commands)"
+
+          input_schema(
+            type: "object",
+            properties: {
+              project_name: {
+                type: "string",
+                description: "Project name"
+              },
+              session_name: {
+                type: "string",
+                description: "Session name (defaults to current session)"
+              }
+            },
+            required: ["project_name"]
+          )
+
+          class << self
+            def call(project_name:, server_context:, session_name: nil)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                rules_manager = server_context[:rules_manager]
+
+                result = rules_manager.apply_rules(project_name, session_name)
+
+                if result[:success]
+                  BaseTool.text_response(
+                    "Rules applied successfully to '#{project_name}'.\n" \
+                    "Applied: #{result[:applied_count]} rule(s)"
+                  )
+                else
+                  BaseTool.text_response(
+                    "Some rules failed for '#{project_name}'.\n" \
+                    "Applied: #{result[:applied_count]} rule(s)\n" \
+                    "Errors:\n#{result[:errors].map { |e| "  - #{e}" }.join("\n")}"
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end