legionio 1.6.44 → 1.6.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d5e89a840a146657264710fe44bb2e60a3be0b7b44aece296a8fa1b7abe51df
-  data.tar.gz: e49ca0b195a65c40647960f4c1c7e734b939106200c72d65e992210298a900c7
+  metadata.gz: 55adb4b5b957ffa41629f5d0cf48961096230993a9654f1f85d956a845773043
+  data.tar.gz: 41d97316c383dae8178b9730d2a3712d1669870180e01d55a966fbc3e79afbbc
 SHA512:
-  metadata.gz: 0aacaf7a1d32a6c32bb0862ce0d2b569f1e528fcb31b77f4aa00e78ecbb021a0448ae1591ccff3251cfe61b41b9392a7415da6d40fcf56518b99f2305ddc422b
-  data.tar.gz: a1aa3f9cacd5a88f4351a3014fc9c2a67b3fd225b594937585d64239eb4e349296896151b828d8ef5646994e08897b10378f070a42e4fbc0d186668c6011bd30
+  metadata.gz: 5d062ded2d5c0a87aa28864abd1c74a3d8aacf075f43fba8bd6267a5adcfeb0e74498df3583b5713921901cfbbd0ec96f57986a71dbeb70c48649541404dd484
+  data.tar.gz: afa0809aa907d8e9e508f257d20dd05db8e4c0ddad7dd9aeb989ec6cf135c4df48fcce0a35dda6bfbceb2ba7d1a4d6ad1a658342b026d044bb3262b2ed1d110c

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [1.6.45] - 2026-03-31
+
+### Added
+- `Legion::CLI::ApiClient` shared module — extracts api_get/api_post/api_put/api_delete helpers into a reusable mixin for all CLI commands that talk to the daemon API
+- `/api/knowledge/*` API routes — query, retrieve, ingest, status, health, maintain, quality, and monitor CRUD endpoints for lex-knowledge
+
+### Changed
+- `legionio knowledge` commands now route through the local API instead of loading extension classes directly (fixes NameError when daemon not running)
+- `legionio schedule` commands now route through the existing `/api/schedules/*` API instead of querying Sequel models directly
+- `legionio codegen` commands now route through the existing `/api/codegen/*` API instead of checking `defined?` guards that always fail in CLI context
+- `legionio absorb` commands now use the shared `ApiClient` module instead of inline HTTP helpers
+
 ## [1.6.44] - 2026-03-31
 
 ### Added

data/lib/legion/api/helpers.rb

@@ -52,6 +52,30 @@ module Legion
         halt 503, json_error('scheduler_unavailable', 'lex-scheduler is not loaded', status_code: 503)
       end
 
+      def require_knowledge_query!
+        return if defined?(Legion::Extensions::Knowledge::Runners::Query)
+
+        halt 503, json_error('knowledge_unavailable', 'lex-knowledge is not loaded', status_code: 503)
+      end
+
+      def require_knowledge_ingest!
+        return if defined?(Legion::Extensions::Knowledge::Runners::Ingest)
+
+        halt 503, json_error('knowledge_unavailable', 'lex-knowledge is not loaded', status_code: 503)
+      end
+
+      def require_knowledge_maintenance!
+        return if defined?(Legion::Extensions::Knowledge::Runners::Maintenance)
+
+        halt 503, json_error('knowledge_unavailable', 'lex-knowledge is not loaded', status_code: 503)
+      end
+
+      def require_knowledge_monitor!
+        return if defined?(Legion::Extensions::Knowledge::Runners::Monitor)
+
+        halt 503, json_error('knowledge_unavailable', 'lex-knowledge is not loaded', status_code: 503)
+      end
+
       def require_trace_search!
         return if defined?(Legion::TraceSearch) && defined?(Legion::LLM)
 

