ace-overseer 0.26.1 → 0.28.0

data/lib/ace/overseer/molecules/project_bundle.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "json"
+require "ace/herdr/molecules/bounded_process"
+require "shellwords"
+require "ace/support/cli/toolchain"
+
+module Ace
+  module Overseer
+    module Molecules
+      # A project's own Gemfile/lock and binstub select its ACE version.
+      # Never load child project gems into the lab coordinator's process.
+      class ProjectBundle
+        # A new Herdr shell inherits the server environment, which may differ
+        # from this CLI's environment. Clear known Bundler selectors even
+        # when the requesting process did not have them set.
+        BUNDLE_SELECTORS = %w[
+          BUNDLE_ALLOW_OFFLINE_INSTALL BUNDLE_APP_CONFIG BUNDLE_AUTO_INSTALL
+          BUNDLE_BIN BUNDLE_BIN_PATH BUNDLE_CACHE_ALL BUNDLE_CACHE_ALL_PLATFORMS
+          BUNDLE_CACHE_PATH BUNDLE_CLEAN BUNDLE_CONSOLE BUNDLE_DEPLOYMENT
+          BUNDLE_DISABLE_CHECKSUM_VALIDATION BUNDLE_DISABLE_EXEC_LOAD
+          BUNDLE_DISABLE_LOCAL_BRANCH_CHECK BUNDLE_DISABLE_LOCAL_REVISION_CHECK
+          BUNDLE_DISABLE_SHARED_GEMS BUNDLE_DISABLE_VERSION_CHECK
+          BUNDLE_FORCE_RUBY_PLATFORM BUNDLE_FORGET_CLI_OPTIONS BUNDLE_FROZEN
+          BUNDLE_GEMFILE BUNDLE_GEM__BUNDLE BUNDLE_GEM__CHANGELOG BUNDLE_GEM__CI
+          BUNDLE_GEM__COC BUNDLE_GEM__GITHUB_USERNAME BUNDLE_GEM__LINTER
+          BUNDLE_GEM__MIT BUNDLE_GEM__RUBOCOP BUNDLE_GEM__TEST
+          BUNDLE_GIT__ALLOW_INSECURE BUNDLE_GLOBAL_GEM_CACHE BUNDLE_IGNORE_CONFIG
+          BUNDLE_IGNORE_MESSAGES BUNDLE_INIT_GEMS_RB BUNDLE_INLINE BUNDLE_JOBS
+          BUNDLE_LOCKFILE_CHECKSUMS BUNDLE_NO_INSTALL BUNDLE_NO_PRUNE BUNDLE_ONLY
+          BUNDLE_PATH BUNDLE_PATH__SYSTEM BUNDLE_PLUGINS BUNDLE_PREFER_PATCH
+          BUNDLE_REDIRECT BUNDLE_RETRY BUNDLE_SHEBANG BUNDLE_SILENCE_DEPRECATIONS
+          BUNDLE_SILENCE_ROOT_WARNING BUNDLE_SIMULATE_VERSION BUNDLE_SSL_CA_CERT
+          BUNDLE_SSL_CLIENT_CERT BUNDLE_SSL_VERIFY_MODE BUNDLE_SYSTEM_BINDIR
+          BUNDLE_TIMEOUT BUNDLE_TRUST___POLICY BUNDLE_UPDATE_REQUIRES_ALL_FLAG
+          BUNDLE_USER_HOME BUNDLE_USER_CONFIG BUNDLE_USER_CACHE BUNDLE_USER_PLUGIN
+          BUNDLE_VERBOSE BUNDLE_VERSION BUNDLE_WITH BUNDLE_WITHOUT
+          BUNDLER_SETUP BUNDLER_VERSION
+        ].freeze
+        RUBY_SELECTORS = %w[RUBYOPT RUBYLIB GEM_HOME GEM_PATH ACE_TOOLCHAIN].freeze
+
+        def self.environment(root, env: ENV)
+          if Ace::Support::Cli::Toolchain.installed?
+            # Reuse the installed closure; the project checkout is domain data.
+            # Do not let a project binstub or Gemfile select source dependencies.
+            return Ace::Support::Cli::Toolchain.child_environment.merge(
+              "HERDR_PANE" => nil, "HERDR_TAB" => nil,
+              "HERDR_PANE_ID" => nil, "HERDR_TAB_ID" => nil
+            )
+          end
+          known = BUNDLE_SELECTORS + RUBY_SELECTORS
+          names = env.keys.grep(/\ABUNDLER?_/) + known +
+            (known + %w[PATH]).map { |key| "BUNDLER_ORIG_#{key}" } +
+            %w[HERDR_PANE HERDR_TAB HERDR_PANE_ID HERDR_TAB_ID]
+          names.to_h { |name| [name, nil] }.merge(
+            "BUNDLE_GEMFILE" => File.file?(File.join(root, "Gemfile")) ? File.join(root, "Gemfile") : nil,
+            "PATH" => [File.join(root, "bin"), env.fetch("PATH", "/usr/bin:/bin")].join(File::PATH_SEPARATOR)
+          )
+        end
+
+        def self.shell_setup(root, env: ENV)
+          if Ace::Support::Cli::Toolchain.installed?
+            # A server-created shell may contain selectors absent from this
+            # caller. Clear the same known selectors before applying the
+            # installed closure; never inherit server-side Bundler injection.
+            names = BUNDLE_SELECTORS + BUNDLE_SELECTORS.map { |key| "BUNDLER_ORIG_#{key}" }
+            return "unset #{names.map { |name| Shellwords.escape(name) }.join(' ')}; " +
+              Ace::Support::Cli::Toolchain.shell_setup
+          end
+
+          values = environment(root, env: env).reject { |name, _| %w[HERDR_PANE HERDR_TAB HERDR_PANE_ID HERDR_TAB_ID].include?(name) }
+          cleared, assigned = values.partition { |_, value| value.nil? }
+          "unset #{cleared.map { |name, _| Shellwords.escape(name) }.join(" ")}; export " +
+            assigned.map { |name, value| "#{name}=#{Shellwords.escape(value)}" }.join(" ")
+        end
+
+        def initialize(timeout_s: 240)
+          @timeout_s = timeout_s
+        end
+
+        def call(root:, workspace:, env: ENV)
+          installed = Ace::Support::Cli::Toolchain.installed?
+          unless installed
+            %w[Gemfile Gemfile.lock].each do |name|
+              unless File.file?(File.join(root, name))
+                raise Ace::Overseer::Error, "project bundle missing #{name}; prepare this project's own bundle first"
+              end
+            end
+          end
+          binary = installed ? Ace::Support::Cli::Toolchain.executable("ace-overseer") : File.join(root, "bin", "ace-overseer")
+          command = File.executable?(binary) ? [binary] : ["bundle", "exec", "ace-overseer"]
+          command += ["start", "--scope", "project", "--format", "json"]
+          child_env = self.class.environment(root, env: env).merge("HERDR_WORKSPACE_ID" => workspace)
+          result = Ace::Herdr::Molecules::BoundedProcess.call(command,
+            environment: ENV.to_h.merge(child_env).compact, chdir: root,
+            timeout_s: @timeout_s, output_limit: 1_048_576)
+          raise Ace::Overseer::Error, "project start output exceeded its limit" if result.oversized
+          out, err, status = result.stdout, result.stderr, result.status
+          report = JSON.parse(out)
+          unless report.is_a?(Hash) && report["scope"] == "project" && report["status"].is_a?(String)
+            raise Ace::Overseer::Error, "project start returned no project-scope report"
+          end
+          if !status.success? && %w[started reused ready].include?(report["status"])
+            raise Ace::Overseer::Error, "project start exited #{status.exitstatus} despite a ready report"
+          end
+          report
+        rescue Timeout::Error
+          raise Ace::Overseer::Error, "project start timed out after #{@timeout_s}s; inspect the existing session before retrying"
+        rescue Ace::Herdr::Molecules::BoundedProcess::PostLaunchError => e
+          raise Ace::Overseer::Error, "project start outcome is uncertain: #{e.message}"
+        rescue JSON::ParserError
+          raise Ace::Overseer::Error, "project bundle start returned invalid JSON#{": " + err.strip[0, 300] unless err.to_s.empty?}"
+        rescue SystemCallError => e
+          raise Ace::Overseer::Error, "project bundle could not start: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/overseer/molecules/project_root_resolver.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Ace
+  module Overseer
+    module Molecules
+      # Canonical project-root resolution for `ace-overseer start`
+      # (task 8xs.t.pu0.1): a subdirectory, a symlinked checkout and a
+      # linked WORKTREE of the same repository all resolve to the same
+      # owning root, so one repository never runs two whole-project
+      # overseers. Worktrees map to the main working tree's root through
+      # Git's own `--git-common-dir`; the resolved root is realpathed.
+      # All Git access runs through an injectable argv runner seam.
+      class ProjectRootResolver
+        def initialize(runner: nil)
+          @runner = runner || method(:run_argv)
+        end
+
+        # @param cwd [String] directory the command was invoked in
+        # @return [String] canonical project root (realpath)
+        # @raise [Ace::Overseer::Error] not a repository, or a bare repo
+        def resolve(cwd:)
+          toplevel = git_output(cwd, ["git", "-C", cwd, "rev-parse", "--show-toplevel"])
+          root = File.realpath(toplevel)
+
+          common = git_output(cwd, ["git", "-C", root, "rev-parse", "--git-common-dir"])
+          common_path = File.expand_path(common, root)
+          if File.realpath(common_path) != File.realpath(File.join(root, ".git"))
+            # a linked worktree: the main working tree owns the project
+            main_root = File.dirname(File.realpath(common_path))
+            root = File.realpath(main_root) if File.directory?(main_root)
+          end
+
+          root
+        rescue Errno::ENOENT, Errno::ENOTDIR
+          raise Ace::Overseer::Error, "cannot resolve the project root: '#{cwd}' does not exist"
+        end
+
+        private
+
+        def git_output(cwd, argv)
+          result = @runner.call(argv)
+          unless result["status"] == "ok"
+            raise Ace::Overseer::Error,
+              "cannot resolve the project root under '#{cwd}': run " \
+                "ace-overseer start inside the configured project repository"
+          end
+
+          line = result["out"].to_s.lines.first.to_s.strip
+          raise Ace::Overseer::Error, "git returned no root for '#{cwd}'" if line.empty?
+
+          line
+        end
+
+        def run_argv(argv)
+          out, err, status = Open3.capture3(*argv)
+          {"status" => status.success? ? "ok" : (status.exitstatus || "signal"),
+           "out" => out, "err" => err}
+        rescue Errno::ENOENT
+          {"status" => "enoent", "out" => "", "err" => ""}
+        rescue SystemCallError => e
+          {"status" => "exec_failed", "out" => "", "err" => e.class.name}
+        end
+      end
+    end
+  end
+end

