Module: Legion::API::Routes::Apollo

Defined in:
lib/legion/api/apollo.rb

Class Method Summary collapse

Class Method Details

.register_expertise_route(app) ⇒ Object 



110
111
112
113
114
115
116
 
# File 'lib/legion/api/apollo.rb', line 110

def self.register_expertise_route(app)
  app.get '/api/apollo/expertise' do
    halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503) unless apollo_loaded?

    json_response(apollo_expertise_map)
  end
end

.register_graph_route(app) ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/legion/api/apollo.rb', line 102

def self.register_graph_route(app)
  app.get '/api/apollo/graph' do
    halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503) unless apollo_loaded?

    json_response(apollo_graph_topology)
  end
end

.register_ingest_route(app) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/legion/api/apollo.rb', line 55

def self.register_ingest_route(app)
  app.post '/api/apollo/ingest' do
    halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503) unless apollo_loaded?

    body = parse_request_body
    result = apollo_runner.handle_ingest(
      content:          body[:content],
      content_type:     body[:content_type] || :observation,
      tags:             body[:tags] || [],
      source_agent:     body[:source_agent] || 'api',
      source_provider:  body[:source_provider],
      source_channel:   body[:source_channel] || 'rest_api',
      knowledge_domain: body[:knowledge_domain],
      context:          body[:context] || {}
    )
    json_response(result, status_code: 201)
  end
end

.register_maintenance_route(app) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/legion/api/apollo.rb', line 87

def self.register_maintenance_route(app)
  app.post '/api/apollo/maintenance' do
    halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503) unless apollo_loaded?

    body = parse_request_body
    action = body[:action]&.to_sym
    halt 400, json_error('invalid_action', 'action must be decay_cycle or corroboration') unless %i[
      decay_cycle corroboration
    ].include?(action)

    result = run_maintenance(action)
    json_response(result)
  end
end

.register_query_route(app) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/legion/api/apollo.rb', line 37

def self.register_query_route(app)
  app.post '/api/apollo/query' do
    halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503) unless apollo_loaded?

    body = parse_request_body
    result = apollo_runner.handle_query(
      query:          body[:query],
      limit:          body[:limit] || 10,
      min_confidence: body[:min_confidence] || 0.3,
      status:         body[:status] || [:confirmed],
      tags:           body[:tags],
      domain:         body[:domain],
      agent_id:       body[:agent_id] || 'api'
    )
    json_response(result)
  end
end

.register_related_route(app) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/legion/api/apollo.rb', line 74

def self.register_related_route(app)
  app.get '/api/apollo/entries/:id/related' do
    halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503) unless apollo_loaded?

    result = apollo_runner.related_entries(
      entry_id:       params[:id].to_i,
      relation_types: params[:relation_types]&.split(','),
      depth:          (params[:depth] || 2).to_i
    )
    json_response(result)
  end
end

.register_stats_route(app) ⇒ Object 



29
30
31
32
33
34
35
 
# File 'lib/legion/api/apollo.rb', line 29

def self.register_stats_route(app)
  app.get '/api/apollo/stats' do
    halt 503, json_error('apollo_unavailable', 'apollo is not available', status_code: 503) unless apollo_loaded?

    json_response(apollo_stats)
  end
end

.register_status_route(app) ⇒ Object 



19
20
21
22
23
24
25
26
27
 
# File 'lib/legion/api/apollo.rb', line 19

def self.register_status_route(app)
  app.get '/api/apollo/status' do
    if apollo_loaded?
      json_response({ available: true, data_connected: apollo_data_connected? })
    else
      json_response({ available: false }, status_code: 503)
    end
  end
end

.registered(app) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/legion/api/apollo.rb', line 7

def self.registered(app)
  app.helpers ApolloHelpers
  register_status_route(app)
  register_stats_route(app)
  register_query_route(app)
  register_ingest_route(app)
  register_related_route(app)
  register_maintenance_route(app)
  register_graph_route(app)
  register_expertise_route(app)
end