data/lib/legion/api/knowledge.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Knowledge
+        def self.registered(app)
+          register_query_routes(app)
+          register_ingest_routes(app)
+          register_maintenance_routes(app)
+          register_monitor_routes(app)
+        end
+
+        def self.register_query_routes(app)
+          app.post '/api/knowledge/query' do
+            require_knowledge_query!
+            body = parse_request_body
+            result = Legion::Extensions::Knowledge::Runners::Query.query(
+              question:   body[:question],
+              top_k:      body[:top_k] || 5,
+              synthesize: body.fetch(:synthesize, true)
+            )
+            json_response(result)
+          end
+
+          app.post '/api/knowledge/retrieve' do
+            require_knowledge_query!
+            body = parse_request_body
+            result = Legion::Extensions::Knowledge::Runners::Query.retrieve(
+              question: body[:question],
+              top_k:    body[:top_k] || 5
+            )
+            json_response(result)
+          end
+        end
+
+        def self.register_ingest_routes(app)
+          app.post '/api/knowledge/ingest' do
+            require_knowledge_ingest!
+            body = parse_request_body
+
+            result = if body[:content]
+                       Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
+                         content: body[:content],
+                         tags:    body[:tags] || [],
+                         source:  body[:source]
+                       )
+                     elsif body[:path]
+                       if File.directory?(body[:path])
+                         Legion::Extensions::Knowledge::Runners::Ingest.ingest_corpus(
+                           path:    body[:path],
+                           force:   body[:force] || false,
+                           dry_run: body[:dry_run] || false
+                         )
+                       else
+                         Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
+                           file_path: body[:path],
+                           force:     body[:force] || false,
+                           dry_run:   body[:dry_run] || false
+                         )
+                       end
+                     else
+                       halt 400, json_error('missing_param', 'content or path is required')
+                     end
+            json_response(result)
+          end
+
+          app.post '/api/knowledge/status' do
+            require_knowledge_ingest!
+            body = parse_request_body
+            path = body[:path] || Dir.pwd
+            result = Legion::Extensions::Knowledge::Runners::Ingest.scan_corpus(path: path)
+            json_response(result)
+          end
+        end
+
+        def self.register_maintenance_routes(app)
+          app.post '/api/knowledge/health' do
+            require_knowledge_maintenance!
+            body = parse_request_body
+            result = Legion::Extensions::Knowledge::Runners::Maintenance.health(path: body[:path])
+            json_response(result)
+          end
+
+          app.post '/api/knowledge/maintain' do
+            require_knowledge_maintenance!
+            body = parse_request_body
+            result = Legion::Extensions::Knowledge::Runners::Maintenance.cleanup_orphans(
+              path:    body[:path],
+              dry_run: body.fetch(:dry_run, true)
+            )
+            json_response(result)
+          end
+
+          app.post '/api/knowledge/quality' do
+            require_knowledge_maintenance!
+            body = parse_request_body
+            result = Legion::Extensions::Knowledge::Runners::Maintenance.quality_report(
+              limit: body[:limit] || 10
+            )
+            json_response(result)
+          end
+        end
+
+        def self.register_monitor_routes(app)
+          app.get '/api/knowledge/monitors' do
+            require_knowledge_monitor!
+            monitors = Legion::Extensions::Knowledge::Runners::Monitor.list_monitors
+            json_response(monitors)
+          end
+
+          app.post '/api/knowledge/monitors' do
+            require_knowledge_monitor!
+            body = parse_request_body
+            result = Legion::Extensions::Knowledge::Runners::Monitor.add_monitor(
+              path:       body[:path],
+              extensions: body[:extensions],
+              label:      body[:label]
+            )
+            json_response(result, status_code: 201)
+          end
+
+          app.delete '/api/knowledge/monitors' do
+            require_knowledge_monitor!
+            body = parse_request_body
+            result = Legion::Extensions::Knowledge::Runners::Monitor.remove_monitor(
+              identifier: body[:identifier]
+            )
+            json_response(result)
+          end
+
+          app.get '/api/knowledge/monitors/status' do
+            require_knowledge_monitor!
+            result = Legion::Extensions::Knowledge::Runners::Monitor.monitor_status
+            json_response(result)
+          end
+        end
+
+        class << self
+          private :register_query_routes, :register_ingest_routes,
+                  :register_maintenance_routes, :register_monitor_routes
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -47,6 +47,7 @@ require_relative 'api/traces'
 require_relative 'api/stats'
 require_relative 'api/absorbers'
 require_relative 'api/codegen'
+require_relative 'api/knowledge'
 require_relative 'api/logs'
 require_relative 'api/router'
 require_relative 'api/library_routes'
@@ -176,6 +177,7 @@ module Legion
     register Routes::Stats
     register Routes::Absorbers
     register Routes::Codegen
+    register Routes::Knowledge
     register Routes::Logs
     register Routes::TbiPatterns
     register Routes::GraphQL if defined?(Routes::GraphQL)

data/lib/legion/cli/absorb_command.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
-require 'json'
+require_relative 'api_client'
 
 module Legion
   module CLI
@@ -66,60 +64,12 @@ module Legion
       end
 
       no_commands do
+        include ApiClient
+
         def formatter
           @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
         end
 
