lex-cognitive-debugging 0.1.0

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDebugging
+      module Runners
+        module CognitiveDebugging
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def detect_error(error_type:, description:, severity:, source_phase:, confidence_at_detection: 0.5, **)
+            unless Helpers::Constants::ERROR_TYPES.include?(error_type)
+              Legion::Logging.debug "[cognitive_debugging] detect_error: invalid error_type=#{error_type}"
+              return { success: false, error: :invalid_error_type, valid: Helpers::Constants::ERROR_TYPES }
+            end
+
+            err = engine.detect_error(
+              error_type:              error_type,
+              description:             description,
+              severity:                severity,
+              source_phase:            source_phase,
+              confidence_at_detection: confidence_at_detection
+            )
+
+            if err
+              Legion::Logging.info "[cognitive_debugging] error detected: id=#{err.id[0..7]} type=#{error_type} " \
+                                   "phase=#{source_phase} severity=#{err.severity_label}"
+              { success: true, error_id: err.id, error_type: error_type, severity_label: err.severity_label }
+            else
+              Legion::Logging.warn '[cognitive_debugging] detect_error: engine returned nil (cap reached?)'
+              { success: false, error: :cap_reached }
+            end
+          end
+
+          def trace_error(error_id:, steps:, root_cause:, confidence: 0.5, **)
+            trace = engine.trace_error(
+              error_id:   error_id,
+              steps:      steps,
+              root_cause: root_cause,
+              confidence: confidence
+            )
+
+            if trace
+              Legion::Logging.info "[cognitive_debugging] error traced: error_id=#{error_id[0..7]} " \
+                                   "trace_id=#{trace.id[0..7]} depth=#{trace.depth} root_cause=#{root_cause}"
+              { success: true, trace_id: trace.id, depth: trace.depth, root_cause: root_cause }
+            else
+              Legion::Logging.debug "[cognitive_debugging] trace_error: error_id=#{error_id[0..7]} not found or cap"
+              { success: false, error: :not_found_or_cap }
+            end
+          end
+
+          def propose_correction(error_id:, strategy:, description:, **)
+            unless Helpers::Constants::CORRECTION_STRATEGIES.include?(strategy)
+              Legion::Logging.debug "[cognitive_debugging] propose_correction: invalid strategy=#{strategy}"
+              return { success: false, error: :invalid_strategy, valid: Helpers::Constants::CORRECTION_STRATEGIES }
+            end
+
+            correction = engine.propose_correction(error_id: error_id, strategy: strategy, description: description)
+
+            if correction
+              Legion::Logging.info "[cognitive_debugging] correction proposed: error_id=#{error_id[0..7]} " \
+                                   "correction_id=#{correction.id[0..7]} strategy=#{strategy}"
+              { success: true, correction_id: correction.id, strategy: strategy }
+            else
+              Legion::Logging.debug "[cognitive_debugging] propose_correction: error_id=#{error_id[0..7]} not found"
+              { success: false, error: :not_found }
+            end
+          end
+
+          def apply_correction(correction_id:, **)
+            correction = engine.apply_correction(correction_id: correction_id)
+
+            if correction
+              Legion::Logging.info "[cognitive_debugging] correction applied: id=#{correction_id[0..7]}"
+              { success: true, correction_id: correction_id, applied: true }
+            else
+              Legion::Logging.debug "[cognitive_debugging] apply_correction: id=#{correction_id[0..7]} not found"
+              { success: false, error: :not_found }
+            end
+          end
+
+          def measure_correction(correction_id:, effectiveness:, **)
+            correction = engine.measure_correction(correction_id: correction_id, effectiveness: effectiveness)
+
+            if correction
+              Legion::Logging.info "[cognitive_debugging] correction measured: id=#{correction_id[0..7]} " \
+                                   "effectiveness=#{correction.effectiveness} effective=#{correction.effective?}"
+              { success: true, correction_id: correction_id, effectiveness: correction.effectiveness,
+                effective: correction.effective? }
+            else
+              Legion::Logging.debug "[cognitive_debugging] measure_correction: id=#{correction_id[0..7]} not found"
+              { success: false, error: :not_found }
+            end
+          end
+
+          def resolve_error(error_id:, **)
+            err = engine.resolve_error(error_id: error_id)
+
+            if err
+              Legion::Logging.info "[cognitive_debugging] error resolved: id=#{error_id[0..7]}"
+              { success: true, error_id: error_id, resolved: true }
+            else
+              Legion::Logging.debug "[cognitive_debugging] resolve_error: id=#{error_id[0..7]} not found"
+              { success: false, error: :not_found }
+            end
+          end
+
+          def active_errors(**)
+            errors = engine.active_errors
+            Legion::Logging.debug "[cognitive_debugging] active_errors: count=#{errors.size}"
+            { success: true, errors: errors.map(&:to_h), count: errors.size }
+          end
+
+          def resolved_errors(**)
+            errors = engine.resolved_errors
+            Legion::Logging.debug "[cognitive_debugging] resolved_errors: count=#{errors.size}"
+            { success: true, errors: errors.map(&:to_h), count: errors.size }
+          end
+
+          def errors_by_type(**)
+            tally = engine.errors_by_type
+            Legion::Logging.debug "[cognitive_debugging] errors_by_type: types=#{tally.keys.join(',')}"
+            { success: true, tally: tally }
+          end
+
+          def errors_by_phase(**)
+            tally = engine.errors_by_phase
+            Legion::Logging.debug "[cognitive_debugging] errors_by_phase: phases=#{tally.keys.join(',')}"
+            { success: true, tally: tally }
+          end
+
+          def most_common_error_type(**)
+            type = engine.most_common_error_type
+            Legion::Logging.debug "[cognitive_debugging] most_common_error_type: type=#{type}"
+            { success: true, error_type: type }
+          end
+
+          def most_effective_strategy(**)
+            strategy = engine.most_effective_strategy
+            Legion::Logging.debug "[cognitive_debugging] most_effective_strategy: strategy=#{strategy}"
+            { success: true, strategy: strategy }
+          end
+
+          def correction_success_rate(**)
+            rate = engine.correction_success_rate
+            Legion::Logging.debug "[cognitive_debugging] correction_success_rate: rate=#{rate}"
+            { success: true, rate: rate }
+          end
+
+          def debugging_report(**)
+            report = engine.debugging_report
+            Legion::Logging.info "[cognitive_debugging] debugging_report: total_errors=#{report[:total_errors]} " \
+                                 "active=#{report[:active_errors]}"
+            { success: true, report: report }
+          end
+
+          def snapshot(**)
+            data = engine.to_h
+            Legion::Logging.debug "[cognitive_debugging] snapshot: errors=#{data[:errors].size} " \
+                                  "traces=#{data[:traces].size} corrections=#{data[:corrections].size}"
+            { success: true, snapshot: data }
+          end
+
+          private
+
+          def engine
+            @engine ||= Helpers::DebuggingEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_debugging.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_debugging/version'
+require 'legion/extensions/cognitive_debugging/helpers/constants'
+require 'legion/extensions/cognitive_debugging/helpers/reasoning_error'
+require 'legion/extensions/cognitive_debugging/helpers/causal_trace'
+require 'legion/extensions/cognitive_debugging/helpers/correction'
+require 'legion/extensions/cognitive_debugging/helpers/debugging_engine'
+require 'legion/extensions/cognitive_debugging/runners/cognitive_debugging'
+
+module Legion
+  module Extensions
+    module CognitiveDebugging
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

