shiplog 0.1.0 → 0.2.0

data/app/frontend/shiplog/inbox.js

@@ -0,0 +1,78 @@
+// Idempotent: runs now and again on turbo:load (inert without Turbo), binding each container once.
+const init = () => {
+  const inbox = document.querySelector("[data-shiplog-inbox]")
+  if (!inbox || inbox.dataset.shiplogBound) return
+  inbox.dataset.shiplogBound = "true"
+
+  // Host layouts may not render csrf_meta_tags, so the container carries the token as a fallback.
+  const csrfToken = document.querySelector("meta[name=csrf-token]")?.content ?? inbox.dataset.csrfToken
+  const status = inbox.querySelector("[data-shiplog-status]")
+  const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)")
+
+  const announce = (text, alert = false) => {
+    status.textContent = text
+    status.classList.toggle("shiplog-admin__live--alert", alert)
+    status.setAttribute("role", alert ? "alert" : "status")
+    status.hidden = false
+  }
+
+  const showEmptyState = () => {
+    const empty = document.createElement("p")
+    empty.className = "shiplog-admin__empty"
+    empty.textContent = inbox.dataset.emptyText
+    inbox.querySelector("table").replaceWith(empty)
+  }
+
+  const removeRow = (row) => {
+    const done = () => {
+      row.remove()
+      if (!inbox.querySelector(".shiplog-entry-row")) showEmptyState()
+    }
+    if (reducedMotion.matches) return done()
+    row.classList.add("shiplog-entry-row--leaving")
+    row.addEventListener("transitionend", done, { once: true })
+    setTimeout(() => row.isConnected && done(), 400)
+  }
+
+  const replaceRow = (row, html) => {
+    const template = document.createElement("template")
+    template.innerHTML = html.trim()
+    row.replaceWith(template.content.firstElementChild)
+  }
+
+  // Bubbling submit on the container runs before Turbo's document-level listener.
+  inbox.addEventListener("submit", async (event) => {
+    const form = event.target.closest("form[data-shiplog-inline]")
+    if (!form) return
+    event.preventDefault()
+
+    const row = form.closest(".shiplog-entry-row")
+    const title = row.querySelector("a").textContent.trim()
+    const button = event.submitter ?? form.querySelector("button")
+    button.disabled = true
+    try {
+      // Rails reads a hidden _method field (button_to), so the request itself is always a POST.
+      const response = await fetch(form.action, {
+        method: "POST",
+        headers: { "Accept": "application/json", "X-CSRF-Token": csrfToken },
+        body: new FormData(form)
+      })
+      if (response.status !== 200 && response.status !== 422) throw new Error(response.status)
+
+      const data = await response.json()
+      if (response.status === 422) {
+        button.disabled = false
+        return announce(`${title}: ${data.error}`, true)
+      }
+      announce(`${title}: ${data.message}`)
+      if (data.matches_filter) replaceRow(row, data.row)
+      else removeRow(row)
+    } catch (error) {
+      // Network or server failure: fall back to a normal form submission.
+      form.submit()
+    }
+  })
+}
+
+init()
+document.addEventListener("turbo:load", init)

data/app/frontend/shiplog/shiplog.css

@@ -67,6 +67,37 @@
   .shiplog-page__title { font-size: 1.875rem; line-height: 1.2; margin: 0; }
   .shiplog-page__lede { color: var(--sl-muted); margin: 0.5rem 0 0; }
 
