mighost 0.4.0

data/lib/mighost/git_recovery.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "time"
+require "shellwords"
+require_relative "git_metadata"
+
+module Mighost
+  # Searches git history to find migration files that exist in other branches/commits
+  module GitRecovery
+    class << self
+      # Find migration file content from git history
+      # Returns { content:, filename:, branch:, sha:, commit_date: } or nil
+      def find_migration(version)
+        return nil unless GitMetadata.git_available?
+
+        # Search for the migration file across all branches using --all
+        pattern = "db/migrate/#{version}_*.rb"
+
+        result = find_latest_commit_with_file(pattern)
+        return nil unless result
+
+        content = get_file_content(result[:sha], result[:path])
+        return nil unless content
+
+        {
+          content: content,
+          filename: File.basename(result[:path]),
+          branch: result[:branch],
+          sha: result[:sha][0, 12],
+          commit_date: result[:date],
+          author_name: result[:author_name],
+          author_email: result[:author_email]
+        }
+      end
+
+      private
+
+      def find_latest_commit_with_file(pattern)
+        # Use git log --all to search across ALL refs in a single command
+        # %D shows decorated refs (branches/tags pointing to commit)
+        # --name-only includes the filename in output
+        # --diff-filter=d excludes deletion commits: without it, a migration whose
+        # last touch was a delete resolves to the deleting commit, where the file
+        # no longer exists and `git show` fails
+        fmt = "%H\t%aI\t%D\t%aN\t%aE"
+        cmd = "git log --all -1 --diff-filter=d --format='#{fmt}' --name-only -- #{Shellwords.escape(pattern)} 2>/dev/null"
+        output = `#{cmd}`.strip
+        return nil if output.empty?
+
+        lines = output.split("\n").map(&:strip).reject(&:empty?)
+        return nil if lines.empty?
+
+        # First non-empty line: commit info (sha\tdate\tdecorated_refs\tauthor_name\tauthor_email)
+        commit_line = lines[0]
+        sha, date_str, decorated_refs, author_name, author_email = commit_line.split("\t", 5)
+        return nil unless sha && date_str
+
+        # Second non-empty line: the file path
+        file_path = lines[1]
+        return nil if file_path.nil? || file_path.empty?
+
+        date = begin
+          Time.parse(date_str)
+        rescue
+          nil
+        end
+        return nil unless date
+
+        # Extract branch name from decorated refs (may be empty if commit is not a branch tip)
+        branch = extract_branch_from_decorated_refs(decorated_refs)
+
+        # If no branch found from decoration, try to find which branch contains this commit
+        branch ||= find_branch_containing_commit(sha)
+
+        {
+          sha: sha,
+          path: file_path,
+          branch: branch,
+          date: date,
+          author_name: author_name,
+          author_email: author_email
+        }
+      end
+
+      def extract_branch_from_decorated_refs(refs)
+        return nil if refs.nil? || refs.strip.empty?
+
+        # Decorated refs look like: "HEAD -> main, origin/main, feature-branch"
+        # Extract the first branch-like ref
+        refs.split(",").each do |ref|
+          ref = ref.strip
+          ref = ref.sub(/^HEAD -> /, "")
+          ref = ref.sub(%r{^origin/}, "")
+          next if ref.empty? || ref.start_with?("tag:")
+
+          return ref
+        end
+        nil
+      end
+
+      def find_branch_containing_commit(sha)
+        # Find branches that contain this commit
+        output = `git branch -a --contains #{sha} 2>/dev/null`.strip
+        return nil if output.empty?
+
+        # Parse output - each line is a branch name, * = current branch, + = worktree-checked-out
+        lines = output.split("\n").map { |l| l.sub(/^[*+]?\s*/, "").strip }
+        return nil if lines.empty?
+
+        # Prefer local branches over remote, clean up names
+        lines.each do |branch|
+          next if branch.start_with?("remotes/")
+          return branch
+        end
+
+        # Fall back to first remote branch, cleaned up
+        first = lines.first
+        first&.sub(%r{^remotes/origin/}, "")
+      end
+
+      def get_file_content(sha, path)
+        content = `git show #{Shellwords.escape("#{sha}:#{path}")} 2>/dev/null`
+        return nil unless $?.success?
+
+        content
+      end
+    end
+  end
+end

