lex-dual-process 0.1.0

data/spec/legion/extensions/dual_process/runners/dual_process_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/dual_process/client'
+
+RSpec.describe Legion::Extensions::DualProcess::Runners::DualProcess do
+  let(:client) { Legion::Extensions::DualProcess::Client.new }
+
+  describe '#register_heuristic' do
+    it 'returns success: true' do
+      result = client.register_heuristic(pattern: 'hello', domain: :social, response: :wave)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns heuristic data' do
+      result = client.register_heuristic(pattern: 'hello', domain: :social, response: :wave)
+      expect(result[:heuristic]).to include(:id, :pattern, :domain, :response, :confidence)
+    end
+
+    it 'accepts custom confidence' do
+      result = client.register_heuristic(pattern: :x, domain: :d, response: :r, confidence: 0.9)
+      expect(result[:heuristic][:confidence]).to eq(0.9)
+    end
+
+    it 'ignores nil confidence and uses default' do
+      result = client.register_heuristic(pattern: :x, domain: :d, response: :r, confidence: nil)
+      expect(result[:heuristic][:confidence]).to eq(Legion::Extensions::DualProcess::Helpers::Constants::DEFAULT_CONFIDENCE)
+    end
+  end
+
+  describe '#route_decision' do
+    it 'returns success: true' do
+      result = client.route_decision(query: 'test', domain: :work, complexity: 0.3)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a system key' do
+      result = client.route_decision(query: 'test', domain: :work, complexity: 0.3)
+      expect(Legion::Extensions::DualProcess::Helpers::Constants::SYSTEMS).to include(result[:system])
+    end
+
+    it 'returns a reason' do
+      result = client.route_decision(query: 'test', domain: :work, complexity: 0.3)
+      expect(result[:reason]).not_to be_nil
+    end
+  end
+
+  describe '#execute_system_one' do
+    it 'returns success: true' do
+      result = client.execute_system_one(query: 'test', domain: :work)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns system: :system_one' do
+      result = client.execute_system_one(query: 'test', domain: :work)
+      expect(result[:system]).to eq(:system_one)
+    end
+
+    it 'returns a decision_id' do
+      result = client.execute_system_one(query: 'test', domain: :work)
+      expect(result[:decision_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#execute_system_two' do
+    it 'returns success: true' do
+      result = client.execute_system_two(query: 'complex', domain: :work)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns system: :system_two' do
+      result = client.execute_system_two(query: 'complex', domain: :work)
+      expect(result[:system]).to eq(:system_two)
+    end
+
+    it 'returns a decision_id' do
+      result = client.execute_system_two(query: 'complex', domain: :work)
+      expect(result[:decision_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'accepts deliberation context' do
+      result = client.execute_system_two(
+        query: 'complex', domain: :work,
+        deliberation: { confidence: 0.9, response: :approved }
+      )
+      expect(result[:confidence]).to eq(0.9)
+      expect(result[:response]).to eq(:approved)
+    end
+  end
+
+  describe '#record_decision_outcome' do
+    it 'returns success for known decision' do
+      exec = client.execute_system_one(query: 'x', domain: :d)
+      result = client.record_decision_outcome(decision_id: exec[:decision_id], outcome: :correct)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown decision' do
+      result = client.record_decision_outcome(decision_id: 'bogus-id', outcome: :correct)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#effort_assessment' do
+    it 'returns success: true' do
+      result = client.effort_assessment
+      expect(result[:success]).to be true
+    end
+
+    it 'includes effort_level' do
+      result = client.effort_assessment
+      expect(result[:effort_level]).to be_between(0.0, 1.0)
+    end
+
+    it 'includes routing_label' do
+      result = client.effort_assessment
+      expect(result[:routing_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#best_heuristics' do
+    it 'returns success: true' do
+      result = client.best_heuristics
+      expect(result[:success]).to be true
+    end
+
+    it 'returns heuristics array' do
+      result = client.best_heuristics
+      expect(result[:heuristics]).to be_an(Array)
+    end
+
+    it 'respects custom limit' do
+      5.times do |i|
+        client.register_heuristic(pattern: "p#{i}", domain: :d, response: :r, confidence: 0.9)
+      end
+      engine = client.send(:engine)
+      engine.instance_variable_get(:@heuristics).each_value do |h|
+        5.times { h.use!(success: true) }
+      end
+      result = client.best_heuristics(limit: 2)
+      expect(result[:heuristics].size).to be <= 2
+    end
+  end
+
+  describe '#system_usage_stats' do
+    it 'returns success: true' do
+      result = client.system_usage_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes stats hash' do
+      result = client.system_usage_stats
+      expect(result[:stats]).to include(:system_one, :system_two, :total)
+    end
+  end
+
+  describe '#update_dual_process' do
+    it 'returns success: true' do
+      result = client.update_dual_process
+      expect(result[:success]).to be true
+    end
+
+    it 'recovers effort' do
+      client.execute_system_two(query: 'x', domain: :d)
+      before = client.effort_assessment[:effort_level]
+      client.update_dual_process
+      after = client.effort_assessment[:effort_level]
+      expect(after).to be >= before
+    end
+
+    it 'returns routing_label' do
+      result = client.update_dual_process
+      expect(result[:routing_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#dual_process_stats' do
+    it 'returns success: true' do
+      result = client.dual_process_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes full stats' do
+      result = client.dual_process_stats
+      expect(result).to include(:effort_budget, :effort_level, :routing_label,
+                                :heuristic_count, :decision_count, :system_stats)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+  end
+
+  module Extensions
+    module Helpers; end
+  end
+end
+
+require 'legion/extensions/dual_process'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: lex-dual-process
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+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: 'Kahneman''s Dual Process Theory for brain-modeled agentic AI: System
+  1 (fast/intuitive) vs System 2 (slow/deliberate)'
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lex-dual-process.gemspec
+- lib/legion/extensions/dual_process.rb
+- lib/legion/extensions/dual_process/client.rb
+- lib/legion/extensions/dual_process/helpers/constants.rb
+- lib/legion/extensions/dual_process/helpers/decision.rb
+- lib/legion/extensions/dual_process/helpers/dual_process_engine.rb
+- lib/legion/extensions/dual_process/helpers/heuristic.rb
+- lib/legion/extensions/dual_process/runners/dual_process.rb
+- lib/legion/extensions/dual_process/version.rb
+- spec/legion/extensions/dual_process/client_spec.rb
+- spec/legion/extensions/dual_process/helpers/constants_spec.rb
+- spec/legion/extensions/dual_process/helpers/decision_spec.rb
+- spec/legion/extensions/dual_process/helpers/dual_process_engine_spec.rb
+- spec/legion/extensions/dual_process/helpers/heuristic_spec.rb
+- spec/legion/extensions/dual_process/runners/dual_process_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-dual-process
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-dual-process
+  source_code_uri: https://github.com/LegionIO/lex-dual-process
+  documentation_uri: https://github.com/LegionIO/lex-dual-process
+  changelog_uri: https://github.com/LegionIO/lex-dual-process
+  bug_tracker_uri: https://github.com/LegionIO/lex-dual-process/issues
+  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: LEX Dual Process
+test_files: []