prdigest 0.2.0 → 0.4.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prdigest
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Ivan Kuznetsov
@@ -127,8 +127,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.25'
-description: Config-driven GitHub merged-PR facts with deterministic Telegram delivery
-  and optional OpenAI-compatible prose. Hive-independent and secret-safe.
+description: Config-driven GitHub merged-PR facts for agents plus OpenAI-compatible
+  prose for stdout or checkpointed Telegram delivery.
 email:
 - ivan@ikuznetsov.com
 executables:
@@ -149,17 +149,13 @@ files:
 - lib/prdigest/config.rb
 - lib/prdigest/delivery_checkpoint_store.rb
 - lib/prdigest/digest.rb
+- lib/prdigest/document.rb
 - lib/prdigest/facts.rb
 - lib/prdigest/facts_runner.rb
 - lib/prdigest/github.rb
 - lib/prdigest/openai_compatible.rb
 - lib/prdigest/prose_renderer.rb
 - lib/prdigest/prose_runner.rb
-- lib/prdigest/renderer.rb
-- lib/prdigest/result.rb
-- lib/prdigest/runner.rb
-- lib/prdigest/schedule.rb
-- lib/prdigest/state.rb
 - lib/prdigest/telegram.rb
 - lib/prdigest/version.rb
 - scripts/systemd/prdigest.service
@@ -188,5 +184,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Deterministic multi-repo merged-PR facts and digests
+summary: Merged-PR facts for agents and provider-written prose
 test_files: []

