rails-hyperdrive 0.3.0 → 0.4.0

data/lib/rails/hyperdrive/drift_verdict.rb

@@ -1,11 +1,9 @@
 require "digest"
-require "rails/hyperdrive/audit_header"
 
 module Rails
   module Hyperdrive
-    # The lock's source_sha is computed over the install-ready body before any
-    # header injection, so hashing an installed file's comparable bytes
-    # (disk_sha) reproduces it exactly for an unedited file.
+    # Installed files are byte-identical to their install-ready body, so an
+    # unedited file's disk hash reproduces the lock's source_sha exactly.
     module DriftVerdict
       STATES = %i[current outdated edited missing orphaned].freeze
 
@@ -16,25 +14,22 @@ module Rails
         Digest::SHA256.hexdigest(content.to_s)
       end
 
-      # AuditHeader.strip's line matching can raise on binary content, so
-      # skill_support files compare as raw bytes.
-      def disk_sha(file, kind:)
-        return body_sha(File.binread(file)) if kind.to_s == "skill_support"
-        body_sha(AuditHeader.strip(File.read(file)))
+      def disk_sha(file)
+        body_sha(File.binread(file))
       end
 
-      # A file counts as unedited when its comparable bytes still hash to what
-      # the lock recorded at install time, not to what the gem ships now.
+      # A file counts as unedited when its bytes still hash to what the lock
+      # recorded at install time, not to what the gem ships now.
       def unedited?(file, lock_entry:)
-        disk_sha(file, kind: lock_entry.kind) == lock_entry.source_sha
+        disk_sha(file) == lock_entry.source_sha
       end
 
       # gem_sha nil means the bundle no longer offers this destination.
-      def verdict(file:, kind:, lock_entry:, gem_sha:)
+      def verdict(file:, lock_entry:, gem_sha:)
         return File.exist?(file) ? :orphaned : :missing if gem_sha.nil?
         return :missing unless File.exist?(file)
         return :edited if lock_entry.nil?
-        return :edited if disk_sha(file, kind: kind) != lock_entry.source_sha
+        return :edited if disk_sha(file) != lock_entry.source_sha
         lock_entry.source_sha == gem_sha ? :current : :outdated
       end
     end

data/lib/rails/hyperdrive/install_layout.rb

@@ -20,6 +20,10 @@ module Rails
         end
       end
 
+      def sidecar_path(dest)
+        "#{dest}.new"
+      end
+
       def installed_name(type, dest)
         case type
         when :skill         then File.basename(File.dirname(dest))

data/lib/rails/hyperdrive/install_pipeline.rb

@@ -1,8 +1,9 @@
 require "time"
-require "rails/hyperdrive/audit_header"
+require "rails/hyperdrive/ancestor_locator"
 require "rails/hyperdrive/bundler_artifact_discovery"
 require "rails/hyperdrive/claude_md_import"
 require "rails/hyperdrive/drift_verdict"
+require "rails/hyperdrive/three_way_merge"
 require "rails/hyperdrive/eager_footprint"
 require "rails/hyperdrive/index_document"
 require "rails/hyperdrive/install_layout"
@@ -20,9 +21,10 @@ module Rails
       WARN_LINES = 150
       WARN_TOKENS = 1_500
 
-      MODES = %i[preserve overwrite additive].freeze
+      MODES = %i[preserve overwrite additive sidecar merge].freeze
 
-      Result = Struct.new(:installed, :updated, :unchanged, :skipped, :orphaned, :removed, keyword_init: true)
+      Result = Struct.new(:installed, :updated, :unchanged, :skipped, :orphaned, :removed, :merged, :sidecars,
+        keyword_init: true)
 
       def initialize(root:, shell:, artifacts:, mode: :preserve, warnings: [])
         raise ArgumentError, "unknown mode #{mode.inspect}" unless MODES.include?(mode)
@@ -32,7 +34,9 @@ module Rails
         @artifacts = artifacts
         @mode = mode
         @warnings = warnings
-        @result = Result.new(installed: [], updated: [], unchanged: [], skipped: [], orphaned: [], removed: [])
+        @result = Result.new(
+          installed: [], updated: [], unchanged: [], skipped: [], orphaned: [], removed: [], merged: [], sidecars: []
+        )
       end
 
       def call
@@ -81,6 +85,14 @@ module Rails
         @mode == :overwrite
       end
 
