Class: Legion::Extensions::Agentic::Executive::CognitiveDebt::Helpers::DebtEngine

Inherits:
Object
  • Object
show all
Defined in:
lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb

Instance Method Summary collapse

Constructor Details

#initialize ⇒ DebtEngine

Returns a new instance of DebtEngine.



10
11
12
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 10

def initialize
  @debts = {}
end

Instance Method Details

#accrue_all_interest ⇒ Object 



37
38
39
40
41
42
43
44
45
46
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 37

def accrue_all_interest
  count = 0
  @debts.each_value do |item|
    next if item.repaid?

    item.accrue!
    count += 1
  end
  { accrued: count, total_debt: total_debt }
end

#create_debt(label:, debt_type:, principal: Constants::DEFAULT_PRINCIPAL, domain: 'general') ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 14

def create_debt(label:, debt_type:, principal: Constants::DEFAULT_PRINCIPAL, domain: 'general')
  return { created: false, reason: :debt_type_invalid } unless Constants::DEBT_TYPES.include?(debt_type.to_sym)
  return { created: false, reason: :limit_reached } if @debts.size >= Constants::MAX_DEBTS

  item = DebtItem.new(
    label:     label,
    debt_type: debt_type,
    principal: principal,
    domain:    domain
  )
  @debts[item.id] = item
  { created: true, debt_id: item.id, debt: item.to_h }
end

#debt_by_domain(domain:) ⇒ Object 



58
59
60
61
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 58

def debt_by_domain(domain:)
  items = @debts.values.select { |d| d.domain == domain && !d.repaid? }
  { domain: domain, count: items.size, items: items.map(&:to_h) }
end

#debt_by_type(debt_type:) ⇒ Object 



52
53
54
55
56
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 52

def debt_by_type(debt_type:)
  type = debt_type.to_sym
  items = @debts.values.select { |d| d.debt_type == type && !d.repaid? }
  { debt_type: type, count: items.size, items: items.map(&:to_h) }
end

#debt_report ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 79

def debt_report
  active = @debts.values.reject(&:repaid?)
  by_type = Constants::DEBT_TYPES.to_h do |type|
    typed = active.select { |d| d.debt_type == type }
    [type, { count: typed.size, total_cost: typed.sum(&:total_cost).round(10) }]
  end

  priority = active.sort_by { |d| -d.total_cost }.first(5)

  {
    total_debt:           total_debt,
    active_count:         active.size,
    repaid_count:         @debts.values.count(&:repaid?),
    by_type:              by_type,
    recommended_priority: priority.map(&:to_h)
  }
end

#most_costly(limit: 10) ⇒ Object 



63
64
65
66
67
68
69
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 63

def most_costly(limit: 10)
  items = @debts.values
                .reject(&:repaid?)
                .sort_by { |d| -d.total_cost }
                .first(limit)
  { count: items.size, items: items.map(&:to_h) }
end

#oldest_debts(limit: 10) ⇒ Object 



71
72
73
74
75
76
77
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 71

def oldest_debts(limit: 10)
  items = @debts.values
                .reject(&:repaid?)
                .sort_by(&:created_at)
                .first(limit)
  { count: items.size, items: items.map(&:to_h) }
end

#prune_repaid ⇒ Object 



97
98
99
100
101
102
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 97

def prune_repaid
  before = @debts.size
  @debts.delete_if { |_id, item| item.repaid? }
  pruned = before - @debts.size
  { pruned: pruned, remaining: @debts.size }
end

#repay_debt(debt_id:, amount: Constants::REPAYMENT_RATE) ⇒ Object 



28
29
30
31
32
33
34
35
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 28

def repay_debt(debt_id:, amount: Constants::REPAYMENT_RATE)
  item = @debts[debt_id]
  return { found: false } unless item
  return { found: true, repaid: false, reason: :already_repaid } if item.repaid?

  item.repay!(amount: amount)
  { found: true, repaid: true, debt_id: debt_id, debt: item.to_h }
end

#to_h ⇒ Object 



104
105
106
107
108
109
110
111
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 104

def to_h
  {
    total_debt:   total_debt,
    active_count: @debts.values.reject(&:repaid?).size,
    total_count:  @debts.size,
    debts:        @debts.values.map(&:to_h)
  }
end

#total_debt ⇒ Object 



48
49
50
 
# File 'lib/legion/extensions/agentic/executive/cognitive_debt/helpers/debt_engine.rb', line 48

def total_debt
  @debts.values.reject(&:repaid?).sum(&:total_cost).round(10)
end