rails-markup 1.2.0

data/lib/generators/rails_markup/install_generator.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module RailsMarkup
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("install/templates", __dir__)
+
+      desc "Install Rails Markup: create migration, initializer, auth controller, toolbar, and mount engine routes."
+
+      class_option :mount_path, type: :string, default: "/admin/annotations",
+        desc: "Path to mount the Rails Markup engine"
+      class_option :base_controller, type: :string, default: "ApplicationController",
+        desc: "Base controller class for authentication"
+      class_option :layout, type: :string, default: "application",
+        desc: "Layout to inject the toolbar into"
+      class_option :table_name, type: :string, default: "rails_markup_annotations",
+        desc: "Database table name for annotations (must match config.table_name)"
+
+      def copy_migration
+        migration_template "create_rails_markup_annotations.rb.erb",
+          "db/migrate/create_rails_markup_annotations.rb"
+      end
+
+      def create_initializer
+        template "initializer.rb.erb", "config/initializers/rails_markup.rb"
+      end
+
+      # Keep the model's config.table_name in lockstep with the table the
+      # migration actually creates when a custom name is requested.
+      def configure_table_name
+        return if options[:table_name] == "rails_markup_annotations"
+
+        gsub_file "config/initializers/rails_markup.rb",
+          /^\s*#?\s*config\.table_name\s*=.*$/,
+          %(  config.table_name = "#{options[:table_name]}")
+      end
+
+      def create_auth_controller
+        template "auth_controller.rb.erb", "app/controllers/rails_markup_auth_controller.rb"
+      end
+
+      def mount_engine
+        mount_path = options[:mount_path]
+        route_line = %{mount RailsMarkup::Engine, at: "#{mount_path}" if defined?(RailsMarkup::Engine)}
+        route route_line
+      end
+
+      def inject_toolbar_into_layout
+        layout_path = "app/views/layouts/#{options[:layout]}.html.erb"
+
+        unless File.exist?(File.join(destination_root, layout_path))
+          say_status :skip, "#{layout_path} not found — add the toolbar manually", :yellow
+          return
+        end
+
+        toolbar_block = <<~ERB.indent(4)
+          <%# Rails Markup annotation toolbar %>
+          <% if lookup_context.exists?("rails_markup/shared/toolbar", [], true) %>
+            <%= render "rails_markup/shared/toolbar" %>
+          <% end %>
+        ERB
+
+        if File.read(File.join(destination_root, layout_path)).include?("rails_markup/shared/toolbar")
+          say_status :skip, "toolbar already present in #{layout_path}", :yellow
+          return
+        end
+
+        inject_into_file layout_path, toolbar_block, before: %r{</body>}
+      end
+
+      def inject_procfile
+        procfile = File.join(destination_root, "Procfile.dev")
+        return unless File.exist?(procfile)
+
+        content = File.read(procfile)
+
+        if content =~ /^markup:/
+          unless content =~ /^markup:\s*bin\/markup\s+server/
+            gsub_file "Procfile.dev", /^markup:.*$/, "markup: bin/markup server"
+            say_status :update, "Procfile.dev (markup → bin/markup server)", :green
+          else
+            say_status :skip, "Procfile.dev already uses bin/markup server", :yellow
+          end
+        else
+          append_to_file "Procfile.dev", "markup: bin/markup server\n"
+          say_status :append, "Procfile.dev (added markup server)", :green
+        end
+      end
+
+      def create_bin_wrapper
+        template "bin_markup.erb", "bin/markup"
+        chmod "bin/markup", 0o755
+      end
+
+      def configure_mcp
+        require_relative "../../rails_markup/mcp_config"
+        config = RailsMarkup::McpConfig.new(dir: destination_root)
+        dev_url = detect_dev_url
+        env_updates = {
+          "RAILS_MARKUP_DEV_URL" => dev_url,
+          "RAILS_MARKUP_MOUNT_PATH" => options[:mount_path]
+        }
+        config.update_env(env_updates)
+        say_status :create, ".mcp.json (dev URL: #{dev_url})", :green
+      end
+
+      def show_post_install
+        say ""
+        say "Rails Markup installed successfully!", :green
+        say ""
+        say "Created:"
+        say "  - db/migrate/*_create_rails_markup_annotations.rb"
+        say "  - config/initializers/rails_markup.rb"
+        say "  - app/controllers/rails_markup_auth_controller.rb"
+        say "  - bin/markup"
+        say "  - .mcp.json (MCP config for AI agents)"
+        say ""
+        say "Next steps:"
+        say "  1. Run migrations:  rails db:migrate"
+        say "  2. Visit dashboard: #{options[:mount_path]}"
+        say "  3. Configure auth in config/initializers/rails_markup.rb"
+        say ""
+        dev_url = detect_dev_url
+        unless dev_url == "http://localhost:3000"
+          say "Detected dev server: #{dev_url} (from Procfile.dev)"
+        end
+        say ""
+        say "Not using localhost:3000? Update your dev URL:", :yellow
+        say "  bin/markup configure --dev-url=http://YOUR_HOST:PORT"
+        say ""
+        say "CLI commands:"
+        say "  bin/markup fetch              # See pending annotations"
+        say "  bin/markup fetch --env=production  # From production"
+        say "  bin/markup configure --prod-url=URL --prod-token=TOKEN"
+        say "  bin/markup status             # Show current config"
+        say ""
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def detect_dev_url
+        # Try to read bind address and port from Procfile.dev
+        procfile = File.join(destination_root, "Procfile.dev")
+        if File.exist?(procfile)
+          content = File.read(procfile)
+          if content =~ /-b\s+([\d.]+)\s+-p\s+(\d+)/
+            return "http://#{$1}:#{$2}"
+          end
+          if content =~ /-p\s+(\d+)/
+            return "http://localhost:#{$1}"
+          end
+        end
+
+        "http://localhost:3000"
+      end
+    end
+  end
+end

