invoicehn 0.1.0

data/config/locales/es.yml

@@ -0,0 +1,87 @@
+# Textos de la interfaz de línea de comandos.
+#
+# IMPORTANTE: este catálogo NO contiene el texto del documento fiscal. Las
+# leyendas de la Factura ("FACTURA", "Original: Cliente", "CONSUMIDOR FINAL",
+# "ANULADA") son texto legal fijado por el Reglamento y viven como constantes en
+# Invoicehn::Renderers::Text. Traducirlas produciría un documento inválido.
+es:
+  setup:
+    title: "Configuración del emisor (Art. 10 num. 1)"
+    intro: "Estos datos se imprimen en cada factura. Todos son obligatorios."
+    rtn: "RTN del emisor (14 dígitos)"
+    legal_name: "Nombre o razón social"
+    trade_name: "Nombre comercial"
+    headquarters: "Dirección de la casa matriz"
+    branch: "Dirección del establecimiento (dejar vacío si es la casa matriz)"
+    phone: "Número telefónico"
+    email: "Correo electrónico"
+    saved: "Emisor guardado en %{path}"
+
+  auth:
+    title: "Registrar autorización del SAR"
+    intro: |
+      El CAI, el rango autorizado y la fecha límite de emisión los otorga el SAR
+      (Arts. 59-61). Cópielos del documento de autorización; este programa no los genera.
+    cai: "CAI (Clave de Autorización de Impresión)"
+    establishment: "Establecimiento (3 dígitos; casa matriz = 000)"
+    emission_point: "Punto de emisión (3 dígitos)"
+    range_start: "Correlativo inicial autorizado (8 dígitos)"
+    range_end: "Correlativo final autorizado (8 dígitos)"
+    limit_date: "Fecha límite de emisión (AAAA-MM-DD)"
+    saved: "Autorización registrada: %{range}"
+    none: "No hay autorizaciones registradas. Use «invoicehn auth add»."
+    list_header: "Autorizaciones registradas"
+
+  invoice:
+    customer_kind: "Tipo de cliente"
+    kind_consumidor_final: "Consumidor final"
+    kind_taxpayer: "Obligado tributario (sustenta crédito fiscal)"
+    kind_exonerado: "Adquirente exonerado"
+    customer_name: "Nombre o razón social del cliente"
+    customer_rtn: "RTN del cliente"
+    id_type: "Tipo de documento de identificación"
+    id_number: "Número de documento de identificación"
+    purchase_order: "Número de Orden de Compra Exenta"
+    exoneration_registry: "Número de Constancia del Registro de Exonerados"
+    sag_registry: "Número del Registro SAG"
+    add_line: "¿Agregar una línea de detalle?"
+    description: "Descripción detallada del bien o servicio"
+    quantity: "Cantidad de unidades"
+    unit_price: "Valor unitario"
+    discount: "Descuento otorgado (0 si no aplica)"
+    treatment: "Tratamiento del ISV"
+    currency: "Moneda"
+    exchange_rate: "Tasa de cambio vigente a la fecha de emisión"
+    exchange_source: "Fuente de la tasa de cambio"
+    notes: "Notas adicionales (opcional)"
+    confirm: "¿Emitir esta factura?"
+    cancelled: "Emisión cancelada. No se consumió ningún correlativo."
+    issued: "Factura emitida: %{correlative}"
+
+  check:
+    title: "Estado del sistema de facturación"
+    issuer_ok: "Emisor configurado y completo"
+    issuer_missing: "Faltan datos del emisor: %{fields}"
+    issuer_absent: "No hay emisor configurado. Ejecute «invoicehn setup»."
+    auth_active: "Autorización vigente: %{cai}"
+    auth_absent: "No hay autorización vigente para %{identifier}"
+    next: "Próximo correlativo: %{correlative}"
+    remaining: "Documentos disponibles: %{count}"
+    days: "Días hasta la fecha límite: %{days}"
+    lapsed: |
+      Atención: %{count} autorización(es) vencieron con documentos sin utilizar.
+      El Art. 42 obliga a comunicarlo al SAR dentro de los primeros 10 días
+      hábiles del mes siguiente.
+    ready: "Listo para emitir."
+    not_ready: "No se puede emitir todavía."
+
+  errors:
+    not_initialized: "No se ha configurado el emisor. Ejecute «invoicehn setup» primero."
+    not_found: "No existe la factura %{correlative}"
+    compliance: "La factura no cumple los requisitos legales:"
+
+  common:
+    yes: "Sí"
+    no: "No"
+    total: "Total"
+    cancel: "Cancelar"

