sxn 0.2.0

data/lib/sxn/templates.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Sxn Templates module provides secure, sandboxed template processing
+# using the Liquid template engine. It includes built-in templates for
+# common project types and comprehensive security measures.
+#
+# Features:
+# - Liquid-based template processing (safe, no code execution)
+# - Whitelisted variables and filters
+# - Built-in templates for Rails, JavaScript, and common projects
+# - Template security validation
+# - Variable collection from session, git, project, and environment
+# - Performance optimizations with caching
+#
+# Example usage:
+#   engine = Sxn::Templates::TemplateEngine.new(session: session, project: project)
+#   engine.process_template("rails/CLAUDE.md", "/path/to/output.md")
+
+require_relative "templates/errors"
+require_relative "templates/template_security"
+require_relative "templates/template_processor"
+require_relative "templates/template_variables"
+require_relative "templates/template_engine"
+
+module Sxn
+  module Templates
+  end
+end

data/lib/sxn/ui/output.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Sxn
+  module UI
+    # Formatted output with colors and status indicators
+    class Output
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      def success(message)
+        puts @pastel.green("✅ #{message}")
+      end
+
+      def error(message)
+        puts @pastel.red("❌ #{message}")
+      end
+
+      def warning(message)
+        puts @pastel.yellow("⚠️  #{message}")
+      end
+
+      def info(message)
+        puts @pastel.blue("ℹ️  #{message}")
+      end
+
+      def debug(message)
+        puts @pastel.dim("🔍 #{message}") if debug_mode?
+      end
+
+      def status(label, message, color = :blue)
+        colored_label = @pastel.public_send(color, "[#{label.upcase}]")
+        puts "#{colored_label} #{message}"
+      end
+
+      def section(title)
+        puts ""
+        puts @pastel.bold(@pastel.cyan("═" * 60))
+        puts @pastel.bold(@pastel.cyan("  #{title}"))
+        puts @pastel.bold(@pastel.cyan("═" * 60))
+        puts ""
+      end
+
+      def subsection(title)
+        puts ""
+        puts @pastel.bold(title.to_s)
+        puts @pastel.dim("─" * title.length)
+      end
+
+      def list_item(item, description = nil)
+        if description
+          puts "  • #{@pastel.bold(item)} - #{description}"
+        else
+          puts "  • #{item}"
+        end
+      end
+
+      def empty_state(message)
+        puts @pastel.dim("  #{message}")
+      end
+
+      def key_value(key, value, indent: 0)
+        spacing = " " * indent
+        puts "#{spacing}#{@pastel.bold(key)}: #{value}"
+      end
+
+      def progress_start(message)
+        print "#{message}... "
+      end
+
+      def progress_done
+        puts @pastel.green("✅")
+      end
+
+      def progress_failed
+        puts @pastel.red("❌")
+      end
+
+      def newline
+        puts ""
+      end
+
+      def recovery_suggestion(message)
+        puts ""
+        puts @pastel.yellow("💡 Suggestion: #{message}")
+      end
+
+      def command_example(command, description = nil)
+        puts "  #{@pastel.dim(description)}" if description
+        puts "  #{@pastel.cyan("$ #{command}")}"
+        puts ""
+      end
+
+      private
+
+      def debug_mode?
+        ENV["SXN_DEBUG"] == "true"
+      end
+    end
+  end
+end