data/lib/generators/rails_markup/uninstall_generator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RailsMarkup
+  module Generators
+    class UninstallGenerator < Rails::Generators::Base
+      desc "Uninstall Rails Markup: remove initializer, auth controller, toolbar, routes, and bin wrapper."
+
+      class_option :remove_migration, type: :boolean, default: false,
+        desc: "Also remove the migration file (dangerous — only if table was never created)"
+
+      def remove_route_mount
+        route_file = File.join(destination_root, "config/routes.rb")
+        return unless File.exist?(route_file)
+
+        gsub_file "config/routes.rb", /^\s*mount RailsMarkup::Engine.*\n/, ""
+        say_status :remove, "RailsMarkup engine mount from routes", :green
+      end
+
+      def remove_initializer
+        path = "config/initializers/rails_markup.rb"
+        remove_file path if File.exist?(File.join(destination_root, path))
+      end
+
+      def remove_auth_controller
+        path = "app/controllers/rails_markup_auth_controller.rb"
+        full_path = File.join(destination_root, path)
+        return unless File.exist?(full_path)
+
+        content = File.read(full_path)
+        if content.include?("RailsMarkupAuthController")
+          remove_file path
+        else
+          say_status :skip, "#{path} doesn't match generated pattern — leaving in place", :yellow
+        end
+      end
+
+      def remove_toolbar_from_layouts
+        Dir.glob(File.join(destination_root, "app/views/layouts/*.html.erb")).each do |layout|
+          relative = layout.sub("#{destination_root}/", "")
+          content = File.read(layout)
+          next unless content.include?("rails_markup/shared/toolbar")
+
+          gsub_file relative, /^\s*<%# Rails Markup annotation toolbar %>\n/, ""
+          gsub_file relative, /^\s*<% if lookup_context\.exists\?\("rails_markup\/shared\/toolbar".*%>\n\s*<%= render "rails_markup\/shared\/toolbar" %>\n\s*<% end %>\n/, ""
+          say_status :remove, "toolbar from #{relative}", :green
+        end
+      end
+
+      def remove_mcp_config
+        mcp_path = File.join(destination_root, ".mcp.json")
+        return unless File.exist?(mcp_path)
+
+        config = JSON.parse(File.read(mcp_path))
+        server = config.dig("mcpServers", "rails-markup")
+        return unless server
+
+        config["mcpServers"].delete("rails-markup")
+
+        if config["mcpServers"].empty?
+          remove_file ".mcp.json"
+        else
+          File.write(mcp_path, JSON.pretty_generate(config) + "\n")
+          say_status :remove, "rails-markup entry from .mcp.json", :green
+        end
+      rescue JSON::ParserError
+        say_status :skip, ".mcp.json has invalid JSON — leaving in place", :yellow
+      end
+
+      def remove_bin_wrapper
+        path = "bin/markup"
+        full_path = File.join(destination_root, path)
+        return unless File.exist?(full_path)
+
+        content = File.read(full_path)
+        if content.include?("rails_markup") || content.include?("RailsMarkup")
+          remove_file path
+        else
+          say_status :skip, "#{path} doesn't reference rails_markup — leaving in place", :yellow
+        end
+      end
+
+      def remove_migration
+        return unless options[:remove_migration]
+
+        migration = Dir.glob(File.join(destination_root, "db/migrate/*_create_rails_markup_annotations.rb")).first
+        if migration
+          remove_file migration.sub("#{destination_root}/", "")
+        else
+          say_status :skip, "no rails_markup migration found", :yellow
+        end
+      end
+
+      def show_post_uninstall
+        say ""
+        say "Rails Markup uninstalled.", :green
+        say ""
+        say "Remaining manual steps:"
+        say "  1. Remove 'rails_markup' from your Gemfile and run bundle"
+        unless options[:remove_migration]
+          say "  2. Drop the table: rails db:migrate:down VERSION=<migration_version>"
+          say "     Or: rails generate rails_markup:uninstall --remove-migration"
+        end
+        say "  3. Search for stale references: grep -r 'rails_markup\\|RailsMarkup' app/ config/"
+        say ""
+      end
+    end
+  end
+end

data/lib/rails_markup/cli/base.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module RailsMarkup
+  class Cli < Thor
+  end
+end

data/lib/rails_markup/cli/initializer_writer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module RailsMarkup
+  class Cli
+    # Reads/writes config/initializers/rails_markup.rb with upsert semantics.
+    # Handles toolbar_accent, toolbar_position, toolbar_size, enable_screenshots,
+    # toolbar_enabled, fab_visible.
+    class InitializerWriter
+      MANAGED_KEYS = %w[toolbar_accent toolbar_position toolbar_size enable_screenshots toolbar_enabled fab_visible].freeze
+
+      def initialize(dir: Dir.pwd)
+        @path = File.join(dir, "config", "initializers", "rails_markup.rb")
+      end
+
+      def write(**options)
+        content = File.exist?(@path) ? File.read(@path) : template
+        options.each do |key, value|
+          content = upsert_config(content, key.to_s, value)
+        end
+        File.write(@path, content)
+      end
+
+      private
+
+      def upsert_config(content, key, value)
+        formatted = format_value(value)
+        pattern = /^(\s*)#?\s*config\.#{Regexp.escape(key)}\s*=.*$/
+
+        if content.match?(pattern)
+          content.gsub(pattern, "\\1config.#{key} = #{formatted}")
+        else
+          content.sub(/^(end\s*)$/, "  config.#{key} = #{formatted}\n\\1")
+        end
+      end
+
+      def format_value(value)
+        case value
+        when true, false then value.to_s
+        when Integer, Float then value.to_s
+        else %("#{value}")
+        end
+      end
+
+      def template
+        <<~RUBY
+          RailsMarkup.configure do |config|
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rails_markup/cli/setup_wizard.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "bubbletea"
+require "lipgloss"
+require_relative "base"
+require_relative "../mcp_config"
+require_relative "initializer_writer"
+
+module RailsMarkup
+  class Cli
+    # Interactive TUI setup wizard using Bubbletea's Elm architecture.
+    # State machine: accent → position → size → fab → screenshots → url → scope → confirm
+    class SetupWizard
+      include Bubbletea::Model
+
+      STEPS = %i[accent position size fab screenshots url scope confirm].freeze
+
+      STEP_CONFIG = {
+        accent: {
+          title: "Toolbar Accent",
+          type: :select,
+          options: %w[indigo amber blue emerald rose]
+        },
+        position: {
+          title: "Toolbar Position",
+          type: :select,
+          options: %w[bl br tl tr],
+          labels: { "bl" => "Bottom-left", "br" => "Bottom-right", "tl" => "Top-left", "tr" => "Top-right" }
+        },
+        size: {
+          title: "Toolbar Size",
+          type: :select,
+          options: %w[slim compact default],
+          labels: { "slim" => "Slim (32px)", "compact" => "Compact (40px)", "default" => "Default (48px)" }
+        },
+        fab: {
+          title: "Show Floating Button",
+          type: :select,
+          options: %w[yes no],
+          labels: { "yes" => "Yes — show the FAB", "no" => "No — hide the FAB (pins still show)" }
+        },
+        screenshots: {
+          title: "Enable Screenshots",
+          type: :select,
+          options: %w[yes no],
+          labels: { "yes" => "Yes", "no" => "No" }
+        },
+        url: {
+          title: "Production URL",
+          type: :text,
+          hint: "Optional — press Enter to skip"
+        },
+        scope: {
+          title: "MCP Server Scope",
+          type: :select,
+          options: %w[local global codex],
+          labels: {
+            "local"  => "This project only (.mcp.json)",
+            "global" => "All projects — Claude Code (~/.claude/settings.json)",
+            "codex"  => "All projects — Codex CLI (~/.codex/config.toml)"
+          }
+        },
+        confirm: {
+          title: "Confirm Setup",
+          type: :confirm
+        }
+      }.freeze
+
+      HEADER_STYLE = Lipgloss::Style.new.bold(true).foreground("#FFFFFF").background("#5C4AE4").padding(0, 1)
+      HINT_STYLE   = Lipgloss::Style.new.foreground("#6B7280")
+      CURSOR_STYLE = Lipgloss::Style.new.bold(true).foreground("#818cf8")
+      OPTION_STYLE = Lipgloss::Style.new.foreground("#E2E2E2")
+
+      attr_reader :completed, :choices
+
+      def initialize(dir: Dir.pwd)
+        @dir = dir
+        @step_index = 0
+        @cursor = 0
+        @choices = {}
+        @text_input = ""
+        @completed = false
+      end
+
+      def init
+        [self, nil]
+      end
+
+      def update(message)
+        case message
+        when Bubbletea::KeyMessage
+          handle_key(message)
+        else
+          [self, nil]
+        end
+      end
+
+      def view
+        step = current_step
+        config = STEP_CONFIG[step]
+
+        lines = []
+        lines << HEADER_STYLE.render(" Rails Markup Setup — Step #{@step_index + 1}/#{STEPS.size} ")
+        lines << ""
+        lines << "  #{config[:title]}"
+        lines << ""
+
+        case config[:type]
+        when :select
+          config[:options].each_with_index do |opt, i|
+            label = config.dig(:labels, opt) || opt
+            if i == @cursor
+              lines << "  #{CURSOR_STYLE.render("▸")} #{label}"
+            else
+              lines << "    #{OPTION_STYLE.render(label)}"
+            end
+          end
+        when :text
+          lines << "  #{HINT_STYLE.render(config[:hint])}"
+          lines << ""
+          lines << "  > #{@text_input}█"
+        when :confirm
+          lines << render_summary
+          lines << ""
+          lines << "  #{HINT_STYLE.render("Press Enter to write config, Esc to cancel")}"
+        end
+
+        lines << ""
+        lines << "  #{HINT_STYLE.render("↑/↓ navigate · Enter select · Esc cancel")}" unless step == :confirm
+
+        lines.join("\n")
+      end
+
+      private
+
+      def current_step
+        STEPS[@step_index]
+      end
+
+      def handle_key(msg)
+        return [self, Bubbletea.quit] if msg.esc?
+
+        step = current_step
+        config = STEP_CONFIG[step]
+
+        case config[:type]
+        when :select then handle_select(msg, config)
+        when :text   then handle_text(msg)
+        when :confirm then handle_confirm(msg)
+        else [self, nil]
+        end
+      end
+
+      def handle_select(msg, config)
+        if msg.up?
+          @cursor = (@cursor - 1) % config[:options].size
+        elsif msg.down?
+          @cursor = (@cursor + 1) % config[:options].size
+        elsif msg.enter?
+          value = config[:options][@cursor]
+          store_choice(current_step, value)
+          advance_step
+        end
+
+        [self, nil]
+      end
+
+      def handle_text(msg)
+        if msg.enter?
+          store_choice(:url, @text_input.empty? ? nil : @text_input)
+          advance_step
+        elsif msg.backspace?
+          @text_input = @text_input[0..-2] || ""
+        elsif msg.runes?
+          @text_input += msg.char if msg.char
+        end
+
+        [self, nil]
+      end
+
+      def handle_confirm(msg)
+        if msg.enter?
+          write_config
+          @completed = true
+          return [self, Bubbletea.quit]
+        end
+
+        [self, nil]
+      end
+
+      def store_choice(step, value)
+        case step
+        when :accent      then @choices[:toolbar_accent] = value
+        when :position    then @choices[:toolbar_position] = value
+        when :size        then @choices[:toolbar_size] = value
+        when :fab         then @choices[:fab_visible] = (value == "yes")
+        when :screenshots then @choices[:enable_screenshots] = (value == "yes")
+        when :url         then @choices[:url] = value
+        when :scope       then @choices[:scope] = value
+        end
+      end
+
+      def advance_step
+        @step_index += 1
+        @cursor = 0
+        @text_input = ""
+      end
+
+      def write_config
+        writer = InitializerWriter.new(dir: @dir)
+        init_opts = @choices.except(:url, :scope)
+        writer.write(**init_opts)
+
+        scope = @choices[:scope] || "local"
+        config = McpConfig.new(dir: @dir, scope: scope)
+        env_vars = {}
+        env_vars["RAILS_MARKUP_PROD_URL"] = @choices[:url] if @choices[:url]
+        config.update_env(env_vars)
+      end
+
+      def render_summary
+        lines = @choices.map do |key, value|
+          "  #{key}: #{value.nil? ? '(skipped)' : value}"
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end