mighost 0.4.0

data/lib/mighost/snapshot.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "time"
+require "digest"
+require "active_support"
+require "active_support/core_ext/time"
+
+module Mighost
+  class Snapshot
+    attr_accessor :id, :version, :content, :filename, :branch_name, :git_sha, :content_hash, :migrated_at, :source,
+      :dismissed, :dismissed_at, :author_name, :author_email
+
+    # Special version used to store scan metadata
+    SCAN_METADATA_VERSION = "__scan_metadata__"
+
+    def initialize(attrs = {})
+      attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+    end
+
+    class << self
+      def table_name
+        "mighost_snapshots"
+      end
+
+      def ensure_table_exists!
+        db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS #{table_name} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            version TEXT NOT NULL UNIQUE,
+            content TEXT NOT NULL,
+            filename TEXT NOT NULL,
+            branch_name TEXT,
+            git_sha TEXT,
+            content_hash TEXT,
+            migrated_at TEXT NOT NULL,
+            source TEXT DEFAULT 'file',
+            dismissed INTEGER DEFAULT 0,
+            dismissed_at TEXT,
+            author_name TEXT,
+            author_email TEXT
+          )
+        SQL
+        db.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_#{table_name}_version ON #{table_name}(version)")
+        migrate_columns!
+      end
+
+      def find_by_version(version)
+        ensure_table_exists!
+        row = db.get_first_row(
+          "SELECT * FROM #{table_name} WHERE version = ? LIMIT 1",
+          [version.to_s]
+        )
+        return nil unless row
+
+        row_to_snapshot(row)
+      end
+
+      def find_or_recover(version)
+        existing = find_by_version(version)
+        return existing if existing
+
+        require_relative "git_recovery"
+        git_data = GitRecovery.find_migration(version)
+        if git_data
+          return store(
+            version: version,
+            content: git_data[:content],
+            filename: git_data[:filename],
+            branch_name: git_data[:branch],
+            git_sha: git_data[:sha],
+            source: "git",
+            author_name: git_data[:author_name],
+            author_email: git_data[:author_email]
+          )
+        end
+
+        require_relative "worktree_recovery"
+        wt_data = WorktreeRecovery.find_migration(version)
+        return nil unless wt_data
+
+        store(
+          version: version,
+          content: wt_data[:content],
+          filename: wt_data[:filename],
+          branch_name: wt_data[:branch],
+          source: "worktree",
+          author_name: wt_data[:author_name],
+          author_email: wt_data[:author_email]
+        )
+      end
+
+      def store(version:, content:, filename:, branch_name: nil, git_sha: nil, source: "file", author_name: nil, author_email: nil)
+        ensure_table_exists!
+        content_hash = Digest::SHA256.hexdigest(content)
+        migrated_at = Time.current.iso8601
+
+        existing = find_by_version(version)
+        if existing
+          db.execute(<<~SQL, [content, filename, branch_name, git_sha, content_hash, migrated_at, source, author_name, author_email, version.to_s])
+            UPDATE #{table_name}
+            SET content = ?, filename = ?, branch_name = ?, git_sha = ?, content_hash = ?, migrated_at = ?, source = ?,
+                author_name = ?, author_email = ?
+            WHERE version = ?
+          SQL
+        else
+          db.execute(<<~SQL, [version.to_s, content, filename, branch_name, git_sha, content_hash, migrated_at, source, author_name, author_email])
+            INSERT INTO #{table_name} (version, content, filename, branch_name, git_sha, content_hash, migrated_at, source, author_name, author_email)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          SQL
+        end
+
+        find_by_version(version)
+      end
+
+      # Store scan context metadata (branch and SHA when scan was performed)
+      def store_scan_metadata(branch:, sha:)
+        ensure_table_exists!
+        store(
+          version: SCAN_METADATA_VERSION,
+          content: "",
+          filename: "",
+          branch_name: branch,
+          git_sha: sha,
+          source: "metadata"
+        )
+      end
+
+      # Retrieve scan context metadata
+      def scan_metadata
+        ensure_table_exists!
+        record = find_by_version(SCAN_METADATA_VERSION)
+        return nil unless record
+
+        {branch: record.branch_name, sha: record.git_sha}
+      end
+
+      # Dismiss a migration (mark as hidden)
+      def dismiss(version)
+        ensure_table_exists!
+        existing = find_by_version(version)
+
+        unless existing
+          store(
+            version: version,
+            content: "",
+            filename: "",
+            source: nil
+          )
+        end
+
+        dismissed_at = Time.current.iso8601
+        db.execute(
+          "UPDATE #{table_name} SET dismissed = ?, dismissed_at = ? WHERE version = ?",
+          [1, dismissed_at, version.to_s]
+        )
+
+        find_by_version(version)
+      end
+
+      # Undismiss a migration (restore visibility)
+      def undismiss(version)
+        ensure_table_exists!
+        existing = find_by_version(version)
+        return nil unless existing
+
+        db.execute(
+          "UPDATE #{table_name} SET dismissed = ?, dismissed_at = ? WHERE version = ?",
+          [0, nil, version.to_s]
+        )
+
+        find_by_version(version)
+      end
+
+      # Get all dismissed versions
+      def dismissed_versions
+        ensure_table_exists!
+        db.execute(
+          "SELECT version FROM #{table_name} WHERE dismissed = 1 AND version != ?",
+          [SCAN_METADATA_VERSION]
+        ).flatten
+      end
+
+      def delete_by_version(version)
+        ensure_table_exists!
+        db.execute("DELETE FROM #{table_name} WHERE version = ?", [version.to_s])
+      end
+
+      def all_snapshots
+        ensure_table_exists!
+        db.execute(
+          "SELECT * FROM #{table_name} WHERE version != ? ORDER BY migrated_at DESC",
+          [SCAN_METADATA_VERSION]
+        ).map { |row| row_to_snapshot(row) }
+      end
+
+      # Lightweight version - only metadata, no content (for status display)
+      def all_metadata
+        ensure_table_exists!
+        cols = %i[version filename branch_name git_sha migrated_at source dismissed author_name author_email]
+        db.execute(
+          "SELECT version, filename, branch_name, git_sha, migrated_at, source, dismissed, author_name, author_email FROM #{table_name} WHERE version != ?",
+          [SCAN_METADATA_VERSION]
+        ).map do |row|
+          record = new(cols.zip(row).to_h)
+          record.dismissed = record.dismissed == 1
+          record
+        end
+      end
+
+      def all_versions
+        ensure_table_exists!
+        db.execute(
+          "SELECT version FROM #{table_name} WHERE version != ?",
+          [SCAN_METADATA_VERSION]
+        ).flatten
+      end
+
+      # Close and forget the database handle. Needed when storage_path changes
+      # (the handle is memoized on first access).
+      def reset_db!
+        @db&.close
+        @db = nil
+      end
+
+      private
+
+      def db
+        @db ||= begin
+          require "sqlite3"
+          SQLite3::Database.new(resolve_storage_path)
+        end
+      end
+
+      def migrate_columns!
+        columns = db.execute("PRAGMA table_info(#{table_name})").map { |c| c[1] }
+
+        unless columns.include?("source")
+          db.execute("ALTER TABLE #{table_name} ADD COLUMN source TEXT DEFAULT 'file'")
+        end
+        unless columns.include?("dismissed")
+          db.execute("ALTER TABLE #{table_name} ADD COLUMN dismissed INTEGER DEFAULT 0")
+        end
+        unless columns.include?("dismissed_at")
+          db.execute("ALTER TABLE #{table_name} ADD COLUMN dismissed_at TEXT")
+        end
+        unless columns.include?("author_name")
+          db.execute("ALTER TABLE #{table_name} ADD COLUMN author_name TEXT")
+        end
+        unless columns.include?("author_email")
+          db.execute("ALTER TABLE #{table_name} ADD COLUMN author_email TEXT")
+        end
+      end
+
+      SNAPSHOT_COLUMNS = %i[id version content filename branch_name git_sha content_hash migrated_at source dismissed dismissed_at author_name author_email].freeze
+      private_constant :SNAPSHOT_COLUMNS
+
+      def row_to_snapshot(row)
+        record = new(SNAPSHOT_COLUMNS.zip(row).to_h)
+        record.dismissed = record.dismissed == 1
+        record
+      end
+
+      def resolve_storage_path
+        path = Mighost.configuration.storage_path
+
+        if defined?(Rails) && Rails.root
+          Rails.root.join(path).to_s
+        else
+          File.expand_path(path, Dir.pwd)
+        end
+      end
+    end
+  end
+end

