lex-agentic-language 0.1.0

data/lib/legion/extensions/agentic/language/narrator/helpers/prose.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module Narrator
+          module Helpers
+            module Prose
+              module_function
+
+              def emotion_phrase(valence: 0.0, arousal: 0.5, gut: nil)
+                emotion_label = emotion_label_for(valence)
+                arousal_label = arousal_label_for(arousal)
+                base = "I am #{arousal_label} and #{emotion_label}"
+                gut_note = gut_phrase(gut)
+                gut_note ? "#{base}. #{gut_note}" : base
+              end
+
+              def curiosity_phrase(intensity: 0.0, top_wonder: nil, wonder_count: 0)
+                label = curiosity_label_for(intensity)
+                base = "I am #{label}"
+                if top_wonder && wonder_count.positive?
+                  "#{base}, with #{wonder_count} open #{'question' if wonder_count == 1}#{'questions' if wonder_count != 1}. " \
+                    "Most pressing: \"#{top_wonder}\""
+                else
+                  base
+                end
+              end
+
+              def prediction_phrase(confidence: 0.0, pending: 0, mode: nil)
+                label = confidence_label_for(confidence)
+                base = "I am #{label}"
+                base += " (#{mode} reasoning)" if mode
+                base += ", with #{pending} pending predictions" if pending.positive?
+                base
+              end
+
+              def attention_phrase(spotlight: 0, peripheral: 0, focused_domains: [])
+                parts = ["#{spotlight} signals in spotlight focus, #{peripheral} in peripheral awareness"]
+                parts << "manually focused on: #{focused_domains.join(', ')}" if focused_domains.any?
+                parts.join('. ')
+              end
+
+              def memory_phrase(trace_count: 0, health: 1.0)
+                health_label = health_label_for(health)
+                "Memory system #{health_label} with #{trace_count} active traces"
+              end
+
+              def reflection_phrase(health: 1.0, pending_adaptations: 0, recent_severity: nil)
+                label = health_label_for(health)
+                base = "Cognitive health: #{label}"
+                base += ". #{pending_adaptations} pending adaptation recommendations" if pending_adaptations.positive?
+                base += ". Most recent concern: #{recent_severity}" if recent_severity
+                base
+              end
+
+              def overall_narrative(sections)
+                "#{sections.compact.reject(&:empty?).join('. ')}."
+              end
+
+              def gut_phrase(gut)
+                return nil unless gut.is_a?(Hash)
+
+                signal = gut[:signal] || gut[:gut_signal]
+                return nil unless signal
+
+                if signal > 0.3
+                  'My gut says something important is happening'
+                elsif signal < -0.3
+                  'I have an uneasy feeling about the current situation'
+                end
+              end
+
+              def emotion_label_for(valence)
+                if valence > 0.5      then Constants::EMOTION_LABELS[:high_positive]
+                elsif valence > 0.1   then Constants::EMOTION_LABELS[:low_positive]
+                elsif valence > -0.1  then Constants::EMOTION_LABELS[:neutral]
+                elsif valence > -0.5  then Constants::EMOTION_LABELS[:low_negative]
+                else Constants::EMOTION_LABELS[:high_negative]
+                end
+              end
+
+              def arousal_label_for(arousal)
+                if arousal > 0.7    then Constants::AROUSAL_LABELS[:high]
+                elsif arousal > 0.4 then Constants::AROUSAL_LABELS[:medium]
+                elsif arousal > 0.1 then Constants::AROUSAL_LABELS[:low]
+                else Constants::AROUSAL_LABELS[:dormant]
+                end
+              end
+
+              def curiosity_label_for(intensity)
+                if intensity > 0.7    then Constants::CURIOSITY_LABELS[:high]
+                elsif intensity > 0.4 then Constants::CURIOSITY_LABELS[:medium]
+                elsif intensity > 0.1 then Constants::CURIOSITY_LABELS[:low]
+                else Constants::CURIOSITY_LABELS[:none]
+                end
+              end
+
+              def confidence_label_for(confidence)
+                if confidence > 0.7    then Constants::CONFIDENCE_LABELS[:high]
+                elsif confidence > 0.4 then Constants::CONFIDENCE_LABELS[:medium]
+                elsif confidence > 0.1 then Constants::CONFIDENCE_LABELS[:low]
+                else Constants::CONFIDENCE_LABELS[:none]
+                end
+              end
+
+              def health_label_for(health)
+                if health > 0.9    then Constants::HEALTH_LABELS[:excellent]
+                elsif health > 0.7 then Constants::HEALTH_LABELS[:good]
+                elsif health > 0.5 then Constants::HEALTH_LABELS[:fair]
+                elsif health > 0.3 then Constants::HEALTH_LABELS[:poor]
+                else Constants::HEALTH_LABELS[:critical]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/narrator/helpers/synthesizer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module Narrator
+          module Helpers
+            module Synthesizer
+              module_function
+
+              def narrate(tick_results: {}, cognitive_state: {})
+                sections = build_sections(tick_results, cognitive_state)
+                narrative = Prose.overall_narrative(sections.values)
+                mood = infer_mood(tick_results, cognitive_state)
+
+                {
+                  timestamp: Time.now.utc,
+                  narrative: narrative,
+                  sections:  sections,
+                  mood:      mood,
+                  tick_seq:  tick_results[:tick_seq] || cognitive_state[:tick_seq]
+                }
+              end
+
+              def build_sections(tick_results, cognitive_state)
+                {
+                  attention:  synthesize_attention(tick_results, cognitive_state),
+                  emotion:    synthesize_emotion(tick_results, cognitive_state),
+                  curiosity:  synthesize_curiosity(tick_results, cognitive_state),
+                  prediction: synthesize_prediction(tick_results, cognitive_state),
+                  memory:     synthesize_memory(tick_results, cognitive_state),
+                  reflection: synthesize_reflection(cognitive_state)
+                }
+              end
+
+              def synthesize_attention(tick_results, cognitive_state)
+                attention = tick_results[:sensory_processing] || {}
+                focus = cognitive_state[:attention_status] || {}
+
+                Prose.attention_phrase(
+                  spotlight:       attention[:spotlight] || 0,
+                  peripheral:      attention[:peripheral] || 0,
+                  focused_domains: extract_focused_domains(focus)
+                )
+              end
+
+              def synthesize_emotion(tick_results, cognitive_state)
+                valence_data = tick_results[:emotional_evaluation] || {}
+                gut_data = tick_results[:gut_instinct] || cognitive_state[:gut] || {}
+
+                Prose.emotion_phrase(
+                  valence: valence_data[:valence] || cognitive_state.dig(:emotion, :valence) || 0.0,
+                  arousal: valence_data[:arousal] || cognitive_state.dig(:emotion, :arousal) || 0.5,
+                  gut:     gut_data
+                )
+              end
+
+              def synthesize_curiosity(tick_results, cognitive_state)
+                curiosity_data = cognitive_state[:curiosity] || {}
+                wonder_data = tick_results[:working_memory_integration] || {}
+
+                Prose.curiosity_phrase(
+                  intensity:    curiosity_data[:intensity] || wonder_data[:curiosity_intensity] || 0.0,
+                  top_wonder:   extract_top_wonder(curiosity_data, wonder_data),
+                  wonder_count: curiosity_data[:active_count] || wonder_data[:active_wonders] || 0
+                )
+              end
+
+              def synthesize_prediction(tick_results, cognitive_state)
+                pred_data = tick_results[:prediction_engine] || {}
+                pred_state = cognitive_state[:prediction] || {}
+
+                Prose.prediction_phrase(
+                  confidence: pred_data[:confidence] || pred_state[:confidence] || 0.0,
+                  pending:    pred_state[:pending_count] || 0,
+                  mode:       pred_data[:mode] || pred_state[:mode]
+                )
+              end
+
+              def synthesize_memory(tick_results, cognitive_state)
+                memory_data = cognitive_state[:memory] || {}
+                consol = tick_results[:memory_consolidation] || {}
+
+                Prose.memory_phrase(
+                  trace_count: memory_data[:trace_count] || consol[:remaining] || 0,
+                  health:      memory_data[:health] || 1.0
+                )
+              end
+
+              def synthesize_reflection(cognitive_state)
+                ref_data = cognitive_state[:reflection] || {}
+
+                Prose.reflection_phrase(
+                  health:              ref_data[:health] || 1.0,
+                  pending_adaptations: ref_data[:pending_adaptations] || 0,
+                  recent_severity:     ref_data[:recent_severity]
+                )
+              end
+
+              def infer_mood(tick_results, cognitive_state)
+                valence = tick_results.dig(:emotional_evaluation, :valence) ||
+                          cognitive_state.dig(:emotion, :valence) || 0.0
+                arousal = tick_results.dig(:emotional_evaluation, :arousal) ||
+                          cognitive_state.dig(:emotion, :arousal) || 0.5
+
+                classify_mood(valence, arousal)
+              end
+
+              def classify_mood(valence, arousal)
+                if valence > 0.3 && arousal > 0.5 then :energized
+                elsif valence > 0.3                   then :content
+                elsif valence < -0.3 && arousal > 0.5 then :anxious
+                elsif valence < -0.3                  then :subdued
+                elsif arousal > 0.7                   then :alert
+                elsif arousal < 0.2                   then :dormant
+                else :neutral
+                end
+              end
+
+              def extract_focused_domains(focus)
+                manual = focus[:manual_focus]
+                return [] unless manual.is_a?(Hash)
+
+                manual.keys.map(&:to_s)
+              end
+
+              def extract_top_wonder(curiosity_data, wonder_data)
+                curiosity_data[:top_question] || wonder_data[:top_question] ||
+                  (wonder_data[:top_wonder].is_a?(Hash) ? wonder_data[:top_wonder][:question] : nil)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/narrator/runners/narrator.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module Narrator
+          module Runners
+            module Narrator
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def narrate(tick_results: {}, cognitive_state: {}, **)
+                entry = Helpers::Synthesizer.narrate(tick_results: tick_results, cognitive_state: cognitive_state)
+
+                if Helpers::LlmEnhancer.available?
+                  sections_data = build_llm_sections_data(tick_results, cognitive_state, entry)
+                  llm_result = Helpers::LlmEnhancer.narrate(sections_data: sections_data)
+                  if llm_result
+                    entry = entry.merge(narrative: llm_result, source: :llm)
+                    journal.append(entry)
+                    Legion::Logging.debug "[narrator] mood=#{entry[:mood]} source=llm sections=#{entry[:sections].keys.size}"
+                    return {
+                      narrative: entry[:narrative],
+                      mood:      entry[:mood],
+                      timestamp: entry[:timestamp],
+                      sections:  entry[:sections],
+                      source:    :llm
+                    }
+                  end
+                end
+
+                journal.append(entry)
+                Legion::Logging.debug "[narrator] mood=#{entry[:mood]} sections=#{entry[:sections].keys.size}"
+
+                {
+                  narrative: entry[:narrative],
+                  mood:      entry[:mood],
+                  timestamp: entry[:timestamp],
+                  sections:  entry[:sections]
+                }
+              end
+
+              def recent_entries(limit: 10, **)
+                entries = journal.recent(limit: limit)
+                {
+                  entries: entries.map { |e| format_entry(e) },
+                  count:   entries.size,
+                  total:   journal.size
+                }
+              end
+
+              def entries_since(since:, **)
+                timestamp = since.is_a?(Time) ? since : Time.parse(since.to_s)
+                entries = journal.since(timestamp)
+                {
+                  entries: entries.map { |e| format_entry(e) },
+                  count:   entries.size,
+                  since:   timestamp
+                }
+              end
+
+              def mood_history(mood: nil, limit: 20, **)
+                entries = mood ? journal.by_mood(mood.to_sym) : journal.entries
+                recent = entries.last(limit)
+                {
+                  entries: recent.map { |e| { timestamp: e[:timestamp], mood: e[:mood], narrative: e[:narrative] } },
+                  count:   recent.size,
+                  mood:    mood
+                }
+              end
+
+              def current_narrative(**)
+                entry = journal.entries.last
+                return { narrative: 'No cognitive activity recorded yet.', mood: :dormant } unless entry
+
+                {
+                  narrative:   entry[:narrative],
+                  mood:        entry[:mood],
+                  timestamp:   entry[:timestamp],
+                  age_seconds: (Time.now.utc - entry[:timestamp]).round(1)
+                }
+              end
+
+              def narrator_stats(**)
+                stats = journal.stats
+                mood_summary = stats[:moods] || {}
+                dominant_mood = mood_summary.max_by { |_, count| count }&.first
+
+                {
+                  journal_size:  journal.size,
+                  capacity:      Helpers::Constants::MAX_JOURNAL_SIZE,
+                  dominant_mood: dominant_mood,
+                  mood_counts:   mood_summary,
+                  oldest:        stats[:oldest],
+                  newest:        stats[:newest]
+                }
+              end
+
+              private
+
+              def journal
+                @journal ||= Helpers::Journal.new
+              end
+
+              def build_llm_sections_data(tick_results, cognitive_state, entry)
+                {
+                  emotion:    llm_emotion_data(tick_results, cognitive_state),
+                  curiosity:  llm_curiosity_data(tick_results, cognitive_state),
+                  prediction: llm_prediction_data(tick_results, cognitive_state),
+                  memory:     llm_memory_data(tick_results, cognitive_state),
+                  attention:  llm_attention_data(tick_results, cognitive_state),
+                  reflection: llm_reflection_data(cognitive_state),
+                  mood:       entry[:mood]
+                }
+              end
+
+              def llm_emotion_data(tick_results, cognitive_state)
+                v = tick_results[:emotional_evaluation] || {}
+                g = tick_results[:gut_instinct] || cognitive_state[:gut] || {}
+                {
+                  valence: v[:valence] || cognitive_state.dig(:emotion, :valence) || 0.0,
+                  arousal: v[:arousal] || cognitive_state.dig(:emotion, :arousal) || 0.5,
+                  gut:     g[:signal] || g[:gut_signal]
+                }
+              end
+
+              def llm_curiosity_data(tick_results, cognitive_state)
+                c = cognitive_state[:curiosity] || {}
+                w = tick_results[:working_memory_integration] || {}
+                {
+                  intensity:    c[:intensity] || w[:curiosity_intensity] || 0.0,
+                  wonder_count: c[:active_count] || w[:active_wonders] || 0,
+                  top_wonder:   c[:top_question] || w[:top_question]
+                }
+              end
+
+              def llm_prediction_data(tick_results, cognitive_state)
+                p = tick_results[:prediction_engine] || {}
+                s = cognitive_state[:prediction] || {}
+                {
+                  confidence: p[:confidence] || s[:confidence] || 0.0,
+                  pending:    s[:pending_count] || 0,
+                  mode:       p[:mode] || s[:mode]
+                }
+              end
+
+              def llm_memory_data(tick_results, cognitive_state)
+                m = cognitive_state[:memory] || {}
+                c = tick_results[:memory_consolidation] || {}
+                {
+                  trace_count: m[:trace_count] || c[:remaining] || 0,
+                  health:      m[:health] || 1.0
+                }
+              end
+
+              def llm_attention_data(tick_results, cognitive_state)
+                a = tick_results[:sensory_processing] || {}
+                f = cognitive_state[:attention_status] || {}
+                {
+                  spotlight:       a[:spotlight] || 0,
+                  peripheral:      a[:peripheral] || 0,
+                  focused_domains: extract_focused_domains_for_llm(f)
+                }
+              end
+
+              def llm_reflection_data(cognitive_state)
+                r = cognitive_state[:reflection] || {}
+                {
+                  health:              r[:health] || 1.0,
+                  pending_adaptations: r[:pending_adaptations] || 0
+                }
+              end
+
+              def extract_focused_domains_for_llm(focus)
+                manual = focus[:manual_focus]
+                return [] unless manual.is_a?(Hash)
+
+                manual.keys.map(&:to_s)
+              end
+
+              def format_entry(entry)
+                {
+                  timestamp: entry[:timestamp],
+                  narrative: entry[:narrative],
+                  mood:      entry[:mood],
+                  sections:  entry[:sections]
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/narrator/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module Narrator
+          VERSION = '0.1.1'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/narrator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/language/narrator/version'
+require 'legion/extensions/agentic/language/narrator/helpers/constants'
+require 'legion/extensions/agentic/language/narrator/helpers/prose'
+require 'legion/extensions/agentic/language/narrator/helpers/journal'
+require 'legion/extensions/agentic/language/narrator/helpers/synthesizer'
+require 'legion/extensions/agentic/language/narrator/helpers/llm_enhancer'
+require 'legion/extensions/agentic/language/narrator/runners/narrator'
+require 'legion/extensions/agentic/language/narrator/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module Narrator
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/pragmatic_inference/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/language/pragmatic_inference/helpers/constants'
+require 'legion/extensions/agentic/language/pragmatic_inference/helpers/utterance'
+require 'legion/extensions/agentic/language/pragmatic_inference/helpers/pragmatic_engine'
+require 'legion/extensions/agentic/language/pragmatic_inference/runners/pragmatic_inference'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module PragmaticInference
+          class Client
+            include Runners::PragmaticInference
+
+            def initialize(**)
+              @engine = Helpers::PragmaticEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/pragmatic_inference/helpers/constants.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module PragmaticInference
+          module Helpers
+            module Constants
+              MAX_UTTERANCES   = 500
+              MAX_IMPLICATURES = 200
+              MAX_HISTORY      = 300
+
+              DEFAULT_CONFIDENCE  = 0.5
+              CONFIDENCE_FLOOR    = 0.0
+              CONFIDENCE_CEILING  = 1.0
+              REINFORCEMENT_RATE  = 0.1
+              DECAY_RATE          = 0.02
+
+              MAXIMS = %i[quality quantity relevance manner].freeze
+
+              VIOLATION_TYPES = %i[none flouting violating opting_out].freeze
+
+              SPEECH_ACTS = %i[assert question request promise warn inform suggest].freeze
+
+              MAXIM_DESCRIPTIONS = {
+                quality:   'be truthful, have evidence',
+                quantity:  'be informative, not more than needed',
+                relevance: 'be relevant to the conversation',
+                manner:    'be clear, brief, orderly, unambiguous'
+              }.freeze
+
+              module_function
+
+              def valid_maxim?(maxim)
+                MAXIMS.include?(maxim)
+              end
+
+              def valid_violation_type?(type)
+                VIOLATION_TYPES.include?(type)
+              end
+
+              def valid_speech_act?(act)
+                SPEECH_ACTS.include?(act)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end