data/lib/sxn/ui/progress_bar.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "tty-progressbar"
+
+module Sxn
+  module UI
+    # Progress bars for long-running operations
+    class ProgressBar
+      def initialize(title, total: 100, format: :classic)
+        format_string = case format
+                        when :classic
+                          "#{title} [:bar] :percent :elapsed"
+                        when :detailed
+                          "#{title} [:bar] :current/:total (:percent) :elapsed ETA: :eta"
+                        when :simple
+                          "#{title} :percent"
+                        else
+                          title
+                        end
+
+        @bar = TTY::ProgressBar.new(format_string, total: total, clear: true)
+      end
+
+      def advance(step = 1)
+        @bar.advance(step)
+      end
+
+      def finish
+        @bar.finish
+      end
+
+      def current
+        @bar.current
+      end
+
+      def total
+        @bar.total
+      end
+
+      def percent
+        @bar.percent
+      end
+
+      def log(message)
+        @bar.log(message)
+      end
+
+      def self.with_progress(title, items, format: :classic, &block)
+        return [] if items.empty?
+
+        progress = new(title, total: items.size, format: format)
+        results = []
+
+        items.each do |item|
+          result = block.call(item, progress)
+          results << result
+          progress.advance
+        end
+
+        progress.finish
+        results
+      end
+
+      def self.for_operation(title, total_steps: 5, &block)
+        progress = new(title, total: total_steps, format: :detailed)
+
+        stepper = Stepper.new(progress)
+        result = block.call(stepper)
+
+        progress.finish
+        result
+      end
+
+      # Helper class for step-by-step operations
+      class Stepper
+        def initialize(progress_bar)
+          @progress = progress_bar
+        end
+
+        def step(message = nil)
+          @progress.log(message) if message
+          @progress.advance
+        end
+
+        def log(message)
+          @progress.log(message)
+        end
+      end
+    end
+  end
+end

data/lib/sxn/ui/prompt.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+
+module Sxn
+  module UI
+    # Interactive prompts with validation
+    class Prompt
+      def initialize
+        @prompt = TTY::Prompt.new(interrupt: :exit)
+      end
+
+      def ask(message, options = {}, &)
+        @prompt.ask(message, **options, &)
+      end
+
+      def ask_yes_no(message, default: false)
+        @prompt.yes?(message, default: default)
+      end
+
+      def select(message, choices, options = {})
+        @prompt.select(message, choices, **options)
+      end
+
+      def multi_select(message, choices, options = {})
+        @prompt.multi_select(message, choices, **options)
+      end
+
+      def folder_name(message = "Enter sessions folder name:", default: nil)
+        ask(message, default: default) do |q|
+          q.validate(/\A[a-zA-Z0-9_-]+\z/, "Folder name must contain only letters, numbers, hyphens, and underscores")
+          q.modify :strip
+        end
+      end
+
+      def session_name(message = "Enter session name:", existing_sessions: [])
+        ask(message) do |q|
+          q.validate(/\A[a-zA-Z0-9_-]+\z/, "Session name must contain only letters, numbers, hyphens, and underscores")
+          q.validate(lambda { |name|
+            !existing_sessions.include?(name)
+          }, "Session name already exists")
+          q.modify :strip
+        end
+      end
+
+      def project_name(message = "Enter project name:")
+        ask(message) do |q|
+          q.validate(/\A[a-zA-Z0-9_-]+\z/, "Project name must contain only letters, numbers, hyphens, and underscores")
+          q.modify :strip
+        end
+      end
+
+      def project_path(message = "Enter project path:")
+        ask(message) do |q|
+          q.validate(lambda { |path|
+            expanded = File.expand_path(path)
+            File.directory?(expanded) && File.readable?(expanded)
+          }, "Path must be a readable directory")
+          q.modify :strip
+          q.convert ->(path) { File.expand_path(path) }
+        end
+      end
+
+      def branch_name(message = "Enter branch name:", default: nil)
+        ask(message, default: default) do |q|
+          q.validate(%r{\A[a-zA-Z0-9_/-]+\z}, "Branch name must be a valid git branch name")
+          q.modify :strip
+        end
+      end
+
+      def confirm_deletion(item_name, item_type = "item")
+        ask_yes_no("Are you sure you want to delete #{item_type} '#{item_name}'? This action cannot be undone.",
+                   default: false)
+      end
+
+      def rule_type
+        select("Select rule type:", [
+                 { name: "Copy Files", value: "copy_files" },
+                 { name: "Setup Commands", value: "setup_commands" },
+                 { name: "Template", value: "template" }
+               ])
+      end
+
+      def sessions_folder_setup
+        puts "Setting up sessions folder..."
+        puts "This will create a folder where all your development sessions will be stored."
+        puts ""
+
+        default_folder = "#{File.basename(Dir.pwd)}-sessions"
+        folder = folder_name("Sessions folder name:", default: default_folder)
+
+        current_dir = ask_yes_no("Create sessions folder in current directory?", default: true)
+
+        unless current_dir
+          base_path = project_path("Base path for sessions folder:")
+          folder = File.join(base_path, folder)
+        end
+
+        folder
+      end
+
+      def project_detection_confirm(detected_projects)
+        return false if detected_projects.empty?
+
+        puts ""
+        puts "Detected projects in current directory:"
+        detected_projects.each do |project|
+          puts "  #{project[:name]} (#{project[:type]}) - #{project[:path]}"
+        end
+        puts ""
+
+        ask_yes_no("Would you like to register these projects automatically?", default: true)
+      end
+    end
+  end
+end

