lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/apprenticeship/helpers/apprenticeship_model_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::ApprenticeshipModel do
+  subject(:model) { described_class }
+
+  describe 'constants' do
+    it 'defines METHODS with six items' do
+      expect(model::METHODS.size).to eq(6)
+      expect(model::METHODS).to include(:modeling, :coaching, :scaffolding, :articulation, :reflection, :exploration)
+    end
+
+    it 'defines MASTERY_THRESHOLD as 0.85' do
+      expect(model::MASTERY_THRESHOLD).to eq(0.85)
+    end
+
+    it 'defines LEARNING_GAIN as 0.08' do
+      expect(model::LEARNING_GAIN).to eq(0.08)
+    end
+
+    it 'defines EXPLORATION_MULTIPLIER as 2.0' do
+      expect(model::EXPLORATION_MULTIPLIER).to eq(2.0)
+    end
+
+    it 'defines COACHING_MULTIPLIER as 1.5' do
+      expect(model::COACHING_MULTIPLIER).to eq(1.5)
+    end
+
+    it 'defines DECAY_RATE as 0.01' do
+      expect(model::DECAY_RATE).to eq(0.01)
+    end
+  end
+
+  describe '.phase_for' do
+    it 'returns :modeling for mastery 0.0..0.19' do
+      expect(model.phase_for(0.0)).to eq(:modeling)
+      expect(model.phase_for(0.1)).to eq(:modeling)
+    end
+
+    it 'returns :coaching for mastery 0.2..0.39' do
+      expect(model.phase_for(0.2)).to eq(:coaching)
+      expect(model.phase_for(0.3)).to eq(:coaching)
+    end
+
+    it 'returns :scaffolding for mastery 0.4..0.59' do
+      expect(model.phase_for(0.4)).to eq(:scaffolding)
+    end
+
+    it 'returns :articulation for mastery 0.6..0.74' do
+      expect(model.phase_for(0.6)).to eq(:articulation)
+    end
+
+    it 'returns :reflection for mastery 0.75..0.84' do
+      expect(model.phase_for(0.75)).to eq(:reflection)
+    end
+
+    it 'returns :exploration for mastery >= 0.85' do
+      expect(model.phase_for(0.85)).to eq(:exploration)
+      expect(model.phase_for(1.0)).to eq(:exploration)
+    end
+  end
+
+  describe '.mastery_label_for' do
+    it 'returns :novice for mastery < 0.2' do
+      expect(model.mastery_label_for(0.1)).to eq(:novice)
+    end
+
+    it 'returns :apprentice for mastery 0.2..0.39' do
+      expect(model.mastery_label_for(0.3)).to eq(:apprentice)
+    end
+
+    it 'returns :intermediate for mastery 0.4..0.59' do
+      expect(model.mastery_label_for(0.5)).to eq(:intermediate)
+    end
+
+    it 'returns :proficient for mastery 0.6..0.79' do
+      expect(model.mastery_label_for(0.7)).to eq(:proficient)
+    end
+
+    it 'returns :expert for mastery >= 0.8' do
+      expect(model.mastery_label_for(0.9)).to eq(:expert)
+    end
+  end
+
+  describe '.clamp_mastery' do
+    it 'floors at MASTERY_FLOOR' do
+      expect(model.clamp_mastery(-0.5)).to eq(0.0)
+    end
+
+    it 'caps at MASTERY_CEILING' do
+      expect(model.clamp_mastery(1.5)).to eq(1.0)
+    end
+
+    it 'passes through valid values' do
+      expect(model.clamp_mastery(0.5)).to eq(0.5)
+    end
+  end
+
+  describe '.new_apprenticeship' do
+    let(:entry) do
+      model.new_apprenticeship(
+        skill_name:    'ruby',
+        domain:        'programming',
+        mentor_id:     'mentor-1',
+        apprentice_id: 'apprentice-1'
+      )
+    end
+
+    it 'sets default mastery' do
+      expect(entry[:mastery]).to eq(model::DEFAULT_MASTERY)
+    end
+
+    it 'sets current_phase from mastery' do
+      expect(entry[:current_phase]).to eq(model.phase_for(model::DEFAULT_MASTERY))
+    end
+
+    it 'generates a uuid id' do
+      expect(entry[:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets session_count to 0' do
+      expect(entry[:session_count]).to eq(0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/apprenticeship/helpers/apprenticeship_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::Apprenticeship do
+  let(:appr) do
+    described_class.new(
+      skill_name:    'ruby',
+      domain:        'programming',
+      mentor_id:     'mentor-1',
+      apprentice_id: 'apprentice-1'
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets skill_name' do
+      expect(appr.skill_name).to eq('ruby')
+    end
+
+    it 'sets domain' do
+      expect(appr.domain).to eq('programming')
+    end
+
+    it 'starts at DEFAULT_MASTERY' do
+      expect(appr.mastery).to eq(Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::ApprenticeshipModel::DEFAULT_MASTERY)
+    end
+
+    it 'starts with zero sessions' do
+      expect(appr.session_count).to eq(0)
+    end
+
+    it 'generates a uuid' do
+      expect(appr.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#current_phase' do
+    it 'returns :modeling at default mastery' do
+      expect(appr.current_phase).to eq(:modeling)
+    end
+  end
+
+  describe '#mastery_label' do
+    it 'returns :novice at default mastery' do
+      expect(appr.mastery_label).to eq(:novice)
+    end
+  end
+
+  describe '#graduated?' do
+    it 'returns false below threshold' do
+      expect(appr.graduated?).to be false
+    end
+
+    it 'returns true at threshold' do
+      30.times { appr.learn!(method: :exploration, success: true) }
+      expect(appr.graduated?).to be true
+    end
+  end
+
+  describe '#recommended_method' do
+    it 'returns :modeling at default mastery' do
+      expect(appr.recommended_method).to eq(:modeling)
+    end
+  end
+
+  describe '#learn!' do
+    it 'increases mastery on success' do
+      before = appr.mastery
+      appr.learn!(method: :modeling, success: true)
+      expect(appr.mastery).to be > before
+    end
+
+    it 'does not increase mastery on failure' do
+      before = appr.mastery
+      appr.learn!(method: :modeling, success: false)
+      expect(appr.mastery).to eq(before)
+    end
+
+    it 'applies exploration multiplier' do
+      a1 = described_class.new(skill_name: 'skill', domain: 'dom', mentor_id: 'mtr', apprentice_id: 'app')
+      a2 = described_class.new(skill_name: 'skill', domain: 'dom', mentor_id: 'mtr', apprentice_id: 'app')
+      a1.learn!(method: :modeling, success: true)
+      a2.learn!(method: :exploration, success: true)
+      expect(a2.mastery).to be > a1.mastery
+    end
+
+    it 'applies coaching multiplier' do
+      a1 = described_class.new(skill_name: 'skill', domain: 'dom', mentor_id: 'mtr', apprentice_id: 'app')
+      a2 = described_class.new(skill_name: 'skill', domain: 'dom', mentor_id: 'mtr', apprentice_id: 'app')
+      a1.learn!(method: :modeling, success: true)
+      a2.learn!(method: :coaching, success: true)
+      expect(a2.mastery).to be > a1.mastery
+    end
+
+    it 'increments session_count' do
+      appr.learn!(method: :scaffolding, success: true)
+      expect(appr.session_count).to eq(1)
+    end
+
+    it 'clamps mastery at ceiling' do
+      100.times { appr.learn!(method: :exploration, success: true) }
+      expect(appr.mastery).to be <= 1.0
+    end
+
+    it 'updates last_session_at' do
+      appr.learn!(method: :reflection, success: true)
+      expect(appr.last_session_at).not_to be_nil
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces mastery' do
+      appr.learn!(method: :exploration, success: true)
+      before = appr.mastery
+      appr.decay!
+      expect(appr.mastery).to be < before
+    end
+
+    it 'clamps at floor' do
+      100.times { appr.decay! }
+      expect(appr.mastery).to be >= 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = appr.to_h
+      expect(h).to include(:id, :skill_name, :domain, :mentor_id, :apprentice_id,
+                           :mastery, :current_phase, :mastery_label, :graduated,
+                           :session_count, :created_at, :last_session_at)
+    end
+
+    it 'reflects graduated status' do
+      30.times { appr.learn!(method: :exploration, success: true) }
+      expect(appr.to_h[:graduated]).to be true
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/apprenticeship/runners/cognitive_apprenticeship_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/apprenticeship/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Apprenticeship::Runners::CognitiveApprenticeship do
+  let(:client) { Legion::Extensions::Agentic::Social::Apprenticeship::Client.new }
+
+  let(:valid_params) do
+    {
+      skill_name:    'ruby',
+      domain:        'programming',
+      mentor_id:     'mentor-1',
+      apprentice_id: 'learner-1'
+    }
+  end
+
+  def create_one
+    client.create_apprenticeship(**valid_params)
+  end
+
+  describe '#create_apprenticeship' do
+    it 'returns success: true with a valid apprenticeship hash' do
+      result = create_one
+      expect(result[:success]).to be true
+      expect(result[:apprenticeship]).to include(:id, :skill_name, :mastery)
+    end
+
+    it 'returns success: false when a param is too short' do
+      result = client.create_apprenticeship(skill_name: 'ab', domain: 'dom', mentor_id: 'mtr', apprentice_id: 'app')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:param_too_short)
+    end
+  end
+
+  describe '#conduct_apprenticeship_session' do
+    it 'returns success: true and updated mastery' do
+      created = create_one
+      id = created[:apprenticeship][:id]
+      result = client.conduct_apprenticeship_session(apprenticeship_id: id, method: :modeling, success: true)
+      expect(result[:success]).to be true
+      expect(result[:apprenticeship][:mastery]).to be > 0.1
+    end
+
+    it 'returns success: false for unknown apprenticeship' do
+      result = client.conduct_apprenticeship_session(apprenticeship_id: 'nope', method: :modeling, success: true)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'returns success: false for invalid method' do
+      created = create_one
+      id = created[:apprenticeship][:id]
+      result = client.conduct_apprenticeship_session(apprenticeship_id: id, method: :unknown, success: true)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:invalid_method)
+    end
+
+    it 'accepts all six valid methods' do
+      Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::ApprenticeshipModel::METHODS.each do |method|
+        c = Legion::Extensions::Agentic::Social::Apprenticeship::Client.new
+        created = c.create_apprenticeship(**valid_params)
+        id = created[:apprenticeship][:id]
+        result = c.conduct_apprenticeship_session(apprenticeship_id: id, method: method, success: true)
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  describe '#recommend_apprenticeship_method' do
+    it 'returns success: true with a valid method' do
+      created = create_one
+      id = created[:apprenticeship][:id]
+      result = client.recommend_apprenticeship_method(apprenticeship_id: id)
+      expect(result[:success]).to be true
+      expect(Legion::Extensions::Agentic::Social::Apprenticeship::Helpers::ApprenticeshipModel::METHODS).to include(result[:recommended_method])
+    end
+
+    it 'returns success: false for unknown apprenticeship' do
+      result = client.recommend_apprenticeship_method(apprenticeship_id: 'nope')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#graduated_apprenticeships' do
+    it 'returns success: true and an empty list initially' do
+      result = client.graduated_apprenticeships
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'includes graduated apprenticeships' do
+      created = create_one
+      id = created[:apprenticeship][:id]
+      30.times { client.conduct_apprenticeship_session(apprenticeship_id: id, method: :exploration, success: true) }
+      result = client.graduated_apprenticeships
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#active_apprenticeships' do
+    it 'returns the newly created apprenticeship' do
+      create_one
+      result = client.active_apprenticeships
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#mentor_apprenticeships' do
+    it 'returns apprenticeships for the mentor' do
+      create_one
+      result = client.mentor_apprenticeships(mentor_id: 'mentor-1')
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#apprentice_apprenticeships' do
+    it 'returns apprenticeships for the apprentice' do
+      create_one
+      result = client.apprentice_apprenticeships(apprentice_id: 'learner-1')
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#domain_apprenticeships' do
+    it 'returns apprenticeships for the domain' do
+      create_one
+      result = client.domain_apprenticeships(domain: 'programming')
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#update_cognitive_apprenticeship' do
+    it 'delegates to conduct_apprenticeship_session' do
+      created = create_one
+      id = created[:apprenticeship][:id]
+      result = client.update_cognitive_apprenticeship(apprenticeship_id: id, method: :coaching, success: true)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#cognitive_apprenticeship_stats' do
+    it 'returns success: true with stats' do
+      create_one
+      result = client.cognitive_apprenticeship_stats
+      expect(result[:success]).to be true
+      expect(result[:total]).to eq(1)
+      expect(result).to include(:active, :graduated, :sessions)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/conflict/actors/stale_check_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every; end # rubocop:disable Lint/EmptyClass
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/social/conflict/actors/stale_check'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conflict::Actor::StaleCheck do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Social::Conflict::Runners::Conflict }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'check_stale_conflicts' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 3600 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

data/spec/legion/extensions/agentic/social/conflict/client_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/conflict/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conflict::Client do
+  it 'responds to conflict runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:register_conflict)
+    expect(client).to respond_to(:add_exchange)
+    expect(client).to respond_to(:resolve_conflict)
+    expect(client).to respond_to(:get_conflict)
+    expect(client).to respond_to(:active_conflicts)
+    expect(client).to respond_to(:recommended_posture)
+  end
+end