Module: Legion::Extensions::Catalog::Registry

Defined in:
lib/legion/extensions/catalog/registry.rb

Class Method Summary collapse

Class Method Details

.capabilities ⇒ Object 



45
46
47
 
# File 'lib/legion/extensions/catalog/registry.rb', line 45

def capabilities
  @mutex.synchronize { @capabilities.dup.freeze }
end

.count ⇒ Object 



80
81
82
 
# File 'lib/legion/extensions/catalog/registry.rb', line 80

def count
  @mutex.synchronize { @capabilities.length }
end

.find(name:) ⇒ Object 



49
50
51
 
# File 'lib/legion/extensions/catalog/registry.rb', line 49

def find(name:)
  @mutex.synchronize { @by_name[name] }
end

.find_by_intent(text) ⇒ Object 



53
54
55
56
57
 
# File 'lib/legion/extensions/catalog/registry.rb', line 53

def find_by_intent(text)
  @mutex.synchronize do
    @capabilities.select { |c| c.matches_intent?(text) }
  end
end

.find_by_mcp_name(mcp_name) ⇒ Object 



63
64
65
66
67
 
# File 'lib/legion/extensions/catalog/registry.rb', line 63

def find_by_mcp_name(mcp_name)
  @mutex.synchronize do
    @capabilities.find { |cap| cap.to_mcp_tool[:name] == mcp_name }
  end
end

.for_mcp ⇒ Object 



59
60
61
 
# File 'lib/legion/extensions/catalog/registry.rb', line 59

def for_mcp
  @mutex.synchronize { @capabilities.dup }
end

.for_override(tool_name) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
 
# File 'lib/legion/extensions/catalog/registry.rb', line 69

def for_override(tool_name)
  @mutex.synchronize do
    normalized = tool_name.downcase.tr('-', '_')
    @capabilities.find do |cap|
      cap.function.downcase == normalized ||
        cap.name.downcase.end_with?(normalized) ||
        cap.tags.any? { |t| t.downcase == normalized }
    end
  end
end

.on_change(&block) ⇒ Object 



84
85
86
 
# File 'lib/legion/extensions/catalog/registry.rb', line 84

def on_change(&block)
  @mutex.synchronize { @on_change_callbacks << block }
end

.register(capability) ⇒ Object 



14
15
16
17
18
19
20
21
22
 
# File 'lib/legion/extensions/catalog/registry.rb', line 14

def register(capability)
  @mutex.synchronize do
    return if @by_name.key?(capability.name)

    @capabilities << capability
    @by_name[capability.name] = capability
  end
  notify_change
end

.reset! ⇒ Object 



88
89
90
91
92
93
94
 
# File 'lib/legion/extensions/catalog/registry.rb', line 88

def reset!
  @mutex.synchronize do
    @capabilities.clear
    @by_name.clear
    @on_change_callbacks.clear
  end
end

.unregister(name) ⇒ Object 



24
25
26
27
28
29
30
31
 
# File 'lib/legion/extensions/catalog/registry.rb', line 24

def unregister(name)
  @mutex.synchronize do
    cap = @by_name.delete(name)
    @capabilities.delete(cap) if cap
    return unless cap
  end
  notify_change
end

.unregister_extension(extension_name) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/legion/extensions/catalog/registry.rb', line 33

def unregister_extension(extension_name)
  @mutex.synchronize do
    removed = @capabilities.select { |c| c.extension == extension_name }
    removed.each do |cap|
      @by_name.delete(cap.name)
      @capabilities.delete(cap)
    end
    return if removed.empty?
  end
  notify_change
end