data/spec/legion/extensions/cognitive_debugging/client_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_debugging/client'
+
+RSpec.describe Legion::Extensions::CognitiveDebugging::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:detect_error)
+    expect(client).to respond_to(:trace_error)
+    expect(client).to respond_to(:propose_correction)
+    expect(client).to respond_to(:apply_correction)
+    expect(client).to respond_to(:measure_correction)
+    expect(client).to respond_to(:resolve_error)
+    expect(client).to respond_to(:active_errors)
+    expect(client).to respond_to(:resolved_errors)
+    expect(client).to respond_to(:errors_by_type)
+    expect(client).to respond_to(:errors_by_phase)
+    expect(client).to respond_to(:most_common_error_type)
+    expect(client).to respond_to(:most_effective_strategy)
+    expect(client).to respond_to(:correction_success_rate)
+    expect(client).to respond_to(:debugging_report)
+    expect(client).to respond_to(:snapshot)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::CognitiveDebugging::Helpers::DebuggingEngine.new
+    client = described_class.new(engine: engine)
+    result = client.detect_error(
+      error_type:              :overconfidence,
+      description:             'Test injection',
+      severity:                0.5,
+      source_phase:            :tick,
+      confidence_at_detection: 0.8
+    )
+    expect(result[:success]).to be true
+    expect(engine.errors.size).to eq(1)
+  end
+
+  it 'creates a fresh engine when none injected' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.detect_error(error_type: :inconsistency, description: 'x', severity: 0.5,
+                    source_phase: :tick, confidence_at_detection: 0.5)
+    expect(c2.active_errors[:count]).to eq(0)
+  end
+end