data/exe/invoicehn

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "invoicehn"
+require "invoicehn/cli"
+
+Invoicehn::CLI::Main.start(ARGV)

data/lib/invoicehn/authorization.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Invoicehn
+  # A SAR authorization: the CAI, the authorized range, and the fecha límite de
+  # emisión, granted per emission point and document type (Art. 59).
+  #
+  # Art. 10 requires the invoice to show num. 3 the CAI, num. 4 the fecha límite
+  # de emisión vigente, and num. 5 the rango autorizado vigente.
+  #
+  # This library consumes these values; it never generates them. Obtaining them
+  # is the operator's obligation under Arts. 59-61.
+  class Authorization
+    attr_reader :cai, :range_start, :range_end, :limit_date
+
+    # @param cai [String] the Clave de Autorización de Impresión, as SAR issued
+    #   it. Art. 4 num. 7 defines it only as "una serie alfanumérica generada
+    #   electrónicamente" — no length or grouping is fixed anywhere in the
+    #   decree and no authoritative layout is published, so it is stored and
+    #   printed verbatim. Validating it against a guessed format would reject
+    #   real CAIs.
+    # @param range_start [String, Correlative] first authorized number
+    # @param range_end [String, Correlative] last authorized number
+    # @param limit_date [Date, String] fecha límite de emisión
+    def initialize(cai:, range_start:, range_end:, limit_date:)
+      @cai = cai.to_s.strip
+      raise ValidationError, "el CAI es obligatorio (Art. 10 num. 3)" if @cai.empty?
+
+      @range_start = coerce_correlative(range_start, "inicio del rango")
+      @range_end   = coerce_correlative(range_end, "fin del rango")
+      @limit_date  = coerce_date(limit_date)
+
+      validate_range!
+      freeze
+    end
+
+    # The (establecimiento, punto de emisión, tipo de documento) triple this
+    # authorization covers.
+    def identifier = @range_start.identifier
+
+    def document_type = @range_start.document_type
+    def establishment = @range_start.establishment
+    def emission_point = @range_start.emission_point
+
+    # Art. 62: "Los Comprobantes Fiscales y/o Documentos Complementarios
+    # perderán su validez y no podrán ser utilizados cuando se haya vencido el
+    # plazo de tiempo autorizado." The fecha límite is the last day on which a
+    # document may be issued, so it is still usable on that date itself.
+    def expired?(on = Date.today) = on > @limit_date
+
+    def days_remaining(from = Date.today) = (@limit_date - from).to_i
+
+    def covers?(correlative)
+      correlative = Correlative.parse(correlative.to_s)
+      correlative.identifier == identifier &&
+        correlative.sequence >= @range_start.sequence &&
+        correlative.sequence <= @range_end.sequence
+    end
+
+    # Total documents SAR authorized under this grant.
+    def capacity = @range_end.sequence - @range_start.sequence + 1
+
+    # Whether this authorization can still be used to issue the given number.
+    def usable?(correlative, on: Date.today)
+      !expired?(on) && covers?(correlative)
+    end
+
+    # Raises with the specific reason, so the caller can report which of the two
+    # conditions failed rather than a generic refusal.
+    def assert_usable!(correlative, on: Date.today)
+      if expired?(on)
+        raise AuthorizationExpired,
+              "la fecha límite de emisión (#{@limit_date}) ya venció; " \
+              "los documentos pierden validez (Art. 62)"
+      end
+
+      unless covers?(correlative)
+        raise RangeExhausted,
+              "el correlativo #{correlative} está fuera del rango autorizado " \
+              "#{@range_start}–#{@range_end} (Art. 10 num. 5)"
+      end
+
+      self
+    end
+
+    # "000-001-01-00000001 al 000-001-01-00000500" as printed on the document.
+    def range_label = "#{@range_start} al #{@range_end}"
+
+    def to_h
+      {
+        "cai" => @cai,
+        "range_start" => @range_start.to_s,
+        "range_end" => @range_end.to_s,
+        "limit_date" => @limit_date.iso8601
+      }
+    end
+
+    def self.from_h(hash)
+      new(
+        cai: hash["cai"],
+        range_start: hash["range_start"],
+        range_end: hash["range_end"],
+        limit_date: hash["limit_date"]
+      )
+    end
+
+    def to_s = "CAI #{@cai} · #{range_label} · vence #{@limit_date}"
+
+    private
+
+    def coerce_correlative(value, label)
+      return value if value.is_a?(Correlative)
+
+      Correlative.parse(value)
+    rescue ValidationError => e
+      raise ValidationError, "#{label}: #{e.message}"
+    end
+
+    def coerce_date(value)
+      case value
+      when Date then value
+      when String then Date.parse(value)
+      else
+        raise ValidationError, "fecha límite de emisión inválida: #{value.inspect}"
+      end
+    rescue ArgumentError, TypeError
+      raise ValidationError, "fecha límite de emisión inválida: #{value.inspect}"
+    end
+
+    def validate_range!
+      unless @range_start.identifier == @range_end.identifier
+        raise ValidationError,
+              "el rango abarca identificadores distintos: " \
+              "#{@range_start.identifier} y #{@range_end.identifier}"
+      end
+
+      return unless @range_end.sequence < @range_start.sequence
+
+      raise ValidationError,
+            "el rango termina (#{@range_end}) antes de comenzar (#{@range_start})"
+    end
+  end
+end