data/lib/sxn/ui/table.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "tty-table"
+require "pastel"
+
+module Sxn
+  module UI
+    # Table formatting for lists and data display
+    class Table
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      def sessions(sessions)
+        return empty_table("No sessions found") if sessions.empty?
+
+        headers = %w[Name Status Projects Created Updated]
+        rows = sessions.map do |session|
+          [
+            session[:name],
+            status_indicator(session[:status]),
+            session[:projects]&.join(", ") || "",
+            format_date(session[:created_at]),
+            format_date(session[:updated_at])
+          ]
+        end
+
+        render_table(headers, rows)
+      end
+
+      def projects(projects)
+        return empty_table("No projects configured") if projects.empty?
+
+        headers = ["Name", "Type", "Path", "Default Branch"]
+        rows = projects.map do |project|
+          [
+            project[:name],
+            project[:type] || "unknown",
+            truncate_path(project[:path]),
+            project[:default_branch] || "master"
+          ]
+        end
+
+        render_table(headers, rows)
+      end
+
+      def worktrees(worktrees)
+        return empty_table("No worktrees in current session") if worktrees.empty?
+
+        headers = %w[Project Branch Path Status]
+        rows = worktrees.map do |worktree|
+          [
+            worktree[:project],
+            worktree[:branch],
+            truncate_path(worktree[:path]),
+            worktree_status(worktree)
+          ]
+        end
+
+        render_table(headers, rows)
+      end
+
+      def rules(rules, project_filter = nil)
+        filtered_rules = project_filter ? rules.select { |r| r[:project] == project_filter } : rules
+        return empty_table("No rules configured") if filtered_rules.empty?
+
+        headers = %w[Project Type Config Status]
+        rows = filtered_rules.map do |rule|
+          [
+            rule[:project],
+            rule[:type],
+            truncate_config(rule[:config]),
+            rule[:enabled] ? @pastel.green("✓") : @pastel.red("✗")
+          ]
+        end
+
+        render_table(headers, rows)
+      end
+
+      def config_summary(config)
+        headers = %w[Setting Value Source]
+        rows = [
+          ["Sessions Folder", config[:sessions_folder] || "Not set", "config"],
+          ["Current Session", config[:current_session] || "None", "config"],
+          ["Auto Cleanup", config[:auto_cleanup] ? "Enabled" : "Disabled", "config"],
+          ["Max Sessions", config[:max_sessions] || "Unlimited", "config"]
+        ]
+
+        render_table(headers, rows)
+      end
+
+      # Add a header to the table output
+      def header(title)
+        puts "\n#{@pastel.bold.underline(title)}"
+        puts
+      end
+
+      private
+
+      def render_table(headers, rows)
+        table = TTY::Table.new(header: headers, rows: rows)
+        puts table.render(:unicode, padding: [0, 1])
+      end
+
+      def empty_table(message)
+        puts @pastel.dim("  #{message}")
+      end
+
+      def status_indicator(status)
+        case status
+        when "active"
+          @pastel.green("● Active")
+        when "inactive"
+          @pastel.yellow("○ Inactive")
+        when "archived"
+          @pastel.dim("◌ Archived")
+        else
+          @pastel.dim("? Unknown")
+        end
+      end
+
+      def worktree_status(worktree)
+        if File.directory?(worktree[:path])
+          if git_clean?(worktree[:path])
+            @pastel.green("Clean")
+          else
+            @pastel.yellow("Modified")
+          end
+        else
+          @pastel.red("Missing")
+        end
+      rescue StandardError
+        @pastel.red("Missing")
+      end
+
+      def git_clean?(path)
+        result = Dir.chdir(path) do
+          system("git diff-index --quiet HEAD --", out: File::NULL, err: File::NULL)
+        end
+        !!result
+      rescue StandardError
+        false
+      end
+
+      def format_date(date_string)
+        return "" unless date_string
+
+        date = Time.parse(date_string)
+        if date > Time.now - 86_400 # Within 24 hours
+          date.strftime("%H:%M")
+        elsif date > Time.now - 604_800 # Within a week
+          date.strftime("%a %H:%M")
+        else
+          date.strftime("%m/%d")
+        end
+      rescue StandardError
+        date_string
+      end
+
+      def truncate_path(path, max_length: 30)
+        return "" unless path
+        return path if path.length <= max_length
+
+        # Show just the filename with "..." prefix
+        filename = File.basename(path)
+        "...#{filename}"
+      end
+
+      def truncate_config(config, max_length: 40)
+        return "" unless config
+
+        config_str = config.is_a?(String) ? config : config.to_s
+        return config_str if config_str.length <= max_length
+
+        # Take the beginning and add "..." at the end
+        # For max_length 20, we want "This is a very lo..." (20 chars total)
+        # So we take first 17 chars + "..." = 20 chars total
+        truncate_length = max_length - 3
+        "#{config_str[0, truncate_length]}..."
+      end
+    end
+  end
+end