-        def api_port
-          Connection.ensure_settings
-          api_settings = Legion::Settings[:api]
-          (api_settings.is_a?(Hash) && api_settings[:port]) || 4567
-        rescue StandardError
-          4567
-        end
-
-        def api_post(path, **payload)
-          uri = URI("http://127.0.0.1:#{api_port}#{path}")
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.read_timeout = 300
-          request = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json')
-          request.body = ::JSON.generate(payload)
-          response = http.request(request)
-          unless response.is_a?(Net::HTTPSuccess)
-            formatter.error("API returned #{response.code} for #{path}")
-            raise SystemExit, 1
-          end
-          body = ::JSON.parse(response.body, symbolize_names: true)
-          body[:data]
-        rescue Errno::ECONNREFUSED
-          formatter.error('Daemon not running. Start with: legionio start')
-          raise SystemExit, 1
-        rescue SystemExit
-          raise
-        rescue StandardError => e
-          formatter.error("API request failed: #{e.message}")
-          raise SystemExit, 1
-        end
-
-        def api_get(path)
-          uri = URI("http://127.0.0.1:#{api_port}#{path}")
-          response = Net::HTTP.get_response(uri)
-          unless response.is_a?(Net::HTTPSuccess)
-            formatter.error("API returned #{response.code} for #{path}")
-            raise SystemExit, 1
-          end
-          body = ::JSON.parse(response.body, symbolize_names: true)
-          body[:data]
-        rescue Errno::ECONNREFUSED
-          formatter.error('Daemon not running. Start with: legionio start')
-          raise SystemExit, 1
-        rescue SystemExit
-          raise
-        rescue StandardError => e
-          formatter.error("API request failed: #{e.message}")
-          raise SystemExit, 1
-        end
-
         def fetch_absorbers
           api_get('/api/absorbers')
         end

data/lib/legion/cli/api_client.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Legion
+  module CLI
+    # Shared HTTP client for CLI commands that talk to the running daemon API.
+    # Include this module inside a Thor command's `no_commands` block, or
+    # extend it at the class level, to get api_get / api_post / api_put /
+    # api_delete helpers that target http://127.0.0.1:<port>/api/*.
+    module ApiClient
+      def api_port
+        Connection.ensure_settings
+        api_settings = Legion::Settings[:api]
+        (api_settings.is_a?(Hash) && api_settings[:port]) || 4567
+      rescue StandardError
+        4567
+      end
+
+      def api_get(path)
+        uri = URI("http://127.0.0.1:#{api_port}#{path}")
+        http = build_http(uri)
+        response = http.get(uri.request_uri)
+        handle_response(response, path)
+      rescue Errno::ECONNREFUSED
+        daemon_not_running!
+      rescue SystemExit
+        raise
+      rescue StandardError => e
+        api_error!(e, path)
+      end
+
+      def api_post(path, **payload)
+        uri = URI("http://127.0.0.1:#{api_port}#{path}")
+        http = build_http(uri, read_timeout: 300)
+        request = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json')
+        request.body = ::JSON.generate(payload)
+        response = http.request(request)
+        handle_response(response, path)
+      rescue Errno::ECONNREFUSED
+        daemon_not_running!
+      rescue SystemExit
+        raise
+      rescue StandardError => e
+        api_error!(e, path)
+      end
+
+      def api_put(path, **payload)
+        uri = URI("http://127.0.0.1:#{api_port}#{path}")
+        http = build_http(uri)
+        request = Net::HTTP::Put.new(uri.path, 'Content-Type' => 'application/json')
+        request.body = ::JSON.generate(payload)
+        response = http.request(request)
+        handle_response(response, path)
+      rescue Errno::ECONNREFUSED
+        daemon_not_running!
+      rescue SystemExit
+        raise
+      rescue StandardError => e
+        api_error!(e, path)
+      end
+
+      def api_delete(path)
+        uri = URI("http://127.0.0.1:#{api_port}#{path}")
+        http = build_http(uri)
+        response = http.delete(uri.path)
+        handle_response(response, path)
+      rescue Errno::ECONNREFUSED
+        daemon_not_running!
+      rescue SystemExit
+        raise
+      rescue StandardError => e
+        api_error!(e, path)
+      end
+
+      private
+
+      def build_http(uri, read_timeout: 10)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = 3
+        http.read_timeout = read_timeout
+        http
+      end
+
+      def handle_response(response, path)
+        unless response.is_a?(Net::HTTPSuccess)
+          formatter.error("API returned #{response.code} for #{path}")
+          raise SystemExit, 1
+        end
+        body = ::JSON.parse(response.body, symbolize_names: true)
+        body[:data]
+      end
+
+      def daemon_not_running!
+        formatter.error('Daemon not running. Start with: legionio start')
+        raise SystemExit, 1
+      end
+
+      def api_error!(err, path)
+        formatter.error("API request failed (#{path}): #{err.message}")
+        raise SystemExit, 1
+      end
+    end
+  end
+end

data/lib/legion/cli/chat/tools/search_traces.rb

@@ -31,7 +31,7 @@ module Legion
             ['Job', 'jobTitle', :jobTitle]
           ].freeze
 