data/lib/invoicehn/cli/builder.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Invoicehn
+  module CLI
+    # Turns a plain hash — from a JSON file or the wizard — into an issued
+    # invoice. Shared by the scriptable and interactive paths so both go through
+    # exactly the same construction and validation.
+    class Builder
+      attr_reader :issuance
+
+      def initialize(issuance)
+        @issuance = issuance
+      end
+
+      def from_hash(data, identifier: "000-001-01")
+        currency = (data["currency"] || "HNL").to_s.upcase
+
+        @issuance.issue(
+          identifier: identifier,
+          customer: build_customer(data["customer"] || {}),
+          line_items: Array(data["items"] || data["line_items"]).map { |i| build_line(i, currency) },
+          currency: currency,
+          exchange_rate: build_rate(data["exchange_rate"], currency),
+          notes: data["notes"]
+        )
+      end
+
+      def build_customer(data)
+        kind = (data["kind"] || data["tipo"] || "consumidor_final").to_s
+
+        case kind
+        when "taxpayer", "obligado_tributario"
+          Customer::Taxpayer.new(name: data["name"], rtn: data["rtn"])
+        when "exonerado"
+          Customer::Exonerado.new(
+            name: data["name"], rtn: data["rtn"],
+            purchase_order: data["purchase_order"],
+            exoneration_registry: data["exoneration_registry"],
+            sag_registry: data["sag_registry"]
+          )
+        else
+          Customer::ConsumidorFinal.new(
+            name: data["name"],
+            identification_type: data["identification_type"],
+            identification_number: data["identification_number"]
+          )
+        end
+      end
+
+      def build_line(data, currency)
+        discount = data["discount"] || data["descuento"]
+
+        LineItem.new(
+          description: data["description"] || data["descripcion"],
+          quantity: to_decimal(data["quantity"] || data["cantidad"] || 1),
+          unit_price: Money.new(to_decimal(data["unit_price"] || data["precio"]), currency),
+          discount: discount && Money.new(to_decimal(discount), currency),
+          treatment: data["treatment"] || data["tratamiento"] || :gravado_15
+        )
+      end
+
+      def build_rate(data, currency)
+        return nil if data.nil?
+        return ExchangeRate.from_h(data) if data.is_a?(Hash)
+
+        ExchangeRate.new(rate: to_decimal(data), date: Date.today, currency: currency)
+      end
+
+      private
+
+      # JSON numbers arrive as Float, which must never reach a fiscal figure —
+      # so they are converted through their decimal text form, not their binary
+      # value.
+      def to_decimal(value)
+        case value
+        when BigDecimal then value
+        when Integer then BigDecimal(value)
+        when Float then BigDecimal(value.to_s)
+        when String then BigDecimal(value)
+        when nil then raise ValidationError, "falta un importe o cantidad en el archivo"
+        else raise ValidationError, "valor no numérico: #{value.inspect}"
+        end
+      rescue ArgumentError
+        raise ValidationError, "valor no numérico: #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/invoicehn/cli/main.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+
+module Invoicehn
+  module CLI
+    # `invoicehn <command>`.
+    #
+    # Subcommands are scriptable; `invoicehn new` opens the interactive wizard.
+    # Both drive the same Invoicehn::Issuance service, so neither can produce a
+    # document the other could not.
+    class Main < Thor
+      class_option :lang, type: :string, aliases: "-l",
+                          desc: "Idioma de la interfaz / interface language (es, en)"
+      class_option :"data-dir", type: :string,
+                                desc: "Directorio de datos (por defecto ~/.invoicehn)"
+
+      def self.exit_on_failure? = true
+
+      desc "setup", "Configura los datos del emisor (Art. 10 num. 1)"
+      method_option :rtn, type: :string
+      method_option :"legal-name", type: :string
+      method_option :"trade-name", type: :string
+      method_option :address, type: :string, desc: "Dirección de la casa matriz"
+      method_option :branch, type: :string, desc: "Dirección del establecimiento"
+      method_option :phone, type: :string
+      method_option :email, type: :string
+      def setup
+        prepare
+
+        # Every Art. 10 num. 1 field supplied on the command line means the
+        # profile can be set up unattended; otherwise the wizard asks.
+        required = [options[:rtn], options[:"legal-name"], options[:"trade-name"],
+                    options[:address], options[:phone], options[:email]]
+
+        if required.all?
+          issuer = Issuer.new(
+            rtn: options[:rtn], legal_name: options[:"legal-name"],
+            trade_name: options[:"trade-name"], headquarters_address: options[:address],
+            branch_address: options[:branch], phone: options[:phone], email: options[:email]
+          ).validate!
+
+          issuance.store.save_issuer(issuer)
+          say Locale.t("setup.saved", path: config.issuer_path), :green
+        else
+          Wizard.new(issuance, shell).setup
+        end
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "auth SUBCOMANDO", "Gestiona las autorizaciones del SAR (CAI, rango, fecha límite)"
+      subcommand "auth", Class.new(Thor) {
+        class_option :"data-dir", type: :string
+        def self.exit_on_failure? = true
+
+        desc "add", "Registra un CAI, su rango autorizado y su fecha límite"
+        method_option :cai, type: :string
+        method_option :from, type: :string, desc: "Correlativo inicial (NNN-NNN-NN-NNNNNNNN)"
+        method_option :to, type: :string, desc: "Correlativo final"
+        method_option :limit, type: :string, desc: "Fecha límite de emisión (AAAA-MM-DD)"
+        def add
+          cli = Main.new([], options)
+          if options[:cai] && options[:from] && options[:to] && options[:limit]
+            auth = Authorization.new(cai: options[:cai], range_start: options[:from],
+                                     range_end: options[:to], limit_date: options[:limit])
+            cli.send(:issuance).store.add_authorization(auth)
+            cli.send(:issuance).sequence.align_to(auth)
+            say Locale.t("auth.saved", range: auth.range_label)
+          else
+            Wizard.new(cli.send(:issuance), shell).add_authorization
+          end
+        rescue Invoicehn::Error => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+        desc "list", "Muestra las autorizaciones registradas y su vigencia"
+        def list
+          cli = Main.new([], options)
+          Reporter.new(cli.send(:issuance), shell).authorizations
+        end
+      }
+
+      desc "new", "Emite una factura con el asistente interactivo"
+      def new
+        prepare
+        Wizard.new(issuance, shell).issue
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "issue", "Emite una factura desde un archivo JSON"
+      method_option :file, type: :string, required: true, aliases: "-f",
+                           desc: "Archivo JSON con el cliente y las líneas de detalle"
+      method_option :identifier, type: :string, default: "000-001-01"
+      method_option :print, type: :boolean, default: true, desc: "Muestra la factura al emitirla"
+      def issue
+        prepare
+        data = JSON.parse(File.read(options[:file]))
+        invoice = Builder.new(issuance).from_hash(data, identifier: options[:identifier])
+
+        say Locale.t("invoice.issued", correlative: invoice.correlative), :green
+        say "\n#{Renderers::Text.new(invoice).render}" if options[:print]
+      rescue JSON::ParserError => e
+        warn "Archivo JSON inválido: #{e.message}"
+        exit 1
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "show CORRELATIVO", "Muestra una factura emitida"
+      method_option :format, type: :string, default: "text", enum: %w[text json]
+      method_option :copy, type: :string, default: "original", enum: %w[original copia]
+      def show(correlative)
+        invoice = issuance.store.find(correlative)
+
+        case options[:format]
+        when "json" then say Renderers::Json.new(invoice).render
+        else say Renderers::Text.new(invoice, copy: options[:copy].to_sym).render
+        end
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "list", "Lista las facturas emitidas en orden cronológico"
+      method_option :from, type: :string, desc: "Desde (AAAA-MM-DD)"
+      method_option :to, type: :string, desc: "Hasta (AAAA-MM-DD)"
+      def list
+        Reporter.new(issuance, shell).documents(from: parse_date(options[:from]),
+                                                to: parse_date(options[:to]))
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "annul CORRELATIVO", "Anula una factura (Art. 41)"
+      method_option :reason, type: :string, required: true, aliases: "-r",
+                             desc: "Motivo de la anulación"
+      def annul(correlative)
+        invoice = issuance.annul(correlative, reason: options[:reason])
+
+        say "Factura #{invoice.correlative} anulada.", :yellow
+        say "El correlativo queda consumido y no se reutilizará."
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "pdf CORRELATIVO", "Genera el PDF de una factura"
+      method_option :output, type: :string, aliases: "-o"
+      method_option :copy, type: :string, default: "original", enum: %w[original copia]
+      def pdf(correlative)
+        invoice = issuance.store.find(correlative)
+        path = options[:output] || "#{invoice.correlative}.pdf"
+        Renderers::Pdf.new(invoice, copy: options[:copy].to_sym).render_file(path)
+
+        say "PDF generado: #{path}", :green
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "export", "Exporta las facturas en texto para el SAR (Art. 53 num. 5)"
+      method_option :from, type: :string
+      method_option :to, type: :string
+      method_option :format, type: :string, default: "json", enum: %w[json csv]
+      method_option :output, type: :string, aliases: "-o"
+      def export
+        invoices = issuance.store.all(from: parse_date(options[:from]), to: parse_date(options[:to]))
+
+        content = case options[:format]
+                  when "csv" then Renderers::Json.export_csv(invoices)
+                  else Renderers::Json.export(invoices)
+                  end
+
+        if options[:output]
+          File.write(options[:output], "#{content}\n")
+          say "#{invoices.size} documento(s) exportado(s) a #{options[:output]}", :green
+        else
+          say content
+        end
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "check", "Verifica que se pueda emitir: emisor, autorización y correlativo"
+      method_option :identifier, type: :string, default: "000-001-01"
+      def check
+        Reporter.new(issuance, shell).health(identifier: options[:identifier])
+      rescue Invoicehn::Error => e
+        abort_with(e)
+      end
+
+      desc "version", "Muestra la versión"
+      def version
+        say "invoicehn #{Invoicehn::VERSION}"
+      end
+
+      private
+
+      def config
+        @config ||= Config.new(home: options[:"data-dir"])
+      end
+
+      def issuance
+        Locale.current = options[:lang] if options[:lang]
+        @issuance ||= Issuance.new(config: config)
+      end
+
+      def prepare
+        Locale.current = options[:lang] if options[:lang]
+        config.ensure_home!
+      end
+
+      def parse_date(value)
+        value && Date.parse(value)
+      rescue ArgumentError
+        raise ValidationError, "fecha inválida: #{value}"
+      end
+
+      # Compliance failures list every problem at once, which is more useful
+      # than the first one.
+      def abort_with(error)
+        if error.is_a?(ComplianceError)
+          warn Locale.t("errors.compliance")
+          error.violations.each { |v| warn "  · #{v}" }
+        else
+          warn "Error: #{error.message}"
+        end
+        exit 1
+      end
+    end
+  end
+end