data/lib/mighost/migrator_extension.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "capturer"
+
+module Mighost
+  module MigratorExtension
+    def record_version_state_after_migrating(version)
+      super
+
+      # Only capture on UP migrations, not DOWN
+      return unless up?
+
+      migration = migrations.find { |m| m.version == version }
+      return unless migration
+
+      Capturer.new(version, migration.filename).capture
+    end
+
+    private
+
+    def up?
+      @direction == :up
+    end
+  end
+end
+
+# Prepend to ActiveRecord::Migrator
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Migrator.prepend(Mighost::MigratorExtension)
+end

data/lib/mighost/orphan_detector.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/enumerable"
+require_relative "snapshot"
+require_relative "git_metadata"
+
+module Mighost
+  class OrphanDetector
+    class OrphanedMigration
+      attr_reader :version, :filename, :branch_name, :git_sha, :migrated_at, :source, :dismissed, :author_name, :author_email
+
+      def initialize(version:, filename: nil, branch_name: nil, git_sha: nil, migrated_at: nil, source: nil, dismissed: false, author_name: nil, author_email: nil)
+        @version = version
+        @filename = filename
+        @branch_name = branch_name
+        @git_sha = git_sha
+        @migrated_at = migrated_at
+        @source = source
+        @dismissed = dismissed
+        @author_name = author_name
+        @author_email = author_email
+      end
+
+      def recoverable?
+        source.present?
+      end
+
+      def recovery_source
+        case source
+        when "file" then :snapshot
+        when "git" then :branch
+        when "worktree" then :worktree
+        end
+      end
+
+      # Parse version timestamp (YYYYMMDDHHmmss) -> Time
+      def created_at
+        return @created_at if defined?(@created_at)
+
+        @created_at = begin
+          if version =~ /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/
+            Time.new($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i)
+          end
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      # Is migration older than threshold?
+      def old?(threshold: Mighost.configuration.dismiss_old_threshold)
+        return false unless created_at
+
+        created_at < threshold.ago
+      end
+
+      # Should suggest dismissal? (unrecoverable AND old)
+      def suggested_for_dismiss?
+        !recoverable? && old?
+      end
+
+      # Is actionable? (recoverable OR not old enough to suggest dismissal)
+      def actionable?
+        !suggested_for_dismiss?
+      end
+    end
+
+    class << self
+      attr_accessor :debug
+
+      # Detect orphaned migrations using cached snapshot data only (instant)
+      # @param include_dismissed [Boolean] whether to include dismissed migrations (default: false)
+      def detect(include_dismissed: false)
+        # Load everything upfront for performance
+        versions = migrated_versions
+        file_versions = migration_file_versions
+        dismissed_set = Snapshot.dismissed_versions.to_set
+        snapshots_by_version = Snapshot.all_metadata.index_by(&:version)
+
+        log "Found #{versions.count} migrated versions, #{file_versions.count} files on disk"
+
+        orphaned = []
+        versions.each do |version|
+          # Skip if file exists on disk
+          next if file_versions.include?(version)
+
+          # Skip dismissed unless requested
+          is_dismissed = dismissed_set.include?(version)
+          next if is_dismissed && !include_dismissed
+
+          snapshot = snapshots_by_version[version]
+          log "  #{version} - orphaned#{", has snapshot (#{snapshot.source})" if snapshot}"
+
+          orphaned << OrphanedMigration.new(
+            version: version,
+            filename: snapshot&.filename,
+            branch_name: snapshot&.branch_name,
+            git_sha: snapshot&.git_sha,
+            migrated_at: snapshot&.migrated_at,
+            source: snapshot&.source,
+            dismissed: is_dismissed,
+            author_name: snapshot&.author_name,
+            author_email: snapshot&.author_email
+          )
+        end
+
+        log "Done. Found #{orphaned.count} orphaned migrations."
+        orphaned.sort_by(&:version).reverse
+      end
+
+      def orphaned_count
+        detect.count
+      end
+
+      def recoverable_count
+        detect.count(&:recoverable?)
+      end
+
+      # Get stored scan metadata
+      def scan_metadata
+        Snapshot.scan_metadata
+      end
+
+      # Check if current branch/sha differs from last scan
+      def branch_changed?
+        metadata = scan_metadata
+        return false unless metadata
+
+        current_branch = GitMetadata.current_branch
+        current_sha = GitMetadata.current_sha
+
+        metadata[:branch] != current_branch || metadata[:sha] != current_sha
+      end
+
+      private
+
+      def log(msg)
+        puts "[mighost] #{msg}" if debug
+      end
+
+      def migrated_versions
+        Mighost::Base.connection
+          .select_values("SELECT version FROM #{schema_migrations_table}")
+          .map(&:to_s)
+      end
+
+      def schema_migrations_table
+        Mighost::Base.connection.quote_table_name("schema_migrations")
+      end
+
+      # Load all migration file versions at once (single glob per path)
+      def migration_file_versions
+        versions = Set.new
+        migration_paths.each do |path|
+          Dir.glob(File.join(path, "*.rb")).each do |file|
+            version = File.basename(file).split("_").first
+            versions << version
+          end
+        end
+        versions
+      end
+
+      def migration_paths
+        if defined?(Rails) && Rails.application
+          Rails.application.config.paths["db/migrate"].to_ary
+        else
+          ["db/migrate"]
+        end
+      end
+    end
+  end
+end

data/lib/mighost/plain_ui.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/object/blank"
+require_relative "formatting"
+
+module Mighost
+  # PlainUI is the default UI adapter for mighost.
+  # It outputs plain, uncolored text suitable for any terminal.
+  #
+  # To provide custom (rich) output, replace this adapter:
+  #   Mighost.ui = YourCustomUI.new
+  #
+  # Adapter interface:
+  #   render_orphans(orphans)
+  #   render_records(records, limit:, total_count:)
+  #   render_recoverable_list(orphans)
+  #   render_scan_details(details)
+  #   render_scan_results(captured:, git_recovered:, worktree_recovered:, branch:, sha:)
+  #   render_dismiss_preview(versions, orphan_map)
+  #   render_dismissed_list(dismissed_snapshots)
+  #   confirm?(prompt) -> Boolean
+  #   confirm_each?(orphan) -> :yes, :no, :all, :quit
+  #   confirm_dismiss?(version, name) -> :yes, :no, :all, :quit
+  #   success(msg), error(msg), warning(msg), info(msg), hint(msg)
+  #
+  class PlainUI
+    include Formatting
+
+    def render_orphans(orphans)
+      if orphans.empty?
+        info "No orphaned migrations found."
+        return
+      end
+
+      actionable, suggested = orphans.partition(&:actionable?)
+
+      recoverable_count = orphans.count(&:recoverable?)
+      suggested_count = suggested.count
+
+      header_parts = ["#{orphans.count} total", "#{recoverable_count} recoverable"]
+      header_parts << "#{suggested_count} suggested to dismiss" if suggested_count.positive?
+      puts "\nOrphaned migrations (#{header_parts.join(", ")}):\n\n"
+
+      actionable.each { |o| puts "  #{orphan_line(o)}" }
+
+      if actionable.any? && suggested.any?
+        puts "\n  Suggested to dismiss (#{suggested.count} old, unrecoverable):\n"
+      end
+
+      suggested.each { |o| puts "  #{orphan_line(o)}" }
+
+      if suggested_count.positive?
+        puts "\nTip: Run 'rails mighost:dismiss OLD=1' to bulk-dismiss the #{suggested_count} old migrations."
+      end
+
+      if recoverable_count.positive?
+        puts "\nTip: Run 'rails mighost:rollback' to rollback recoverable migrations."
+      end
+    end
+
+    def render_records(records, limit: nil, total_count: nil)
+      if records.empty?
+        info "No migration records stored."
+        return
+      end
+
+      count_text = if limit && total_count && total_count > records.count
+        "#{records.count} of #{total_count}"
+      else
+        records.count.to_s
+      end
+
+      output = []
+      output << "\nMigration records (#{count_text}):\n\n"
+      records.each do |record|
+        version = format_version(record.version)
+        name = format_name(record.filename)
+        branch = truncate(record.branch_name || "-", 25)
+        sha = record.git_sha || "-"
+        captured = format_captured_at(record.migrated_at)
+        author = truncate(record.author_name || "-", 20)
+
+        output << "  #{version}  #{name.ljust(42)}  #{branch.ljust(27)}  #{sha.ljust(14)}  #{captured}  #{author}\n"
+      end
+
+      text = output.join
+
+      if $stdout.tty? && records.size > 30 && !limit
+        pager = ENV["PAGER"] || "less"
+        IO.popen(pager, "w") { |io| io.puts text }
+      else
+        print text
+      end
+    end
+
+    def render_recoverable_list(orphans)
+      puts "\nRecoverable orphaned migrations:"
+      orphans.each do |orphan|
+        name = orphan.filename || "(unknown)"
+        puts "  #{orphan.version} - #{name}"
+      end
+    end
+
+    def render_scan_details(details)
+      details.each do |detail|
+        case detail[:type]
+        when :captured
+          info "Captured: #{detail[:filename]}"
+        when :git_recovered
+          info "Git recovered: #{detail[:filename]} (from #{detail[:branch]})"
+        when :worktree_recovered
+          info "Worktree recovered: #{detail[:filename]} (from #{detail[:branch]})"
+        end
+      end
+    end
+
+    def render_scan_results(captured:, git_recovered:, worktree_recovered:, branch:, sha:)
+      puts ""
+      success "Scan complete:"
+      info "  Captured #{captured} migration(s) from files"
+      info "  Recovered #{git_recovered} orphan(s) from git history"
+      info "  Recovered #{worktree_recovered} orphan(s) from worktrees" if worktree_recovered > 0
+      info "  Context: #{branch} @ #{sha}"
+    end
+
+    def render_dismiss_preview(versions, orphan_map)
+      puts "\nFound #{versions.count} orphaned migration(s) to dismiss:\n"
+      preview_count = 10
+      versions.first(preview_count).each do |v|
+        puts "  #{v}  (#{format_version(v)})"
+      end
+      if versions.count > preview_count
+        remaining = versions.count - preview_count
+        puts "  ... and #{remaining} more up to #{format_version(versions.last)}"
+      end
+      puts ""
+    end
+
+    def render_dismiss_remaining(versions, orphan_map)
+      puts "\nDismissing all remaining:"
+      versions.each do |v|
+        o = orphan_map[v]
+        puts "  #{v} - #{o&.filename || "(unknown)"}"
+      end
+    end
+
+    def render_dismissed_list(dismissed_snapshots)
+      puts "\nDismissed migrations (#{dismissed_snapshots.count}):\n\n"
+      dismissed_snapshots.each do |version, snapshot|
+        name = snapshot&.filename.presence || "(unknown)"
+        dismissed_at = snapshot&.dismissed_at
+        date_str = dismissed_at ? " (dismissed #{dismissed_at[0, 10]})" : ""
+        puts "  #{version} - #{name}#{date_str}"
+      end
+      puts "\nTip: Use 'rails mighost:undismiss VERSION=x' to restore."
+    end
+
+    def confirm?(prompt)
+      print "\n#{prompt} [y/N] "
+      response = $stdin.gets.chomp.downcase
+      response == "y"
+    end
+
+    def confirm_each?(orphan)
+      name = orphan.filename || "(unknown)"
+      version = format_version(orphan.version)
+      recovery = format_recovery(orphan.recovery_source)
+
+      print "\nRollback #{version} #{name} [#{recovery}]? [y/n/a/q] "
+      parse_multi_choice
+    end
+
+    def confirm_dismiss?(version, name)
+      print "\nDismiss #{format_version(version)} #{name}? [y/n/a/q] "
+      parse_multi_choice
+    end
+
+    def success(msg)
+      puts msg
+    end
+
+    def error(msg)
+      puts msg
+    end
+
+    def warning(msg)
+      puts msg
+    end
+
+    def info(msg)
+      puts msg
+    end
+
+    def hint(msg)
+      puts "Hint: #{msg}"
+    end
+
+    private
+
+    def parse_multi_choice
+      response = $stdin.gets.chomp.downcase
+      case response
+      when "y", "yes" then :yes
+      when "n", "no", "" then :no
+      when "a", "all" then :all
+      when "q", "quit" then :quit
+      else :no
+      end
+    end
+
+    def orphan_line(orphan)
+      version = orphan.version
+      name = format_name(orphan.filename)
+      recovery = orphan.recoverable? ? "recoverable (#{format_recovery(orphan.recovery_source)})" : "not recoverable"
+      branch = orphan.branch_name ? "branch:#{truncate(orphan.branch_name, 30)}" : ""
+      author = orphan.author_name ? "author:#{truncate(orphan.author_name, 20)}" : ""
+
+      parts = [version, name.ljust(42), recovery.ljust(24)]
+      parts << branch unless branch.empty?
+      parts << author unless author.empty?
+      parts.join("  ")
+    end
+  end
+end

data/lib/mighost/railtie.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Mighost
+  class Railtie < Rails::Railtie
+    railtie_name :mighost
+
+    initializer "mighost.configure" do
+      Mighost.configuration.enabled = !Rails.env.production?
+    end
+
+    initializer "mighost.setup_migrator_extension" do
+      ActiveSupport.on_load(:active_record) do
+        require_relative "migrator_extension"
+      end
+    end
+
+    rake_tasks do
+      load File.expand_path("tasks.rake", __dir__)
+    end
+
+    generators do
+      require_relative "../generators/mighost/install_generator"
+    end
+  end
+end

data/lib/mighost/rollbacker.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "active_support"
+require "active_support/core_ext/object/blank"
+require_relative "snapshot"
+require_relative "git_recovery"
+require_relative "worktree_recovery"
+
+module Mighost
+  class Rollbacker
+    attr_reader :version, :content, :filename, :recovery_source
+
+    def initialize(version)
+      @version = version.to_s
+      load_recovery_data
+    end
+
+    def rollback!
+      raise SnapshotNotFound, "No snapshot or git recovery found for version #{version}" unless can_rollback?
+
+      temp_file = write_temp_migration
+      begin
+        load_and_execute_down(temp_file)
+        remove_from_schema_migrations
+        Snapshot.delete_by_version(version) if recovery_source == :snapshot
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    def can_rollback?
+      content.present?
+    end
+
+    private
+
+    def load_recovery_data
+      # Try snapshot first
+      snapshot = Snapshot.find_by_version(version)
+      if snapshot
+        @content = snapshot.content
+        @filename = snapshot.filename
+        @recovery_source = :snapshot
+        return
+      end
+
+      # Fallback to git recovery
+      git_data = GitRecovery.find_migration(version)
+      if git_data
+        @content = git_data[:content]
+        @filename = git_data[:filename]
+        @recovery_source = :branch
+        return
+      end
+
+      # Fallback to worktree recovery (uncommitted files in other worktrees)
+      wt_data = WorktreeRecovery.find_migration(version)
+      if wt_data
+        @content = wt_data[:content]
+        @filename = wt_data[:filename]
+        @recovery_source = :worktree
+      end
+    end
+
+    def write_temp_migration
+      temp = Tempfile.new(["migration_#{version}_", ".rb"])
+      temp.write(content)
+      temp.flush
+      temp
+    end
+
+    def load_and_execute_down(temp_file)
+      class_name = extract_class_name
+      unless class_name
+        raise RollbackFailed, "Could not find migration class in #{filename}"
+      end
+
+      load temp_file.path
+
+      unless Object.const_defined?(class_name)
+        raise RollbackFailed, "Loading #{filename} did not define #{class_name}"
+      end
+
+      Object.const_get(class_name).new.migrate(:down)
+    rescue ActiveRecord::IrreversibleMigration => e
+      raise RollbackFailed, "Migration #{version} is irreversible: #{e.message}"
+    rescue RollbackFailed
+      raise
+    rescue => e
+      raise RollbackFailed, "Failed to rollback #{version}: #{e.message}"
+    end
+
+    def extract_class_name
+      match = content.match(/class\s+(\w+)\s*<\s*ActiveRecord::Migration(\[\d+\.\d+\])?/)
+      match[1] if match
+    end
+
+    def remove_from_schema_migrations
+      conn = Mighost::Base.connection
+      conn.execute(
+        "DELETE FROM schema_migrations WHERE version = #{conn.quote(version)}"
+      )
+    end
+
+    class << self
+      def rollback_version!(version)
+        new(version).rollback!
+      end
+    end
+  end
+end