-          def execute(query:, person: nil, domain: nil, trace_type: nil, limit: nil)
+          def execute(query:, person: nil, domain: nil, trace_type: nil, limit: nil, **) # rubocop:disable Metrics/ParameterLists
             return 'Memory trace system not available (lex-agentic-memory not loaded).' unless trace_store_available?
 
             limit = (limit || 20).clamp(1, 50)

data/lib/legion/cli/codegen_command.rb

@@ -1,103 +1,73 @@
 # frozen_string_literal: true
 
+require_relative 'api_client'
+
 module Legion
   module CLI
     class CodegenCommand < Thor
       namespace :codegen
 
+      class_option :json,     type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
+
       desc 'status', 'Show codegen cycle stats, pending gaps, registry counts'
       def status
-        if defined?(Legion::MCP::SelfGenerate)
-          data = Legion::MCP::SelfGenerate.status
-          say Legion::JSON.dump({ data: data })
-        else
-          say Legion::JSON.dump({ error: 'codegen not available' })
-        end
+        data = api_get('/api/codegen/status')
+        formatter.json(data)
       end
 
       desc 'list', 'List generated functions'
       method_option :status, type: :string, desc: 'Filter by status'
       def list
-        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
-          say Legion::JSON.dump({ error: 'codegen registry not available' })
-          return
-        end
-
-        records = Legion::Extensions::Codegen::Helpers::GeneratedRegistry.list(status: options[:status])
-        say Legion::JSON.dump({ data: records })
+        path = '/api/codegen/generated'
+        path += "?status=#{options[:status]}" if options[:status]
+        data = api_get(path)
+        formatter.json(data)
       end
 
       desc 'show ID', 'Show details of a generated function'
       def show(id)
-        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
-          say Legion::JSON.dump({ error: 'codegen registry not available' })
-          return
-        end
-
-        record = Legion::Extensions::Codegen::Helpers::GeneratedRegistry.get(id: id)
-        if record
-          say Legion::JSON.dump({ data: record })
-        else
-          say Legion::JSON.dump({ error: 'not found' })
-        end
+        data = api_get("/api/codegen/generated/#{id}")
+        formatter.json(data)
       end
 
       desc 'approve ID', 'Manually approve a parked generated function'
       def approve(id)
-        unless defined?(Legion::Extensions::Codegen::Runners::ReviewHandler)
-          say Legion::JSON.dump({ error: 'review handler not available' })
-          return
-        end
-
-        result = Legion::Extensions::Codegen::Runners::ReviewHandler.handle_verdict(
-          review: { generation_id: id, verdict: :approve, confidence: 1.0 }
-        )
-        say Legion::JSON.dump({ data: result })
+        data = api_post("/api/codegen/generated/#{id}/approve")
+        formatter.json(data)
       end
 
       desc 'reject ID', 'Manually reject a generated function'
       def reject(id)
-        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
-          say Legion::JSON.dump({ error: 'codegen registry not available' })
-          return
-        end
-
-        Legion::Extensions::Codegen::Helpers::GeneratedRegistry.update_status(id: id, status: 'rejected')
-        say Legion::JSON.dump({ data: { id: id, status: 'rejected' } })
+        data = api_post("/api/codegen/generated/#{id}/reject")
+        formatter.json(data)
       end
 
       desc 'retry ID', 'Re-queue a generated function for regeneration'
       def retry_generation(id)
-        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
-          say Legion::JSON.dump({ error: 'codegen registry not available' })
-          return
-        end
-
-        Legion::Extensions::Codegen::Helpers::GeneratedRegistry.update_status(id: id, status: 'pending')
-        say Legion::JSON.dump({ data: { id: id, status: 'pending' } })
+        data = api_post("/api/codegen/generated/#{id}/retry")
+        formatter.json(data)
       end
       map 'retry' => :retry_generation
 
       desc 'gaps', 'List detected capability gaps with priorities'
       def gaps
-        if defined?(Legion::MCP::GapDetector)
-          detected = Legion::MCP::GapDetector.detect_gaps
-          say Legion::JSON.dump({ data: detected })
-        else
-          say Legion::JSON.dump({ error: 'gap detector not available' })
-        end
+        data = api_get('/api/codegen/gaps')
+        formatter.json(data)
       end
 
       desc 'cycle', 'Manually trigger a generation cycle (bypass cooldown)'
       def cycle
-        unless defined?(Legion::MCP::SelfGenerate)
-          say Legion::JSON.dump({ error: 'self_generate not available' })
-          return
-        end
+        data = api_post('/api/codegen/cycle')
+        formatter.json(data)
+      end
 
-        Legion::MCP::SelfGenerate.instance_variable_set(:@last_cycle_at, nil)
-        result = Legion::MCP::SelfGenerate.run_cycle
-        say Legion::JSON.dump({ data: result })
+      no_commands do
+        include ApiClient
+
+        def formatter
+          @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
+        end
       end
     end
   end