data/lib/mighost/tasks.rake

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "mighost"
+
+namespace :mighost do
+  desc "Show available commands"
+  task :help do
+    puts <<~HELP
+      Mighost - Rollback Rails migrations even when the file is missing
+
+      Commands:
+        rails mighost:status              Show orphaned migrations (in DB but no file)
+        rails mighost:rollback            Rollback orphaned migrations (interactive)
+        rails mighost:scan                Capture migrations + search git for orphans
+        rails mighost:list (ls)           List stored migration records
+        rails mighost:dismiss             Dismiss orphans (interactive, or VERSION=x)
+        rails mighost:undismiss           Restore dismissed migrations
+        rails mighost:dismissed           List dismissed migrations
+        rails mighost:cleanup             Remove stale records
+
+      Options:
+        VERSION=x        Target specific version (rollback, dismiss, undismiss)
+        VERSION=a..b     Version range: a to b inclusive
+        VERSION=..b      All versions up to b
+        VERSION=a..      All versions from a onwards
+        RESCAN=1         Force re-capture all snapshots (scan)
+        FORCE=1          Skip confirmations
+        OLD=1            Dismiss only old unrecoverable migrations (dismiss)
+        SHOW_DISMISSED=1 Include dismissed in status
+        LIMIT=N          Limit output rows (list)
+        DEBUG=1          Verbose output (status)
+
+      Typical workflow:
+        1. rails mighost:scan       # First time setup
+        2. rails mighost:status     # Check for orphaned migrations
+        3. rails mighost:rollback   # Rollback interactively
+        4. rails mighost:dismiss    # Dismiss unrecoverable orphans
+
+    HELP
+  end
+
+  desc "Show orphaned migrations (in DB but no file). DEBUG=1, SHOW_DISMISSED=1"
+  task status: :environment do
+    ui = Mighost.ui
+    Mighost::OrphanDetector.debug = ENV["DEBUG"] == "1"
+    show_dismissed = ENV["SHOW_DISMISSED"] == "1"
+
+    orphans = Mighost::API.orphaned_migrations(include_dismissed: show_dismissed)
+    ui.render_orphans(orphans)
+
+    unless show_dismissed
+      dismissed_count = Mighost::API.dismissed_count
+      ui.hint "#{dismissed_count} dismissed migration(s) hidden. Use SHOW_DISMISSED=1 to show." if dismissed_count.positive?
+    end
+
+    non_recoverable = orphans.reject(&:recoverable?)
+    if non_recoverable.any? && Mighost::OrphanDetector.branch_changed?
+      ui.hint "Branch changed since last scan. Run 'rails mighost:scan' to update recovery info."
+    end
+  end
+
+  desc "Rollback orphaned migrations. VERSION=xxx for specific, FORCE=1 to skip confirmation"
+  task rollback: :environment do
+    ui = Mighost.ui
+    version = ENV["VERSION"]
+    force = ENV["FORCE"] == "1"
+
+    if version
+      begin
+        Mighost::API.rollback_version!(version)
+        ui.success "Successfully rolled back migration #{version}"
+      rescue Mighost::SnapshotNotFound
+        ui.error "No record found for version #{version}"
+      rescue Mighost::RollbackFailed => e
+        ui.error "Failed to rollback: #{e.message}"
+      end
+      next
+    end
+
+    orphans = Mighost::API.orphaned_migrations.select(&:recoverable?)
+
+    if orphans.empty?
+      ui.info "No recoverable orphaned migrations found."
+      next
+    end
+
+    ui.render_recoverable_list(orphans)
+
+    results = {rolled_back: [], failed: [], skipped: []}
+    rollback_all = force
+
+    orphans.each do |orphan|
+      unless rollback_all
+        response = ui.confirm_each?(orphan)
+        case response
+        when :quit
+          ui.warning "Aborted."
+          break
+        when :no
+          results[:skipped] << orphan.version
+          next
+        when :all
+          rollback_all = true
+        end
+      end
+
+      begin
+        Mighost::API.rollback_version!(orphan.version)
+        results[:rolled_back] << orphan.version
+        ui.success "  Rolled back #{orphan.version}"
+      rescue => e
+        results[:failed] << {version: orphan.version, error: e.message}
+        ui.error "  Failed: #{e.message}"
+      end
+    end
+
+    ui.info "Done: #{results[:rolled_back].size} rolled back, #{results[:skipped].size} skipped, #{results[:failed].size} failed"
+  end
+
+  desc "Scan and capture existing migrations, search git for orphans. RESCAN=1 to force re-capture all"
+  task scan: :environment do
+    ui = Mighost.ui
+    result = Mighost::API.scan!(rescan: ENV["RESCAN"] == "1")
+
+    ui.render_scan_details(result[:details])
+    ui.render_scan_results(
+      captured: result[:captured],
+      git_recovered: result[:git_recovered],
+      worktree_recovered: result[:worktree_recovered],
+      branch: result[:branch],
+      sha: result[:sha]
+    )
+  end
+
+  desc "List stored migration records (LIMIT=N to limit)"
+  task list: :environment do
+    limit = ENV["LIMIT"]&.to_i
+    records = Mighost::API.all_snapshots
+    total_count = records.count
+    display_records = limit&.positive? ? records.first(limit) : records
+
+    Mighost.ui.render_records(display_records, limit: limit, total_count: total_count)
+  end
+
+  task ls: :list
+
+  desc "Clean up stale records for migrations no longer in schema_migrations"
+  task cleanup: :environment do
+    ui = Mighost.ui
+    Mighost::Snapshot.ensure_table_exists!
+    migrated_versions = Mighost::Base.connection
+      .select_values("SELECT version FROM schema_migrations")
+      .map(&:to_s)
+
+    all_record_versions = Mighost::Snapshot.all_versions
+    stale_versions = all_record_versions - migrated_versions
+
+    if stale_versions.empty?
+      ui.info "No stale records to clean up."
+      next
+    end
+
+    ui.warning "Found #{stale_versions.count} stale record(s):"
+    stale_versions.each { |v| ui.info "  #{v}" }
+
+    unless ENV["FORCE"] == "1"
+      unless ui.confirm?("Delete these records?")
+        ui.warning "Aborted."
+        next
+      end
+    end
+
+    stale_versions.each { |v| Mighost::Snapshot.delete_by_version(v) }
+    ui.success "Cleaned up #{stale_versions.count} record(s)."
+  end
+
+  desc "Dismiss orphaned migrations (hide from status). VERSION=x, VERSION=a..b (range), OLD=1"
+  task dismiss: :environment do
+    ui = Mighost.ui
+    version_param = ENV["VERSION"]
+    old_only = ENV["OLD"] == "1"
+
+    orphans = Mighost::API.orphaned_migrations
+
+    if old_only
+      orphans = orphans.select(&:suggested_for_dismiss?)
+      if orphans.empty?
+        ui.info "No old unrecoverable migrations to dismiss."
+        ui.hint "Migrations must be older than 6 months and not recoverable."
+        next
+      end
+    end
+
+    if orphans.empty?
+      ui.info "No orphaned migrations to dismiss."
+      next
+    end
+
+    orphan_versions = orphans.map(&:version).sort
+    orphan_map = orphans.index_by(&:version)
+
+    to_dismiss = if version_param
+      Mighost::Formatting.parse_version_range(version_param, orphan_versions)
+    else
+      orphan_versions
+    end
+
+    if to_dismiss.empty?
+      ui.warning "No matching orphaned migrations found."
+      next
+    end
+
+    ui.render_dismiss_preview(to_dismiss, orphan_map)
+
+    results = {dismissed: [], skipped: []}
+    dismiss_all = ENV["FORCE"] == "1"
+
+    to_dismiss.each do |version|
+      orphan = orphan_map[version]
+      name = orphan&.filename || "(unknown)"
+
+      unless dismiss_all
+        response = ui.confirm_dismiss?(version, name)
+        case response
+        when :quit
+          ui.warning "Aborted."
+          break
+        when :no
+          results[:skipped] << version
+          next
+        when :all
+          remaining = to_dismiss[to_dismiss.index(version)..]
+          ui.render_dismiss_remaining(remaining, orphan_map)
+
+          if ui.confirm?("Confirm dismiss all #{remaining.count}?")
+            remaining.each do |v|
+              Mighost::API.dismiss(v)
+              results[:dismissed] << v
+            end
+            ui.success "Dismissed #{remaining.count} migration(s)."
+          else
+            ui.warning "Aborted."
+          end
+          break
+        end
+      end
+
+      Mighost::API.dismiss(version)
+      results[:dismissed] << version
+      ui.success "  Dismissed #{version}"
+    end
+
+    ui.info "Done: #{results[:dismissed].size} dismissed, #{results[:skipped].size} skipped"
+  end
+
+  desc "Undismiss migrations (restore visibility). VERSION=x or VERSION=a..b"
+  task undismiss: :environment do
+    ui = Mighost.ui
+    version_param = ENV["VERSION"]
+
+    unless version_param
+      ui.error "VERSION required. Use same format as dismiss."
+      next
+    end
+
+    dismissed = Mighost::Snapshot.dismissed_versions.sort
+
+    if dismissed.empty?
+      ui.info "No dismissed migrations."
+      next
+    end
+
+    targets = Mighost::Formatting.parse_version_range(version_param, dismissed)
+
+    if targets.empty?
+      ui.warning "No matching dismissed migrations found."
+      next
+    end
+
+    targets.each do |version|
+      Mighost::API.undismiss(version)
+      ui.success "Undismissed #{version}"
+    end
+
+    ui.info "Restored #{targets.count} migration(s) to status output."
+  end
+
+  desc "List dismissed migrations"
+  task dismissed: :environment do
+    dismissed = Mighost::Snapshot.dismissed_versions.sort
+
+    if dismissed.empty?
+      Mighost.ui.info "No dismissed migrations."
+      next
+    end
+
+    dismissed_snapshots = dismissed.map { |v| [v, Mighost::API.find_snapshot(v)] }
+    Mighost.ui.render_dismissed_list(dismissed_snapshots)
+  end
+end