+  /* Switcher: Roadmap / Changelog / host pages. It can sit outside .shiplog-page (host pages), so it
+     falls back to the host-safe palette when the page variables are not inherited. */
+  .shiplog-switcher {
+    --sw-border: var(--sl-border, var(--shiplog-border, color-mix(in srgb, currentColor 22%, transparent)));
+    --sw-card: var(--sl-card, var(--shiplog-card, color-mix(in srgb, currentColor 5%, transparent)));
+    --sw-muted: var(--sl-muted, var(--shiplog-muted, color-mix(in srgb, currentColor 65%, transparent)));
+    --sw-accent: var(--sl-accent, var(--shiplog-accent, #2f81f7));
+    background: var(--sw-card);
+    border: 1px solid var(--sw-border);
+    border-radius: 999px;
+    display: inline-flex;
+    flex-wrap: wrap;
+    font-size: 0.875rem;
+    font-weight: 500;
+    gap: 0.25rem;
+    margin-top: var(--sl-space, 1rem);
+    padding: 0.25rem;
+  }
+  .shiplog-switcher__link {
+    border-radius: 999px;
+    color: var(--sw-muted);
+    padding: 0.25rem 1rem;
+    text-decoration: none;
+    transition: background-color 0.15s, color 0.15s;
+  }
+  .shiplog-switcher__link:hover { color: inherit; }
+  .shiplog-switcher__link:focus-visible { outline: 2px solid var(--sw-accent); outline-offset: 2px; }
+  .shiplog-switcher__link--current,
+  .shiplog-switcher__link--current:hover { background: var(--sw-accent); color: #fff; }
+  @media (prefers-reduced-motion: reduce) { .shiplog-switcher__link { transition: none; } }
+
   .shiplog-empty,
   .shiplog-column__empty { color: var(--sl-muted); margin: 0; }
 
@@ -77,17 +108,21 @@
     grid-template-columns: repeat(auto-fit, minmax(min(16rem, 100%), 1fr));
   }
 
+  /* A rule on top and a marker carry the column's place in time: in progress is solid, coming soon
+     is the accent, later is neutral. */
   .shiplog-column {
     --sl-dot: var(--sl-muted);
+    --sl-rule: var(--sl-border);
+    border-top: 2px solid var(--sl-rule);
     min-width: 0;
+    padding-top: 1rem;
   }
-  .shiplog-column--in-progress { --sl-dot: #1a7f37; }
-  .shiplog-column--coming-soon { --sl-dot: var(--sl-accent); }
-  .shiplog-column--later { --sl-dot: var(--sl-muted); }
+  .shiplog-column--in-progress { --sl-dot: #1a7f37; --sl-rule: var(--sl-dot); }
+  .shiplog-column--coming-soon { --sl-dot: var(--sl-accent); --sl-rule: var(--sl-dot); }
+  .shiplog-column--later { --sl-dot: var(--sl-muted); --sl-rule: var(--sl-border); }
 
   .shiplog-column__header {
     align-items: baseline;
-    border-bottom: 1px solid var(--sl-border);
     display: flex;
     flex-wrap: wrap;
     gap: 0 0.5rem;
@@ -95,13 +130,14 @@
     padding-bottom: 0.75rem;
   }
   .shiplog-column__title { align-items: center; display: flex; font-size: 1.125rem; gap: 0.5rem; margin: 0; }
-  .shiplog-column__title::before {
+  .shiplog-column__marker {
     background: var(--sl-dot);
     border-radius: 50%;
-    content: "";
+    flex-shrink: 0;
     height: 0.625rem;
     width: 0.625rem;
   }
+  .shiplog-column__marker--in-progress { box-shadow: 0 0 0 4px color-mix(in srgb, var(--sl-dot) 20%, transparent); }
   .shiplog-column__count {
     background: var(--sl-card);
     border: 1px solid var(--sl-border);
@@ -132,6 +168,58 @@
   .shiplog-entry__body p { margin: 0.25rem 0; }
   .shiplog-card__body { color: var(--sl-muted); font-size: 0.9375rem; }
 
+  .shiplog-card__meta {
+    align-items: center;
+    color: var(--sl-muted);
+    display: flex;
+    flex-wrap: wrap;
+    font-size: 0.75rem;
+    font-weight: 500;
+    gap: 0.5rem;
+    margin: 0.75rem 0 0;
+  }
+  .shiplog-card__tag {
+    border: 1px solid var(--sl-border);
+    border-radius: 0.375rem;
+    padding: 0 0.5rem;
+  }
+
+  /* Recently shipped: a title, a link to the full changelog, then a grid of the latest entries */
+  .shiplog-shipped {
+    align-items: baseline;
+    border-top: 1px solid var(--sl-border);
+    display: grid;
+    gap: 0.5rem 1rem;
+    grid-template-columns: 1fr auto;
+    margin-top: calc(var(--sl-space) * 2.5);
+    padding-top: calc(var(--sl-space) * 1.5);
+  }
+  .shiplog-shipped__title { font-size: 1.125rem; margin: 0; }
+  .shiplog-shipped__list {
+    display: grid;
+    gap: var(--sl-space) calc(var(--sl-space) * 1.5);
+    grid-column: 1 / -1;
+    grid-template-columns: repeat(auto-fit, minmax(min(12rem, 100%), 1fr));
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+  .shiplog-shipped__item { display: grid; gap: 0.25rem; align-content: start; }
+  .shiplog-shipped__date { color: var(--sl-muted); font-size: 0.75rem; }
+  .shiplog-shipped__link { color: inherit; font-weight: 600; text-decoration: none; }
+  .shiplog-shipped__link:hover { color: var(--sl-accent); }
+  .shiplog-shipped__link--all { color: var(--sl-accent); font-size: 0.875rem; font-weight: 500; }
+
+  .shiplog-footnote {
+    border-top: 1px solid var(--sl-border);
+    color: var(--sl-muted);
+    font-size: 0.875rem;
+    margin: calc(var(--sl-space) * 2) 0 0;
+    padding-top: var(--sl-space);
+    text-align: center;
+  }
+  .shiplog-footnote__link { color: var(--sl-accent); font-weight: 500; }
+
   /* Changelog: months hang off a vertical line */
   .shiplog-months { display: grid; gap: calc(var(--sl-space) * 2); }
 
@@ -176,6 +264,33 @@
   .shiplog-pagination__link { color: var(--sl-accent); }
   .shiplog-pagination__link--older { margin-left: auto; }
 
+  .shiplog-search { display: flex; flex-wrap: wrap; gap: 0.5rem; margin: var(--sl-space) 0; }
+  .shiplog-search__input {
+    flex: 1 1 14rem;
+    min-width: 0;
+    font: inherit;
+    color: inherit;
+    background: var(--sl-card);
+    border: 1px solid var(--sl-border);
+    border-radius: var(--sl-radius);
+    padding: 0.4rem 0.75rem;
+  }
+  .shiplog-search__input:focus-visible,
+  .shiplog-search__button:focus-visible,
+  .shiplog-search__clear:focus-visible { outline: 2px solid var(--sl-accent); outline-offset: 2px; }
+  .shiplog-search__button {
+    font: inherit;
+    color: #fff;
+    background: var(--sl-accent);
+    border: 1px solid var(--sl-accent);
+    border-radius: var(--sl-radius);
+    padding: 0.4rem 1rem;
+    cursor: pointer;
+  }
+  .shiplog-search__summary { color: var(--sl-muted); margin: 0 0 var(--sl-space); }
+  .shiplog-search__clear { color: var(--sl-accent); margin-left: 0.5rem; }
+  .shiplog-search__empty { color: var(--sl-muted); margin: 0; }
+
   @media (max-width: 40rem) {
     .shiplog-page { padding: var(--sl-space) 0.75rem; }
     .shiplog-page__title { font-size: 1.5rem; }

data/app/helpers/shiplog/callable_helper.rb

@@ -0,0 +1,12 @@
+module Shiplog
+  module CallableHelper
+    # A config value that is a String, or a callable evaluated in the view so it can use route helpers
+    # and I18n (`-> { main_app.news_path }`, `-> { t("...") }`).
+    def shiplog_resolve(value)
+      case value
+      when Proc then instance_exec(&value)
+      else value.respond_to?(:call) ? value.call : value
+      end
+    end
+  end
+end

data/app/helpers/shiplog/frontend_helper.rb

@@ -1,6 +1,7 @@
 module Shiplog
   module FrontendHelper
     def shiplog_stylesheet_tag(name)
+      @_shiplog_stylesheet_emitted = true if name == "shiplog" # shiplog_switcher then skips its own link
       tag.link rel: "stylesheet", href: shiplog_asset_path("#{name}.css"), nonce: content_security_policy_nonce
     end
 

data/app/helpers/shiplog/host_routes_helper.rb

@@ -3,6 +3,12 @@ module Shiplog
   # the host's own helpers (root_path, new_user_session_path, ...) are undefined there. This forwards
   # any unknown *_path / *_url call to main_app when the host app defines it. Helpers the engine
   # defines itself (roadmap_path, board_path, ...) are real methods and always win.
+  #
+  # Polymorphic URLs get the same treatment. Rails registers `resolve` mappings (Active Storage's
+  # VariantWithRecord, ...) on the host's routes only, so image_tag(record), url_for(record),
+  # link_to(label, record) and polymorphic_path/url(record) would otherwise fall through to
+  # record.to_model. When the engine has no mapping for the record's class but main_app does, the
+  # call is delegated to main_app. Engine mappings keep precedence.
   module HostRoutesHelper
     def method_missing(name, ...)
       if shiplog_host_route?(name)
@@ -16,8 +22,39 @@ module Shiplog
       shiplog_host_route?(name) || super
     end
 
+    def polymorphic_url(record_or_hash_or_array, options = {})
+      return super unless shiplog_host_mapping?(record_or_hash_or_array)
+
+      main_app.polymorphic_url(record_or_hash_or_array, options)
+    end
+
+    def polymorphic_path(record_or_hash_or_array, options = {})
+      return super unless shiplog_host_mapping?(record_or_hash_or_array)
+
+      main_app.polymorphic_path(record_or_hash_or_array, options)
+    end
+
+    def url_for(options = nil)
+      return super unless shiplog_host_mapping?(options)
+
+      _generate_paths_by_default ? polymorphic_path(options) : polymorphic_url(options)
+    end
+
     private
 
+    def shiplog_host_mapping?(record)
+      return false if record.nil? || record.is_a?(Hash) || record.is_a?(Array) || record.is_a?(String) ||
+        record.is_a?(Symbol) || record.is_a?(Class) || record.is_a?(ActionController::Parameters)
+      return false unless respond_to?(:main_app, true)
+
+      model = record.respond_to?(:to_model) ? record.to_model : record
+      # Odd objects (to_model returning something without a model_name) are left to Rails' own error.
+      return false if record.respond_to?(:to_model) && !model.respond_to?(:model_name)
+
+      name = record.respond_to?(:to_model) ? model.model_name.name : record.class.name
+      !_routes.polymorphic_mappings.key?(name) && main_app._routes.polymorphic_mappings.key?(name)
+    end
+
     def shiplog_host_route?(name)
       name.end_with?("_path", "_url") && respond_to?(:main_app, true) && main_app.respond_to?(name)
     end

data/app/helpers/shiplog/roadmap_helper.rb

@@ -0,0 +1,15 @@
+module Shiplog
+  module RoadmapHelper
+    include Shiplog::SwitcherHelper
+
+    # The configured label of a repository (config.repository_labels, matched case-insensitively), or nil.
+    def shiplog_repository_label(repository)
+      labels = Shiplog.config.repository_labels
+      label = labels[repository.full_name] || labels.find { |name, _| name.casecmp?(repository.full_name) }&.last
+      shiplog_resolve(label).presence
+    end
+
+    # The "suggest a feature" target (String or callable), or nil.
+    def shiplog_feedback_path = shiplog_safe_url(shiplog_resolve(Shiplog.config.feedback_path))
+  end
+end

data/app/helpers/shiplog/switcher_helper.rb

@@ -0,0 +1,101 @@
+module Shiplog
+  # The Roadmap / Changelog / extra pages switcher. The default page header renders it, and a host adds
+  # `helper Shiplog::SwitcherHelper` to render it on its own pages (e.g. a news page): `<%= shiplog_switcher %>`.
+  # It uses the engine's own route helpers, or the proxy of the host's mount (whatever its `as:`), so it works in
+  # main-app views too.
+  module SwitcherHelper
+    include Shiplog::StylingHelper
+    include Shiplog::CallableHelper
+
+    # URLs already warned about. Capped, since a callable path could return a new bad URL on every request.
+    WARNED = Set.new
+    MAX_WARNED = 100
+    private_constant :WARNED, :MAX_WARNED
+
+    def self.reset_warnings! = WARNED.clear
+
+    NotMounted = Class.new(StandardError)
+
+    # The name the host gave the engine's mount in its routes (`mount Shiplog::Engine => "/", as: :updates`; the
+    # default is "shiplog"), which is the name of its route proxy in host views. Found by looking for the route
+    # of config/routes.rb whose Rack app is the engine (the Constraints wrapper's `app`; Rails::Engine is what
+    # `mount` stores) and remembered while that route exists.
+    def self.mount_name
+      cached = @mount_name
+      return cached if cached && Rails.application.routes.named_routes.key?(cached)
+
+      route = Rails.application.routes.routes.find { |candidate| candidate.app.try(:app) == Shiplog::Engine }
+      raise NotMounted, "Shiplog::Engine is not mounted in the host's routes: add `mount Shiplog::Engine => \"/\"` to config/routes.rb" unless route&.name
+
+      @mount_name = route.name
+    end
+
+    def self.reset_mount_name! = (@mount_name = nil)
+
+    # The switcher for host pages: the bundled stylesheet (once per page, and not when the engine page already
+    # linked it; unless config.stylesheet is false) and the nav.
+    def shiplog_switcher
+      stylesheet = if Shiplog.config.stylesheet && !@_shiplog_stylesheet_emitted
+        @_shiplog_stylesheet_emitted = true
+        tag.link(rel: "stylesheet", nonce: content_security_policy_nonce,
+          href: shiplog_routes.frontend_path(version: Shiplog::VERSION, name: "shiplog.css"))
+      end
+      safe_join([ stylesheet, render("shiplog/switcher") ])
+    end
+
+    # The nav's aria-label: a plain String (never html_safe markup, never a translation-missing span).
+    def shiplog_switcher_label = String.new(I18n.t("shiplog.switcher.label", default: "Product updates"))
+
+    # [{ label:, path:, current: }] in display order. A path with an unsafe scheme is nil (rendered as text).
+    # Only the page with the longest matching path is current.
+    def shiplog_switcher_pages
+      pages = [
+        { label: t("shiplog.switcher.roadmap", default: "Roadmap"), path: shiplog_routes.roadmap_path },
+        { label: t("shiplog.switcher.changelog", default: "Changelog"), path: shiplog_routes.changelog_path },
+        *Shiplog.config.extra_pages.map { |page| { label: shiplog_resolve(page[:label]), path: shiplog_safe_url(shiplog_resolve(page[:path])) } }
+      ]
+      lengths = pages.map { |page| shiplog_match_length(page[:path]) }
+      best = lengths.compact.max
+      current = best && lengths.index(best)
+      pages.each_with_index.map { |page, index| page.merge(current: index == current) }
+    end
+
+    # The URL when it is safe to link (see Configuration.safe_url?); otherwise nil, with a warning logged once.
+    def shiplog_safe_url(url)
+      return if url.blank?
+      return url.to_s if Shiplog::Configuration.safe_url?(url)
+
+      if WARNED.size < MAX_WARNED && WARNED.add?(url.to_s)
+        Rails.logger.warn("[Shiplog] Not linking #{url.inspect}: only paths, http(s) and mailto: URLs are allowed")
+      end
+      nil
+    end
+
+    private
+
+    # Where the engine's route helpers live: the view itself inside the engine's own pages, otherwise (host pages)
+    # the proxy the host's mount defined, whatever its name.
+    def shiplog_routes
+      return self if controller.try(:_routes) == Shiplog::Engine.routes
+
+      public_send(SwitcherHelper.mount_name)
+    end
+
+    # Length of the link's path when it contains the request path (equal, or a parent segment), else nil.
+    # An absolute URL counts only for http(s) and the request's own host.
+    def shiplog_match_length(url)
+      return if url.nil?
+
+      uri = URI.parse(url)
+      return if uri.scheme && !(uri.scheme.match?(/\Ahttps?\z/i) && uri.host.to_s.casecmp?(request.host))
+
+      prefix = (uri.path || "").chomp("/")
+      current = request.path.to_s.chomp("/")
+      return (prefix.length if current == prefix) if prefix.empty?
+
+      prefix.length if current == prefix || current.start_with?("#{prefix}/")
+    rescue URI::InvalidURIError
+      nil
+    end
+  end
+end

data/app/jobs/shiplog/refresh_job.rb

@@ -15,6 +15,7 @@ module Shiplog
       when "pull_request" then import(repository, number, Github::Queries::PULL_REQUEST, "pullRequest", Sync::PullRequestImporter)
       else raise ArgumentError, "Unknown kind: #{kind.inspect}"
       end
+      Sync::UpgradeDetector.call_isolated(repository) if kind.to_s == "pull_request"
       Drafter.call
     end
 

data/app/jobs/shiplog/scan_changes_job.rb

@@ -2,9 +2,13 @@ module Shiplog
   class ScanChangesJob < ApplicationJob
     DEFAULT_WINDOW = 7.days
 
+    # Where a repository's next scan starts, and so the oldest merge nothing will draft before: the end of the
+    # last scan, or DEFAULT_WINDOW ago for a repository never scanned.
+    def self.window_start(repository) = repository.changes_scanned_at || DEFAULT_WINDOW.ago
+
     def perform
       client = Github::Client.new
-      Shiplog.config.repositories.each do |full_name|
+      Shiplog.config.repository_names.each do |full_name|
         scan(Repository.find_or_create_by!(full_name:), client)
       end
       Drafter.call
@@ -12,19 +16,29 @@ module Shiplog
 
     private
       def scan(repository, client)
-        since = repository.changes_scanned_at || DEFAULT_WINDOW.ago
+        since = self.class.window_start(repository)
         started_at = Time.current
         # Import late-synced PRs first so anything merged before `started_at` is visible to the scan.
         Sync::RepositorySync.new(repository, client:).call
-        Sync::CommitScanner.new(repository, client:).call(since:)
-        draft_changes(ChangeCandidates.new(repository:, since:, before: started_at).to_a)
-        repository.update!(changes_scanned_at: started_at)
+        if Shiplog.config.changelog_repository?(repository.full_name)
+          Sync::CommitScanner.new(repository, client:).call(since:)
+          draft_changes(ChangeCandidates.new(repository:, since:, before: started_at).to_a)
+        end
+        repository.update!(changes_scanned_at: window_end(repository, started_at, since))
       rescue Github::RateLimited
         raise
       rescue StandardError => error
         Rails.error.report(error, handled: true, context: { repository: repository.full_name })
       end
 
+      # Pull requests of this window that await upgrade detection are held back by ChangeCandidates, so the window
+      # stays at the oldest one and the next scan reconsiders it once it is checked. It never ends before `since`:
+      # older pending pull requests are outside the window, and the window must not move backwards.
+      def window_end(repository, started_at, since)
+        oldest_pending = Shiplog.config.changelog_repository?(repository.full_name) ? ChangeCandidates.oldest_pending(repository, since:) : nil
+        [ [ started_at, oldest_pending ].compact.min, since ].max
+      end
+
       def draft_changes(candidates)
         candidates.each { |subject| Drafter.draft(subject, "change", released_on: released_on(subject)) }
       end

data/app/jobs/shiplog/sync_job.rb

@@ -2,7 +2,7 @@ module Shiplog
   class SyncJob < ApplicationJob
     def perform
       client = Github::Client.new
-      repositories = Shiplog.config.repositories.map { |full_name| Repository.find_or_create_by!(full_name:) }
+      repositories = Shiplog.config.repository_names.map { |full_name| Repository.find_or_create_by!(full_name:) }
       repositories.each { |repository| sync(repository, client) }
       Drafter.call
     end

data/app/models/shiplog/change_candidates.rb

@@ -1,6 +1,21 @@
 module Shiplog
   class ChangeCandidates
     COMMIT_TYPE = /\A(\w+)(\([^)]*\))?!?:/
+    # The Conventional Commits types; "Importers: ..." is a topic prefix, not a type.
+    CONVENTIONAL_TYPES = %w[feat fix perf refactor chore docs test ci build style revert deps].freeze
+
+    # Dropped from the upgrade bypass: the label Dependabot adds. Any other excluded label still excludes.
+    UPGRADE_LABEL = "dependencies".freeze
+
+    # The merge time of the oldest merged pull request merged at or after `since` whose upgrade detection has not
+    # run yet, or nil. Such pull requests are held back from candidates, so a scan window must not move past it.
+    # Older ones are outside the window: they are never drafted, and must not drag it backwards. Nil when no gem
+    # is tracked, since detection would never run.
+    def self.oldest_pending(repository, since:)
+      return unless Shiplog.config.tracked_gems.any?
+
+      repository.pull_requests.awaiting_upgrade_check.where(merged_at: since..).reorder(:merged_at).pick(:merged_at)
+    end
 
     def initialize(repository:, since:, before:)
       @repository = repository
@@ -13,25 +28,47 @@ module Shiplog
 
     private
       def pull_requests
-        candidates = @repository.pull_requests.where(state: "merged", merged_at: @window).where.missing(:entries).to_a
-          .reject { |pull_request| excluded_label?(pull_request) || excluded_type?(pull_request) || Shiplog.config.excluded_author?(pull_request.author_login) }
+        candidates = merged_in_window.where.missing(:entries).to_a
+        upgrade_ids = ids_with_upgrades(candidates)
+        candidates = candidates.reject do |pull_request|
+          if upgrade_ids.include?(pull_request.id)
+            excluded_label?(pull_request, ignoring: UPGRADE_LABEL)
+          else
+            excluded_label?(pull_request) || excluded_type?(pull_request) || Shiplog.config.excluded_author?(pull_request.author_login)
+          end
+        end
         public_ids = pull_request_ids_in_public_tree(candidates)
         candidates.reject { |pull_request| public_ids.include?(pull_request.node_id) }
       end
 
+      # Pull requests still awaiting upgrade detection are held back (neither candidates nor excluded): excluding
+      # them now would skip an upgrade for good once the window moves on.
+      def merged_in_window
+        scope = @repository.pull_requests.where(state: "merged", merged_at: @window)
+        Shiplog.config.tracked_gems.any? ? scope.where.not(id: @repository.pull_requests.awaiting_upgrade_check.reorder(nil).select(:id)) : scope
+      end
+
+      # A pull request that upgrades a tracked gem with customer-visible changes is how customers receive them,
+      # so a Dependabot author, a chore(deps) title or a dependencies label does not exclude it. Other excluded
+      # labels, such as an `internal` a human added, still do.
+      def ids_with_upgrades(pull_requests)
+        PullRequestUpgrade.where(pull_request_id: pull_requests.map(&:id)).where("jsonb_array_length(gem_changes) > 0")
+          .distinct.pluck(:pull_request_id).to_set
+      end
+
       def commits
         @repository.commits.where(committed_at: @window).where.missing(:entries).order(:committed_at).to_a
           .select { |commit| eligible_commit?(commit) }
       end
 
-      def excluded_label?(pull_request)
-        pull_request.labels.intersect?(Shiplog.config.excluded_labels)
+      def excluded_label?(pull_request, ignoring: nil)
+        pull_request.labels.intersect?(Shiplog.config.excluded_labels - Array(ignoring))
       end
 
       # Untyped PR titles stay in; the rewriter decides whether customers would notice.
       def excluded_type?(pull_request)
-        type = pull_request.title[COMMIT_TYPE, 1]
-        type.present? && !Shiplog.config.commit_types.include?(type)
+        type = pull_request.title[COMMIT_TYPE, 1]&.downcase
+        CONVENTIONAL_TYPES.include?(type) && !Shiplog.config.commit_types.include?(type)
       end
 
       def eligible_commit?(commit)

data/app/models/shiplog/drafter.rb

@@ -52,7 +52,7 @@ module Shiplog
     end
 
     def self.shipped_candidates
-      drafted = Entry.feature.where(subject_type: Issue.name).select(:subject_id)
+      drafted = Entry.where(kind: Entry::CHANGELOG_KINDS, subject_type: Issue.name).select(:subject_id)
       Issue.publicly_labeled.where(state: "closed", state_reason: "completed", closed_at: FEATURE_LOOKBACK.ago..)
         .where.not(id: drafted)
         .includes(:parent).reject { |issue| issue.parent&.public? }

data/app/models/shiplog/entry.rb

@@ -7,7 +7,36 @@ module Shiplog
     enum :kind, %w[roadmap feature change].index_by(&:itself), validate: true
     enum :status, %w[draft approved discarded].index_by(&:itself), default: "draft", validate: true
 
+    CHANGELOG_KINDS = %w[feature change].freeze
+
     validates :released_on, presence: true, if: -> { approved? && !roadmap? }
+    validate :kind_change_allowed, on: :update
+    validate :kind_free_for_subject, on: :update
+
+    SEARCH_MAX_LENGTH = 100
+    SEARCH_MAX_WORDS = 5
+
+    # The words of a search query: whitespace squished, cut at 100 characters, at most 5 words.
+    def self.search_terms(query)
+      query.to_s.squish.first(SEARCH_MAX_LENGTH).split.first(SEARCH_MAX_WORDS)
+    end
+
+    # Entries whose title or body contains every word of the query (case-insensitive, LIKE wildcards escaped).
+    # A blank query leaves the scope unchanged.
+    def self.search(query)
+      search_terms(query).reduce(all) do |scope, term|
+        pattern = "%#{sanitize_sql_like(term)}%"
+        scope.where("#{table_name}.title ILIKE :pattern OR #{table_name}.body ILIKE :pattern", pattern:)
+      end
+    end
+
+    def changelog_kind = kind
+
+    # Switches a changelog entry between "feature" and "change". Roadmap entries never convert, and
+    # anything other than those two values is ignored.
+    def changelog_kind=(value)
+      self.kind = value if CHANGELOG_KINDS.include?(kind) && CHANGELOG_KINDS.include?(value)
+    end
 
     def self.digest_for(subject)
       Digest::SHA256.hexdigest([ subject.title, subject.body ].join("\n"))
@@ -35,6 +64,18 @@ module Shiplog
 
     private
 
+    def kind_free_for_subject
+      return unless will_save_change_to_kind? && self.class.where(subject_type:, subject_id:, kind:).where.not(id:).exists?
+
+      errors.add(:changelog_kind, :taken)
+    end
+
+    def kind_change_allowed
+      return unless will_save_change_to_kind?
+
+      errors.add(:kind, :invalid) unless CHANGELOG_KINDS.include?(kind_in_database) && CHANGELOG_KINDS.include?(kind)
+    end
+
     def require_status!(action, from:)
       raise InvalidTransition, "Cannot #{action} an entry that is #{status}" unless status == from
     end

data/app/models/shiplog/pull_request.rb

@@ -4,6 +4,10 @@ module Shiplog
     has_many :issue_links, primary_key: :node_id, foreign_key: :pull_request_node_id, dependent: :delete_all
     has_many :issues, through: :issue_links
     has_many :entries, as: :subject, dependent: :destroy
+    has_many :upgrades, class_name: "Shiplog::PullRequestUpgrade", dependent: :destroy
+
+    # Merged pull requests that touched the lockfile and were not inspected yet, newest first.
+    scope :awaiting_upgrade_check, -> { where(state: "merged", lockfile_changed: true, upgrades_checked_at: nil).order(merged_at: :desc, id: :desc) }
 
     def open? = state == "open"
     def merged? = state == "merged"

data/app/models/shiplog/pull_request_upgrade.rb

@@ -0,0 +1,5 @@
+module Shiplog
+  class PullRequestUpgrade < ApplicationRecord
+    belongs_to :pull_request
+  end
+end