+      def merge_mode?
+        @mode == :merge
+      end
+
+      def reconcile_mode?
+        @mode == :sidecar || @mode == :merge
+      end
+
       def abs(path)
         File.join(@root, path)
       end
@@ -102,7 +114,9 @@ module Rails
 
       def install_skills
         @plan.select { |e| e.type == :skill }.each do |entry|
-          install_file(entry: entry, type: :skill, install_ready_body: entry.install_ready_body)
+          skill_relpath = source_relpath_for(entry.artifact)
+          install_file(entry: entry, type: :skill, install_ready_body: entry.install_ready_body,
+            source_relpath: skill_relpath, final_name: entry.final_name)
           entry.support_files.each do |file|
             install_file(
               dest: file[:dest],
@@ -110,7 +124,8 @@ module Rails
               install_ready_body: file[:body],
               source_gem: entry.source_gem,
               version: entry.version,
-              artifact_kind: "skill_support"
+              artifact_kind: "skill_support",
+              source_relpath: skill_relpath && File.join(File.dirname(skill_relpath), file[:path])
             )
           end
         end
@@ -120,12 +135,28 @@ module Rails
         @plan.select { |e| e.type == :guideline }.map do |entry|
           body = entry.install_ready_body
           warn_if_oversize(entry.dest, body)
-          install_file(entry: entry, type: :guideline, install_ready_body: body)
+          install_file(entry: entry, type: :guideline, install_ready_body: body,
+            source_relpath: source_relpath_for(entry.artifact), final_name: entry.final_name)
           { base: "#{entry.final_name}.md", dest: entry.dest, body: body }
         end
       end
 