data/spec/legion/extensions/cognitive_debugging/helpers/causal_trace_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveDebugging::Helpers::CausalTrace do
+  let(:trace) do
+    described_class.new(error_id: 'error-uuid', root_cause: :faulty_premise, confidence: 0.8)
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(trace.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets error_id' do
+      expect(trace.error_id).to eq('error-uuid')
+    end
+
+    it 'sets root_cause' do
+      expect(trace.root_cause).to eq(:faulty_premise)
+    end
+
+    it 'clamps confidence to [0, 1]' do
+      t = described_class.new(error_id: 'x', root_cause: :y, confidence: 1.5)
+      expect(t.confidence).to eq(1.0)
+    end
+
+    it 'initializes empty steps' do
+      expect(trace.steps).to be_empty
+    end
+  end
+
+  describe '#add_step!' do
+    it 'appends a step with phase, description, and timestamp' do
+      trace.add_step!(phase: :emotional_evaluation, description: 'Urgency spike caused premature conclusion')
+      expect(trace.steps.size).to eq(1)
+      step = trace.steps.first
+      expect(step[:phase]).to eq(:emotional_evaluation)
+      expect(step[:description]).to eq('Urgency spike caused premature conclusion')
+      expect(step[:timestamp]).to be_a(Time)
+    end
+
+    it 'returns self for chaining' do
+      result = trace.add_step!(phase: :tick, description: 'step 1')
+      expect(result).to be(trace)
+    end
+
+    it 'accumulates multiple steps' do
+      trace.add_step!(phase: :tick, description: 'step 1')
+      trace.add_step!(phase: :memory_retrieval, description: 'step 2')
+      trace.add_step!(phase: :prediction_engine, description: 'step 3')
+      expect(trace.steps.size).to eq(3)
+    end
+  end
+
+  describe '#depth' do
+    it 'returns 0 for empty trace' do
+      expect(trace.depth).to eq(0)
+    end
+
+    it 'returns step count' do
+      trace.add_step!(phase: :tick, description: 'a')
+      trace.add_step!(phase: :tick, description: 'b')
+      expect(trace.depth).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      trace.add_step!(phase: :tick, description: 'step')
+      h = trace.to_h
+      expect(h).to include(:id, :error_id, :steps, :root_cause, :confidence, :depth)
+    end
+
+    it 'includes depth in hash' do
+      trace.add_step!(phase: :tick, description: 'step')
+      expect(trace.to_h[:depth]).to eq(1)
+    end
+
+    it 'returns dup of steps' do
+      trace.add_step!(phase: :tick, description: 'step')
+      h = trace.to_h
+      expect(h[:steps]).not_to be(trace.steps)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_debugging/helpers/constants_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveDebugging::Helpers::Constants do
+  describe 'ERROR_TYPES' do
+    it 'contains 8 error types' do
+      expect(described_class::ERROR_TYPES.size).to eq(8)
+    end
+
+    it 'includes :inconsistency' do
+      expect(described_class::ERROR_TYPES).to include(:inconsistency)
+    end
+
+    it 'includes :circular_logic' do
+      expect(described_class::ERROR_TYPES).to include(:circular_logic)
+    end
+
+    it 'includes :overconfidence' do
+      expect(described_class::ERROR_TYPES).to include(:overconfidence)
+    end
+
+    it 'includes :confirmation_bias' do
+      expect(described_class::ERROR_TYPES).to include(:confirmation_bias)
+    end
+
+    it 'is frozen' do
+      expect(described_class::ERROR_TYPES).to be_frozen
+    end
+  end
+
+  describe 'CORRECTION_STRATEGIES' do
+    it 'contains 7 strategies' do
+      expect(described_class::CORRECTION_STRATEGIES.size).to eq(7)
+    end
+
+    it 'includes :retrace' do
+      expect(described_class::CORRECTION_STRATEGIES).to include(:retrace)
+    end
+
+    it 'includes :devil_advocate' do
+      expect(described_class::CORRECTION_STRATEGIES).to include(:devil_advocate)
+    end
+
+    it 'is frozen' do
+      expect(described_class::CORRECTION_STRATEGIES).to be_frozen
+    end
+  end
+
+  describe 'capacity limits' do
+    it 'sets MAX_ERRORS to 300' do
+      expect(described_class::MAX_ERRORS).to eq(300)
+    end
+
+    it 'sets MAX_TRACES to 500' do
+      expect(described_class::MAX_TRACES).to eq(500)
+    end
+
+    it 'sets MAX_CORRECTIONS to 200' do
+      expect(described_class::MAX_CORRECTIONS).to eq(200)
+    end
+  end
+
+  describe '.severity_label' do
+    it 'returns :trivial for 0.0' do
+      expect(described_class.severity_label(0.0)).to eq(:trivial)
+    end
+
+    it 'returns :trivial for 0.1' do
+      expect(described_class.severity_label(0.1)).to eq(:trivial)
+    end
+
+    it 'returns :minor for 0.2' do
+      expect(described_class.severity_label(0.2)).to eq(:minor)
+    end
+
+    it 'returns :moderate for 0.4' do
+      expect(described_class.severity_label(0.4)).to eq(:moderate)
+    end
+
+    it 'returns :major for 0.6' do
+      expect(described_class.severity_label(0.6)).to eq(:major)
+    end
+
+    it 'returns :critical for 0.8' do
+      expect(described_class.severity_label(0.8)).to eq(:critical)
+    end
+
+    it 'returns :critical for 1.0' do
+      expect(described_class.severity_label(1.0)).to eq(:critical)
+    end
+  end
+
+  describe 'STATUS_LABELS' do
+    it 'contains expected statuses' do
+      expect(described_class::STATUS_LABELS).to include(:detected, :traced, :correcting, :resolved, :unresolvable)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_debugging/helpers/correction_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveDebugging::Helpers::Correction do
+  let(:correction) do
+    described_class.new(error_id: 'error-uuid', strategy: :retrace, description: 'Re-examine assumptions')
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(correction.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets error_id' do
+      expect(correction.error_id).to eq('error-uuid')
+    end
+
+    it 'sets strategy' do
+      expect(correction.strategy).to eq(:retrace)
+    end
+
+    it 'sets description' do
+      expect(correction.description).to eq('Re-examine assumptions')
+    end
+
+    it 'initializes applied as false' do
+      expect(correction.applied).to be false
+    end
+
+    it 'initializes effectiveness as nil' do
+      expect(correction.effectiveness).to be_nil
+    end
+  end
+
+  describe '#apply!' do
+    it 'sets applied to true' do
+      correction.apply!
+      expect(correction.applied).to be true
+    end
+
+    it 'returns self for chaining' do
+      expect(correction.apply!).to be(correction)
+    end
+  end
+
+  describe '#measure_effectiveness!' do
+    it 'sets effectiveness' do
+      correction.measure_effectiveness!(0.8)
+      expect(correction.effectiveness).to eq(0.8)
+    end
+
+    it 'clamps effectiveness to [0, 1]' do
+      correction.measure_effectiveness!(1.5)
+      expect(correction.effectiveness).to eq(1.0)
+    end
+
+    it 'clamps negative values to 0.0' do
+      correction.measure_effectiveness!(-0.2)
+      expect(correction.effectiveness).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(correction.measure_effectiveness!(0.7)).to be(correction)
+    end
+  end
+
+  describe '#effective?' do
+    it 'returns false when effectiveness is nil' do
+      expect(correction.effective?).to be false
+    end
+
+    it 'returns true when effectiveness >= 0.6' do
+      correction.measure_effectiveness!(0.6)
+      expect(correction.effective?).to be true
+    end
+
+    it 'returns true for high effectiveness' do
+      correction.measure_effectiveness!(0.9)
+      expect(correction.effective?).to be true
+    end
+
+    it 'returns false when effectiveness < 0.6' do
+      correction.measure_effectiveness!(0.5)
+      expect(correction.effective?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes expected keys' do
+      h = correction.to_h
+      expect(h).to include(:id, :error_id, :strategy, :description, :applied, :effectiveness, :effective)
+    end
+
+    it 'reflects effective? result' do
+      correction.measure_effectiveness!(0.7)
+      expect(correction.to_h[:effective]).to be true
+    end
+  end
+end