lex-mind-growth 0.1.0

data/spec/legion/extensions/mind_growth/helpers/build_pipeline_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Helpers::BuildPipeline do
+  let(:proposal) do
+    Legion::Extensions::MindGrowth::Helpers::ConceptProposal.new(
+      name:        'lex-pipeline-test',
+      module_name: 'PipelineTest',
+      category:    :cognition,
+      description: 'Test proposal for build pipeline'
+    )
+  end
+
+  subject(:pipeline) { described_class.new(proposal) }
+
+  describe '#initialize' do
+    it 'starts at scaffold stage' do
+      expect(pipeline.stage).to eq(:scaffold)
+    end
+
+    it 'has empty errors' do
+      expect(pipeline.errors).to be_empty
+    end
+
+    it 'records started_at' do
+      expect(pipeline.started_at).to be_a(Time)
+    end
+
+    it 'leaves completed_at nil' do
+      expect(pipeline.completed_at).to be_nil
+    end
+  end
+
+  describe '#advance!' do
+    context 'with successful result' do
+      it 'advances to next stage' do
+        pipeline.advance!({ success: true })
+        expect(pipeline.stage).to eq(:implement)
+      end
+
+      it 'progresses through all stages' do
+        described_class::STAGES[0...-2].each do
+          pipeline.advance!({ success: true })
+        end
+        expect(pipeline.stage).to eq(:complete)
+      end
+
+      it 'sets completed_at on :complete' do
+        described_class::STAGES[0...-2].each do
+          pipeline.advance!({ success: true })
+        end
+        expect(pipeline.completed_at).to be_a(Time)
+      end
+    end
+
+    context 'with failed result' do
+      it 'records the error' do
+        pipeline.advance!({ success: false, error: 'something went wrong' })
+        expect(pipeline.errors.size).to eq(1)
+        expect(pipeline.errors.first[:error]).to eq('something went wrong')
+      end
+
+      it 'does not advance stage on failure' do
+        pipeline.advance!({ success: false, error: 'err' })
+        expect(pipeline.stage).to eq(:scaffold)
+      end
+
+      it 'transitions to :failed after MAX_FIX_ATTEMPTS errors' do
+        Legion::Extensions::MindGrowth::Helpers::Constants::MAX_FIX_ATTEMPTS.times do
+          pipeline.advance!({ success: false, error: 'repeated error' })
+        end
+        expect(pipeline.stage).to eq(:failed)
+      end
+
+      it 'records stage in each error entry' do
+        pipeline.advance!({ success: false, error: 'err' })
+        expect(pipeline.errors.first[:stage]).to eq(:scaffold)
+      end
+
+      it 'records timestamp in each error entry' do
+        pipeline.advance!({ success: false, error: 'err' })
+        expect(pipeline.errors.first[:at]).to be_a(Time)
+      end
+    end
+
+    context 'when already complete' do
+      before do
+        described_class::STAGES[0...-2].each { pipeline.advance!({ success: true }) }
+      end
+
+      it 'ignores further advance! calls' do
+        pipeline.advance!({ success: true })
+        expect(pipeline.stage).to eq(:complete)
+      end
+
+      it 'does not add errors after completion' do
+        pipeline.advance!({ success: false, error: 'too late' })
+        expect(pipeline.errors).to be_empty
+      end
+    end
+
+    context 'when already failed' do
+      before do
+        Legion::Extensions::MindGrowth::Helpers::Constants::MAX_FIX_ATTEMPTS.times do
+          pipeline.advance!({ success: false, error: 'err' })
+        end
+      end
+
+      it 'ignores further advance! calls with success' do
+        pipeline.advance!({ success: true })
+        expect(pipeline.stage).to eq(:failed)
+      end
+
+      it 'does not accumulate more errors' do
+        count_before = pipeline.errors.size
+        pipeline.advance!({ success: false, error: 'extra' })
+        expect(pipeline.errors.size).to eq(count_before)
+      end
+    end
+  end
+
+  describe '#complete?' do
+    it 'returns false initially' do
+      expect(pipeline.complete?).to be false
+    end
+
+    it 'returns true after all stages complete' do
+      described_class::STAGES[0...-2].each do
+        pipeline.advance!({ success: true })
+      end
+      expect(pipeline.complete?).to be true
+    end
+  end
+
+  describe '#failed?' do
+    it 'returns false initially' do
+      expect(pipeline.failed?).to be false
+    end
+
+    it 'returns true after MAX_FIX_ATTEMPTS failures' do
+      Legion::Extensions::MindGrowth::Helpers::Constants::MAX_FIX_ATTEMPTS.times do
+        pipeline.advance!({ success: false, error: 'err' })
+      end
+      expect(pipeline.failed?).to be true
+    end
+  end
+
+  describe '#duration_ms' do
+    it 'returns a non-negative integer' do
+      expect(pipeline.duration_ms).to be >= 0
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes proposal_id' do
+      expect(pipeline.to_h[:proposal_id]).to eq(proposal.id)
+    end
+
+    it 'includes current stage' do
+      expect(pipeline.to_h[:stage]).to eq(:scaffold)
+    end
+
+    it 'includes errors array' do
+      expect(pipeline.to_h[:errors]).to eq([])
+    end
+
+    it 'includes duration_ms' do
+      expect(pipeline.to_h[:duration_ms]).to be >= 0
+    end
+
+    it 'includes artifacts hash' do
+      expect(pipeline.to_h[:artifacts]).to eq({})
+    end
+
+    it 'records artifacts for completed stages' do
+      pipeline.advance!({ success: true, path: '/tmp/lex-test' })
+      expect(pipeline.to_h[:artifacts][:scaffold]).to include(path: '/tmp/lex-test')
+    end
+  end
+
+  describe '#artifacts' do
+    it 'is empty initially' do
+      expect(pipeline.artifacts).to eq({})
+    end
+
+    it 'stores artifact for each successful stage' do
+      pipeline.advance!({ success: true, files: 12 })
+      expect(pipeline.artifacts[:scaffold][:files]).to eq(12)
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/helpers/cognitive_models_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Helpers::CognitiveModels do
+  subject(:models) { described_class }
+
+  describe '.gap_analysis' do
+    context 'with no existing extensions' do
+      it 'returns analysis for all cognitive models' do
+        result = models.gap_analysis([])
+        expect(result.size).to eq(5)
+      end
+
+      it 'reports zero coverage for all models' do
+        result = models.gap_analysis([])
+        result.each do |entry|
+          expect(entry[:coverage]).to eq(0.0)
+        end
+      end
+
+      it 'lists all required components as missing' do
+        result = models.gap_analysis([])
+        entry = result.find { |r| r[:model] == :global_workspace }
+        expect(entry[:missing]).to eq(%i[attention global_workspace broadcasting working_memory consciousness])
+      end
+    end
+
+    context 'with partial extensions' do
+      it 'calculates partial coverage' do
+        result = models.gap_analysis(%i[attention working_memory])
+        gw = result.find { |r| r[:model] == :global_workspace }
+        # has attention + working_memory out of 5 required = 0.40
+        expect(gw[:coverage]).to eq(0.4)
+      end
+
+      it 'removes matched components from missing list' do
+        result = models.gap_analysis(%i[attention])
+        gw = result.find { |r| r[:model] == :global_workspace }
+        expect(gw[:missing]).not_to include(:attention)
+      end
+    end
+
+    context 'with full coverage' do
+      it 'reports coverage of 1.0 when all required present' do
+        result = models.gap_analysis(%i[attention global_workspace broadcasting working_memory consciousness])
+        gw = result.find { |r| r[:model] == :global_workspace }
+        expect(gw[:coverage]).to eq(1.0)
+        expect(gw[:missing]).to be_empty
+      end
+    end
+
+    it 'includes model name in each entry' do
+      result = models.gap_analysis([])
+      result.each do |entry|
+        expect(entry[:name]).to be_a(String)
+        expect(entry[:name]).not_to be_empty
+      end
+    end
+
+    it 'includes total_required in each entry' do
+      result = models.gap_analysis([])
+      gw = result.find { |r| r[:model] == :global_workspace }
+      expect(gw[:total_required]).to eq(5)
+    end
+  end
+
+  describe '.recommend_from_gaps' do
+    it 'returns symbols most commonly missing across models' do
+      gaps = models.gap_analysis([])
+      recommendations = models.recommend_from_gaps(gaps)
+      expect(recommendations).to be_an(Array)
+      expect(recommendations).not_to be_empty
+      expect(recommendations.first).to be_a(Symbol)
+    end
+
+    it 'returns components missing in multiple models first' do
+      # attention appears in global_workspace and working_memory
+      gaps = models.gap_analysis([])
+      recommendations = models.recommend_from_gaps(gaps)
+      expect(recommendations).to include(:attention)
+      expect(recommendations).to include(:working_memory)
+    end
+
+    it 'returns empty array when no gaps' do
+      all_required = described_class::MODELS.values.flat_map { |m| m[:required] }.uniq
+      gaps = models.gap_analysis(all_required)
+      recommendations = models.recommend_from_gaps(gaps)
+      expect(recommendations).to be_empty
+    end
+  end
+
+  describe 'MODELS constant' do
+    it 'contains all five reference models' do
+      expect(described_class::MODELS.keys).to contain_exactly(
+        :global_workspace, :free_energy, :dual_process, :somatic_marker, :working_memory
+      )
+    end
+
+    it 'each model has required, name, and description' do
+      described_class::MODELS.each_value do |model|
+        expect(model[:required]).to be_an(Array)
+        expect(model[:name]).to be_a(String)
+        expect(model[:description]).to be_a(String)
+      end
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/helpers/concept_proposal_spec.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Helpers::ConceptProposal do
+  let(:valid_params) do
+    {
+      name:        'lex-attention',
+      module_name: 'Attention',
+      category:    :cognition,
+      description: 'Attention gating for cognitive load management'
+    }
+  end
+
+  subject(:proposal) { described_class.new(**valid_params) }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(proposal.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets name' do
+      expect(proposal.name).to eq('lex-attention')
+    end
+
+    it 'sets module_name' do
+      expect(proposal.module_name).to eq('Attention')
+    end
+
+    it 'converts category to symbol' do
+      expect(proposal.category).to eq(:cognition)
+    end
+
+    it 'sets description' do
+      expect(proposal.description).to eq('Attention gating for cognitive load management')
+    end
+
+    it 'defaults metaphor to nil' do
+      expect(proposal.metaphor).to be_nil
+    end
+
+    it 'defaults helpers to empty array' do
+      expect(proposal.helpers).to eq([])
+    end
+
+    it 'defaults runner_methods to empty array' do
+      expect(proposal.runner_methods).to eq([])
+    end
+
+    it 'defaults rationale to nil' do
+      expect(proposal.rationale).to be_nil
+    end
+
+    it 'initializes scores to empty hash' do
+      expect(proposal.scores).to eq({})
+    end
+
+    it 'sets initial status to :proposed' do
+      expect(proposal.status).to eq(:proposed)
+    end
+
+    it 'defaults origin to :proposer' do
+      expect(proposal.origin).to eq(:proposer)
+    end
+
+    it 'sets created_at to a Time' do
+      expect(proposal.created_at).to be_a(Time)
+    end
+
+    it 'leaves evaluated_at nil' do
+      expect(proposal.evaluated_at).to be_nil
+    end
+
+    it 'leaves built_at nil' do
+      expect(proposal.built_at).to be_nil
+    end
+
+    it 'accepts optional metaphor' do
+      p = described_class.new(**valid_params, metaphor: 'spotlight')
+      expect(p.metaphor).to eq('spotlight')
+    end
+
+    it 'accepts optional rationale' do
+      p = described_class.new(**valid_params, rationale: 'fills gap in model')
+      expect(p.rationale).to eq('fills gap in model')
+    end
+
+    it 'accepts custom origin' do
+      p = described_class.new(**valid_params, origin: :manual)
+      expect(p.origin).to eq(:manual)
+    end
+  end
+
+  describe '#evaluate!' do
+    let(:passing_scores) do
+      Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.75] }
+    end
+
+    let(:failing_scores) do
+      Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.5] }
+    end
+
+    it 'sets scores' do
+      proposal.evaluate!(passing_scores)
+      expect(proposal.scores).to eq(passing_scores)
+    end
+
+    it 'sets evaluated_at' do
+      proposal.evaluate!(passing_scores)
+      expect(proposal.evaluated_at).to be_a(Time)
+    end
+
+    it 'approves when all scores >= MIN_DIMENSION_SCORE' do
+      proposal.evaluate!(passing_scores)
+      expect(proposal.status).to eq(:approved)
+    end
+
+    it 'rejects when any score < MIN_DIMENSION_SCORE' do
+      proposal.evaluate!(failing_scores)
+      expect(proposal.status).to eq(:rejected)
+    end
+  end
+
+  describe '#passing_evaluation?' do
+    it 'returns false with empty scores' do
+      expect(proposal.passing_evaluation?).to be false
+    end
+
+    it 'returns true when all dimensions meet threshold' do
+      scores = Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.65] }
+      proposal.evaluate!(scores)
+      expect(proposal.passing_evaluation?).to be true
+    end
+
+    it 'returns false when any dimension is below threshold' do
+      scores = Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.65] }
+      scores[scores.keys.first] = 0.4
+      proposal.evaluate!(scores)
+      expect(proposal.passing_evaluation?).to be false
+    end
+  end
+
+  describe '#auto_approvable?' do
+    it 'returns false with empty scores' do
+      expect(proposal.auto_approvable?).to be false
+    end
+
+    it 'returns true when all dimensions meet AUTO_APPROVE_THRESHOLD' do
+      scores = Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.95] }
+      proposal.evaluate!(scores)
+      expect(proposal.auto_approvable?).to be true
+    end
+
+    it 'returns false when any dimension is below AUTO_APPROVE_THRESHOLD' do
+      scores = Legion::Extensions::MindGrowth::Helpers::Constants::EVALUATION_DIMENSIONS.to_h { |d| [d, 0.95] }
+      scores[scores.keys.first] = 0.8
+      proposal.evaluate!(scores)
+      expect(proposal.auto_approvable?).to be false
+    end
+  end
+
+  describe '#transition!' do
+    it 'updates status' do
+      proposal.transition!(:building)
+      expect(proposal.status).to eq(:building)
+    end
+
+    it 'sets built_at when transitioning to :passing' do
+      proposal.transition!(:passing)
+      expect(proposal.built_at).to be_a(Time)
+    end
+
+    it 'does not set built_at for other statuses' do
+      proposal.transition!(:building)
+      expect(proposal.built_at).to be_nil
+    end
+
+    it 'accepts string status and converts to symbol' do
+      proposal.transition!('building')
+      expect(proposal.status).to eq(:building)
+    end
+
+    it 'raises ArgumentError for invalid status' do
+      expect { proposal.transition!(:banana) }.to raise_error(ArgumentError, /invalid status.*banana/)
+    end
+
+    it 'accepts all valid PROPOSAL_STATUSES' do
+      Legion::Extensions::MindGrowth::Helpers::Constants::PROPOSAL_STATUSES.each do |status|
+        p = described_class.new(**valid_params)
+        expect { p.transition!(status) }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all FIELDS' do
+      h = proposal.to_h
+      described_class::FIELDS.each do |f|
+        expect(h).to have_key(f)
+      end
+    end
+
+    it 'includes the id' do
+      expect(proposal.to_h[:id]).to eq(proposal.id)
+    end
+
+    it 'includes category as symbol' do
+      expect(proposal.to_h[:category]).to eq(:cognition)
+    end
+  end
+end