data/lib/legion/cli/knowledge_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'shellwords'
+require_relative 'api_client'
 
 module Legion
   module CLI
@@ -16,14 +17,10 @@ module Legion
       option :extensions, type: :string,  desc: 'Comma-separated file extensions to watch (e.g. md,rb)'
       option :label,      type: :string,  desc: 'Human-readable label for this monitor'
       def add(path)
-        require_monitor!
-        exts = options[:extensions]&.split(',')&.map(&:strip)
-        result = Legion::Extensions::Knowledge::Runners::Monitor.add_monitor(
-          path:       path,
-          extensions: exts,
-          label:      options[:label]
-        )
         out = formatter
+        exts = options[:extensions]&.split(',')&.map(&:strip)
+        result = api_post('/api/knowledge/monitors', path: path, extensions: exts, label: options[:label])
+
         if options[:json]
           out.json(result)
         elsif result[:success]
@@ -35,9 +32,9 @@ module Legion
 
       desc 'list', 'List registered corpus monitors'
       def list
-        require_monitor!
-        monitors = Legion::Extensions::Knowledge::Runners::Monitor.list_monitors
         out = formatter
+        monitors = api_get('/api/knowledge/monitors')
+
         if options[:json]
           out.json(monitors)
         elsif monitors.nil? || monitors.empty?
@@ -56,9 +53,9 @@ module Legion
 
       desc 'remove IDENTIFIER', 'Remove a corpus monitor by path or label'
       def remove(identifier)
-        require_monitor!
-        result = Legion::Extensions::Knowledge::Runners::Monitor.remove_monitor(identifier:)
         out = formatter
+        result = api_delete("/api/knowledge/monitors?identifier=#{URI.encode_www_form_component(identifier)}")
+
         if options[:json]
           out.json(result)
         elsif result[:success]
@@ -70,9 +67,9 @@ module Legion
 
       desc 'status', 'Show monitor status (counts)'
       def status
-        require_monitor!
-        result = Legion::Extensions::Knowledge::Runners::Monitor.monitor_status
         out = formatter
+        result = api_get('/api/knowledge/monitors/status')
+
         if options[:json]
           out.json(result)
         else
@@ -85,13 +82,11 @@ module Legion
       end
 
       no_commands do
+        include ApiClient
+
         def formatter
           @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
         end
-
-        def require_monitor!
-          Connection.ensure_knowledge unless defined?(Legion::Extensions::Knowledge::Runners::Monitor)
-        end
       end
     end
 
@@ -118,12 +113,7 @@ module Legion
         content = "Git commit: #{sha}\nSubject: #{subject}\n\nDiff stat:\n#{diff_stat}"
         tags    = %w[git commit knowledge-capture]
 
-        Connection.ensure_knowledge unless defined?(Legion::Extensions::Knowledge::Runners::Ingest)
-        result = Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
-          content: content,
-          tags:    tags,
-          source:  "git:#{sha}"
-        )
+        result = api_post('/api/knowledge/ingest', content: content, tags: tags, source: "git:#{sha}")
 
         out = formatter
         if options[:json]
@@ -150,12 +140,8 @@ module Legion
         tags    = ['session', 'knowledge-capture', ::Time.now.strftime('%Y-%m-%d')]
         tags   << "repo:#{repo}" unless repo.empty?
 
-        Connection.ensure_knowledge unless defined?(Legion::Extensions::Knowledge::Runners::Ingest)
-        result = Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
-          content: content,
-          tags:    tags,
-          source:  "session:#{::Time.now.iso8601}"
-        )
+        result = api_post('/api/knowledge/ingest',
+                          content: content, tags: tags, source: "session:#{::Time.now.iso8601}")
 
         out = formatter
         if options[:json]
@@ -201,11 +187,10 @@ module Legion
           content = format_turn(turn, idx + 1)
           next if content.strip.empty?
 
-          result = ingest_content(
-            content: content,
-            tags:    base_tags + ["turn:#{idx + 1}"],
-            source:  "claude-code:#{session_id}:turn-#{idx + 1}"
-          )
+          result = api_post('/api/knowledge/ingest',
+                            content: content,
+                            tags:    base_tags + ["turn:#{idx + 1}"],
+                            source:  "claude-code:#{session_id}:turn-#{idx + 1}")
           ingested += 1 if result[:success]
         end
 
@@ -217,7 +202,9 @@ module Legion
         end
       end
 
-      no_commands do # rubocop:disable Metrics/BlockLength
+      no_commands do
+        include ApiClient
+
         def formatter
           @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
         end
@@ -279,18 +266,6 @@ module Legion
 
           "#{text.byteslice(0, max_bytes - 20)}\n\n[truncated]"
         end