data/lib/prdigest/renderer.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-
-module Prdigest
-  class Renderer
-    Output = Data.define(:chunks, :outcome)
-    SUPPORTED_TAG = %r{</?(?:b|a)(?:\s+href="[^"]*")?>}.freeze
-
-    def self.parsed_length(html)
-      CGI.unescapeHTML(html.gsub(SUPPORTED_TAG, "")).length
-    end
-
-    def initialize(send_empty:, empty_message:, limit: 4_096)
-      @send_empty = send_empty
-      @empty_message = empty_message.to_s
-      @limit = Integer(limit)
-    end
-
-    def render(digest)
-      return render_empty(digest) if digest.total_prs.zero?
-
-      pack(digest)
-    rescue RenderError
-      raise
-    rescue StandardError => e
-      raise RenderError, "digest rendering failed: #{e.class}"
-    end
-
-    private
-
-    def render_empty(digest)
-      return Output.new([].freeze, "suppressed_empty") unless @send_empty
-
-      text = escape(@empty_message.gsub("{date}", digest.date.iso8601))
-      raise RenderError, "configured empty message exceeds Telegram limit" unless fits_text?(text)
-      Output.new([text.freeze].freeze, "rendered")
-    end
-
-    def pack(digest)
-      chunks = []
-      heading = "<b>Merged PR digest — #{digest.date.iso8601}</b>"
-      continuation = "<b>Merged PR digest — #{digest.date.iso8601} (cont.)</b>"
-      current = [heading]
-
-      digest.repositories.each do |section|
-        next if section.pull_requests.empty?
-        current = add_section(chunks, current, continuation, section)
-      end
-
-      footer = render_footer(digest)
-      unless fits_parts?(current + [footer])
-        flush!(chunks, current)
-        current = [continuation, footer]
-        raise RenderError, "digest footer exceeds Telegram limit" unless fits_parts?(current)
-      else
-        current << footer
-      end
-      flush!(chunks, current)
-      Output.new(chunks.map(&:freeze).freeze, "rendered")
-    end
-
-    def add_section(chunks, current, continuation, section)
-      header = "<b>#{escape(section.name)}</b>"
-      entries = section.pull_requests.map { |pull| render_pull(pull) }
-      whole = ([header] + entries).join("\n")
-      if fits_parts?(current + [whole])
-        current << whole
-        return current
-      end
-
-      if current.length > 1
-        flush!(chunks, current)
-        current = [continuation]
-        if fits_parts?(current + [whole])
-          current << whole
-          return current
-        end
-      end
-
-      section_part = header
-      entries.each do |entry|
-        proposed = "#{section_part}\n#{entry}"
-        if fits_parts?(current + [proposed])
-          section_part = proposed
-          next
-        end
-
-        if section_part == header
-          raise RenderError, "pull request entry exceeds Telegram limit"
-        end
-        current << section_part
-        flush!(chunks, current)
-        current = [continuation]
-        section_part = "<b>#{escape(section.name)} (cont.)</b>\n#{entry}"
-        raise RenderError, "pull request entry exceeds Telegram limit" unless fits_parts?(current + [section_part])
-      end
-      current << section_part
-      current
-    end
-
-    def render_pull(pull)
-      number_and_title = "##{pull.number} #{pull.title}"
-      "• <a href=\"#{escape(pull.url)}\">#{escape(number_and_title)}</a> — @#{escape(pull.author)}"
-    end
-
-    def render_footer(digest)
-      label = digest.total_prs == 1 ? "PR" : "PRs"
-      footer = "<b>Total:</b> #{digest.total_prs} #{label}"
-      if digest.line_stats
-        footer += " · +#{digest.total_additions}/−#{digest.total_deletions} · #{digest.total_commits} commits"
-      end
-      footer
-    end
-
-    def flush!(chunks, parts)
-      text = parts.join("\n\n")
-      raise RenderError, "rendered chunk exceeds Telegram limit" unless fits_text?(text)
-      chunks << text
-    end
-
-    def fits_parts?(parts)
-      fits_text?(parts.join("\n\n"))
-    end
-
-    def fits_text?(text)
-      self.class.parsed_length(text) <= @limit
-    end
-
-    def escape(value)
-      CGI.escapeHTML(value.to_s)
-    end
-  end
-end

data/lib/prdigest/result.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Prdigest
-  class Result
-    SCHEMA = "prdigest-result"
-    SCHEMA_VERSION = 1
-    REQUIRED_FIELDS = %i[
-      status mode requested_days settled_days skipped_days failed_date remaining_days error
-    ].freeze
-    EXIT_CODES = {
-      "config" => 2, "cli" => 2, "refusal" => 2,
-      "github" => 3,
-      "telegram" => 4, "telegram_refused" => 4, "telegram_permanent" => 4,
-      "telegram_ambiguous" => 4, "delivery_checkpoint" => 4,
-      "delivery_checkpoint_permanent" => 4,
-      "state" => 5,
-      "provider" => 7, "provider_ambiguous" => 7
-    }.freeze
-
-    attr_reader(*REQUIRED_FIELDS, :chunks, :delivery)
-
-    def initialize(status:, mode:, requested_days: [], settled_days: [], skipped_days: [],
-                   failed_date: nil, remaining_days: [], error: nil, chunks: [], delivery: nil)
-      @status = status.to_s.freeze
-      @mode = mode.to_s.freeze
-      @requested_days = Array(requested_days).freeze
-      @settled_days = Array(settled_days).freeze
-      @skipped_days = Array(skipped_days).freeze
-      @failed_date = failed_date
-      @remaining_days = Array(remaining_days).freeze
-      @error = error&.transform_keys(&:to_sym)&.freeze
-      @chunks = Array(chunks).map(&:to_s).freeze
-      @delivery = delivery&.transform_keys(&:to_sym)&.freeze
-      freeze
-    end
-
-    def self.failure(mode:, error_kind:, message:, requested_days: [], settled_days: [], skipped_days: [],
-                     failed_date: nil, remaining_days: [], chunks: [], delivery: nil)
-      progress = !settled_days.empty? || !skipped_days.empty?
-      new(
-        status: progress ? "partial_failure" : "failure",
-        mode: mode,
-        requested_days: requested_days,
-        settled_days: settled_days,
-        skipped_days: skipped_days,
-        failed_date: failed_date,
-        remaining_days: remaining_days,
-        error: { kind: error_kind.to_s, message: message.to_s },
-        chunks: chunks,
-        delivery: delivery
-      )
-    end
-
-    def exit_code
-      return 0 if %w[success dry_run].include?(status)
-      return 6 if status == "partial_failure"
-      EXIT_CODES.fetch(error && error[:kind], 1)
-    end
-
-    def to_h
-      {
-        schema: SCHEMA,
-        schema_version: SCHEMA_VERSION,
-        status: status,
-        mode: mode,
-        requested_days: serialize_dates(requested_days),
-        settled_days: serialize_dates(settled_days),
-        skipped_days: serialize_dates(skipped_days),
-        failed_date: failed_date&.to_s,
-        remaining_days: serialize_dates(remaining_days),
-        error: error,
-        chunks: chunks,
-        delivery: delivery
-      }
-    end
-
-    private
-
-    def serialize_dates(values)
-      values.map(&:to_s)
-    end
-  end
-end

data/lib/prdigest/runner.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Prdigest
-  class Runner
-    def initialize(config:, date: nil, dry_run: false, clock: nil, state_factory: nil,
-                   github: nil, renderer: nil, telegram_factory: nil, repositories: nil, env: ENV)
-      @config = config
-      @date = date && Date.iso8601(date.to_s)
-      @dry_run = dry_run
-      @clock = clock || Clock.new(timezone: config.timezone)
-      @state_factory = state_factory || -> { State.new(path: config.state_path, timezone: config.timezone) }
-      @env = env
-      @repositories = repositories || config.repos
-      @collector = Collector.new(
-        clock: @clock,
-        github: github || GitHub.new(token: config.github_token(env)),
-        repositories: @repositories,
-        line_stats: config.line_stats?
-      )
-      @renderer = renderer || Renderer.new(send_empty: config.send_empty?, empty_message: config.empty_message)
-      @delivery_checkpoint_store_factory = lambda {
-        DeliveryCheckpointStore.new(root: config.delivery_state_path)
-      }
-      @telegram_factory = telegram_factory || lambda {
-        Telegram.new(
-          token: config.telegram_token(env),
-          chat_id: config.chat_id,
-          allowlist: config.chat_id_allowlist
-        )
-      }
-    end
-
-    def call
-      mode = @date ? "explicit_date_replay" : "scheduled"
-      requested = []
-      settled = []
-      skipped = []
-      chunks = []
-      failed_date = nil
-      delivery = nil
-      state = nil
-      skip_audit = nil
-
-      if @dry_run || @date
-        requested = [@date || @clock.yesterday]
-      else
-        state = @state_factory.call
-        yesterday = @clock.yesterday
-        record = state.read(yesterday: yesterday)
-        skip_audit = record.last_skip
-        skipped.concat(expand_skip(skip_audit)) if skip_audit && skip_audit[:notice_pending]
-        schedule = Schedule.new(
-          yesterday: yesterday,
-          last_digested_date: record.last_digested_date,
-          max_catchup_days: @config.max_catchup_days
-        ).call
-        requested = schedule.requested_days
-        unless schedule.skipped_days.empty?
-          skip_audit = merge_skip_audit(skip_audit, schedule.skipped_days)
-          state.write(last_digested_date: schedule.skipped_days.last, last_skip: skip_audit)
-          skipped |= schedule.skipped_days
-        end
-      end
-
-      telegram = nil
-      requested.each do |date|
-        failed_date = date
-        digest = @collector.call(date: date)
-        rendered = @renderer.render(digest)
-        if @dry_run
-          chunks.concat(rendered.chunks)
-          next
-        end
-
-        unless rendered.chunks.empty?
-          telegram ||= @telegram_factory.call
-          delivery = telegram.deliver(
-            rendered.chunks,
-            digest_date: date,
-            checkpoint_store: @delivery_checkpoint_store_factory.call,
-            scope: @repositories
-          )
-        end
-        if state
-          if skip_audit
-            skip_audit = skip_audit.merge(notice_pending: false)
-          end
-          state.write(last_digested_date: date, last_skip: skip_audit)
-        end
-        settled << date
-        failed_date = nil
-      end
-
-      Result.new(
-        status: @dry_run ? "dry_run" : "success",
-        mode: mode,
-        requested_days: requested,
-        settled_days: settled,
-        skipped_days: skipped,
-        chunks: chunks,
-        delivery: delivery
-      )
-    rescue StandardError => e
-      Result.failure(
-        mode: mode || (@date ? "explicit_date_replay" : "scheduled"),
-        error_kind: error_kind(e),
-        message: safe_message(e),
-        requested_days: requested || [],
-        settled_days: settled || [],
-        skipped_days: skipped || [],
-        failed_date: failed_date,
-        remaining_days: remaining_days(requested || [], failed_date),
-        chunks: chunks || [],
-        delivery: e.is_a?(SendError) ? e.delivery : delivery
-      )
-    end
-
-    def inspect
-      "#<#{self.class} mode=#{@date ? "explicit_date_replay" : "scheduled"} " \
-        "dry_run=#{@dry_run} credentials=[REDACTED]>"
-    end
-
-    alias to_s inspect
-
-    private
-
-    def expand_skip(audit)
-      return [] unless audit
-      (audit.fetch(:start_date)..audit.fetch(:end_date)).to_a
-    end
-
-    def merge_skip_audit(existing, dates)
-      start_date = if existing && existing[:notice_pending]
-                     [existing[:start_date], dates.first].min
-                   else
-                     dates.first
-                   end
-      { start_date: start_date, end_date: dates.last, notice_pending: true }
-    end
-
-    def remaining_days(requested, failed_date)
-      return requested unless failed_date
-      index = requested.index(failed_date)
-      index ? requested.drop(index) : [failed_date]
-    end
-
-    def error_kind(error)
-      case error
-      when ConfigError then "config"
-      when FetchError then error.kind
-      when SendError then error.kind
-      when StateError then "state"
-      when RenderError then error.kind
-      else "internal"
-      end
-    end
-
-    def safe_message(error)
-      message = error.is_a?(Error) ? error.message : "unexpected failure (#{error.class})"
-      secrets = []
-      secrets << @config.github_token(@env) if @config.respond_to?(:github_token)
-      secrets << @config.telegram_token(@env) if @config.respond_to?(:telegram_token)
-      secrets.compact.reject(&:empty?).reduce(message.dup) { |safe, secret| safe.gsub(secret, "[REDACTED]") }
-    end
-  end
-end

data/lib/prdigest/schedule.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Prdigest
-  class Schedule
-    Result = Data.define(:skipped_days, :requested_days)
-
-    def initialize(yesterday:, last_digested_date:, max_catchup_days:)
-      @yesterday = Date.iso8601(yesterday.to_s)
-      @last_digested_date = last_digested_date && Date.iso8601(last_digested_date.to_s)
-      @max_catchup_days = Integer(max_catchup_days)
-    end
-
-    def call
-      raise ArgumentError, "max_catchup_days must be from 1 to 30" unless (1..30).cover?(@max_catchup_days)
-      raise ArgumentError, "last digested date is in the future" if @last_digested_date && @last_digested_date > @yesterday
-
-      owed = if @last_digested_date.nil?
-               [@yesterday]
-             elsif @last_digested_date == @yesterday
-               []
-             else
-               ((@last_digested_date + 1)..@yesterday).to_a
-             end
-      split = [owed.length - @max_catchup_days, 0].max
-      Result.new(owed.first(split).freeze, owed.drop(split).freeze)
-    end
-  end
-end

data/lib/prdigest/state.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "fileutils"
-require "json"
-require "securerandom"
-
-module Prdigest
-  class State
-    VERSION = 1
-    Record = Data.define(:last_digested_date, :last_skip)
-
-    def initialize(path:, timezone:, rename: File.method(:rename), directory_sync: nil)
-      @path = File.expand_path(path)
-      @timezone = timezone
-      @rename = rename
-      @directory_sync = directory_sync || method(:sync_directory)
-    end
-
-    def read(yesterday: nil)
-      return Record.new(nil, nil) unless File.exist?(@path)
-
-      payload = JSON.parse(File.binread(@path))
-      validate_payload!(payload, yesterday: yesterday)
-    rescue StateError
-      raise
-    rescue StandardError => e
-      raise StateError, "cannot read state: #{e.class}"
-    end
-
-    def write(last_digested_date:, last_skip: nil)
-      directory = File.dirname(@path)
-      FileUtils.mkdir_p(directory, mode: 0o700)
-      temp_path = File.join(directory, ".#{File.basename(@path)}.tmp-#{SecureRandom.hex(8)}")
-      payload = JSON.generate(serialize(last_digested_date, last_skip)) << "\n"
-
-      File.open(temp_path, File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
-        file.write(payload)
-        file.chmod(0o600)
-        file.flush
-        file.fsync
-      end
-      rollback_path = preserve_previous_checkpoint(directory)
-      @rename.call(temp_path, @path)
-      begin
-        @directory_sync.call(directory)
-      rescue StandardError
-        restore_previous_checkpoint(rollback_path)
-        raise
-      end
-      Record.new(Date.iso8601(last_digested_date.to_s), normalize_skip(last_skip))
-    rescue StandardError => e
-      raise StateError, "cannot write state: #{e.class}"
-    ensure
-      File.unlink(temp_path) if defined?(temp_path) && temp_path && File.exist?(temp_path)
-      discard_rollback(rollback_path) if defined?(rollback_path) && rollback_path
-    end
-
-    private
-
-    def sync_directory(directory)
-      File.open(directory, File::RDONLY) { |dir| dir.fsync }
-    end
-
-    def preserve_previous_checkpoint(directory)
-      rollback_path = File.join(directory, ".#{File.basename(@path)}.rollback-#{SecureRandom.hex(8)}")
-      File.link(@path, rollback_path)
-      rollback_path
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def restore_previous_checkpoint(rollback_path)
-      if rollback_path
-        File.rename(rollback_path, @path)
-      else
-        File.unlink(@path)
-      end
-    rescue Errno::ENOENT
-      raise if rollback_path
-      nil
-    end
-
-    def discard_rollback(rollback_path)
-      FileUtils.rm_f(rollback_path) if rollback_path
-    end
-
-    def validate_payload!(payload, yesterday:)
-      raise StateError, "state root must be an object" unless payload.is_a?(Hash)
-      raise StateError, "unsupported state version" unless payload["version"] == VERSION
-      raise StateError, "state timezone does not match config" unless payload["timezone"] == @timezone
-      raise StateError, "state last_digested_date is required" unless payload.key?("last_digested_date")
-
-      value = payload["last_digested_date"]
-      last_date = Date.iso8601(value)
-      raise StateError, "state date is in the future" if yesterday && last_date && last_date > Date.iso8601(yesterday.to_s)
-
-      skip = parse_skip(payload["last_skip"])
-      if skip && (skip[:start_date] > skip[:end_date] || skip[:end_date] > last_date)
-        raise StateError, "state last_skip range is invalid"
-      end
-      Record.new(last_date, skip)
-    rescue Date::Error, TypeError
-      raise StateError, "state contains an invalid date"
-    end
-
-    def parse_skip(value)
-      return nil if value.nil?
-      raise StateError, "state last_skip is invalid" unless value.is_a?(Hash)
-
-      pending = value.fetch("notice_pending")
-      raise StateError, "state last_skip is invalid" unless pending == true || pending == false
-      {
-        start_date: Date.iso8601(value.fetch("start_date")),
-        end_date: Date.iso8601(value.fetch("end_date")),
-        notice_pending: pending
-      }
-    rescue KeyError
-      raise StateError, "state last_skip is invalid"
-    end
-
-    def normalize_skip(skip)
-      return nil unless skip
-      {
-        start_date: Date.iso8601(skip.fetch(:start_date).to_s),
-        end_date: Date.iso8601(skip.fetch(:end_date).to_s),
-        notice_pending: skip.fetch(:notice_pending) == true
-      }
-    end
-
-    def serialize(last_date, last_skip)
-      payload = {
-        version: VERSION,
-        timezone: @timezone,
-        last_digested_date: Date.iso8601(last_date.to_s).iso8601
-      }
-      if (skip = normalize_skip(last_skip))
-        payload[:last_skip] = {
-          start_date: skip[:start_date].iso8601,
-          end_date: skip[:end_date].iso8601,
-          notice_pending: skip[:notice_pending]
-        }
-      end
-      payload
-    end
-  end
-end