data/spec/legion/extensions/mind_growth/helpers/fitness_evaluator_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::MindGrowth::Helpers::FitnessEvaluator do
+  subject(:evaluator) { described_class }
+
+  let(:healthy_extension) do
+    {
+      invocation_count: 500,
+      impact_score:     0.8,
+      health_score:     0.95,
+      error_rate:       0.02,
+      avg_latency_ms:   100
+    }
+  end
+
+  let(:poor_extension) do
+    {
+      invocation_count: 0,
+      impact_score:     0.1,
+      health_score:     0.3,
+      error_rate:       0.8,
+      avg_latency_ms:   4000
+    }
+  end
+
+  let(:default_extension) { {} }
+
+  describe '.fitness' do
+    it 'returns a float between 0 and 1' do
+      score = evaluator.fitness(healthy_extension)
+      expect(score).to be_between(0.0, 1.0)
+    end
+
+    it 'returns higher score for healthy extension' do
+      healthy_score = evaluator.fitness(healthy_extension)
+      poor_score    = evaluator.fitness(poor_extension)
+      expect(healthy_score).to be > poor_score
+    end
+
+    it 'returns a score for default extension with all defaults' do
+      score = evaluator.fitness(default_extension)
+      expect(score).to be_between(0.0, 1.0)
+    end
+
+    it 'returns a rounded value (3 decimal places)' do
+      score = evaluator.fitness(healthy_extension)
+      expect(score.to_s.split('.').last.length).to be <= 3
+    end
+
+    it 'clamps score to 0.0 minimum' do
+      very_bad = { invocation_count: 0, impact_score: 0.0, health_score: 0.0, error_rate: 1.0, avg_latency_ms: 5000 }
+      expect(evaluator.fitness(very_bad)).to be >= 0.0
+    end
+
+    it 'clamps score to 1.0 maximum' do
+      perfect = { invocation_count: 10_000, impact_score: 1.0, health_score: 1.0, error_rate: 0.0, avg_latency_ms: 0 }
+      expect(evaluator.fitness(perfect)).to be <= 1.0
+    end
+  end
+
+  describe '.rank' do
+    let(:extensions) { [poor_extension, healthy_extension] }
+
+    it 'returns extensions sorted by fitness descending' do
+      ranked = evaluator.rank(extensions)
+      expect(ranked.first[:fitness]).to be > ranked.last[:fitness]
+    end
+
+    it 'adds fitness key to each extension' do
+      ranked = evaluator.rank(extensions)
+      ranked.each do |e|
+        expect(e).to have_key(:fitness)
+      end
+    end
+
+    it 'does not modify original extensions' do
+      evaluator.rank(extensions)
+      expect(healthy_extension).not_to have_key(:fitness)
+    end
+  end
+
+  describe '.prune_candidates' do
+    it 'returns extensions with fitness below PRUNE_THRESHOLD' do
+      result = evaluator.prune_candidates([poor_extension, healthy_extension])
+      expect(result).to include(poor_extension)
+      expect(result).not_to include(healthy_extension)
+    end
+
+    it 'returns empty array when none qualify' do
+      expect(evaluator.prune_candidates([healthy_extension])).to be_empty
+    end
+  end
+
+  describe '.improvement_candidates' do
+    let(:mediocre_extension) do
+      {
+        invocation_count: 10,
+        impact_score:     0.35,
+        health_score:     0.6,
+        error_rate:       0.15,
+        avg_latency_ms:   500
+      }
+    end
+
+    it 'returns extensions between PRUNE_THRESHOLD and IMPROVEMENT_THRESHOLD' do
+      result = evaluator.improvement_candidates([mediocre_extension, poor_extension, healthy_extension])
+      # mediocre should fall in the improvement range; poor below prune; healthy above improvement
+      fitness_values = result.map { |e| evaluator.fitness(e) }
+      fitness_values.each do |f|
+        expect(f).to be >= Legion::Extensions::MindGrowth::Helpers::Constants::PRUNE_THRESHOLD
+        expect(f).to be < Legion::Extensions::MindGrowth::Helpers::Constants::IMPROVEMENT_THRESHOLD
+      end
+    end
+  end
+
+  describe 'log-scale invocation normalization' do
+    it 'maps zero invocations to 0.0' do
+      score_zero = evaluator.fitness({ invocation_count: 0, impact_score: 0.5, health_score: 1.0, error_rate: 0.0, avg_latency_ms: 0 })
+      score_some = evaluator.fitness({ invocation_count: 100, impact_score: 0.5, health_score: 1.0, error_rate: 0.0, avg_latency_ms: 0 })
+      expect(score_some).to be > score_zero
+    end
+  end
+end