-
-        def ingest_content(content:, tags:, source:)
-          if defined?(Legion::Extensions::Knowledge::Runners::Ingest)
-            Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
-              content: content, tags: tags, source: source
-            )
-          elsif defined?(Legion::Apollo)
-            Legion::Apollo.ingest(content: content, tags: tags, source: source)
-          else
-            { success: false, error: 'neither lex-knowledge nor legion-apollo available' }
-          end
-        end
       end
     end
 
@@ -307,9 +282,8 @@ module Legion
       option :synthesize, type: :boolean, default: true,  desc: 'Synthesize an LLM answer'
       option :verbose,    type: :boolean, default: false, desc: 'Show full source metadata'
       def query(question)
-        require_knowledge!
-        result = knowledge_query.query(question: question, top_k: options[:top_k],
-                                       synthesize: options[:synthesize])
+        result = api_post('/api/knowledge/query',
+                          question: question, top_k: options[:top_k], synthesize: options[:synthesize])
         out = formatter
         if options[:json]
           out.json(result)
@@ -330,8 +304,7 @@ module Legion
       desc 'retrieve QUESTION', 'Retrieve source chunks without LLM synthesis'
       option :top_k, type: :numeric, default: 5, desc: 'Number of source chunks'
       def retrieve(question)
-        require_knowledge!
-        result = knowledge_query.retrieve(question: question, top_k: options[:top_k])
+        result = api_post('/api/knowledge/retrieve', question: question, top_k: options[:top_k])
         out = formatter
         if options[:json]
           out.json(result)
@@ -347,14 +320,8 @@ module Legion
       option :force,   type: :boolean, default: false, desc: 'Re-ingest even unchanged files'
       option :dry_run, type: :boolean, default: false, desc: 'Preview without writing'
       def ingest(path)
-        require_ingest!
-        result = if ::File.directory?(path)
-                   knowledge_ingest.ingest_corpus(path: path, force: options[:force],
-                                                  dry_run: options[:dry_run])
-                 else
-                   knowledge_ingest.ingest_file(file_path: path, force: options[:force],
-                                                dry_run: options[:dry_run])
-                 end
+        result = api_post('/api/knowledge/ingest',
+                          path: ::File.expand_path(path), force: options[:force], dry_run: options[:dry_run])
         out = formatter
         if options[:json]
           out.json(result)
@@ -368,8 +335,7 @@ module Legion
 
       desc 'status', 'Show knowledge base status'
       def status
-        require_ingest!
-        result = knowledge_ingest.scan_corpus(path: ::Dir.pwd)
+        result = api_post('/api/knowledge/status', path: ::Dir.pwd)
         out = formatter
         if options[:json]
           out.json(result)
@@ -386,9 +352,7 @@ module Legion
       desc 'health', 'Show knowledge base health report (local, Apollo, sync)'
       option :corpus_path, type: :string, desc: 'Path to corpus directory (falls back to settings)'
       def health
-        require_maintenance!
-        path = resolve_corpus_path
-        result = knowledge_maintenance.health(path: path)
+        result = api_post('/api/knowledge/health', path: options[:corpus_path])
         out = formatter
         if options[:json]
           out.json(result)
@@ -412,9 +376,8 @@ module Legion
       option :corpus_path, type: :string, desc: 'Path to corpus directory (falls back to settings)'
       option :dry_run, type: :boolean, default: true, desc: 'Preview without archiving (default: true)'
       def maintain
-        require_maintenance!
-        path = resolve_corpus_path
-        result = knowledge_maintenance.cleanup_orphans(path: path, dry_run: options[:dry_run])
+        result = api_post('/api/knowledge/maintain',
+                          path: options[:corpus_path], dry_run: options[:dry_run])
         out = formatter
         if options[:json]
           out.json(result)
@@ -434,8 +397,7 @@ module Legion
       desc 'quality', 'Show knowledge quality report (hot, cold, low-confidence chunks)'
       option :limit, type: :numeric, default: 10, desc: 'Max entries per category'
       def quality
-        require_maintenance!
-        result = knowledge_maintenance.quality_report(limit: options[:limit])
+        result = api_post('/api/knowledge/quality', limit: options[:limit])
         out = formatter
         if options[:json]
           out.json(result)
@@ -459,54 +421,13 @@ module Legion
       desc 'capture SUBCOMMAND', 'Capture knowledge from git commits or sessions'
       subcommand 'capture', CaptureCommand
 
-      no_commands do # rubocop:disable Metrics/BlockLength
+      no_commands do
+        include ApiClient
+
         def formatter
           @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
         end
 
