rails-hyperdrive 0.7.0 → 0.9.0

data/lib/rails/hyperdrive/sidecar_resolver.rb

@@ -0,0 +1,215 @@
+require "open3"
+require "shellwords"
+require "tmpdir"
+require "rails/hyperdrive/ancestor_locator"
+require "rails/hyperdrive/drift_verdict"
+require "rails/hyperdrive/install_layout"
+require "rails/hyperdrive/resolve_prompt"
+
+module Rails
+  module Hyperdrive
+    # Hands each unresolved <dest>.new sidecar to the user's resolver command,
+    # git-mergetool style, and deletes the sidecar when it exits 0. Nothing here
+    # writes the lock: the sidecar's absence is the whole resolution signal.
+    class SidecarResolver
+      TOKENS = %w[LOCAL REMOTE BASE MERGED SOURCE PREVIOUS_SOURCE KIND PROMPT].freeze
+      TOKEN_PATTERN = /\$(#{TOKENS.sort_by { |t| -t.length }.join("|")})\b/
+
+      Outcome = Struct.new(:resolved, :unresolved, :skipped, keyword_init: true)
+
+      Candidate = Struct.new(:dest, :sidecar, :kind, :source, :previous_source, :ancestor, :delivered,
+        keyword_init: true)
+
+      def initialize(root:, shell:, command:, lock:, sidecars: [], prompt_path: nil, dry_run: false)
+        @root = File.expand_path(root.to_s)
+        @shell = shell
+        @command = command.to_s
+        @lock = lock
+        @sidecars = Array(sidecars)
+        @prompt_path = prompt_path
+        @dry_run = dry_run
+        @outcome = Outcome.new(resolved: [], unresolved: [], skipped: [])
+      end
+
+      def call
+        candidates.each { |candidate| process(candidate) }
+        @outcome
+      end
+
+      private
+
+      def candidates
+        written = @sidecars.to_h { |s| [s.dest.to_s, s] }
+        list = []
+        @lock.each_entry do |entry|
+          sidecar = InstallLayout.sidecar_path(entry.path)
+          delivered = written[entry.path.to_s]
+          # A dry run wrote no sidecar to disk, so this run's deliveries are
+          # only knowable from the pipeline result.
+          next unless delivered || File.file?(abs(sidecar))
+
+          list << Candidate.new(
+            dest: entry.path,
+            sidecar: sidecar,
+            kind: entry.kind.to_s,
+            source: entry.source_label.to_s,
+            # A sidecar left over from an earlier run has no struct, so the
+            # base comes back from the ancestor the lock recorded with it.
+            previous_source: delivered&.previous_source || entry.ancestor_label,
+            ancestor: delivered&.ancestor || AncestorLocator.locate_recorded_ancestor(entry),
+            delivered: !delivered.nil?
+          )
+        end
+        list
+      end
+
+      def process(candidate)
+        unless candidate.delivered || pristine?(candidate)
+          @outcome.skipped << candidate.dest
+          @shell.say_status :warn,
+            "#{candidate.sidecar} (sidecar locally modified; resolve or delete it by hand)", :yellow
+          return
+        end
+
+        tokens = command_tokens
+        return unresolved(candidate, "resolve: command: is not a valid command line") if tokens.nil?
+        return unresolved(candidate, "resolve: command: names no program") if tokens.empty?
+
+        if @dry_run
+          @shell.say_status :resolve, "#{candidate.dest} (would run #{tokens.first})", :yellow
+          return
+        end
+
+        run(candidate, tokens)
+      end
+
+      def command_tokens
+        Shellwords.split(@command)
+      rescue ArgumentError
+        nil
+      end
+
+      # A sidecar is machine-written only while it still hashes to the upstream
+      # the lock records as delivered; anything else is the user's own work.
+      def pristine?(candidate)
+        entry = @lock.entry(candidate.dest)
+        return false unless entry
+        DriftVerdict.disk_sha(abs(candidate.sidecar)) == entry.source_sha
+      rescue StandardError
+        false
+      end
+
+      def run(candidate, tokens)
+        Dir.mktmpdir("hyperdrive-resolve") do |dir|
+          base = write_base(candidate, dir)
+          values = values_for(candidate, base: base)
+          argv = substitute(tokens, values, base: base)
+          @shell.say_status :resolve, "#{candidate.dest} via #{argv.first}", :blue
+          _out, err, status = Open3.capture3(env_for(values), *argv, chdir: @root)
+          if status.success?
+            # Exit 0 is the tool's assertion that the file is resolved, so the
+            # sidecar goes even if the tool never wrote $MERGED.
+            resolved(candidate)
+          else
+            unresolved(candidate, "exit #{status.exitstatus}#{detail(err)}")
+          end
+        end
+      rescue StandardError => e
+        unresolved(candidate, first_line(e.message))
+      end
+
+      def resolved(candidate)
+        @shell.remove_file candidate.sidecar
+        @outcome.resolved << candidate.dest
+        @shell.say_status :resolved, candidate.dest, :green
+      end
+
+      def unresolved(candidate, reason)
+        @outcome.unresolved << { dest: candidate.dest, reason: reason }
+        @shell.say_status :unresolved, "#{candidate.dest} (#{reason})", :yellow
+      end
+
+      def write_base(candidate, dir)
+        return nil unless candidate.ancestor
+
+        File.join(dir, "base-#{File.basename(candidate.dest)}").tap do |file|
+          File.binwrite(file, candidate.ancestor)
+        end
+      end
+
+      # Substitution runs per token after the split, so a value holding spaces
+      # stays one argument.
+      def substitute(tokens, values, base:)
+        tokens.each_with_object([]) do |token, argv|
+          next if base.nil? && token == "$BASE"
+          argv << token.gsub(TOKEN_PATTERN) { values[Regexp.last_match(1)].to_s }
+        end
+      end
+
+      def env_for(values)
+        values.to_h { |name, value| ["HYPERDRIVE_#{name}", value] }
+      end
+
+      def values_for(candidate, base:)
+        live = abs(candidate.dest)
+        values = {
+          "LOCAL" => live,
+          "REMOTE" => abs(candidate.sidecar),
+          # A nil BASE substitutes empty and unsets HYPERDRIVE_BASE in the
+          # child, so an outer HYPERDRIVE_BASE can never leak into a run.
+          "BASE" => base,
+          "MERGED" => live,
+          "SOURCE" => candidate.source,
+          "PREVIOUS_SOURCE" => candidate.previous_source.to_s,
+          "KIND" => candidate.kind
+        }
+        values["PROMPT"] = prompt(candidate, base: base, values: values)
+        values
+      end
+
+      def prompt(candidate, base:, values:)
+        knobs = {
+          local: values["LOCAL"], remote: values["REMOTE"], base: base, merged: values["MERGED"],
+          source: candidate.source, previous_source: candidate.previous_source, kind: candidate.kind
+        }
+        template = user_template
+        return ResolvePrompt.render(template, **knobs) if template
+
+        ResolvePrompt.render(ResolvePrompt.default_template, **knobs)
+      rescue StandardError => e
+        raise unless template
+        @shell.say_status :warn,
+          "resolve: prompt: #{@prompt_path} could not be rendered (#{first_line(e.message)}); using the default prompt",
+          :yellow
+        @user_template = false
+        ResolvePrompt.render(ResolvePrompt.default_template, **knobs)
+      end
+
+      def user_template
+        return nil unless @prompt_path
+        return nil if @user_template == false
+
+        @user_template ||= File.read(abs(@prompt_path))
+      rescue StandardError => e
+        @shell.say_status :warn,
+          "resolve: prompt: #{@prompt_path} could not be read (#{first_line(e.message)}); using the default prompt",
+          :yellow
+        @user_template = false
+        nil
+      end
+
+      def detail(stderr)
+        line = first_line(stderr)
+        line.empty? ? "" : ": #{line}"
+      end
+
+      def first_line(message)
+        message.to_s.lines.first.to_s.strip
+      end
+
+      def abs(path)
+        File.join(@root, path)
+      end
+    end
+  end
+end

data/lib/rails/hyperdrive/skill_template.rb

@@ -3,7 +3,7 @@ require "erb"
 module Rails
   module Hyperdrive
     # Renders a skill's *.md.erb sources against the app's resolved bundle.
-    # The three helpers are the only supported template API, but the binding is
+    # The four helpers are the only supported template API, but the binding is
     # an ordinary object rather than a sandbox: a template runs arbitrary Ruby
     # with the privileges of whoever triggered discovery.
     module SkillTemplate
@@ -27,6 +27,10 @@ module Rails
           version&.to_s
         end
 
+        def canonical_render?
+          false
+        end
+
         def template_binding
           binding
         end
@@ -35,7 +39,9 @@ module Rails
       # Canonical render binding: every gem reads as present at any requested
       # version, so an if/elsif/else contributes only its first branch and
       # templates meant for this render must use additive if blocks. There is
-      # no bundle to resolve against, so gem_version is nil.
+      # no bundle to resolve against, so gem_version is nil. canonical_render?
+      # is the exception: it is deterministic in both bindings, so branching on
+      # it is safe.
       class CanonicalContext
         def gem?(_name, _requirement = nil)
           true
@@ -49,6 +55,10 @@ module Rails
           nil
         end
 
+        def canonical_render?
+          true
+        end
+
         def template_binding
           binding
         end

data/lib/rails/hyperdrive/stack_profile.rb

@@ -147,7 +147,7 @@ module Rails
 
       def enabled_gems
         require "rails/hyperdrive/install_layout"
-        require "rails/hyperdrive/lock_file"
+        require "rails/hyperdrive/config_file"
         root =
           if @app_root
             @app_root.to_s
@@ -156,8 +156,8 @@ module Rails
           end
         return [] unless root
 
-        ::Rails::Hyperdrive::LockFile.load(
-          File.join(root, ::Rails::Hyperdrive::InstallLayout::LOCK_PATH)
+        ::Rails::Hyperdrive::ConfigFile.load(
+          File.join(root, ::Rails::Hyperdrive::InstallLayout::CONFIG_PATH)
         ).enabled_gems
       rescue StandardError
         []

data/lib/rails/hyperdrive/version.rb

@@ -1,5 +1,5 @@
 module Rails
   module Hyperdrive
-    VERSION = "0.7.0"
+    VERSION = "0.9.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-hyperdrive
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Bakaface
@@ -104,6 +104,7 @@ files:
 - lib/rails/hyperdrive/canonical_skill_render.rb
 - lib/rails/hyperdrive/claude_md_import.rb
 - lib/rails/hyperdrive/companion_discovery.rb
+- lib/rails/hyperdrive/config_file.rb
 - lib/rails/hyperdrive/console_executor.rb
 - lib/rails/hyperdrive/drift_verdict.rb
 - lib/rails/hyperdrive/eager_footprint.rb
@@ -118,9 +119,12 @@ files:
 - lib/rails/hyperdrive/lock_file.rb
 - lib/rails/hyperdrive/manifest_lint.rb
 - lib/rails/hyperdrive/mcp_server.rb
+- lib/rails/hyperdrive/resolve/prompt.md.erb
+- lib/rails/hyperdrive/resolve_prompt.rb
 - lib/rails/hyperdrive/resources/skill.rb
 - lib/rails/hyperdrive/resources/stack_profile.rb
 - lib/rails/hyperdrive/safety/rack_middleware.rb
+- lib/rails/hyperdrive/sidecar_resolver.rb
 - lib/rails/hyperdrive/skill_template.rb
 - lib/rails/hyperdrive/sql_safety.rb
 - lib/rails/hyperdrive/stack_profile.rb