lex-creativity 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96628e16854f18c4d7b6d4e9aafbaa8de631a6e1839e86cd80e85e7e073f225a
+  data.tar.gz: 3c9b54db5e8a2c1d7c9a0f4a6324bf5ceee01a39a933db03903f2c1392a2f6fc
+SHA512:
+  metadata.gz: 6208469287a145df8ac37de82cb4ff73f56d62cbb8c911468043d76fb5b29acbd8cc3c499131126fbe23aa1ef48ebd97927d47f5b24f1cb6a3b0c3aae8414e31
+  data.tar.gz: ffeb91083b77ebf1e052b85f8b97dcfef4ea20a78b82e118399d93d8bf1c87349b7982e6d3b1e3db0ae5261cb0e93a7d1abf7903f97cfa5cfc763f64a0f1dd76

data/lib/legion/extensions/creativity/client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/creativity/helpers/constants'
+require 'legion/extensions/creativity/helpers/idea'
+require 'legion/extensions/creativity/helpers/idea_store'
+require 'legion/extensions/creativity/helpers/creative_engine'
+require 'legion/extensions/creativity/runners/creativity'
+
+module Legion
+  module Extensions
+    module Creativity
+      class Client
+        include Runners::Creativity
+
+        attr_reader :creative_engine
+
+        def initialize(creative_engine: nil, **)
+          @creative_engine = creative_engine || Helpers::CreativeEngine.new
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/creativity/helpers/constants.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Creativity
+      module Helpers
+        module Constants
+          # The three modes of creative thinking (Guilford + Boden model)
+          CREATIVITY_MODES = %i[divergent convergent combinational].freeze
+
+          # Guilford's four factors of creative thinking
+          IDEA_QUALITIES = %i[fluency flexibility originality elaboration].freeze
+
+          # Weighted contribution of each Guilford factor to composite quality (sum to 1.0)
+          QUALITY_WEIGHTS = {
+            fluency:     0.20,
+            flexibility: 0.25,
+            originality: 0.35,
+            elaboration: 0.20
+          }.freeze
+
+          # EMA alpha for tracking creative potential (slow adaptation, stable baseline)
+          CREATIVITY_ALPHA = 0.1
+
+          # Ideas below this novelty score are too conventional to register
+          NOVELTY_THRESHOLD = 0.5
+
+          # Minimum Jaccard distance between concept sets for an interesting blend
+          BLEND_DISTANCE_MIN = 0.3
+
+          # Maximum ideas held in the store at any time
+          MAX_IDEAS = 200
+
+          # Maximum active seed concepts in the buffer
+          MAX_ACTIVE_SEEDS = 10
+
+          # Minimum ticks an idea must incubate before it can emerge
+          INCUBATION_TICKS = 20
+
+          # Idea lifecycle states
+          IDEA_STATES = %i[incubating emerged evaluated adopted discarded].freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/creativity/helpers/creative_engine.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Creativity
+      module Helpers
+        class CreativeEngine
+          attr_reader :creative_potential, :idea_store
+
+          def initialize(idea_store: nil)
+            @idea_store         = idea_store || IdeaStore.new
+            @creative_potential = 0.0
+          end
+
+          def diverge(prompt:, count: 5)
+            count = [count.to_i, 1].max
+            seeds = extract_seeds(prompt)
+            ideas = []
+
+            count.times do |i|
+              quality = diverge_quality_scores(i, count)
+              idea    = Idea.new(
+                mode:           :divergent,
+                seed_concepts:  seeds + [@idea_store.seed_buffer.sample].compact,
+                description:    "#{prompt} — variant #{i + 1}",
+                quality_scores: quality
+              )
+              novelty        = @idea_store.compute_novelty(idea)
+              idea_with_nov  = Idea.new(
+                mode:           :divergent,
+                seed_concepts:  idea.seed_concepts,
+                description:    idea.description,
+                quality_scores: quality.merge(originality: novelty)
+              )
+              @idea_store.add(idea_with_nov)
+              ideas << idea_with_nov
+            end
+
+            update_potential(ideas)
+            ideas
+          end
+
+          def converge(ideas:)
+            return [] if ideas.nil? || ideas.empty?
+
+            ranked = ideas
+                     .select { |i| %i[emerged evaluated].include?(i.state) }
+                     .sort_by { |i| -i.composite_quality }
+            ranked.each { |i| i.evaluate!(quality_scores: i.quality_scores) if i.state == :emerged }
+            ranked
+          end
+
+          def blend(concept_a:, concept_b:)
+            set_a    = Set.new(Array(concept_a).map(&:to_sym))
+            set_b    = Set.new(Array(concept_b).map(&:to_sym))
+            distance = jaccard_distance(set_a, set_b)
+
+            return too_similar_result(distance) if distance < Constants::BLEND_DISTANCE_MIN
+
+            idea = build_blended_idea(set_a, set_b, distance, concept_a, concept_b)
+            @idea_store.add(idea)
+            update_potential([idea])
+            { status: :ok, idea: idea }
+          end
+
+          def incubate
+            @idea_store.tick
+            @idea_store.emerge_ready
+          end
+
+          def compute_novelty(idea, existing = nil)
+            if existing
+              set_a = idea.seed_concepts.to_set
+              return 1.0 if existing.empty?
+
+              distances = existing.map { |e| jaccard_distance(set_a, e.seed_concepts.to_set) }
+              distances.sum / distances.size.to_f
+            else
+              @idea_store.compute_novelty(idea)
+            end
+          end
+
+          private
+
+          def too_similar_result(distance)
+            {
+              status:  :too_similar,
+              message: "Concepts are too similar (distance=#{distance.round(3)}, min=#{Constants::BLEND_DISTANCE_MIN})"
+            }
+          end
+
+          def build_blended_idea(set_a, set_b, distance, concept_a, concept_b)
+            blended_seeds = (set_a | set_b).to_a
+            quality = {
+              fluency:     0.5,
+              flexibility: distance.clamp(0.0, 1.0),
+              originality: distance.clamp(0.0, 1.0),
+              elaboration: 0.4
+            }
+            draft   = Idea.new(mode: :combinational, seed_concepts: blended_seeds,
+                               description: "Blend of [#{concept_a}] and [#{concept_b}]",
+                               quality_scores: quality)
+            novelty = @idea_store.compute_novelty(draft)
+            Idea.new(mode: :combinational, seed_concepts: blended_seeds,
+                     description: draft.description,
+                     quality_scores: quality.merge(originality: novelty))
+          end
+
+          def extract_seeds(prompt)
+            prompt.to_s.downcase.split(/\W+/).reject(&:empty?).map(&:to_sym).uniq.first(5)
+          end
+
+          def diverge_quality_scores(index, total)
+            spread = total > 1 ? index.to_f / (total - 1) : 0.5
+            {
+              fluency:     (0.4 + (spread * 0.4)).clamp(0.0, 1.0),
+              flexibility: (0.3 + (rand * 0.5)).clamp(0.0, 1.0),
+              originality: 0.5,
+              elaboration: (0.3 + (spread * 0.3)).clamp(0.0, 1.0)
+            }
+          end
+
+          def update_potential(ideas)
+            return if ideas.empty?
+
+            avg_quality = ideas.sum(&:composite_quality) / ideas.size.to_f
+            @creative_potential = ema(@creative_potential, avg_quality, Constants::CREATIVITY_ALPHA)
+          end
+
+          def ema(current, observed, alpha)
+            (current * (1.0 - alpha)) + (observed * alpha)
+          end
+
+          def jaccard_distance(set_a, set_b)
+            return 1.0 if set_a.empty? && set_b.empty?
+
+            intersection = (set_a & set_b).size.to_f
+            union        = (set_a | set_b).size.to_f
+            return 1.0 if union.zero?
+
+            1.0 - (intersection / union)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/creativity/helpers/idea.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Creativity
+      module Helpers
+        class Idea
+          attr_reader :id, :mode, :seed_concepts, :description, :novelty_score,
+                      :quality_scores, :composite_quality, :state,
+                      :created_at, :evaluated_at, :incubation_ticks_remaining
+
+          def initialize(mode:, seed_concepts:, description:, novelty_score: 0.0, quality_scores: {})
+            @id                       = generate_id
+            @mode                     = mode
+            @seed_concepts            = Array(seed_concepts).map(&:to_sym)
+            @description              = description
+            @novelty_score            = novelty_score.clamp(0.0, 1.0)
+            @quality_scores           = build_quality_scores(quality_scores)
+            @composite_quality        = compute_composite
+            @state                    = :incubating
+            @created_at               = Time.now.utc
+            @evaluated_at             = nil
+            @incubation_ticks_remaining = Constants::INCUBATION_TICKS
+          end
+
+          def tick_incubation
+            @incubation_ticks_remaining = [@incubation_ticks_remaining - 1, 0].max
+          end
+
+          def ready_to_emerge?
+            @state == :incubating && @incubation_ticks_remaining.zero?
+          end
+
+          def emerge!
+            return false unless ready_to_emerge?
+
+            @state = :emerged
+            true
+          end
+
+          def evaluate!(quality_scores: {})
+            return false unless @state == :emerged
+
+            @quality_scores    = build_quality_scores(quality_scores.empty? ? @quality_scores : quality_scores)
+            @composite_quality = compute_composite
+            @evaluated_at      = Time.now.utc
+            @state             = :evaluated
+            true
+          end
+
+          def adopt!
+            return false unless @state == :evaluated
+
+            @state = :adopted
+            true
+          end
+
+          def discard!
+            return false if @state == :adopted
+
+            @state = :discarded
+            true
+          end
+
+          def to_h
+            {
+              id:                         @id,
+              mode:                       @mode,
+              seed_concepts:              @seed_concepts,
+              description:                @description,
+              novelty_score:              @novelty_score.round(4),
+              quality_scores:             @quality_scores,
+              composite_quality:          @composite_quality.round(4),
+              state:                      @state,
+              created_at:                 @created_at,
+              evaluated_at:               @evaluated_at,
+              incubation_ticks_remaining: @incubation_ticks_remaining
+            }
+          end
+
+          private
+
+          def generate_id
+            "idea_#{Time.now.utc.to_f.to_s.gsub('.', '')}_#{rand(1000)}"
+          end
+
+          def build_quality_scores(scores)
+            Constants::IDEA_QUALITIES.to_h do |factor|
+              [factor, (scores[factor] || 0.0).clamp(0.0, 1.0)]
+            end
+          end
+
+          def compute_composite
+            Constants::QUALITY_WEIGHTS.sum do |factor, weight|
+              (@quality_scores[factor] || 0.0) * weight
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/creativity/helpers/idea_store.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Creativity
+      module Helpers
+        class IdeaStore
+          attr_reader :ideas, :seed_buffer, :tick_count
+
+          def initialize
+            @ideas       = []
+            @seed_buffer = []
+            @tick_count  = 0
+          end
+
+          def add(idea)
+            @ideas << idea
+            @ideas.shift while @ideas.size > Constants::MAX_IDEAS
+            idea
+          end
+
+          def tick
+            @tick_count += 1
+            @ideas.select { |i| i.state == :incubating }.each(&:tick_incubation)
+          end
+
+          def ingest_seeds(seeds)
+            Array(seeds).each do |seed|
+              sym = seed.to_sym
+              @seed_buffer << sym unless @seed_buffer.include?(sym)
+            end
+            @seed_buffer.shift while @seed_buffer.size > Constants::MAX_ACTIVE_SEEDS
+          end
+
+          def emerge_ready
+            emerged = []
+            @ideas.select(&:ready_to_emerge?).each do |idea|
+              idea.emerge!
+              emerged << idea
+            end
+            emerged
+          end
+
+          def by_state(state)
+            @ideas.select { |i| i.state == state }
+          end
+
+          def best_ideas(limit: 5)
+            @ideas
+              .select { |i| %i[emerged evaluated adopted].include?(i.state) }
+              .sort_by { |i| -i.composite_quality }
+              .first(limit)
+          end
+
+          def compute_novelty(idea)
+            existing = @ideas.reject { |i| i.id == idea.id }
+            return 1.0 if existing.empty?
+
+            set_a = idea.seed_concepts.to_set
+            distances = existing.map do |other|
+              set_b = other.seed_concepts.to_set
+              jaccard_distance(set_a, set_b)
+            end
+            distances.sum / distances.size.to_f
+          end
+
+          def active_count
+            @ideas.count { |i| %i[incubating emerged evaluated].include?(i.state) }
+          end
+
+          def stats
+            {
+              total:      @ideas.size,
+              incubating: by_state(:incubating).size,
+              emerged:    by_state(:emerged).size,
+              evaluated:  by_state(:evaluated).size,
+              adopted:    by_state(:adopted).size,
+              discarded:  by_state(:discarded).size,
+              seeds:      @seed_buffer.size,
+              tick_count: @tick_count
+            }
+          end
+
+          private
+
+          def jaccard_distance(set_a, set_b)
+            return 1.0 if set_a.empty? && set_b.empty?
+
+            intersection = (set_a & set_b).size.to_f
+            union        = (set_a | set_b).size.to_f
+            return 1.0 if union.zero?
+
+            1.0 - (intersection / union)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/creativity/runners/creativity.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Creativity
+      module Runners
+        module Creativity
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def creative_tick(tick_results: {}, **)
+            seeds = harvest_seeds(tick_results)
+            creative_engine.idea_store.ingest_seeds(seeds) if seeds.any?
+
+            emerged = creative_engine.incubate
+            store   = creative_engine.idea_store
+
+            Legion::Logging.debug "[creativity] tick: seeds=#{seeds.size} emerged=#{emerged.size} " \
+                                  "active=#{store.active_count} potential=#{creative_engine.creative_potential.round(3)}"
+
+            {
+              emerged_count:      emerged.size,
+              active_count:       store.active_count,
+              seeds_ingested:     seeds.size,
+              creative_potential: creative_engine.creative_potential.round(4),
+              emerged_ideas:      emerged.map(&:to_h)
+            }
+          end
+
+          def diverge(prompt:, count: 5, **)
+            ideas = creative_engine.diverge(prompt: prompt, count: count)
+
+            Legion::Logging.debug "[creativity] diverge: prompt=#{prompt.inspect} count=#{ideas.size} " \
+                                  "potential=#{creative_engine.creative_potential.round(3)}"
+
+            {
+              mode:      :divergent,
+              prompt:    prompt,
+              ideas:     ideas.map(&:to_h),
+              count:     ideas.size,
+              potential: creative_engine.creative_potential.round(4)
+            }
+          end
+
+          def blend_concepts(concept_a:, concept_b:, **)
+            result = creative_engine.blend(concept_a: concept_a, concept_b: concept_b)
+
+            if result[:status] == :ok
+              Legion::Logging.debug "[creativity] blend: #{concept_a} + #{concept_b} -> " \
+                                    "novelty=#{result[:idea].novelty_score.round(3)}"
+              {
+                status:    :ok,
+                mode:      :combinational,
+                idea:      result[:idea].to_h,
+                potential: creative_engine.creative_potential.round(4)
+              }
+            else
+              Legion::Logging.debug "[creativity] blend rejected: #{result[:message]}"
+              result
+            end
+          end
+
+          def evaluate_ideas(**)
+            emerged = creative_engine.idea_store.by_state(:emerged)
+            ranked  = creative_engine.converge(ideas: emerged)
+
+            Legion::Logging.debug "[creativity] evaluate: #{ranked.size} ideas ranked"
+
+            {
+              evaluated_count: ranked.size,
+              ideas:           ranked.map(&:to_h),
+              best:            ranked.first&.to_h
+            }
+          end
+
+          def adopt_idea(idea_id:, **)
+            idea = creative_engine.idea_store.ideas.find { |i| i.id == idea_id }
+
+            unless idea
+              Legion::Logging.debug "[creativity] adopt: idea_id=#{idea_id} not found"
+              return { status: :not_found, idea_id: idea_id }
+            end
+
+            if idea.adopt!
+              Legion::Logging.debug "[creativity] adopt: idea_id=#{idea_id} adopted"
+              { status: :adopted, idea: idea.to_h }
+            else
+              Legion::Logging.debug "[creativity] adopt: idea_id=#{idea_id} state=#{idea.state} not adoptable"
+              { status: :not_adoptable, idea_id: idea_id, current_state: idea.state }
+            end
+          end
+
+          def creative_status(**)
+            store  = creative_engine.idea_store
+            best   = store.best_ideas(limit: 3)
+
+            Legion::Logging.debug "[creativity] status: potential=#{creative_engine.creative_potential.round(3)} " \
+                                  "active=#{store.active_count}"
+
+            {
+              creative_potential: creative_engine.creative_potential.round(4),
+              active_count:       store.active_count,
+              seed_buffer:        store.seed_buffer,
+              best_ideas:         best.map(&:to_h),
+              stats:              store.stats
+            }
+          end
+
+          def creativity_stats(**)
+            store = creative_engine.idea_store
+            Legion::Logging.debug '[creativity] stats'
+
+            adopted   = store.by_state(:adopted)
+            discarded = store.by_state(:discarded)
+
+            {
+              creative_potential: creative_engine.creative_potential.round(4),
+              total_ideas:        store.ideas.size,
+              active_count:       store.active_count,
+              adopted_count:      adopted.size,
+              discarded_count:    discarded.size,
+              adoption_rate:      adoption_rate(adopted, discarded),
+              modes:              mode_breakdown(store),
+              average_quality:    average_quality(store),
+              tick_count:         store.tick_count,
+              seed_buffer_size:   store.seed_buffer.size
+            }
+          end
+
+          private
+
+          def creative_engine
+            @creative_engine ||= Helpers::CreativeEngine.new
+          end
+
+          def harvest_seeds(tick_results)
+            seeds = []
+            seeds += extract_key_concepts(tick_results.dig(:memory_retrieval, :domains) || [])
+            seeds += extract_key_concepts(tick_results.dig(:attention, :focus_domain) ? [tick_results.dig(:attention, :focus_domain)] : [])
+            seeds += extract_key_concepts(tick_results.dig(:prediction_engine, :active_domains) || [])
+            seeds += extract_key_concepts(tick_results.dig(:volition, :current_domain) ? [tick_results.dig(:volition, :current_domain)] : [])
+            seeds.uniq
+          end
+
+          def extract_key_concepts(domains)
+            Array(domains).map { |d| d.to_s.split(/\W+/) }.flatten.map(&:to_sym).reject { |s| s.to_s.empty? }
+          end
+
+          def adoption_rate(adopted, discarded)
+            total = adopted.size + discarded.size
+            return 0.0 if total.zero?
+
+            (adopted.size.to_f / total).round(4)
+          end
+
+          def mode_breakdown(store)
+            Helpers::Constants::CREATIVITY_MODES.to_h do |mode|
+              [mode, store.ideas.count { |i| i.mode == mode }]
+            end
+          end
+
+          def average_quality(store)
+            scored = store.ideas.select { |i| %i[evaluated adopted discarded].include?(i.state) }
+            return 0.0 if scored.empty?
+
+            (scored.sum(&:composite_quality) / scored.size.to_f).round(4)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/creativity/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Creativity
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/creativity.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/creativity/version'
+require 'legion/extensions/creativity/helpers/constants'
+require 'legion/extensions/creativity/helpers/idea'
+require 'legion/extensions/creativity/helpers/idea_store'
+require 'legion/extensions/creativity/helpers/creative_engine'
+require 'legion/extensions/creativity/runners/creativity'
+require 'legion/extensions/creativity/client'
+
+module Legion
+  module Extensions
+    module Creativity
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: lex-creativity
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthew Iverson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generates novel ideas via divergent, convergent, and combinational creativity
+  modes; tracks creative potential via EMA; incubates and evaluates ideas using Guilford
+  quality factors
+email:
+- matt@legionIO.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/creativity.rb
+- lib/legion/extensions/creativity/client.rb
+- lib/legion/extensions/creativity/helpers/constants.rb
+- lib/legion/extensions/creativity/helpers/creative_engine.rb
+- lib/legion/extensions/creativity/helpers/idea.rb
+- lib/legion/extensions/creativity/helpers/idea_store.rb
+- lib/legion/extensions/creativity/runners/creativity.rb
+- lib/legion/extensions/creativity/version.rb
+homepage: https://github.com/LegionIO/lex-creativity
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Divergent thinking and conceptual blending engine for LegionIO cognitive
+  agents
+test_files: []