legion-apollo 0.5.7 → 0.5.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d677b83515f568ba99bf3288a9b2f7ade65775b816559092b65265966e8a2cd
-  data.tar.gz: 9fd3698f16f43357ecc6b1e9791bf46d03d28afb6f7f28bbeac52e7af0a9fe3f
+  metadata.gz: f096b7552b38d67434c6ae3431526bcd37ebe43c75fa90a19c8ec790e3d323a0
+  data.tar.gz: c8484053dfcda88edee17da060f7a5cab87235c0ea6258d2faecc6542135b1f5
 SHA512:
-  metadata.gz: b7e5ccadab990babeed6409b43c2db932ca85a990defe38f07bde539bccfdcf8620e06140f0dcddae85c8c2016e5251bd91afa0b3aaae31f7f6368ab97104e09
-  data.tar.gz: bbbe65132a326f90ba9ebd573f4938a9cfd8cbfba688cd742e4ec39f4128fd72d07a236787f8a23a757336477459034d4907a387e0040416f72e08b49318d4ad
+  metadata.gz: 246787437bfdf6c9667563e73bbba1bd56fe3328f2d1836d2a9daf14cc870ad1df25f96ff725f80a14ed9e4174efa4479f0c41eb314538138122d54cb8dbb424
+  data.tar.gz: fcee5919bc41cc594d77ab04188212265c54b5281383c9ff6e003222ea4ce2cf25859b39666cdf16c2b09fbcabbfd998af84c33d6fad4cdca86b683e1c140739

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [0.5.13] - 2026-10-29
+
+### Fixed
+- Preserve L0/L1 summaries when normalizing public local and merged retrieval results, exposing the projected text as content instead of nil.
+
+## [0.5.12] - 2026-10-29
+
+### Fixed
+- Honor raw source and temporal-window updates during upsert. Refresh derived raw content when indexed content changes, preserve omitted explicit sources/windows, and allow explicit nil windows to clear validity bounds.
+- Remove old FTS5 terms before changing their external content row, preventing index corruption during upsert while preserving transactional rollback.
+
+## [0.5.11] - 2026-10-29
+
+### Fixed
+- Renew expired content on duplicate ingestion while preserving its ID, source, tags, and deduplicated response; active duplicates retain their original expiration.
+
+## [0.5.10] - 2026-10-29
+
+### Fixed
+- Apply local eligibility filters before filling the candidate budget, streaming full-text, blank, and fallback searches so rejected rows cannot hide later matching knowledge.
+
+## [0.5.9] - 2026-10-29
+
+### Fixed
+- Return logged failure results from local graph operations when the optional database is absent, disconnected, or has no usable connection, instead of leaking lifecycle exceptions.
+
+## [0.5.8] - 2026-10-29
+
+### Fixed
+- Generate local ingest/upsert embeddings outside the write mutex so slow providers do not serialize unrelated writes; retain atomic duplicate checks and persistence.
+
 ## [0.5.7] - 2026-07-15
 ### Removed
 - Remove .md self-knowledge seed pipeline (bonds must be earned, not implanted)

data/README.md

@@ -2,7 +2,7 @@
 
 Apollo is the LegionIO knowledge client. It gives extensions one API for writing, retrieving, and merging knowledge across the global Apollo service and the node-local SQLite store.
 
-**Version**: 0.5.2
+**Version**: 0.5.13
 
 `legion-apollo` provides `query`, `ingest`, and `retrieve` with smart routing: co-located `lex-apollo`, RabbitMQ transport, node-local SQLite, or graceful failure. `Apollo::Local` mirrors the same public API for offline and low-latency retrieval without requiring remote infrastructure.
 
@@ -58,10 +58,18 @@ Features:
 - `raw_content` preservation for verbatim source text
 - `valid_from` / `valid_to` temporal windows with `as_of:` query filtering
 - Optional LLM embeddings (1024-dim) with cosine rerank when `Legion::LLM.can_embed?`
-- TTL expiry (default 5-year retention)
+- Embedding generation runs outside the local write mutex; persistence and duplicate checks remain serialized
+- TTL expiry (default 5-year retention); re-ingesting expired content renews retention without replacing its stored source or ID
 - FTS5 full-text search with `ILIKE` fallback
+- Confidence, tags, visibility, inference, and history filters run before filling the reranking candidate budget
 - Null-byte removal and invalid UTF-8 scrubbing before persistence or backend routing
 
