shiplog 0.1.0

data/app/frontend/shiplog/shiplog.css

@@ -0,0 +1,184 @@
+/*
+ * Shiplog public pages. Everything lives in the `shiplog` cascade layer, so any unlayered CSS in
+ * your app wins over it without needing higher specificity. Only BEM classes are styled.
+ *
+ * Inside a host layout the page inherits the host's text colour and uses transparent surfaces and
+ * borders mixed from currentColor, so it suits light and dark hosts alike. Only the engine's own
+ * layout (`.shiplog-layout`), which paints the page background, follows prefers-color-scheme.
+ *
+ * Variables (set them on :root, body or .shiplog-page):
+ *   --shiplog-fg      text colour            --shiplog-border  borders and dividers
+ *   --shiplog-muted   secondary text         --shiplog-accent  links, feature marker, focus
+ *   --shiplog-bg      page background        --shiplog-radius  corner radius of cards and pills
+ *   --shiplog-card    card background        --shiplog-font    font family
+ *   --shiplog-space   base spacing unit (default 1rem)
+ */
+@layer shiplog {
+  /* Host-safe defaults: inherit the text colour, derive surfaces and borders from it. */
+  .shiplog-page,
+  .shiplog-layout {
+    --sl-fg: var(--shiplog-fg, currentColor);
+    --sl-muted: var(--shiplog-muted, color-mix(in srgb, currentColor 65%, transparent));
+    --sl-bg: var(--shiplog-bg, transparent);
+    --sl-card: var(--shiplog-card, color-mix(in srgb, currentColor 5%, transparent));
+    --sl-border: var(--shiplog-border, color-mix(in srgb, currentColor 22%, transparent));
+    --sl-accent: var(--shiplog-accent, #2f81f7);
+    --sl-radius: var(--shiplog-radius, 0.5rem);
+    --sl-font: var(--shiplog-font, system-ui, -apple-system, "Segoe UI", sans-serif);
+    --sl-space: var(--shiplog-space, 1rem);
+  }
+
+  /* The engine's own layout owns the page background, so it picks its own light and dark palette. */
+  .shiplog-layout,
+  .shiplog-layout .shiplog-page {
+    --sl-fg: var(--shiplog-fg, #1f2328);
+    --sl-muted: var(--shiplog-muted, #59636e);
+    --sl-bg: var(--shiplog-bg, #ffffff);
+    --sl-card: var(--shiplog-card, #f6f8fa);
+    --sl-border: var(--shiplog-border, #d1d9e0);
+    --sl-accent: var(--shiplog-accent, #0969da);
+  }
+
+  @media (prefers-color-scheme: dark) {
+    .shiplog-layout,
+    .shiplog-layout .shiplog-page {
+      --sl-fg: var(--shiplog-fg, #e6edf3);
+      --sl-muted: var(--shiplog-muted, #9198a1);
+      --sl-bg: var(--shiplog-bg, #0d1117);
+      --sl-card: var(--shiplog-card, #151b23);
+      --sl-border: var(--shiplog-border, #3d444d);
+      --sl-accent: var(--shiplog-accent, #4493f8);
+    }
+  }
+
+  /* Only the engine's own layout paints the body; a host layout keeps its background. */
+  .shiplog-layout { background: var(--sl-bg); color: var(--sl-fg); margin: 0; }
+
+  .shiplog-page {
+    color: var(--sl-fg);
+    font-family: var(--sl-font);
+    line-height: 1.5;
+    margin: 0 auto;
+    max-width: 72rem;
+    padding: calc(var(--sl-space) * 1.5) var(--sl-space);
+  }
+
+  .shiplog-page__header { margin-bottom: calc(var(--sl-space) * 2); }
+  .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; }
+
+  .shiplog-empty,
+  .shiplog-column__empty { color: var(--sl-muted); margin: 0; }
+
+  /* Roadmap */
+  .shiplog-columns {
+    display: grid;
+    gap: calc(var(--sl-space) * 1.5);
+    grid-template-columns: repeat(auto-fit, minmax(min(16rem, 100%), 1fr));
+  }
+
+  .shiplog-column {
+    --sl-dot: var(--sl-muted);
+    min-width: 0;
+  }
+  .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__header {
+    align-items: baseline;
+    border-bottom: 1px solid var(--sl-border);
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0 0.5rem;
+    margin-bottom: var(--sl-space);
+    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 {
+    background: var(--sl-dot);
+    border-radius: 50%;
+    content: "";
+    height: 0.625rem;
+    width: 0.625rem;
+  }
+  .shiplog-column__count {
+    background: var(--sl-card);
+    border: 1px solid var(--sl-border);
+    border-radius: 1rem;
+    color: var(--sl-muted);
+    font-size: 0.75rem;
+    padding: 0 0.5rem;
+  }
+  .shiplog-column__description { color: var(--sl-muted); flex-basis: 100%; font-size: 0.875rem; margin: 0.25rem 0 0; }
+
+  .shiplog-cards,
+  .shiplog-entries { display: grid; gap: 0.75rem; list-style: none; margin: 0; padding: 0; }
+
+  .shiplog-card,
+  .shiplog-entry {
+    background: var(--sl-card);
+    border: 1px solid var(--sl-border);
+    border-radius: var(--sl-radius);
+    padding: 0.75rem var(--sl-space);
+  }
+
+  .shiplog-card { transition: border-color 0.15s, box-shadow 0.15s; }
+  .shiplog-card:hover { border-color: var(--sl-accent); box-shadow: 0 1px 6px rgb(0 0 0 / 0.1); }
+  @media (prefers-reduced-motion: reduce) { .shiplog-card { transition: none; } }
+
+  .shiplog-card__title { font-size: 1rem; margin: 0 0 0.25rem; }
+  .shiplog-card__body p,
+  .shiplog-entry__body p { margin: 0.25rem 0; }
+  .shiplog-card__body { color: var(--sl-muted); font-size: 0.9375rem; }
+
+  /* Changelog: months hang off a vertical line */
+  .shiplog-months { display: grid; gap: calc(var(--sl-space) * 2); }
+
+  .shiplog-month {
+    border-left: 2px solid var(--sl-border);
+    margin-left: 0.375rem;
+    padding-left: calc(var(--sl-space) * 1.5);
+    position: relative;
+  }
+  .shiplog-month__title { font-size: 1.125rem; margin: 0 0 0.75rem; }
+  .shiplog-month__title::before {
+    background: var(--sl-accent);
+    border-radius: 50%;
+    content: "";
+    height: 0.75rem;
+    left: calc(-1px - 0.375rem);
+    position: absolute;
+    top: 0.45rem;
+    width: 0.75rem;
+  }
+
+  .shiplog-entry { align-items: center; display: flex; flex-wrap: wrap; gap: 0.25rem 0.625rem; }
+  .shiplog-entry__title,
+  .shiplog-entry__body { flex-basis: 100%; }
+  .shiplog-entry__title { font-size: 1rem; margin: 0.25rem 0 0; }
+  .shiplog-entry__body { color: var(--sl-muted); }
+  .shiplog-entry__date { color: var(--sl-muted); font-size: 0.8125rem; }
+
+  .shiplog-entry__category {
+    border: 1px solid var(--sl-border);
+    border-radius: 1rem;
+    color: var(--sl-muted);
+    font-size: 0.75rem;
+    font-weight: 600;
+    padding: 0 0.5rem;
+  }
+  .shiplog-entry--feature { border-left: 4px solid var(--sl-accent); padding: var(--sl-space) calc(var(--sl-space) * 1.25); }
+  .shiplog-entry--feature .shiplog-entry__title { font-size: 1.25rem; }
+  .shiplog-entry--feature .shiplog-entry__category { background: var(--sl-accent); border-color: var(--sl-accent); color: #fff; }
+
+  .shiplog-pagination { display: flex; flex-wrap: wrap; gap: var(--sl-space); justify-content: space-between; margin-top: calc(var(--sl-space) * 2); }
+  .shiplog-pagination__link { color: var(--sl-accent); }
+  .shiplog-pagination__link--older { margin-left: auto; }
+
+  @media (max-width: 40rem) {
+    .shiplog-page { padding: var(--sl-space) 0.75rem; }
+    .shiplog-page__title { font-size: 1.5rem; }
+    .shiplog-month { padding-left: var(--sl-space); }
+  }
+}

data/app/helpers/shiplog/admin/entries_helper.rb

@@ -0,0 +1,27 @@
+module Shiplog
+  module Admin
+    module EntriesHelper
+      def source_title(subject)
+        subject.is_a?(Commit) ? subject.message.lines.first.to_s.strip : subject.title
+      end
+
+      def source_body(subject)
+        subject.is_a?(Commit) ? subject.message.lines.drop(1).join.strip : subject.body.to_s
+      end
+
+      def source_reference(subject)
+        return subject.sha.first(7) if subject.is_a?(Commit)
+
+        "#{subject.repository.full_name}##{subject.number}"
+      end
+
+      def entry_heading(entry)
+        entry.title.presence || source_title(entry.subject)
+      end
+
+      def entries_filter_path(status: nil, kind: nil, page: nil)
+        root_path({ status:, kind:, page: }.compact_blank)
+      end
+    end
+  end
+end

data/app/helpers/shiplog/application_helper.rb

@@ -0,0 +1,14 @@
+module Shiplog
+  module ApplicationHelper
+    GITHUB_URL_PREFIX = "https://github.com/".freeze
+
+    # Links only to github.com over https; anything else (javascript:, data:, other hosts) renders as plain text.
+    def shiplog_github_link(text, url)
+      if url.to_s.start_with?(GITHUB_URL_PREFIX)
+        link_to text, url, rel: "noopener noreferrer", target: "_blank"
+      else
+        text
+      end
+    end
+  end
+end

data/app/helpers/shiplog/frontend_helper.rb

@@ -0,0 +1,17 @@
+module Shiplog
+  module FrontendHelper
+    def shiplog_stylesheet_tag(name)
+      tag.link rel: "stylesheet", href: shiplog_asset_path("#{name}.css"), nonce: content_security_policy_nonce
+    end
+
+    def shiplog_javascript_tag(name)
+      tag.script "", src: shiplog_asset_path("#{name}.js"), type: "module", nonce: content_security_policy_nonce
+    end
+
+    private
+
+    def shiplog_asset_path(file)
+      frontend_path(version: Shiplog::VERSION, name: file)
+    end
+  end
+end

data/app/helpers/shiplog/host_routes_helper.rb

@@ -0,0 +1,25 @@
+module Shiplog
+  # A host layout rendered by a Shiplog controller runs in the engine's isolated routing context, so
+  # 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.
+  module HostRoutesHelper
+    def method_missing(name, ...)
+      if shiplog_host_route?(name)
+        main_app.public_send(name, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      shiplog_host_route?(name) || super
+    end
+
+    private
+
+    def shiplog_host_route?(name)
+      name.end_with?("_path", "_url") && respond_to?(:main_app, true) && main_app.respond_to?(name)
+    end
+  end
+end

data/app/helpers/shiplog/styling_helper.rb

@@ -0,0 +1,24 @@
+module Shiplog
+  module StylingHelper
+    # The stable BEM class of an element, BEM modifiers (class--modifier) and the host's classes
+    # from config.classes[key]. Unknown keys raise outside production so typos surface early.
+    def shiplog_class(key, *modifiers)
+      key = key.to_sym
+      base = Shiplog::Classes::BEM[key]
+      if base.nil?
+        raise ArgumentError, "Unknown Shiplog class key #{key.inspect}. Valid keys: #{Shiplog::Classes::KEYS.join(", ")}" unless Rails.env.production?
+        return shiplog_host_classes(key)
+      end
+
+      bem = [ base, *modifiers.compact.map { |modifier| "#{base}--#{modifier.to_s.dasherize}" } ]
+      [ *bem, shiplog_host_classes(key) ].compact_blank.join(" ")
+    end
+
+    private
+
+    def shiplog_host_classes(key)
+      configured = Shiplog.config.classes
+      Array(configured[key] || configured[key.to_s]).join(" ").squish.presence
+    end
+  end
+end

data/app/jobs/shiplog/application_job.rb

@@ -0,0 +1,14 @@
+module Shiplog
+  class ApplicationJob < ActiveJob::Base
+    MAX_RATE_LIMIT_RETRIES = 5
+
+    rescue_from Github::RateLimited do |error|
+      if executions >= MAX_RATE_LIMIT_RETRIES
+        Rails.error.report(error, handled: false, context: { job: self.class.name, executions: })
+        raise error
+      end
+
+      retry_job wait_until: error.reset_at + 1.second
+    end
+  end
+end

data/app/jobs/shiplog/refresh_job.rb

@@ -0,0 +1,38 @@
+module Shiplog
+  class RefreshJob < ApplicationJob
+    retry_on Github::Transient, attempts: 5, wait: :polynomially_longer
+
+    def perform(repository_full_name, kind, number)
+      configured_name = Shiplog.config.repository_configured?(repository_full_name)
+      unless configured_name
+        Rails.logger.info("[shiplog] Ignoring refresh for unconfigured repository #{repository_full_name}")
+        return
+      end
+
+      repository = Repository.find_or_create_by!(full_name: configured_name)
+      case kind.to_s
+      when "issue" then import(repository, number, Github::Queries::ISSUE, "issue", Sync::IssueImporter)
+      when "pull_request" then import(repository, number, Github::Queries::PULL_REQUEST, "pullRequest", Sync::PullRequestImporter)
+      else raise ArgumentError, "Unknown kind: #{kind.inspect}"
+      end
+      Drafter.call
+    end
+
+    private
+
+    def import(repository, number, query, field, importer)
+      owner, name = repository.full_name.split("/", 2)
+      node = Github::Client.new.query(query, { owner:, name:, number: }).dig("repository", field)
+      importer.new(repository).import(node) if node
+      close_deleted(repository, number, node) if field == "issue"
+    end
+
+    # Deleted issues come back as null; transferred ones may come back as a different node. Either way the local
+    # row at this repository and number is gone from GitHub: close it, keeping the row and its entries for audit.
+    def close_deleted(repository, number, node)
+      Issue.where(repository:, number:).where.not(node_id: node&.fetch("id")).find_each do |issue|
+        issue.update!(state: "closed", state_reason: "deleted", closed_at: issue.closed_at || Time.current)
+      end
+    end
+  end
+end

data/app/jobs/shiplog/rewrite_entry_job.rb

@@ -0,0 +1,9 @@
+module Shiplog
+  class RewriteEntryJob < ApplicationJob
+    discard_on ActiveRecord::RecordNotFound
+
+    def perform(entry_id, force: false)
+      Rewriter.new(Entry.find(entry_id)).call(force:)
+    end
+  end
+end

data/app/jobs/shiplog/scan_changes_job.rb

@@ -0,0 +1,36 @@
+module Shiplog
+  class ScanChangesJob < ApplicationJob
+    DEFAULT_WINDOW = 7.days
+
+    def perform
+      client = Github::Client.new
+      Shiplog.config.repositories.each do |full_name|
+        scan(Repository.find_or_create_by!(full_name:), client)
+      end
+      Drafter.call
+    end
+
+    private
+      def scan(repository, client)
+        since = repository.changes_scanned_at || DEFAULT_WINDOW.ago
+        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)
+      rescue Github::RateLimited
+        raise
+      rescue StandardError => error
+        Rails.error.report(error, handled: true, context: { repository: repository.full_name })
+      end
+
+      def draft_changes(candidates)
+        candidates.each { |subject| Drafter.draft(subject, "change", released_on: released_on(subject)) }
+      end
+
+      def released_on(subject)
+        (subject.is_a?(PullRequest) ? subject.merged_at : subject.committed_at).to_date
+      end
+  end
+end

data/app/jobs/shiplog/sync_job.rb

@@ -0,0 +1,20 @@
+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.each { |repository| sync(repository, client) }
+      Drafter.call
+    end
+
+    private
+
+    def sync(repository, client)
+      Sync::RepositorySync.new(repository, client:).call
+    rescue Github::RateLimited
+      raise
+    rescue StandardError => error
+      Rails.error.report(error, handled: true, context: { repository: repository.full_name })
+    end
+  end
+end

data/app/models/shiplog/application_record.rb

@@ -0,0 +1,5 @@
+module Shiplog
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/shiplog/board_arrangement.rb

@@ -0,0 +1,38 @@
+module Shiplog
+  class BoardArrangement
+    def self.unpin!(issue)
+      issue.update!(pinned_column: nil, position: nil)
+    end
+
+    # Pins only the moved card to the column; every id in issue_ids (the full visible order of the column) gets a position.
+    def initialize(column:, moved_id:, issue_ids:)
+      @column = column.to_s
+      @moved_id = Integer(moved_id.to_s, 10)
+      @issue_ids = Array(issue_ids).map { |id| Integer(id.to_s, 10) }.uniq
+    end
+
+    def save!
+      raise ArgumentError, "Unknown column: #{@column.inspect}" unless Issue::COLUMNS.include?(@column)
+      raise ArgumentError, "moved_id must be one of issue_ids" unless @issue_ids.include?(@moved_id)
+
+      Issue.transaction do
+        issues = Issue.where(id: roadmap_issue_ids & @issue_ids).index_by(&:id)
+        missing = @issue_ids - issues.keys
+        raise ActiveRecord::RecordNotFound, "Not roadmap items: #{missing.join(", ")}" if missing.any?
+
+        @issue_ids.each_with_index do |id, position|
+          issue = issues.fetch(id)
+          issue.pinned_column = @column if id == @moved_id
+          issue.position = position
+          issue.save!
+        end
+      end
+    end
+
+    private
+
+    def roadmap_issue_ids
+      Roadmap.new(published_only: false).items.map { |item| item.issue.id }
+    end
+  end
+end

data/app/models/shiplog/change_candidates.rb

@@ -0,0 +1,77 @@
+module Shiplog
+  class ChangeCandidates
+    COMMIT_TYPE = /\A(\w+)(\([^)]*\))?!?:/
+
+    def initialize(repository:, since:, before:)
+      @repository = repository
+      @window = since...before
+    end
+
+    def to_a
+      pull_requests + commits
+    end
+
+    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) }
+        public_ids = pull_request_ids_in_public_tree(candidates)
+        candidates.reject { |pull_request| public_ids.include?(pull_request.node_id) }
+      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)
+      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)
+      end
+
+      def eligible_commit?(commit)
+        type = commit.title[COMMIT_TYPE, 1]
+        type && Shiplog.config.commit_types.include?(type) && !Shiplog.config.excluded_author?(commit.author_login)
+      end
+
+      # Node ids of the pull requests linked to an issue that is public or has a public ancestor.
+      # One query for the links, one for the linked issues, then one per ancestor level.
+      def pull_request_ids_in_public_tree(pull_requests)
+        return Set.new if pull_requests.empty?
+
+        links = IssueLink.where(pull_request_node_id: pull_requests.map(&:node_id)).pluck(:issue_node_id, :pull_request_node_id)
+        public_issue_ids = public_tree_issue_ids(links.map(&:first).uniq)
+        links.filter_map { |issue_id, pull_request_id| pull_request_id if public_issue_ids.include?(issue_id) }.to_set
+      end
+
+      def public_tree_issue_ids(issue_ids)
+        public_ids = Set.new
+        current = Issue.where(node_id: issue_ids).index_by(&:node_id) # origin node_id => issue at the current level
+        seen = current.transform_values { |issue| Set[issue.node_id] }
+
+        (Issue::MAX_DEPTH + 1).times do
+          break if current.empty?
+
+          current.each { |origin, issue| public_ids << origin if issue.public? }
+          current = climb(current.reject { |origin, _| public_ids.include?(origin) }, seen)
+        end
+        public_ids
+      end
+
+      def climb(current, seen)
+        parent_ids = current.values.filter_map(&:parent_node_id).uniq
+        return {} if parent_ids.empty?
+
+        parents = Issue.where(node_id: parent_ids).index_by(&:node_id)
+        current.each_with_object({}) do |(origin, issue), next_level|
+          parent = parents[issue.parent_node_id]
+          next_level[origin] = parent if parent && seen[origin].add?(parent.node_id)
+        end
+      end
+  end
+end

data/app/models/shiplog/commit.rb

@@ -0,0 +1,9 @@
+module Shiplog
+  class Commit < ApplicationRecord
+    belongs_to :repository
+    has_many :entries, as: :subject, dependent: :destroy
+
+    def title = message.lines.first.to_s.strip
+    def body = message.lines.drop(1).join.strip
+  end
+end

data/app/models/shiplog/drafter.rb

@@ -0,0 +1,69 @@
+module Shiplog
+  module Drafter
+    # Only issues closed within this window get a feature draft, so a first-run backfill
+    # cannot flood the inbox with years-old work. Recently closed issues are still backfilled.
+    FEATURE_LOOKBACK = 90.days
+
+    def self.call
+      draft_roadmap_items
+      draft_shipped_features
+      requeue_lost_rewrites
+    end
+
+    # Rewrite jobs can be lost (queue flushed, process killed). Drafts that never got a result nor an error are retried.
+    REQUEUE_AFTER = 1.hour
+    REQUEUE_LIMIT = 100
+
+    # Returns the new entry, or nil when one already exists for the subject and kind.
+    def self.draft(subject, kind, released_on: nil)
+      entry = Entry.create_or_find_by!(subject:, kind:) do |new_entry|
+        new_entry.title = subject.title
+        new_entry.body = subject.body
+        new_entry.released_on = released_on
+      end
+      return unless entry.previously_new_record?
+
+      RewriteEntryJob.perform_later(entry.id)
+      entry
+    end
+
+    def self.draft_roadmap_items
+      Roadmap.new(published_only: false).items.each do |item|
+        draft(item.issue, "roadmap") unless item.entry
+      end
+    end
+
+    def self.draft_shipped_features
+      issues = shipped_candidates
+      return if issues.empty?
+
+      index = Issue.children_index(issues)
+      merged_at_by_issue = merged_at_by_issue_node_id(issues, index)
+      issues.each do |issue|
+        tree = [ issue, *Issue.descendants_in(index, issue) ]
+        merged_at = tree.filter_map { |member| merged_at_by_issue[member.node_id] }.max
+        draft(issue, "feature", released_on: merged_at.to_date) if merged_at
+      end
+    end
+
+    def self.requeue_lost_rewrites
+      Entry.draft.where(rewritten_at: nil, rewrite_error: nil, created_at: ..REQUEUE_AFTER.ago)
+        .order(:created_at).limit(REQUEUE_LIMIT).ids.each { |id| RewriteEntryJob.perform_later(id) }
+    end
+
+    def self.shipped_candidates
+      drafted = Entry.feature.where(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? }
+    end
+
+    def self.merged_at_by_issue_node_id(issues, index)
+      node_ids = issues.map(&:node_id) + index.values.flatten.map(&:node_id)
+      IssueLink.where(issue_node_id: node_ids.uniq).joins(:pull_request).merge(PullRequest.where(state: "merged"))
+        .group(:issue_node_id).maximum(PullRequest.arel_table[:merged_at])
+    end
+
+    private_class_method :draft_roadmap_items, :draft_shipped_features, :requeue_lost_rewrites, :shipped_candidates, :merged_at_by_issue_node_id
+  end
+end

data/app/models/shiplog/entry.rb

@@ -0,0 +1,42 @@
+module Shiplog
+  class Entry < ApplicationRecord
+    class InvalidTransition < StandardError; end
+
+    belongs_to :subject, polymorphic: true
+
+    enum :kind, %w[roadmap feature change].index_by(&:itself), validate: true
+    enum :status, %w[draft approved discarded].index_by(&:itself), default: "draft", validate: true
+
+    validates :released_on, presence: true, if: -> { approved? && !roadmap? }
+
+    def self.digest_for(subject)
+      Digest::SHA256.hexdigest([ subject.title, subject.body ].join("\n"))
+    end
+
+    def approve!(by:)
+      require_status!("approve", from: "draft")
+      update!(status: "approved", approved_at: Time.current, approved_by: by, discard_reason: nil,
+        released_on: released_on || Date.current)
+    end
+
+    def discard!(reason:)
+      require_status!("discard", from: "draft")
+      update!(status: "discarded", discard_reason: reason)
+    end
+
+    def restore!
+      require_status!("restore", from: "discarded")
+      update!(status: "draft", discard_reason: nil)
+    end
+
+    def source_changed?
+      source_digest.present? && source_digest != self.class.digest_for(subject)
+    end
+
+    private
+
+    def require_status!(action, from:)
+      raise InvalidTransition, "Cannot #{action} an entry that is #{status}" unless status == from
+    end
+  end
+end