data/lib/ace/overseer/molecules/remote_sources.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Ace
+  module Overseer
+    module Molecules
+      # Remote PR/repo observation (task 8xs.t.pu0.4): projects configured
+      # pull requests through the EXISTING forge provider adapters
+      # (Ace::Git::Providers.for — Forgejo and GitHub; no separate HTTP
+      # client here). Observed PRs come from the project's own
+      # configuration (`observe.remote.pull_requests` in the overseer
+      # cascade) — never a scan of every accessible account.
+      #
+      # Rows follow the standing-observation contract of LocalSources:
+      # stable key + SEMANTIC revision (state, head SHA, review/comment
+      # identity sets — never poll timestamps or list order), so repeated
+      # reads of identical state project identical revisions (zero model
+      # turns) while a new HEAD, review, approval, comment, merge, close
+      # or reopen revises exactly its row. The row carries the wake
+      # payload: forge, PR number/title, event kind, author, link.
+      #
+      # A failing forge (401/403, rate limit, timeout, malformed payload)
+      # degrades ONLY its source — a marker revision keyed by error
+      # class wakes once per failure mode, never as an empty healthy
+      # list — and recovery re-observes the real state.
+      class RemoteSources
+        def initialize(provider_factory: nil, timeout: nil)
+          @provider_factory = provider_factory || ->(server_name) {
+            server = Ace::Git::ServerRegistry.resolve(server_name)
+            Ace::Git::Providers.for(server, timeout: timeout)
+          }
+        end
+
+        # @param pull_requests [Array<Hash>] {"server" =>, "number" =>}
+        #   entries from the project's observe.remote configuration
+        # @return [Hash] {"events" => Array, "sources" => {name => health}}
+        def call(pull_requests:)
+          sources = {}
+          events = []
+
+          # Validate entries BEFORE grouping: a malformed entry (non-Hash,
+          # missing server/number) must degrade its group to a health
+          # marker, never crash the whole observation pass.
+          valid, invalid = Array(pull_requests).partition do |entry|
+            entry.is_a?(Hash) && !entry["server"].to_s.empty? && !entry["number"].to_s.empty?
+          end
+          invalid.group_by { |entry| entry.is_a?(Hash) ? entry["server"].to_s : "" }.each do |server, entries|
+            if server.empty?
+              # Non-Hash or server-less entries still surface as health
+              # markers, never silently disappear.
+              sources["observe.remote"] ||= {"state" => "degraded",
+                "reason" => "invalid observe.remote.pull_requests entry: #{entries.first.inspect}"}
+            else
+              sources["pr:#{server}"] ||= {"state" => "degraded",
+                "reason" => "invalid observe.remote.pull_requests entry: #{entries.first.inspect}"}
+            end
+          end
+
+          valid.group_by { |entry| entry["server"] }.each do |server, entries|
+            collect(sources, events, "pr:#{server}") do
+              entries.flat_map { |entry| project(server, entry["number"]) }
+            end
+          end
+
+          {"events" => events, "sources" => sources}
+        end
+
+        private
+
+        def collect(sources, events, name)
+          rows = yield
+          sources[name] = {"status" => "ok"}
+          events.concat(rows)
+        rescue StandardError => e
+          sources[name] = {"status" => "degraded", "error" => "#{e.class}: #{e.message}"}
+          events << {"key" => "source:#{name}",
+                     "revision" => Digest::SHA256.hexdigest("degraded:#{e.class}"),
+                     "type" => "source-health", "status" => "degraded",
+                     "error" => "#{e.class}: #{e.message}"}
+        end
+
+        def project(server, number)
+          provider = @provider_factory.call(server)
+          pr = provider.pull_request(number: number)
+          return [] if pr.nil?
+
+          rows = [pr_row(server, pr)]
+          evidence = provider.pull_request_review_evidence(number: number, expected_head: pr.head_sha)
+          rows << activity_row(server, pr, evidence) if evidence
+          rows
+        end
+
+        # The PR's own lifecycle: new HEAD (head_sha), merge, close,
+        # reopen, title/draft changes. Read fresh before any merge
+        # decision — remote data stays data.
+        def pr_row(server, pr)
+          payload = {"number" => pr.number, "state" => pr.state.to_s,
+                     "head_sha" => pr.head_sha, "draft" => pr.draft,
+                     "title" => pr.title, "merged_at" => pr.merged_at,
+                     "merge_commit_sha" => pr.merge_commit_sha}
+          {"key" => "pr:#{server}:#{pr.number}", "revision" => digest(payload),
+           "type" => "pr", "forge" => server, "number" => pr.number,
+           "title" => pr.title, "state" => pr.state.to_s, "head_sha" => pr.head_sha,
+           "author" => pr.author, "url" => pr.url}
+        end
+
+        # Review/comment/approval activity: the revision covers the
+        # SORTED identity set (id, author, state, head binding) of every
+        # review and comment — re-ordered payloads and volatile counters
+        # never revise; a new verdict, approval or comment revises once.
+        # The row's summary names the latest item for the wake payload.
+        def activity_row(server, pr, evidence)
+          reviews = Array(evidence.reviews).map { |review|
+            {"id" => review.id.to_s, "author" => review.author, "state" => review.state.to_s,
+             "head_sha" => review.head_sha, "kind" => "review"}
+          }
+          comments = Array(evidence.comments).map { |comment|
+            {"id" => comment.id.to_s, "author" => comment.author, "state" => nil,
+             "head_sha" => comment.head_sha, "kind" => "comment"}
+          }
+          items = (reviews + comments).sort_by { |item| item["id"] }
+          latest = items.last
+
+          {"key" => "pr-activity:#{server}:#{pr.number}", "revision" => digest(items),
+           "type" => "pr-activity", "forge" => server, "number" => pr.number,
+           "title" => pr.title, "event_kind" => latest && latest["kind"],
+           "event_id" => latest && latest["id"], "author" => latest && latest["author"],
+           "url" => pr.url, "items" => items.size}
+        end
+
+        def digest(payload)
+          Digest::SHA256.hexdigest(JSON.generate(payload))
+        end
+      end
+    end
+  end
+end