data/lib/invoicehn/cli/reporter.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Invoicehn
+  module CLI
+    # Terminal reports: authorization status, the document list, and the
+    # pre-flight check.
+    class Reporter
+      def initialize(issuance, shell = Thor::Base.shell.new)
+        @issuance = issuance
+        @shell = shell
+      end
+
+      def authorizations
+        list = @issuance.store.authorizations
+
+        return say(Locale.t("auth.none"), :yellow) if list.empty?
+
+        say Locale.t("auth.list_header"), :bold
+        rows = list.map do |auth|
+          issued = @issuance.sequence.issued_count(auth.identifier)
+          remaining = [auth.range_end.sequence - [issued, auth.range_start.sequence - 1].max, 0].max
+          status = auth.expired? ? "VENCIDA" : "vigente"
+
+          [auth.cai, auth.range_label, auth.limit_date.to_s, status, remaining.to_s]
+        end
+
+        table(%w[CAI Rango Vence Estado Disponibles], rows)
+      end
+
+      def documents(from: nil, to: nil)
+        invoices = @issuance.store.all(from: from, to: to)
+
+        return say("No hay facturas emitidas en ese período.", :yellow) if invoices.empty?
+
+        rows = invoices.map do |inv|
+          [
+            inv.correlative.to_s,
+            inv.issue_date.to_s,
+            truncate(inv.customer.to_s, 28),
+            inv.total.to_s,
+            inv.annulled? ? "ANULADA" : ""
+          ]
+        end
+
+        table(%w[Correlativo Fecha Cliente Total Estado], rows)
+        say "\n#{invoices.size} documento(s). " \
+            "Total emitido: #{sum_of(invoices.reject(&:annulled?))}"
+      end
+
+      def health(identifier: "000-001-01")
+        status = @issuance.health(identifier: identifier)
+
+        say Locale.t("check.title"), :bold
+        say ""
+
+        if !status[:issuer_configured]
+          say "  ✗ #{Locale.t("check.issuer_absent")}", :red
+        elsif !status[:issuer_complete]
+          say "  ✗ #{Locale.t("check.issuer_missing", fields: status[:issuer_missing].join("; "))}", :red
+        else
+          say "  ✓ #{Locale.t("check.issuer_ok")}", :green
+        end
+
+        if status[:active_authorization]
+          auth = status[:active_authorization]
+          say "  ✓ #{Locale.t("check.auth_active", cai: auth.cai)}", :green
+          say "    #{Locale.t("check.next", correlative: status[:next_correlative])}"
+          say "    #{Locale.t("check.remaining", count: status[:remaining])}",
+              status[:remaining] < 25 ? :yellow : nil
+          say "    #{Locale.t("check.days", days: status[:days_remaining])}",
+              status[:days_remaining] < 30 ? :yellow : nil
+        else
+          say "  ✗ #{Locale.t("check.auth_absent", identifier: identifier)}", :red
+        end
+
+        # Art. 42 — expired authorizations holding unused documents must be
+        # reported to SAR within the first 10 business days of the next month.
+        if status[:lapsed_with_unused].any?
+          say ""
+          say Locale.t("check.lapsed", count: status[:lapsed_with_unused].size), :yellow
+        end
+
+        say ""
+        if status[:ready]
+          say Locale.t("check.ready"), :green
+        else
+          say Locale.t("check.not_ready"), :red
+        end
+      end
+
+      private
+
+      def say(message, color = nil) = @shell.say(message, color)
+
+      def sum_of(invoices)
+        return Money.zero if invoices.empty?
+
+        Money.sum(invoices.map(&:total), currency: invoices.first.currency)
+      end
+
+      def truncate(text, limit)
+        text.length > limit ? "#{text[0, limit - 1]}…" : text
+      end
+
+      # Rows are right-stripped because Thor's #say omits the trailing newline
+      # when a line ends in whitespace, which would run padded rows together.
+      def table(headers, rows)
+        widths = headers.each_with_index.map do |header, i|
+          [header.length, *rows.map { |r| r[i].to_s.length }].max
+        end
+
+        row_line = lambda do |cells|
+          widths.each_with_index.map { |w, i| cells[i].to_s.ljust(w) }.join("  ").rstrip
+        end
+
+        say row_line.call(headers), :bold
+        say widths.map { |w| "─" * w }.join("  ")
+        rows.each { |row| say row_line.call(row) }
+      end
+    end
+  end
+end