sxn 0.3.0 → 0.4.0

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