-      def install_file(dest: nil, type:, install_ready_body:, entry: nil, source_gem: nil, version: nil, artifact_kind: nil)
+      # The shipped file's path relative to its gem root, normalized to the
+      # install-target form (.md.erb -> .md).
+      def source_relpath_for(artifact)
+        root = artifact.source_root
+        return nil if root.nil? || root.to_s.empty?
+
+        prefix = "#{File.expand_path(root.to_s)}/"
+        expanded = File.expand_path(artifact.path.to_s)
+        return nil unless expanded.start_with?(prefix)
+
+        rel = expanded.delete_prefix(prefix)
+        rel.end_with?(".md.erb") ? rel.delete_suffix(".erb") : rel
+      end
+
+      def install_file(dest: nil, type:, install_ready_body:, entry: nil, source_gem: nil, version: nil,
+                       artifact_kind: nil, source_relpath: nil, final_name: nil)
         write = {
           dest: dest || entry.dest,
           type: type,
@@ -140,25 +171,152 @@ module Rails
         return additive_install(write, old) if additive?
 
         file = abs(write[:dest])
-        case DriftVerdict.verdict(file: file, kind: write[:artifact_kind], lock_entry: old, gem_sha: write[:gem_sha])
+        case DriftVerdict.verdict(file: file, lock_entry: old, gem_sha: write[:gem_sha])
         when :missing
           @shell.say_status(:reinstall, "#{write[:dest]} (was missing)", :yellow) if old
           write_artifact(**write)
+          sweep_sidecar(write, old)
         when :current
           @new_lock.carry(old)
           @result.unchanged << write[:dest]
           @shell.say_status :unchanged, write[:dest], :blue
+          sweep_sidecar(write, old)
         when :outdated
           write_artifact(**write)
+          sweep_sidecar(write, old)
         when :edited
           if overwrite_mode?
             write_artifact(**write)
+            sweep_sidecar(write, old)
+          elsif reconcile_mode?
+            reconcile_edited(write, old, source_relpath: source_relpath, final_name: final_name)
+          else
+            skip_edited(write, old)
+          end
+        end
+      end
+
+      def skip_edited(write, old)
+        @result.skipped << write[:dest]
+        @shell.say_status :skip,
+          "#{write[:dest]} (locally modified; run hyperdrive:sync with --merge, --sidecar, or --overwrite to reconcile)",
+          :yellow
+        @new_lock.carry(old) if old
+      end
+
+      # Reconciliation for a locally-modified destination in :sidecar/:merge
+      # mode. The lock records the newest upstream *delivered* — installed
+      # live, merged in, or written as a sidecar — never the live file's own
+      # hash, so the same upstream version is offered exactly once.
+      def reconcile_edited(write, old, source_relpath:, final_name:)
+        dest = write[:dest]
+        sidecar = InstallLayout.sidecar_path(dest)
+
+        if old && old.source_sha == write[:gem_sha]
+          skip_edited(write, old)
+          if File.exist?(abs(sidecar))
+            @shell.say_status :warn, "#{sidecar} (unresolved sidecar; reconcile it with #{dest}, then delete it)", :yellow
+          end
+          return
+        end
+
+        # An edited sidecar is user work: leave it, and leave the lock at the
+        # old upstream so this delivery is re-offered once the user clears it.
+        if File.exist?(abs(sidecar)) && !sidecar_pristine?(sidecar, write, old)
+          @result.skipped << dest
+          @shell.say_status :warn, "#{sidecar} (sidecar locally modified; resolve or delete it)", :yellow
+          @new_lock.carry(old) if old
+          return
+        end
+
+        reason = nil
+        if merge_mode?
+          if File.exist?(abs(sidecar))
+            # A pending sidecar means the last delivered upstream never reached
+            # the live file, so the reconstructable ancestor is stale; merging
+            # over it would silently revert that delivery.
+            reason = "previous delivery still unresolved"
           else
-            @result.skipped << write[:dest]
-            @shell.say_status :skip, "#{write[:dest]} (locally modified; run hyperdrive:sync --overwrite to overwrite)", :yellow
-            @new_lock.carry(old) if old
+            merged, reason = attempt_merge(write, old, source_relpath: source_relpath, final_name: final_name)
+            if merged
+              write_merged(write, merged)
+              sweep_sidecar(write, old)
+              return
+            end
           end
         end
+
+        write_sidecar(write, reason)
+      end
+
+      def attempt_merge(write, old, source_relpath:, final_name:)
+        return [nil, "no previous install recorded"] unless old
+
+        ancestor = AncestorLocator.locate(
+          kind: write[:artifact_kind], relpath: source_relpath, lock_entry: old, final_name: final_name
+        )
+        return [nil, "#{old.source_label} not found in installed gems"] unless ancestor
+
+        ours = live_body(write)
+        if ours.nil? || [ours, ancestor, write[:body]].any? { |b| ThreeWayMerge.binary?(b) }
+          return [nil, "binary content"]
+        end
+
+        outcome = ThreeWayMerge.merge(ours: ours, base: ancestor, theirs: write[:body])
+        case outcome.status
+        when :clean      then [outcome.body, nil]
+        when :conflicted then [nil, "conflicting edits"]
+        else                  [nil, "git merge-file unavailable"]
+        end
+      end
+
+      def live_body(write)
+        file = abs(write[:dest])
+        return File.binread(file) if write[:type] == :skill_support
+        File.read(file)
+      rescue StandardError
+        nil
+      end
+
+      def write_merged(write, merged_body)
+        @shell.create_file write[:dest], merged_body
+        @result.merged << write[:dest]
+        @shell.say_status :merged, "#{write[:dest]} (local edits merged with #{write[:source_gem]}@#{write[:version]})", :green
+        upsert_lock(write, Time.now.utc)
+      end
+
+      # The sidecar is byte-identical to what a live install of the new
+      # upstream would write, so `mv <dest>.new <dest>` accepts it wholesale
+      # and the lock already verifies it.
+      def write_sidecar(write, reason)
+        sidecar = InstallLayout.sidecar_path(write[:dest])
+        @shell.create_file sidecar, write[:body]
+        @result.sidecars << write[:dest]
+        message = "#{write[:dest]} (locally modified; new upstream delivered to #{sidecar}"
+        message += "; #{reason}" if reason
+        @shell.say_status :sidecar, "#{message})", :yellow
+        upsert_lock(write, Time.now.utc)
+      end
+
+      # Only a machine-pristine sidecar — one still hashing to a delivered
+      # upstream — may be refreshed or removed; anything else is user work.
+      def sidecar_pristine?(sidecar, write, old)
+        sha = DriftVerdict.disk_sha(abs(sidecar))
+        [old&.source_sha, write[:gem_sha]].compact.include?(sha)
+      rescue StandardError
+        false
+      end
+
+      def sweep_sidecar(write, old)
+        sidecar = InstallLayout.sidecar_path(write[:dest])
+        return unless File.exist?(abs(sidecar))
+
+        if sidecar_pristine?(sidecar, write, old)
+          @shell.remove_file sidecar
+          @result.removed << sidecar
+        else
+          @shell.say_status :warn, "#{sidecar} (sidecar locally modified; resolve or delete it)", :yellow
+        end
       end
 
       # Additive installs can create a file and never overwrite one, so an
@@ -174,24 +332,11 @@ module Rails
         end
       end
 
-      # Supporting files land byte-identical to what the gem ships — no audit
-      # header, since they may be non-markdown or binary; provenance and sha
-      # live in the lock alone.
+      # Every artifact lands byte-identical to its install-ready body;
+      # provenance and sha live in the lock alone.
       def write_artifact(dest:, type:, body:, source_gem:, version:, gem_sha:, artifact_kind:)
-        installed_at = Time.now.utc
-        header_args = { source_gem: source_gem, version: version, sha256: gem_sha, installed_at: installed_at }
-        on_disk =
-          case type
-          when :skill
-            AuditHeader.inject_into_frontmatter(body, AuditHeader.build(**header_args))
-          when :skill_support
-            body
-          else
-            AuditHeader.prepend_html(body, AuditHeader.build_html(**header_args))
-          end
-
         existed = old_lock.entry(dest)
-        @shell.create_file dest, on_disk
+        @shell.create_file dest, body
         (existed ? @result.updated : @result.installed) << dest
         @new_lock.upsert(
           path: dest,
@@ -199,6 +344,17 @@ module Rails
           source_gem: source_gem,
           source_version: version,
           source_sha: gem_sha,
+          installed_at: Time.now.utc.iso8601
+        )
+      end
+
+      def upsert_lock(write, installed_at)
+        @new_lock.upsert(
+          path: write[:dest],
+          kind: write[:artifact_kind],
+          source_gem: write[:source_gem],
+          source_version: write[:version],
+          source_sha: write[:gem_sha],
           installed_at: installed_at.iso8601
         )
       end
@@ -284,11 +440,11 @@ module Rails
         old_lock.each_entry do |entry|
           next if planned.include?(entry.path)
           next if @new_lock.entry(entry.path)
-          next unless DriftVerdict.verdict(file: abs(entry.path), kind: entry.kind, lock_entry: entry, gem_sha: nil) == :orphaned
+          next unless DriftVerdict.verdict(file: abs(entry.path), lock_entry: entry, gem_sha: nil) == :orphaned
 
           @result.orphaned << entry.path
           @shell.say_status :orphan,
-            "#{entry.path} (source #{entry.source_label} no longer in bundle; left in place)", :yellow
+            "#{entry.path} (no longer shipped by #{entry.source_label}; left in place)", :yellow
           @new_lock.carry(entry)
         end
       end

data/lib/rails/hyperdrive/resources/stack_profile.rb

@@ -14,7 +14,7 @@ module Rails
           ::MCP::Resource.new(
             uri: URI,
             name: "Stack Profile",
-            description: "Parsed Gemfile.lock + categorization (rails, ruby, database, test, jobs, frontend, auth, authz, db_gems, gem_skills).",
+            description: "Parsed Gemfile.lock (rails, ruby, database, direct_dependencies, gem_skills).",
             mime_type: "application/json"
           )
         end

data/lib/rails/hyperdrive/stack_profile.rb

@@ -5,15 +5,7 @@ require "digest"
 module Rails
   module Hyperdrive
     class StackProfile
-      CATEGORIES_PATH = File.expand_path("data/gem_categories.yml", __dir__)
-
       class << self
-        def categories
-          @categories ||= YAML.load_file(CATEGORIES_PATH).each_with_object({}) do |(cat, gems), acc|
-            gems.each { |g| acc[g] = cat.to_sym }
-          end
-        end
-
         def current
           @current ||= from_lockfile(default_lockfile_path)
         end
@@ -54,16 +46,11 @@ module Rails
         specs    = parser.specs.each_with_object({}) { |s, h| h[s.name] = s.version.to_s }
 
         @data = {
-          rails:      rails_info(specs),
-          ruby:       ruby_info(parser),
-          database:   database_info(specs),
-          test:       bucket(specs, :test),
-          jobs:       bucket(specs, :jobs),
-          frontend:   frontend_info(specs),
-          auth:       bucket(specs, :auth),
-          authz:      bucket(specs, :authz),
-          db_gems:    bucket(specs, :db),
-          gem_skills: gem_skills_info
+          rails:               rails_info(specs),
+          ruby:                ruby_info(parser),
+          database:            database_info(specs),
+          direct_dependencies: direct_dependencies(parser, specs),
+          gem_skills:          gem_skills_info
         }
         self
       end
@@ -77,8 +64,7 @@ module Rails
       def empty_profile
         {
           rails: {}, ruby: {}, database: {},
-          test: [], jobs: [], frontend: [],
-          auth: [], authz: [], db_gems: [], gem_skills: []
+          direct_dependencies: [], gem_skills: []
         }
       end
 
@@ -132,28 +118,14 @@ module Rails
         ::Rails.root.join("config", "database.yml").to_s
       end
 
-      def bucket(specs, category)
-        gem_names = self.class.categories.select { |_, c| c == category }.keys
-        gem_names.filter_map do |name|
-          version = specs[name]
-          next unless version
-          { key: name.to_sym, version: version }
+      # Presence in the resolved specs does not mean the app chose a gem —
+      # minitest resolves under every Rails app. Transitive gems stay out.
+      def direct_dependencies(parser, specs)
+        parser.dependencies.keys.sort.map do |name|
+          { name: name, version: specs[name] }
         end
       end
 
-      # Frontend gets a special shape because Hotwire is actually two gems.
-      def frontend_info(specs)
-        bucket(specs, :frontend).map do |entry|
-          if entry[:key] == :"turbo-rails" || entry[:key] == :"stimulus-rails"
-            turbo = specs["turbo-rails"]
-            stim  = specs["stimulus-rails"]
-            { key: :hotwire, versions: { turbo: turbo, stimulus: stim }.compact }
-          else
-            entry
-          end
-        end.uniq
-      end
-
       # Loaded lazily and rescued broadly so StackProfile stays usable where
       # Bundler is absent or refuses to resolve.
       def gem_skills_info

data/lib/rails/hyperdrive/three_way_merge.rb

@@ -0,0 +1,47 @@
+require "open3"
+require "tmpdir"
+
+module Rails
+  module Hyperdrive
+    # Tempfiles live in the system tmpdir, never in the app, so a dry run
+    # stays write-free. Fail-open: a missing or erroring git reads as
+    # :unavailable, never an exception.
+    module ThreeWayMerge
+      Outcome = Struct.new(:status, :body, keyword_init: true) do
+        def clean?
+          status == :clean
+        end
+      end
+
+      module_function
+
+      def merge(ours:, base:, theirs:)
+        return Outcome.new(status: :unavailable) if [ours, base, theirs].any? { |b| binary?(b) }
+
+        Dir.mktmpdir("hyperdrive-merge") do |dir|
+          paths = { "ours" => ours, "base" => base, "theirs" => theirs }.map do |name, content|
+            File.join(dir, name).tap { |p| File.binwrite(p, content) }
+          end
+
+          out, _err, status = Open3.capture3("git", "merge-file", "-p", *paths)
+          if status.success?
+            Outcome.new(status: :clean, body: out)
+          elsif status.exited? && status.exitstatus.between?(1, 127)
+            # git merge-file exits with the conflict count.
+            Outcome.new(status: :conflicted)
+          else
+            Outcome.new(status: :unavailable)
+          end
+        end
+      rescue SystemCallError, IOError
+        Outcome.new(status: :unavailable)
+      end
+
+      def binary?(content)
+        s = content.to_s
+        return true if s.include?("\0".b)
+        !s.dup.force_encoding(Encoding::UTF_8).valid_encoding?
+      end
+    end
+  end
+end

data/lib/rails/hyperdrive/tools/describe_app.rb

@@ -6,7 +6,7 @@ module Rails
     module Tools
       class DescribeApp < Base
         tool_name "describe_app"
-        description "Snapshot of Rails/Ruby/DB versions plus the full StackProfile (test, jobs, frontend, auth, authz, db_gems, gem_skills)."
+        description "Snapshot of Rails/Ruby/DB versions plus the app's direct gem dependencies and installed gem skills."
 
         input_schema(properties: {})
 

data/lib/rails/hyperdrive/version.rb

@@ -1,5 +1,5 @@
 module Rails
   module Hyperdrive
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/tasks/hyperdrive.rake

@@ -6,7 +6,7 @@ namespace :hyperdrive do
     Rails::Generators::Hyperdrive::InstallGenerator.start(ARGV.drop(1))
   end
 
-  desc "Sync Rails Hyperdrive content (skills, guidelines, index.md, lockfile); locally-edited files are preserved — pass --overwrite to restore gem-shipped content"
+  desc "Sync Rails Hyperdrive content (skills, guidelines, index.md, lockfile); locally-edited files are preserved — pass --merge (three-way merge), --sidecar (deliver upstream to <file>.new), or --overwrite (restore gem-shipped content)"
   task :sync do
     require "rails/generators"
     require "generators/hyperdrive/sync/sync_generator"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-hyperdrive
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Bakaface
@@ -96,14 +96,13 @@ files:
 - lib/generators/hyperdrive/sync_runner.rb
 - lib/rails-hyperdrive.rb
 - lib/rails/hyperdrive.rb
+- lib/rails/hyperdrive/ancestor_locator.rb
 - lib/rails/hyperdrive/artifact_status.rb
-- lib/rails/hyperdrive/audit_header.rb
 - lib/rails/hyperdrive/auto_install.rb
 - lib/rails/hyperdrive/bundler_artifact_discovery.rb
 - lib/rails/hyperdrive/claude_md_import.rb
 - lib/rails/hyperdrive/companion_discovery.rb
 - lib/rails/hyperdrive/console_executor.rb
-- lib/rails/hyperdrive/data/gem_categories.yml
 - lib/rails/hyperdrive/drift_verdict.rb
 - lib/rails/hyperdrive/eager_footprint.rb
 - lib/rails/hyperdrive/engine.rb
@@ -120,6 +119,7 @@ files:
 - lib/rails/hyperdrive/skill_template.rb
 - lib/rails/hyperdrive/sql_safety.rb
 - lib/rails/hyperdrive/stack_profile.rb
+- lib/rails/hyperdrive/three_way_merge.rb
 - lib/rails/hyperdrive/tools/base.rb
 - lib/rails/hyperdrive/tools/describe_app.rb
 - lib/rails/hyperdrive/tools/list_models.rb

data/lib/rails/hyperdrive/audit_header.rb

@@ -1,83 +0,0 @@
-require "time"
-
-module Rails
-  module Hyperdrive
-    module AuditHeader
-      YAML_LINE = /\A#\s*hyperdrive:/.freeze
-      HTML_LINE = /\A<!--\s*hyperdrive:.*-->\s*\z/.freeze
-
-      module_function
-
-      def fields(source_gem:, version:, sha256:, installed_at: Time.now.utc)
-        [
-          "source=#{source_gem}@#{version}",
-          "sha256=#{sha256}",
-          "installed_at=#{installed_at.iso8601}"
-        ]
-      end
-
-      def build(source_gem:, version:, sha256:, installed_at: Time.now.utc)
-        fields(source_gem: source_gem, version: version, sha256: sha256, installed_at: installed_at)
-          .map { |f| "# hyperdrive: #{f}" }
-          .join("\n")
-      end
-
-      def build_html(source_gem:, version:, sha256:, installed_at: Time.now.utc)
-        fields(source_gem: source_gem, version: version, sha256: sha256, installed_at: installed_at)
-          .map { |f| "<!-- hyperdrive: #{f} -->" }
-          .join("\n")
-      end
-
-      def inject_into_frontmatter(body, header_block)
-        lines = body.lines
-        unless lines.first&.strip == "---"
-          return "---\n#{header_block}\n---\n\n#{body}"
-        end
-
-        closing_index = lines[1..].index { |l| l.strip == "---" }
-        return body unless closing_index
-
-        absolute_closing = closing_index + 1
-        lines.insert(absolute_closing, header_block + "\n")
-        lines.join
-      end
-
-      def prepend_html(body, header_block)
-        "#{header_block}\n\n#{body}"
-      end
-
-      # Strips only the contiguous injected block, never stray "# hyperdrive:"
-      # or "<!-- -->" lines elsewhere in the body.
-      def strip(body)
-        lines = body.lines
-        if lines.first&.strip == "---"
-          strip_yaml(lines)
-        else
-          strip_html(lines)
-        end
-      end
-
-      def strip_yaml(lines)
-        closing_index = lines[1..].index { |l| l.strip == "---" }
-        return lines.join unless closing_index
-
-        absolute_closing = closing_index + 1
-        first = (1...absolute_closing).find { |i| lines[i] =~ YAML_LINE }
-        return lines.join unless first
-
-        last = first
-        last += 1 while last < absolute_closing && lines[last] =~ YAML_LINE
-        (lines[0...first] + lines[last..]).join
-      end
-
-      def strip_html(lines)
-        return lines.join unless lines.first =~ HTML_LINE
-
-        i = 0
-        i += 1 while lines[i] =~ HTML_LINE
-        i += 1 if lines[i] && lines[i].strip.empty?
-        lines[i..].join
-      end
-    end
-  end
-end