-        def require_knowledge!
-          Connection.ensure_knowledge unless defined?(Legion::Extensions::Knowledge::Runners::Query)
-        end
-
-        def require_ingest!
-          Connection.ensure_knowledge unless defined?(Legion::Extensions::Knowledge::Runners::Ingest)
-        end
-
-        def require_maintenance!
-          Connection.ensure_knowledge unless defined?(Legion::Extensions::Knowledge::Runners::Maintenance)
-        end
-
-        def knowledge_query
-          Legion::Extensions::Knowledge::Runners::Query
-        end
-
-        def knowledge_ingest
-          Legion::Extensions::Knowledge::Runners::Ingest
-        end
-
-        def knowledge_maintenance
-          Legion::Extensions::Knowledge::Runners::Maintenance
-        end
-
-        def resolve_corpus_path
-          if options[:corpus_path]
-            options[:corpus_path]
-          elsif defined?(Legion::Extensions::Knowledge::Runners::Monitor)
-            monitors = Legion::Extensions::Knowledge::Runners::Monitor.resolve_monitors
-            monitors.first&.dig(:path) || legacy_corpus_path || ::Dir.pwd
-          elsif defined?(Legion::Settings)
-            Legion::Settings.dig(:knowledge, :corpus_path) || ::Dir.pwd
-          else
-            ::Dir.pwd
-          end
-        end
-
-        def legacy_corpus_path
-          return unless defined?(Legion::Settings)
-
-          Legion::Settings.dig(:knowledge, :corpus_path)
-        end
-
         def print_sources(sources, out, verbose:)
           return out.warn('No sources found') if sources.empty?
 

data/lib/legion/cli/schedule_command.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'api_client'
+
 module Legion
   module CLI
     class Schedule < Thor
@@ -17,22 +19,20 @@ module Legion
       option :limit, type: :numeric, default: 20, desc: 'Max results'
       def list
         out = formatter
-        with_data do
-          require_scheduler!
-          ds = Legion::Extensions::Scheduler::Data::Model::Schedule.dataset
-          ds = ds.where(active: true) if options[:active]
-          schedules = ds.limit(options[:limit]).all
-
-          if options[:json]
-            out.json(schedules.map(&:values))
-          else
-            rows = schedules.map do |s|
-              [s[:id], s[:function_id] || '-', s[:cron] || s[:interval] || '-',
-               out.status(s[:active] ? 'active' : 'inactive'), s[:description] || '-']
-            end
-            out.table(%w[ID Function Schedule Status Description], rows)
-            puts "  #{schedules.size} schedule(s)"
+        query = "/api/schedules?limit=#{options[:limit]}"
+        query += '&active=true' if options[:active]
+        schedules = api_get(query)
+        schedules = [] if schedules.nil?
+
+        if options[:json]
+          out.json(schedules)
+        else
+          rows = Array(schedules).map do |s|
+            [s[:id], s[:function_id] || '-', s[:cron] || s[:interval] || '-',
+             out.status(s[:active] ? 'active' : 'inactive'), s[:description] || '-']
           end
+          out.table(%w[ID Function Schedule Status Description], rows)
+          puts "  #{rows.size} schedule(s)"
         end
       end
       default_task :list
@@ -40,21 +40,14 @@ module Legion
       desc 'show ID', 'Show schedule details'
       def show(id)
         out = formatter
-        with_data do
-          require_scheduler!
-          schedule = Legion::Extensions::Scheduler::Data::Model::Schedule[id.to_i]
-          unless schedule
-            out.error("Schedule not found: #{id}")
-            return
-          end
-
-          if options[:json]
-            out.json(schedule.values)
-          else
-            out.header("Schedule ##{id}")
-            out.spacer
-            out.detail(schedule.values.transform_keys(&:to_s))
-          end
+        schedule = api_get("/api/schedules/#{id}")
+
+        if options[:json]
+          out.json(schedule)
+        else
+          out.header("Schedule ##{id}")
+          out.spacer
+          out.detail(schedule.transform_keys(&:to_s))
         end
       end
 
@@ -65,24 +58,22 @@ module Legion
       option :description, type: :string, desc: 'Schedule description'
       def add
         out = formatter
-        with_data do
-          require_scheduler!
-          attrs = { function_id: options[:function_id], active: true, created_at: Time.now.utc }
-          attrs[:cron] = options[:cron] if options[:cron]
-          attrs[:interval] = options[:interval] if options[:interval]
-          attrs[:description] = options[:description] if options[:description]
-
-          unless attrs[:cron] || attrs[:interval]
-            out.error('Either --cron or --interval is required')
-            return
-          end
 
-          id = Legion::Extensions::Scheduler::Data::Model::Schedule.insert(attrs)
-          if options[:json]
-            out.json({ id: id, created: true })
-          else
-            out.success("Schedule ##{id} created")
-          end
+        unless options[:cron] || options[:interval]
+          out.error('Either --cron or --interval is required')
+          return
+        end
+
+        payload = { function_id: options[:function_id], active: true }
+        payload[:cron] = options[:cron] if options[:cron]
+        payload[:interval] = options[:interval] if options[:interval]
+        payload[:description] = options[:description] if options[:description]
+
+        result = api_post('/api/schedules', **payload)
+        if options[:json]
+          out.json(result)
+        else
+          out.success("Schedule ##{result[:id]} created")
         end
       end
 
