Module: Legion::Extensions::Agentic::Executive::Chunking::Runners::CognitiveChunking

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb

Instance Method Summary collapse

Instance Method Details

#add_item(content:, domain: :general, engine: nil) ⇒ Object 



13
14
15
16
17
18
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 13

def add_item(content:, domain: :general, engine: nil, **)
  eng = engine || chunking_engine
  result = eng.add_item(content: content, domain: domain)
  Legion::Logging.debug "[cognitive_chunking] add_item: domain=#{domain} success=#{result[:success]}"
  result
end

#chunking_report(engine: nil) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 78

def chunking_report(engine: nil, **)
  eng    = engine || chunking_engine
  report = eng.chunking_report
  eff = report[:chunking_efficiency].round(2)
  Legion::Logging.debug "[cognitive_chunking] report: items=#{report[:total_items]} chunks=#{report[:total_chunks]} efficiency=#{eff}"
  { success: true, report: report }
end

#create_chunk(label:, item_ids:, engine: nil) ⇒ Object 



20
21
22
23
24
25
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 20

def create_chunk(label:, item_ids:, engine: nil, **)
  eng = engine || chunking_engine
  result = eng.create_chunk(label: label, item_ids: item_ids)
  Legion::Logging.debug "[cognitive_chunking] create_chunk: label=#{label} items=#{item_ids.size} success=#{result[:success]}"
  result
end

#decay_all(engine: nil) ⇒ Object 



64
65
66
67
68
69
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 64

def decay_all(engine: nil, **)
  eng    = engine || chunking_engine
  result = eng.decay_all!
  Legion::Logging.debug "[cognitive_chunking] decay_all: chunks_decayed=#{result[:chunks_decayed]}"
  result
end

#load_to_working_memory(chunk_id:, engine: nil) ⇒ Object 



34
35
36
37
38
39
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 34

def load_to_working_memory(chunk_id:, engine: nil, **)
  eng = engine || chunking_engine
  result = eng.load_to_working_memory(chunk_id: chunk_id)
  Legion::Logging.debug "[cognitive_chunking] load_wm: chunk_id=#{chunk_id} wm_size=#{result[:working_memory_size]} success=#{result[:success]}"
  result
end

#merge_chunks(chunk_ids:, label:, engine: nil) ⇒ Object 



27
28
29
30
31
32
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 27

def merge_chunks(chunk_ids:, label:, engine: nil, **)
  eng = engine || chunking_engine
  result = eng.merge_chunks(chunk_ids: chunk_ids, label: label)
  Legion::Logging.debug "[cognitive_chunking] merge_chunks: label=#{label} sources=#{chunk_ids.size} success=#{result[:success]}"
  result
end

#reinforce_chunk(chunk_id:, engine: nil) ⇒ Object 



71
72
73
74
75
76
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 71

def reinforce_chunk(chunk_id:, engine: nil, **)
  eng    = engine || chunking_engine
  result = eng.reinforce_chunk(chunk_id: chunk_id)
  Legion::Logging.debug "[cognitive_chunking] reinforce_chunk: chunk_id=#{chunk_id} success=#{result[:success]}"
  result
end

#strongest_chunks(limit: 10, engine: nil) ⇒ Object 



86
87
88
89
90
91
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 86

def strongest_chunks(limit: 10, engine: nil, **)
  eng    = engine || chunking_engine
  chunks = eng.strongest_chunks(limit: limit)
  Legion::Logging.debug "[cognitive_chunking] strongest_chunks: count=#{chunks.size}"
  { success: true, chunks: chunks }
end

#unchunked_items(engine: nil) ⇒ Object 



93
94
95
96
97
98
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 93

def unchunked_items(engine: nil, **)
  eng   = engine || chunking_engine
  items = eng.unchunked_items
  Legion::Logging.debug "[cognitive_chunking] unchunked_items: count=#{items.size}"
  { success: true, items: items }
end

#unload_from_working_memory(chunk_id:, engine: nil) ⇒ Object 



41
42
43
44
45
46
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 41

def unload_from_working_memory(chunk_id:, engine: nil, **)
  eng = engine || chunking_engine
  result = eng.unload_from_working_memory(chunk_id: chunk_id)
  Legion::Logging.debug "[cognitive_chunking] unload_wm: chunk_id=#{chunk_id} success=#{result[:success]}"
  result
end

#working_memory_status(engine: nil) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/legion/extensions/agentic/executive/chunking/runners/cognitive_chunking.rb', line 48

def working_memory_status(engine: nil, **)
  eng    = engine || chunking_engine
  load   = eng.working_memory_load
  label  = Helpers::Constants::CAPACITY_LABELS.find { |range, _| range.cover?(load) }&.last || :empty

  Legion::Logging.debug "[cognitive_chunking] wm_status: load=#{load.round(2)} label=#{label}"
  {
    success:    true,
    size:       eng.working_memory.size,
    capacity:   Helpers::Constants::WORKING_MEMORY_CAPACITY,
    load:       load,
    label:      label,
    overloaded: eng.working_memory_overloaded?
  }
end