sxn 0.3.0 → 0.4.0

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

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Tools
+      module Sessions
+        # List all sessions with optional filtering
+        class ListSessions < ::MCP::Tool
+          description "List all sxn development sessions with optional status filtering"
+
+          input_schema(
+            type: "object",
+            properties: {
+              status: {
+                type: "string",
+                enum: %w[active inactive archived],
+                description: "Filter sessions by status"
+              },
+              limit: {
+                type: "integer",
+                default: 100,
+                description: "Maximum number of sessions to return"
+              }
+            },
+            required: []
+          )
+
+          class << self
+            def call(server_context:, status: nil, limit: 100)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                session_manager = server_context[:session_manager]
+                sessions = session_manager.list_sessions(status: status, limit: limit)
+
+                if sessions.empty?
+                  BaseTool.text_response("No sessions found.")
+                else
+                  summary = "Found #{sessions.length} session(s):"
+                  formatted = sessions.map do |s|
+                    "- #{s[:name]} (#{s[:status]}) - #{s[:worktrees].keys.length} worktrees"
+                  end.join("\n")
+
+                  BaseTool.text_response("#{summary}\n#{formatted}")
+                end
+              end
+            end
+          end
+        end
+
+        # Create a new session
+        class CreateSession < ::MCP::Tool
+          description "Create a new sxn development session with optional template"
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                pattern: "^[a-zA-Z0-9_-]+$",
+                description: "Session name (alphanumeric, hyphens, underscores only)"
+              },
+              description: {
+                type: "string",
+                description: "Optional session description"
+              },
+              default_branch: {
+                type: "string",
+                description: "Default branch for worktrees (defaults to session name)"
+              },
+              template_id: {
+                type: "string",
+                description: "Template to apply (creates predefined worktrees)"
+              },
+              linear_task: {
+                type: "string",
+                description: "Associated Linear task ID (e.g., ATL-1234)"
+              }
+            },
+            required: ["name"]
+          )
+
+          class << self
+            def call(name:, server_context:, description: nil, default_branch: nil, template_id: nil, linear_task: nil)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                session_manager = server_context[:session_manager]
+
+                session = session_manager.create_session(
+                  name,
+                  description: description,
+                  default_branch: default_branch,
+                  template_id: template_id,
+                  linear_task: linear_task
+                )
+
+                # If template specified, apply it
+                apply_template(server_context, name, template_id, default_branch || name) if template_id && server_context[:template_manager]
+
+                BaseTool.text_response(
+                  "Session '#{name}' created successfully.\n" \
+                  "Path: #{session[:path]}\n" \
+                  "Branch: #{session[:default_branch]}"
+                )
+              end
+            end
+
+            private
+
+            def apply_template(server_context, session_name, template_id, default_branch)
+              template_manager = server_context[:template_manager]
+              worktree_manager = server_context[:worktree_manager]
+
+              # Get template projects
+              projects = template_manager.get_template_projects(template_id, default_branch: default_branch)
+
+              # Create worktrees for each project
+              projects.each do |project|
+                worktree_manager.add_worktree(
+                  project[:name],
+                  project[:branch],
+                  session_name: session_name
+                )
+              end
+            rescue StandardError => e
+              # Log template application error but don't fail session creation
+              Sxn.logger&.warn("Failed to apply template: #{e.message}")
+            end
+          end
+        end
+
+        # Get detailed session info
+        class GetSession < ::MCP::Tool
+          description "Get detailed information about a specific session"
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Session name to retrieve"
+              }
+            },
+            required: ["name"]
+          )
+
+          class << self
+            def call(name:, server_context:)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                session_manager = server_context[:session_manager]
+                session = session_manager.get_session(name)
+
+                raise Sxn::SessionNotFoundError, "Session '#{name}' not found" unless session
+
+                # Format session info
+                worktrees_info = session[:worktrees].map do |project, info|
+                  "  - #{project}: #{info[:branch] || info["branch"]} (#{info[:path] || info["path"]})"
+                end.join("\n")
+
+                output = <<~INFO
+                  Session: #{session[:name]}
+                  Status: #{session[:status]}
+                  Path: #{session[:path]}
+                  Created: #{session[:created_at]}
+                  Default Branch: #{session[:default_branch]}
+                  #{"Description: #{session[:description]}" if session[:description]}
+                  #{"Linear Task: #{session[:linear_task]}" if session[:linear_task]}
+                  #{"Template: #{session[:template_id]}" if session[:template_id]}
+
+                  Worktrees (#{session[:worktrees].keys.length}):
+                  #{worktrees_info.empty? ? "  (none)" : worktrees_info}
+                INFO
+
+                BaseTool.text_response(output.strip)
+              end
+            end
+          end
+        end
+
+        # Delete a session
+        class DeleteSession < ::MCP::Tool
+          description "Delete a session and its worktrees"
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Session name to delete"
+              },
+              force: {
+                type: "boolean",
+                default: false,
+                description: "Force deletion even with uncommitted changes"
+              }
+            },
+            required: ["name"]
+          )
+
+          class << self
+            def call(name:, server_context:, force: false)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                session_manager = server_context[:session_manager]
+                session_manager.remove_session(name, force: force)
+
+                BaseTool.text_response("Session '#{name}' deleted successfully.")
+              end
+            end
+          end
+        end
+
+        # Archive a session
+        class ArchiveSession < ::MCP::Tool
+          description "Archive a session (preserves data but marks as archived)"
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Session name to archive"
+              }
+            },
+            required: ["name"]
+          )
+
+          class << self
+            def call(name:, server_context:)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                session_manager = server_context[:session_manager]
+                session_manager.archive_session(name)
+
+                BaseTool.text_response("Session '#{name}' archived successfully.")
+              end
+            end
+          end
+        end
+
+        # Activate an archived session
+        class ActivateSession < ::MCP::Tool
+          description "Activate an archived session"
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Session name to activate"
+              }
+            },
+            required: ["name"]
+          )
+
+          class << self
+            def call(name:, server_context:)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                session_manager = server_context[:session_manager]
+                session_manager.activate_session(name)
+
+                BaseTool.text_response("Session '#{name}' activated successfully.")
+              end
+            end
+          end
+        end
+
+        # Swap to a different session with navigation info
+        class SwapSession < ::MCP::Tool
+          description "Switch to a different session and get navigation instructions. " \
+                      "Returns the session path and shell commands for changing directory."
+
+          input_schema(
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Session name to switch to"
+              },
+              project: {
+                type: "string",
+                description: "Specific project worktree to navigate to (optional)"
+              }
+            },
+            required: ["name"]
+          )
+
+          class << self
+            def call(name:, server_context:, project: nil)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                session_manager = server_context[:session_manager]
+                workspace_path = server_context[:workspace_path]
+
+                # Activate the session
+                session = session_manager.use_session(name)
+
+                # Determine target path
+                target_path = if project
+                                worktrees = session[:worktrees]
+                                worktree_info = worktrees[project]
+                                if worktree_info
+                                  worktree_info[:path] || worktree_info["path"]
+                                else
+                                  session[:path]
+                                end
+                              else
+                                session[:path]
+                              end
+
+                # Determine navigation strategy
+                navigation = determine_navigation_strategy(workspace_path, target_path)
+
+                # Build response
+                worktrees_list = session[:worktrees].map do |proj, info|
+                  "- #{proj}: #{info[:path] || info["path"]}"
+                end.join("\n")
+
+                output = <<~SWAP
+                  Switched to session '#{name}'.
+
+                  Session path: #{session[:path]}
+                  Target path: #{target_path}
+
+                  Navigation (#{navigation[:strategy]}):
+                  #{navigation[:instruction]}
+
+                  Worktrees:
+                  #{worktrees_list.empty? ? "(none)" : worktrees_list}
+                SWAP
+
+                # Add structured data for programmatic use
+                BaseTool.text_response(output.strip)
+              end
+            end
+
+            private
+
+            def determine_navigation_strategy(workspace_path, target_path)
+              # Check if target is within or contains workspace
+              target_expanded = File.expand_path(target_path)
+              workspace_expanded = File.expand_path(workspace_path)
+
+              if target_expanded.start_with?(workspace_expanded) ||
+                 workspace_expanded.start_with?(target_expanded)
+                {
+                  strategy: "bash_cd",
+                  instruction: "Run: cd #{target_path}",
+                  bash_command: "cd #{target_path}",
+                  reason: "Session is within the current workspace"
+                }
+              else
+                {
+                  strategy: "new_instance",
+                  instruction: "Session is outside current workspace. " \
+                               "Start a new Claude Code instance with:\n  claude --cwd #{target_path}",
+                  shell_command: "claude --cwd #{target_path}",
+                  reason: "Session is outside the current workspace"
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Tools
+      module Templates
+        # List available templates
+        class ListTemplates < ::MCP::Tool
+          description "List available session templates"
+
+          input_schema(
+            type: "object",
+            properties: {},
+            required: []
+          )
+
+          class << self
+            def call(server_context:)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                template_manager = server_context[:template_manager]
+                templates = template_manager.list_templates
+
+                if templates.empty?
+                  BaseTool.text_response(
+                    "No templates defined. Templates can be created in .sxn/templates.yml"
+                  )
+                else
+                  formatted = templates.map do |t|
+                    desc = t[:description] ? " - #{t[:description]}" : ""
+                    "- #{t[:name]} (#{t[:project_count]} projects)#{desc}"
+                  end.join("\n")
+
+                  BaseTool.text_response("Available templates:\n#{formatted}")
+                end
+              end
+            end
+          end
+        end
+
+        # Apply a template to a session
+        class ApplyTemplate < ::MCP::Tool
+          description "Apply a template to create multiple worktrees in a session"
+
+          input_schema(
+            type: "object",
+            properties: {
+              template_name: {
+                type: "string",
+                description: "Template name to apply"
+              },
+              session_name: {
+                type: "string",
+                description: "Target session (defaults to current session)"
+              }
+            },
+            required: ["template_name"]
+          )
+
+          class << self
+            def call(template_name:, server_context:, session_name: nil)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                template_manager = server_context[:template_manager]
+                worktree_manager = server_context[:worktree_manager]
+                session_manager = server_context[:session_manager]
+                config_manager = server_context[:config_manager]
+
+                # Get session (use current if not specified)
+                session_name ||= config_manager.current_session
+                raise Sxn::NoActiveSessionError, "No active session" unless session_name
+
+                session = session_manager.get_session(session_name)
+                raise Sxn::SessionNotFoundError, "Session '#{session_name}' not found" unless session
+
+                # Validate template
+                template_manager.validate_template(template_name)
+
+                # Get template projects with default branch
+                default_branch = session[:default_branch] || session_name
+                projects = template_manager.get_template_projects(template_name, default_branch: default_branch)
+
+                # Create worktrees for each project
+                results = []
+                projects.each do |project|
+                  result = worktree_manager.add_worktree(
+                    project[:name],
+                    project[:branch],
+                    session_name: session_name
+                  )
+                  results << { project: project[:name], status: "success", path: result[:path] }
+                rescue StandardError => e
+                  results << { project: project[:name], status: "error", error: e.message }
+                end
+
+                # Format output
+                successful = results.select { |r| r[:status] == "success" }
+                failed = results.select { |r| r[:status] == "error" }
+
+                output = "Template '#{template_name}' applied to session '#{session_name}'.\n\n"
+                output += "Created #{successful.length} worktree(s):\n"
+                successful.each { |r| output += "  - #{r[:project]}: #{r[:path]}\n" }
+
+                unless failed.empty?
+                  output += "\nFailed (#{failed.length}):\n"
+                  failed.each { |r| output += "  - #{r[:project]}: #{r[:error]}\n" }
+                end
+
+                BaseTool.text_response(output.strip)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Sxn
+  module MCP
+    module Tools
+      module Worktrees
+        # List worktrees in a session
+        class ListWorktrees < ::MCP::Tool
+          description "List all worktrees in a session"
+
+          input_schema(
+            type: "object",
+            properties: {
+              session_name: {
+                type: "string",
+                description: "Session name (defaults to current session)"
+              }
+            },
+            required: []
+          )
+
+          class << self
+            def call(server_context:, session_name: nil)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                worktree_manager = server_context[:worktree_manager]
+                worktrees = worktree_manager.list_worktrees(session_name: session_name)
+
+                if worktrees.empty?
+                  BaseTool.text_response("No worktrees found in the session.")
+                else
+                  formatted = worktrees.map do |w|
+                    status_icon = case w[:status]
+                                  when "clean" then "[clean]"
+                                  when "modified" then "[modified]"
+                                  when "staged" then "[staged]"
+                                  when "untracked" then "[untracked]"
+                                  when "missing" then "[missing]"
+                                  else "[#{w[:status]}]"
+                                  end
+                    "- #{w[:project]} (#{w[:branch]}) #{status_icon}\n  #{w[:path]}"
+                  end.join("\n")
+
+                  BaseTool.text_response("Worktrees (#{worktrees.length}):\n#{formatted}")
+                end
+              end
+            end
+          end
+        end
+
+        # Add a worktree to a session
+        class AddWorktree < ::MCP::Tool
+          description "Add a project worktree to the current or specified session. " \
+                      "Automatically applies project rules after creation."
+
+          input_schema(
+            type: "object",
+            properties: {
+              project_name: {
+                type: "string",
+                description: "Registered project name"
+              },
+              branch: {
+                type: "string",
+                description: "Branch name (defaults to session's default branch)"
+              },
+              session_name: {
+                type: "string",
+                description: "Target session (defaults to current session)"
+              },
+              apply_rules: {
+                type: "boolean",
+                default: true,
+                description: "Apply project rules after creation (copy files, etc.)"
+              }
+            },
+            required: ["project_name"]
+          )
+
+          class << self
+            def call(project_name:, server_context:, branch: nil, session_name: nil, apply_rules: true)
+              BaseTool.ensure_initialized!(server_context)
+
+              BaseTool::ErrorMapping.wrap do
+                worktree_manager = server_context[:worktree_manager]
+
+                result = worktree_manager.add_worktree(
+                  project_name,
+                  branch,
+                  session_name: session_name
+                )
+
+                # Apply rules if requested
+                rules_result = nil
+                if apply_rules && server_context[:rules_manager]
+                  rules_result = apply_project_rules(
+                    server_context,
+                    project_name,
+                    result[:session]
+                  )
+                end
+
+                output = <<~RESULT
+                  Worktree created successfully:
+                  - Project: #{result[:project]}
+                  - Branch: #{result[:branch]}
+                  - Path: #{result[:path]}
+                  - Session: #{result[:session]}
+                RESULT
+
+                if rules_result
+                  output += "\nRules applied: #{rules_result[:applied_count]} rule(s)"
+                  output += "\nRule errors: #{rules_result[:errors].join(", ")}" unless rules_result[:errors].empty?
+                end
+
+                BaseTool.text_response(output.strip)
+              end
+            end
+
+            private
+
+            def apply_project_rules(server_context, project_name, session_name)
+              rules_manager = server_context[:rules_manager]
+              rules_manager.apply_rules(project_name, session_name)
+            rescue StandardError => e
+              # Don't fail worktree creation if rules fail
+              { applied_count: 0, errors: [e.message] }
+            end
+          end
+        end
+
+        # Remove a worktree from a session
+        class RemoveWorktree < ::MCP::Tool
+          description "Remove a worktree from a session"
+
+          input_schema(
+            type: "object",
+            properties: {
+              project_name: {
+                type: "string",
+                description: "Project name of the worktree to remove"
+              },
+              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
+                worktree_manager = server_context[:worktree_manager]
+                worktree_manager.remove_worktree(project_name, session_name: session_name)
+
+                BaseTool.text_response("Worktree for '#{project_name}' removed successfully.")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sxn/mcp.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+require_relative "mcp/server"
+require_relative "mcp/tools/base_tool"
+require_relative "mcp/tools/sessions"
+require_relative "mcp/tools/worktrees"
+require_relative "mcp/tools/projects"
+require_relative "mcp/tools/templates"
+require_relative "mcp/tools/rules"
+require_relative "mcp/resources/session_resources"
+require_relative "mcp/prompts/workflow_prompts"
+
+module Sxn
+  # MCP (Model Context Protocol) server for sxn
+  # Enables AI assistants like Claude Code to manage development sessions
+  module MCP
+  end
+end

data/lib/sxn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sxn
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/sxn.rb

@@ -13,6 +13,7 @@ require_relative "sxn/templates"
 require_relative "sxn/ui"
 require_relative "sxn/commands"
 require_relative "sxn/CLI"
+# MCP module is loaded on demand via require "sxn/mcp"
 
 module Sxn
   class << self