data/lib/sxn/ui.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "ui/prompt"
+require_relative "ui/output"
+require_relative "ui/table"
+require_relative "ui/progress_bar"
+
+module Sxn
+  # UI namespace for all user interface components
+  module UI
+  end
+end

data/lib/sxn/version.rb

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

data/lib/sxn.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require_relative "sxn/version"
+require_relative "sxn/errors"
+require_relative "sxn/runtime_validations"
+require_relative "sxn/config"
+require_relative "sxn/core"
+require_relative "sxn/database"
+require_relative "sxn/rules"
+require_relative "sxn/security"
+require_relative "sxn/templates"
+require_relative "sxn/ui"
+require_relative "sxn/commands"
+require_relative "sxn/CLI"
+
+module Sxn
+  class << self
+    attr_accessor :logger, :config
+
+    def root
+      File.expand_path("..", __dir__)
+    end
+
+    def lib_root
+      File.expand_path(__dir__)
+    end
+
+    def version
+      VERSION
+    end
+
+    def load_config
+      @config = Config.current
+    end
+
+    def setup_logger(level: :info)
+      require "logger"
+      @logger = Logger.new($stdout)
+
+      # Convert string level to symbol if needed
+      level = level.to_sym if level.is_a?(String)
+
+      @logger.level = case level
+                      when :debug then Logger::DEBUG
+                      when :info then Logger::INFO
+                      when :warn then Logger::WARN
+                      when :error then Logger::ERROR
+                      else Logger::INFO
+                      end
+
+      # Set custom formatter
+      @logger.formatter = proc do |severity, datetime, _progname, msg|
+        "[#{datetime.strftime("%Y-%m-%d %H:%M:%S")}] #{severity}: #{msg}\n"
+      end
+
+      @logger
+    end
+  end
+
+  # Initialize logger on module load unless in test environment
+  @logger = setup_logger unless defined?(RSpec)
+end