@@ -90,25 +81,17 @@ module Legion
       option :yes, type: :boolean, default: false, aliases: '-y', desc: 'Skip confirmation'
       def remove(id)
         out = formatter
-        with_data do
-          require_scheduler!
-          schedule = Legion::Extensions::Scheduler::Data::Model::Schedule[id.to_i]
-          unless schedule
-            out.error("Schedule not found: #{id}")
-            return
-          end
 
-          unless options[:yes]
-            print "Delete schedule ##{id}? [y/N] "
-            return unless $stdin.gets&.strip&.downcase == 'y'
-          end
+        unless options[:yes]
+          print "Delete schedule ##{id}? [y/N] "
+          return unless $stdin.gets&.strip&.downcase == 'y'
+        end
 
-          schedule.delete
-          if options[:json]
-            out.json({ id: id.to_i, deleted: true })
-          else
-            out.success("Schedule ##{id} deleted")
-          end
+        result = api_delete("/api/schedules/#{id}")
+        if options[:json]
+          out.json({ id: id.to_i, deleted: true }.merge(result || {}))
+        else
+          out.success("Schedule ##{id} deleted")
         end
       end
 
@@ -116,58 +99,33 @@ module Legion
       option :limit, type: :numeric, default: 20, desc: 'Max results'
       def logs(id)
         out = formatter
-        with_data do
-          require_scheduler!
-          schedule = Legion::Extensions::Scheduler::Data::Model::Schedule[id.to_i]
-          unless schedule
-            out.error("Schedule not found: #{id}")
-            return
-          end
-
-          log_entries = Legion::Extensions::Scheduler::Data::Model::ScheduleLog
-                        .where(schedule_id: id.to_i)
-                        .order(Sequel.desc(:id))
-                        .limit(options[:limit]).all
-
-          if options[:json]
-            out.json(log_entries.map(&:values))
+        log_entries = api_get("/api/schedules/#{id}/logs?limit=#{options[:limit]}")
+        log_entries = [] if log_entries.nil?
+
+        if options[:json]
+          out.json(log_entries)
+        else
+          out.header("Logs for Schedule ##{id}")
+          if Array(log_entries).empty?
+            puts '  No logs found.'
           else
-            out.header("Logs for Schedule ##{id}")
-            if log_entries.empty?
-              puts '  No logs found.'
-            else
-              rows = log_entries.map { |l| [l[:id], l[:status] || '-', l[:started_at]&.to_s || '-', l[:message] || '-'] }
-              out.table(%w[ID Status Started Message], rows)
+            rows = Array(log_entries).map do |l|
+              [l[:id], l[:status] || '-', l[:started_at]&.to_s || '-', l[:message] || '-']
             end
+            out.table(%w[ID Status Started Message], rows)
           end
         end
       end
 
       no_commands do
+        include ApiClient
+
         def formatter
           @formatter ||= Output::Formatter.new(
             json:  options[:json],
             color: !options[:no_color]
           )
         end
-
-        def with_data
-          Connection.config_dir = options[:config_dir] if options[:config_dir]
-          Connection.log_level = options[:verbose] ? 'debug' : 'error'
-          Connection.ensure_data
-          yield
-        rescue CLI::Error => e
-          formatter.error(e.message)
-          raise SystemExit, 1
-        ensure
-          Connection.shutdown
-        end
-
-        def require_scheduler!
-          return if defined?(Legion::Extensions::Scheduler::Data::Model::Schedule)
-
-          raise CLI::Error, 'lex-scheduler extension is not loaded. Install and enable it first.'
-        end
       end
     end
   end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.44'
+  VERSION = '1.6.45'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.44
+  version: 1.6.45
 platform: ruby
 authors:
 - Esity
@@ -489,6 +489,7 @@ files:
 - lib/legion/api/graphql/types/task_type.rb
 - lib/legion/api/graphql/types/worker_type.rb
 - lib/legion/api/helpers.rb
+- lib/legion/api/knowledge.rb
 - lib/legion/api/lex_dispatch.rb
 - lib/legion/api/library_routes.rb
 - lib/legion/api/llm.rb
@@ -540,6 +541,7 @@ files:
 - lib/legion/cli/acp_command.rb
 - lib/legion/cli/admin/purge_topology.rb
 - lib/legion/cli/admin_command.rb
+- lib/legion/cli/api_client.rb
 - lib/legion/cli/apollo_command.rb
 - lib/legion/cli/audit_command.rb
 - lib/legion/cli/auth_command.rb