+Local graph operations return `{ success: false, error: ... }` when the optional database is unavailable; they do not require callers to rescue missing-connection exceptions.
+
+`Local.upsert` honors explicit `raw_content`, `valid_from`, and `valid_to` updates. Omitted validity bounds and distinct verbatim sources are preserved; derived raw content follows the updated indexed content. Explicit nil validity bounds clear the corresponding restriction.
+
+Public `query`/`retrieve` calls with `tier: :l0` or `tier: :l1` retain the local `summary` and expose it as `content` in both `scope: :local` and `scope: :all` results.
+
 ## Configuration
 
 ```json

data/lib/legion/apollo/local/graph.rb

@@ -12,6 +12,7 @@ module Legion
       # Graph traversal expands one frontier batch per depth to avoid per-node queries.
       module Graph # rubocop:disable Metrics/ModuleLength
         VALID_RELATION_TYPES = %w[AFFECTS OWNED_BY DEPENDS_ON RELATED_TO SUPERSEDES].freeze
+        class DatabaseUnavailable < StandardError; end
 
         class << self # rubocop:disable Metrics/ClassLength
           include Legion::Logging::Helper
@@ -32,7 +33,7 @@ module Legion
             end
             log.info { "Apollo::Local::Graph created entity id=#{id} type=#{type} name=#{name}" }
             { success: true, id: id }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(
               e,
               level:       :error,
@@ -49,7 +50,7 @@ module Legion
 
             log.debug { "Apollo::Local::Graph found entity id=#{id}" }
             { success: true, entity: decode_entity(row) }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(e, level: :error, operation: 'apollo.local.graph.find_entity', entity_id: id)
             { success: false, error: e.message }
           end
@@ -58,7 +59,7 @@ module Legion
             rows = db[:local_entities].where(entity_type: type.to_s).limit(limit).all
             log.debug { "Apollo::Local::Graph found entities type=#{type} count=#{rows.size}" }
             { success: true, entities: rows.map { |r| decode_entity(r) }, count: rows.size }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(
               e,
               level:       :error,
@@ -73,7 +74,7 @@ module Legion
             rows = db[:local_entities].where(name: name.to_s).limit(limit).all
             log.debug { "Apollo::Local::Graph found entities name=#{name} count=#{rows.size}" }
             { success: true, entities: rows.map { |r| decode_entity(r) }, count: rows.size }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(
               e,
               level:     :error,
@@ -95,7 +96,7 @@ module Legion
 
             log.info { "Apollo::Local::Graph updated entity id=#{id}" }
             { success: true, id: id }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(
               e,
               level:     :error,
@@ -112,7 +113,7 @@ module Legion
 
             log.info { "Apollo::Local::Graph deleted entity id=#{id}" }
             result
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(e, level: :error, operation: 'apollo.local.graph.delete_entity', entity_id: id)
             { success: false, error: e.message }
           end
@@ -132,6 +133,10 @@ module Legion
                 "target_id=#{target_id} relation_type=#{normalized_relation_type}"
             end
             { success: true, id: id }
+          rescue DatabaseUnavailable => e
+            handle_exception(e, level: :error, operation: 'apollo.local.graph.create_relationship',
+                                source_id: source_id, target_id: target_id)
+            { success: false, error: e.message }
           rescue Sequel::UniqueConstraintViolation => e
             duplicate = handle_duplicate_relationship(source_id, target_id, normalized_relation_type)
             return duplicate if duplicate
@@ -170,7 +175,7 @@ module Legion
                 "relation_type=#{relation_type || 'any'} count=#{rows.size}"
             end
             { success: true, relationships: rows.map { |r| decode_relationship(r) }, count: rows.size }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(
               e,
               level:         :error,
@@ -188,7 +193,7 @@ module Legion
 
             log.info { "Apollo::Local::Graph deleted relationship id=#{id}" }
             { success: true, id: id }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(e, level: :error, operation: 'apollo.local.graph.delete_relationship', relationship_id: id)
             { success: false, error: e.message }
           end
@@ -217,7 +222,7 @@ module Legion
               edges:   edge_rows.map   { |r| decode_relationship(r) },
               count:   entity_rows.size
             }
-          rescue Sequel::Error => e
+          rescue DatabaseUnavailable, Sequel::Error => e
             handle_exception(
               e,
               level:         :error,
@@ -357,7 +362,14 @@ module Legion
           end
 
           def db
-            Legion::Data::Local.connection
+            unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+              raise DatabaseUnavailable, 'local database unavailable'
+            end
+
+            connection = Legion::Data::Local.connection
+            return connection if connection && !(connection.respond_to?(:closed?) && connection.closed?)
+
+            raise DatabaseUnavailable, 'local database unavailable'
           end
 
           def timestamp

data/lib/legion/apollo/local.rb

@@ -42,12 +42,18 @@ module Legion
           @started == true
         end
 
-        def ingest(content:, tags: [], access_scope: 'global', **opts) # rubocop:disable Metrics/MethodLength
+        def ingest(content:, tags: [], access_scope: 'global', **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
           return not_started_error unless started?
 
           tags = normalize_tags_input(tags)
+          content = normalize_text_input(content)
+          hash = content_hash(content)
+          duplicate = WRITE_MUTEX.synchronize { deduplicated_ingest(hash, expires_at: opts[:expires_at]) }
+          return duplicate if duplicate
+
+          embedding_fields = embedding_columns(content, opts)
           WRITE_MUTEX.synchronize do
-            ingest_without_lock(content: content, tags: tags,
+            ingest_without_lock(content: content, tags: tags, embedding_fields: embedding_fields,
                                 **inject_identity_context(opts).merge(access_scope: access_scope))
           end
         rescue StandardError => e
@@ -67,14 +73,26 @@ module Legion
           sorted_tags = normalize_tags_input(tags).sort
           tag_json = Legion::JSON.dump(sorted_tags)
           merged_opts = inject_identity_context(opts).merge(access_scope: access_scope)
+          content = normalize_text_input(content)
+          hash = content_hash(content)
+          duplicate = WRITE_MUTEX.synchronize do
+            if db[:local_knowledge].where(tags: tag_json).empty?
+              deduplicated_ingest(hash,
+                                  expires_at: opts[:expires_at])
+            end
+          end
+          return duplicate if duplicate
+
+          embedding_fields = embedding_columns(content, merged_opts)
           WRITE_MUTEX.synchronize do
             existing = db[:local_knowledge].where(tags: tag_json).first
 
             if existing
-              update_upsert_entry(existing, content, tag_json, merged_opts)
+              update_upsert_entry(existing, content, tag_json, merged_opts, embedding_fields)
             else
-              result = ingest_without_lock(content: content, tags: sorted_tags, **merged_opts)
-              result[:mode] = :inserted if result[:success] && result[:mode] != :deduplicated
+              result = ingest_without_lock(content: content, tags: sorted_tags,
+                                           embedding_fields: embedding_fields, **merged_opts)
+              result[:mode] = :inserted if result[:mode] == :local
               result
             end
           end
@@ -104,13 +122,15 @@ module Legion
           end
           log.debug { "Apollo::Local query limit=#{limit} min_confidence=#{min_confidence} tags=#{Array(tags).size}" }
 
-          candidates = fts_search(text, limit: limit * multiplier, as_of: as_of)
           include_inferences = opts.fetch(:include_inferences, true)
           include_history = opts.fetch(:include_history, false)
-          candidates = filter_candidates(candidates, min_confidence: min_confidence, tags: tags,
-                                                     options: { include_inferences: include_inferences,
-                                                                include_history: include_history, as_of: as_of,
-                                                                requesting_principal_id: requesting_principal_id })
+          candidates = fts_search(text, as_of: as_of) do |dataset|
+            filter_candidates(dataset.lazy, min_confidence: min_confidence, tags: tags,
+                                            options: { include_inferences: include_inferences,
+                                                       include_history: include_history, as_of: as_of,
+                                                       requesting_principal_id: requesting_principal_id })
+              .take(limit * multiplier).force
+          end
           candidates = cosine_rerank(text, candidates) if can_rerank?
           results = candidates.first(limit)
 
@@ -303,13 +323,6 @@ module Legion
           Digest::MD5.hexdigest(normalized)
         end
 
-        def duplicate?(hash)
-          db[:local_knowledge].where(content_hash: hash).any?
-        rescue StandardError => e
-          handle_exception(e, level: :debug, operation: 'apollo.local.duplicate_check', hash: hash)
-          false
-        end
-
         def start_without_lock
           return if @started
           return unless local_enabled? && data_local_available?
@@ -319,11 +332,12 @@ module Legion
           log.info 'Legion::Apollo::Local started'
         end
 
-        def ingest_without_lock(content:, tags:, **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        def ingest_without_lock(content:, tags:, embedding_fields:, **opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
           content = normalize_text_input(content)
           raw_content = normalize_raw_content_input(opts[:raw_content], fallback: content)
           hash = content_hash(content)
-          return deduplicated_ingest(hash) if duplicate?(hash)
+          duplicate = deduplicated_ingest(hash, expires_at: opts[:expires_at])
+          return duplicate if duplicate
 
           log.info do
             "Apollo::Local ingest accepted content_length=#{content.to_s.length} " \
@@ -334,15 +348,17 @@ module Legion
           metadata = opts.dup
           metadata.delete(:raw_content)
           row = build_ingest_row(content: content, raw_content: raw_content, hash: hash, tags: tags, **metadata)
+                .merge(embedding_fields)
           id = persist_ingest_row(row, metadata)
           mark_parent_superseded(metadata[:parent_knowledge_id]) if metadata[:parent_knowledge_id]
 
           log.info { "Apollo::Local ingest stored id=#{id} hash=#{hash}" }
           { success: true, mode: :local, id: id }
         rescue Sequel::UniqueConstraintViolation
-          raise unless duplicate?(hash)
+          duplicate = deduplicated_ingest(hash, expires_at: opts[:expires_at])
+          raise unless duplicate
 
-          deduplicated_ingest(hash)
+          duplicate
         end
 
         def build_ingest_row(content:, raw_content:, hash:, tags:, **opts) # rubocop:disable Metrics/MethodLength
@@ -356,7 +372,7 @@ module Legion
             opts:               opts,
             is_inference:       is_inference,
             default_confidence: default_confidence
-          ).merge(embedding_columns(content, opts)).merge(timestamp_columns)
+          ).merge(timestamp_columns)
         end
 
         def ingest_metadata_columns(context)
@@ -424,7 +440,17 @@ module Legion
           handle_exception(e, level: :warn, operation: 'apollo.local.create_source_link', entry_id: entry_id)
         end
 
-        def deduplicated_ingest(hash)
+        def deduplicated_ingest(hash, expires_at: nil) # rubocop:disable Metrics/MethodLength
+          dataset = db[:local_knowledge].where(content_hash: hash)
+          existing = dataset.select(:expires_at).first
+          return unless existing
+
+          now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
+          previous_expiry = existing[:expires_at]
+          if previous_expiry && previous_expiry <= now
+            dataset.where(Sequel.lit('expires_at <= ?', now))
+                   .update(expires_at: expires_at || compute_expires_at, updated_at: now)
+          end
           log.info { "Apollo::Local ingest deduplicated hash=#{hash}" }
           { success: true, mode: :deduplicated }
         end
@@ -494,33 +520,31 @@ module Legion
           Legion::JSON.dump(normalize_tags_input(tags))
         end
 
-        def fts_search(text, limit:, as_of: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        def fts_search(text, as_of: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
           now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
-          return active_knowledge_dataset(now: now, as_of: as_of).limit(limit).all if text.to_s.strip.empty?
+          return yield active_knowledge_dataset(now: now, as_of: as_of) if text.to_s.strip.empty?
 
           tokens = text.to_s.scan(/[\p{L}\p{N}_]+/)
-          return ilike_search(text, now: now, limit: limit, as_of: as_of) if tokens.empty?
+          return yield ilike_search(text, now: now, as_of: as_of) if tokens.empty?
 
           escaped = tokens.map { |t| %("#{t}") }.join(' ')
           temporal_sql, temporal_params = temporal_window_sql(as_of, table_alias: 'lk')
-          db.fetch(
+          yield db.fetch(
             'SELECT lk.* FROM local_knowledge lk ' \
             'INNER JOIN local_knowledge_fts fts ON lk.id = fts.rowid ' \
             "WHERE local_knowledge_fts MATCH ? AND lk.expires_at > ?#{temporal_sql} " \
-            'ORDER BY fts.rank LIMIT ?',
-            escaped, now, *temporal_params, limit
-          ).all
+            'ORDER BY fts.rank',
+            escaped, now, *temporal_params
+          )
         rescue StandardError => e
-          handle_exception(e, level: :debug, operation: 'apollo.local.fts_search', limit: limit, fallback: :ilike)
-          ilike_search(text, now: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ'), limit: limit, as_of: as_of)
+          handle_exception(e, level: :debug, operation: 'apollo.local.fts_search', fallback: :ilike)
+          yield ilike_search(text, now: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ'), as_of: as_of)
         end
 
-        def ilike_search(text, now:, limit:, as_of: nil)
+        def ilike_search(text, now:, as_of: nil)
           safe_text = text.to_s.gsub('\\', '\\\\\\\\').gsub('%', '\%').gsub('_', '\_')
           active_knowledge_dataset(now: now, as_of: as_of)
             .where(Sequel.lit("content LIKE ? ESCAPE '\\' COLLATE NOCASE", "%#{safe_text}%"))
-            .limit(limit)
-            .all
         end
 
         def filter_candidates(candidates, min_confidence:, tags:, options: {}) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/AbcSize
@@ -726,20 +750,26 @@ module Legion
           end.first(limit)
         end
 
-        def update_upsert_entry(existing, content, tags_json, opts) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        def update_upsert_entry(existing, content, tags_json, opts, embedding_fields) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
           content = normalize_text_input(content)
           new_hash = content_hash(content)
-          embedding, embedded_at = generate_embedding(content)
           now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
           expires_at = compute_expires_at
+          raw_content = opts.fetch(:raw_content) do
+            existing[:raw_content] unless existing[:raw_content] == existing[:content]
+          end
 
           db.transaction do
+            db.run("DELETE FROM local_knowledge_fts WHERE rowid = #{existing[:id]}")
             db[:local_knowledge].where(id: existing[:id]).update(
               content:                 content,
+              raw_content:             normalize_raw_content_input(raw_content, fallback: content),
+              valid_from:              normalize_temporal_value(opts.fetch(:valid_from, existing[:valid_from])),
+              valid_to:                normalize_temporal_value(opts.fetch(:valid_to, existing[:valid_to])),
               content_hash:            new_hash,
               tags:                    tags_json,
-              embedding:               embedding ? Legion::JSON.dump(embedding) : nil,
-              embedded_at:             embedded_at,
+              embedding:               embedding_fields[:embedding],
+              embedded_at:             embedding_fields[:embedded_at],
               confidence:              opts.fetch(:confidence, existing[:confidence]),
               expires_at:              expires_at,
               source_channel:          opts.fetch(:source_channel, existing[:source_channel]),
@@ -751,18 +781,12 @@ module Legion
               identity_id:             opts.fetch(:identity_id, existing[:identity_id]),
               updated_at:              now
             )
-            rebuild_fts_entry!(existing[:id], content, tags_json)
+            sync_fts!(existing[:id], content, tags_json)
           end
           log.info { "Apollo::Local upsert updated id=#{existing[:id]} hash=#{new_hash}" }
           { success: true, mode: :updated, id: existing[:id] }
         end
 
-        def rebuild_fts_entry!(id, content, tags_json)
-          db.run("DELETE FROM local_knowledge_fts WHERE rowid = #{id}")
-          sync_fts!(id, content, tags_json)
-          log.debug { "Apollo::Local FTS rebuilt id=#{id}" }
-        end
-
         def project_tier(entry, tier) # rubocop:disable Metrics/MethodLength
           case tier
           when :l0

data/lib/legion/apollo/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Apollo
-    VERSION = '0.5.7'
+    VERSION = '0.5.13'
   end
 end

data/lib/legion/apollo.rb

@@ -369,25 +369,28 @@ module Legion
         payload.merge(text: normalized_text, query: normalized_text)
       end
 
-      def normalize_local_entries(entries) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      def normalize_local_entries(entries) # rubocop:disable Metrics/AbcSize
         entries.map do |e|
-          hash = e[:content_hash] || Digest::MD5.hexdigest(e[:content].to_s.strip.downcase.gsub(/\s+/, ' '))
-          tags = if e[:tags].is_a?(String)
-                   begin
-                     Legion::JSON.parse(e[:tags])
-                   rescue StandardError => ex
-                     handle_exception(ex, level: :debug, operation: 'apollo.normalize_local_entries', entry_id: e[:id])
-                     []
-                   end
-                 else
-                   Array(e[:tags])
-                 end
-          { id: e[:id], content: e[:content], raw_content: e[:raw_content] || e[:content], content_hash: hash,
-            confidence: e[:confidence] || 0.5, content_type: 'fact', tags: tags, source: :local,
-            valid_from: e[:valid_from], valid_to: e[:valid_to] }
+          content = e[:content] || e[:summary]
+          hash = e[:content_hash] || Digest::MD5.hexdigest(content.to_s.strip.downcase.gsub(/\s+/, ' '))
+          tags = normalize_local_entry_tags(e)
+          entry = { id: e[:id], content: content, raw_content: e[:raw_content] || content, content_hash: hash,
+                    confidence: e[:confidence] || 0.5, content_type: 'fact', tags: tags, source: :local,
+                    valid_from: e[:valid_from], valid_to: e[:valid_to] }
+          entry[:summary] = e[:summary] if e.key?(:summary)
+          entry
         end
       end
 
+      def normalize_local_entry_tags(entry)
+        return Array(entry[:tags]) unless entry[:tags].is_a?(String)
+
+        Legion::JSON.parse(entry[:tags])
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'apollo.normalize_local_entries', entry_id: entry[:id])
+        []
+      end
+
       def normalize_global_entries(entries)
         entries.map { |entry| normalize_global_entry(entry) }
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-apollo
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.13
 platform: ruby
 authors:
 - Esity