data/lib/mighost/version.rb

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

data/lib/mighost/worktree_recovery.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "active_support"
+require "active_support/core_ext/object/blank"
+require_relative "git_metadata"
+
+module Mighost
+  # Searches other git worktrees for migration files that exist on disk
+  # but haven't been committed yet (invisible to git log --all)
+  module WorktreeRecovery
+    class << self
+      # Find migration file in other worktrees
+      # Returns { content:, filename:, branch:, worktree_path: } or nil
+      def find_migration(version)
+        return nil unless GitMetadata.git_available?
+
+        worktrees = list_worktrees
+        return nil if worktrees.empty?
+
+        current_root = git_root
+        return nil unless current_root
+
+        worktrees.each do |wt|
+          next if wt[:path] == current_root
+
+          result = find_in_worktree(wt, version)
+          return result if result
+        end
+
+        nil
+      end
+
+      # List all git worktrees with their paths and branches
+      def list_worktrees
+        output = `git worktree list --porcelain 2>/dev/null`.strip
+        return [] if output.empty?
+
+        worktrees = []
+        current = {}
+
+        output.each_line do |line|
+          line = line.chomp
+          if line.start_with?("worktree ")
+            current = {path: line.sub("worktree ", "")}
+          elsif line.start_with?("branch ")
+            ref = line.sub("branch ", "")
+            # refs/heads/feature-branch -> feature-branch
+            current[:branch] = ref.sub(%r{^refs/heads/}, "")
+          elsif line == "detached"
+            current[:branch] = nil
+          elsif line.empty? && current[:path]
+            worktrees << current
+            current = {}
+          end
+        end
+
+        # Last entry (no trailing blank line)
+        worktrees << current if current[:path]
+
+        worktrees
+      end
+
+      private
+
+      def find_in_worktree(wt, version)
+        pattern = File.join(wt[:path], "db", "migrate", "#{version}_*.rb")
+        matches = Dir.glob(pattern)
+        return nil if matches.empty?
+
+        file = matches.first
+        content = File.read(file)
+
+        author_name, author_email = worktree_git_user(wt[:path])
+
+        {
+          content: content,
+          filename: File.basename(file),
+          branch: wt[:branch],
+          worktree_path: wt[:path],
+          author_name: author_name,
+          author_email: author_email
+        }
+      rescue => e
+        warn "[Mighost] Failed to read worktree migration #{file}: #{e.message}"
+        nil
+      end
+
+      def worktree_git_user(path)
+        escaped = Shellwords.escape(path)
+        name = `git -C #{escaped} config user.name 2>/dev/null`.strip
+        email = `git -C #{escaped} config user.email 2>/dev/null`.strip
+        [name.presence, email.presence]
+      end
+
+      def git_root
+        result = `git rev-parse --show-toplevel 2>/dev/null`.strip
+        result.empty? ? nil : result
+      end
+    end
+  end
+end