legionio 1.4.93 → 1.4.95

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 318839858d16ecbaaf6c7db4a0d9562e1641ca24d174fda914b9d359f3f91e69
-  data.tar.gz: 91e1415070e2f547bc7c71646e79312f048f8973b2cb004045a8d546a0000387
+  metadata.gz: a110098f876265aa1233e4ca1e60baf30f5a23340b8d9de1f4a9c942ea0128fd
+  data.tar.gz: 3144aab6b5cab4ed042fee55d344cd2a8493ac48284a74ef431238643d91a863
 SHA512:
-  metadata.gz: e5cd6e2ff71cc11db2a1e8928aae0c53104f931c18829bf470658bbcac3e2f90a18aeb7c564dcc7eb3f113fa9c65b54bb165a0f322fc3b1021a0ebf98148bf66
-  data.tar.gz: ff3c9e796fef50d7ca2e7b1970c4516a2d839031f8bee6036fc43b758f0035d85b5bc80fd631c5e55d8a83ce28fe5a7ccfa55fa69b67237b868331d1606d3d34
+  metadata.gz: 8a5a7090df59bcf09e9bc2dc5cd2c60a7e774b7551b2cc7583d2eb1afdc5f6b3319ec911a8cce0130c0dc93679260ac83cf57e5c598b17c6d6ccb4ba229058ac
+  data.tar.gz: f6a2135e2ce480e7bce8f80eec8ab6e467c9e531ea10960470f2d2e7c3fb7325b84d3b9f256247255cd5c00220d21f53da8520c5b3e3045a6f446ce75f1600d8

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Legion Changelog
 
+## [1.4.95] - 2026-03-20
+
+### Added
+- `GET /api/prompts` — list all prompt templates via lex-prompt Client
+- `GET /api/prompts/:name` — show prompt details for the latest version
+- `POST /api/prompts/:name/run` — render a prompt template with variables and run it through Legion::LLM; returns rendered_prompt, response, usage, model, version
+- 503 guard for missing lex-prompt dependency (LoadError rescue in `prompt_client` helper)
+- 503 guard for LLM subsystem unavailable on the `/run` endpoint
+- 404 on prompt not found, 422 on version not found for `/run`
+- 32 new specs in `spec/legion/api/prompts_spec.rb` covering all routes and error paths
+
+## [1.4.94] - 2026-03-20
+
+### Added
+- `legion prompt play NAME` subcommand: renders a prompt template with variables and sends it to an LLM via `Legion::LLM.chat`
+- `--variables` (JSON), `--version`, `--model`, `--provider`, and `--compare` options on `play`
+- Compare mode (`--compare VERSION`): renders two prompt versions, calls LLM for each, displays side-by-side responses and diff when they differ
+- JSON output mode for `play` and compare via `--json`
+- `Connection.ensure_llm` called inside `with_prompt_client` so LLM is available to all prompt subcommands
+- 14 new specs for `play` covering single-version, compare, LLM unavailable, JSON output, and error paths
+
 ## [1.4.93] - 2026-03-20
 
 ### Added

data/lib/legion/api/prompts.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Prompts
+        def self.registered(app)
+          app.helpers do
+            define_method(:require_llm!) do
+              return if defined?(Legion::LLM) &&
+                        Legion::LLM.respond_to?(:started?) &&
+                        Legion::LLM.started?
+
+              halt 503, json_error('llm_unavailable', 'LLM subsystem is not available', status_code: 503)
+            end
+
+            define_method(:prompt_client) do
+              require 'legion/extensions/prompt/client'
+              Legion::Extensions::Prompt::Client.new
+            rescue LoadError
+              halt 503, json_error('prompt_unavailable', 'lex-prompt is not loaded', status_code: 503)
+            end
+          end
+
+          register_list(app)
+          register_show(app)
+          register_run(app)
+        end
+
+        def self.register_list(app)
+          app.get '/api/prompts' do
+            client = prompt_client
+            result = client.list_prompts
+            json_response(result)
+          rescue StandardError => e
+            Legion::Logging.error "API prompts list error: #{e.message}"
+            json_error('execution_error', e.message, status_code: 500)
+          end
+        end
+
+        def self.register_show(app)
+          app.get '/api/prompts/:name' do
+            name = params[:name]
+            client = prompt_client
+            result = client.get_prompt(name: name)
+
+            halt 404, json_error('not_found', "prompt '#{name}' not found", status_code: 404) if result[:error]
+
+            json_response(result)
+          rescue StandardError => e
+            Legion::Logging.error "API prompts show error: #{e.message}"
+            json_error('execution_error', e.message, status_code: 500)
+          end
+        end
+
+        def self.register_run(app)
+          app.post '/api/prompts/:name/run' do
+            require_llm!
+
+            name      = params[:name]
+            body      = parse_request_body
+            variables = body[:variables] || {}
+            version   = body[:version]
+            model     = body[:model]
+            provider  = body[:provider]
+
+            client = prompt_client
+            rendered = client.render_prompt(name: name, variables: variables, version: version)
+
+            if rendered[:error]
+              code = rendered[:error] == 'not_found' ? 404 : 422
+              halt code, json_error(rendered[:error], "prompt '#{name}' #{rendered[:error].tr('_', ' ')}", status_code: code)
+            end
+
+            session  = Legion::LLM.chat_direct(model: model, provider: provider)
+            response = session.ask(rendered[:rendered])
+
+            prompt_version = rendered[:prompt_version]
+            model_used     = session.model.to_s
+
+            usage = {
+              input_tokens:  response.respond_to?(:input_tokens) ? response.input_tokens : nil,
+              output_tokens: response.respond_to?(:output_tokens) ? response.output_tokens : nil
+            }
+
+            json_response({
+                            name:            name,
+                            version:         prompt_version,
+                            rendered_prompt: rendered[:rendered],
+                            response:        response.content,
+                            usage:           usage,
+                            model:           model_used,
+                            provider:        provider
+                          })
+          rescue StandardError => e
+            Legion::Logging.error "API prompts run error: #{e.message}"
+            json_error('execution_error', e.message, status_code: 500)
+          end
+        end
+
+        class << self
+          private :register_list, :register_show, :register_run
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -38,6 +38,7 @@ require_relative 'api/org_chart'
 require_relative 'api/workflow'
 require_relative 'api/governance'
 require_relative 'api/acp'
+require_relative 'api/prompts'
 
 module Legion
   class API < Sinatra::Base
@@ -120,6 +121,7 @@ module Legion
     register Routes::OrgChart
     register Routes::Governance
     register Routes::Acp
+    register Routes::Prompts
 
     use Legion::Rbac::Middleware if defined?(Legion::Rbac::Middleware)
 

data/lib/legion/cli/prompt_command.rb

@@ -140,6 +140,36 @@ module Legion
         end
       end
 
+      desc 'play NAME', 'Run a prompt through an LLM and display the response'
+      option :variables, type: :string,  desc: 'Template variables as JSON'
+      option :version,   type: :numeric, desc: 'Prompt version'
+      option :model,     type: :string,  desc: 'LLM model override'
+      option :provider,  type: :string,  desc: 'LLM provider override'
+      option :compare,   type: :numeric, desc: 'Compare with this version'
+      def play(name)
+        out = formatter
+        with_prompt_client do |client|
+          unless defined?(Legion::LLM) && Legion::LLM.started?
+            out.error('legion-llm is not available. Install legion-llm and configure a provider.')
+            raise SystemExit, 1
+          end
+
+          vars = parse_variables(options[:variables], out)
+          return if vars.nil?
+
+          llm_kwargs = {}
+          llm_kwargs[:model]    = options[:model]    if options[:model]
+          llm_kwargs[:provider] = options[:provider] if options[:provider]
+
+          base_ctx = { name: name, vars: vars, llm_kwargs: llm_kwargs, client: client, out: out }
+          if options[:compare]
+            run_compare(base_ctx.merge(ver_a: options[:version], ver_b: options[:compare]))
+          else
+            run_single(base_ctx.merge(version: options[:version]))
+          end
+        end
+      end
+
       no_commands do
         def formatter
           @formatter ||= Output::Formatter.new(
@@ -152,6 +182,7 @@ module Legion
           Connection.config_dir = options[:config_dir] if options[:config_dir]
           Connection.log_level  = options[:verbose] ? 'debug' : 'error'
           Connection.ensure_data
+          Connection.ensure_llm
 
           begin
             require 'legion/extensions/prompt'
@@ -181,6 +212,15 @@ module Legion
           nil
         end
 
+        def parse_variables(raw, out)
+          return {} if raw.nil? || raw.empty?
+
+          ::JSON.parse(raw)
+        rescue ::JSON::ParserError => e
+          out.error("Invalid JSON for --variables: #{e.message}")
+          nil
+        end
+
         def diff_lines(old_text, new_text)
           old_lines = old_text.split("\n")
           new_lines = new_text.split("\n")
@@ -191,6 +231,102 @@ module Legion
           new_lines.each { |l| result << "+ #{l}" unless old_set.include?(l) }
           result.join("\n")
         end
+
+        def run_single(ctx)
+          name, version, vars, llm_kwargs, client, out = ctx.values_at(:name, :version, :vars, :llm_kwargs, :client, :out)
+          prompt = fetch_prompt(name, version, client, out)
+          return if prompt.nil?
+
+          rendered = render_prompt(name, version, vars, client, out)
+          return if rendered.nil?
+
+          response = Legion::LLM.chat(
+            messages: [{ role: 'user', content: rendered }],
+            **llm_kwargs
+          )
+
+          if options[:json]
+            out.json({ name: name, version: prompt[:version], rendered: rendered,
+                       response: response[:content], usage: response[:usage] })
+          else
+            out.header("Prompt: #{name} (v#{prompt[:version]})")
+            out.spacer
+            out.header('Rendered Template')
+            puts rendered
+            out.spacer
+            out.header('LLM Response')
+            puts response[:content]
+            display_usage(response[:usage], out)
+          end
+        end
+
+        def run_compare(ctx)
+          name, ver_a, ver_b, vars, llm_kwargs, client, out =
+            ctx.values_at(:name, :ver_a, :ver_b, :vars, :llm_kwargs, :client, :out)
+          prompt_a = fetch_prompt(name, ver_a, client, out)
+          return if prompt_a.nil?
+
+          prompt_b = fetch_prompt(name, ver_b, client, out)
+          return if prompt_b.nil?
+
+          rendered_a = render_prompt(name, prompt_a[:version], vars, client, out)
+          return if rendered_a.nil?
+
+          rendered_b = render_prompt(name, prompt_b[:version], vars, client, out)
+          return if rendered_b.nil?
+
+          response_a = Legion::LLM.chat(messages: [{ role: 'user', content: rendered_a }], **llm_kwargs)
+          response_b = Legion::LLM.chat(messages: [{ role: 'user', content: rendered_b }], **llm_kwargs)
+
+          if options[:json]
+            out.json({ name: name, version_a: prompt_a[:version], version_b: prompt_b[:version],
+                       rendered_a: rendered_a, rendered_b: rendered_b,
+                       response_a: response_a[:content], response_b: response_b[:content],
+                       usage_a: response_a[:usage], usage_b: response_b[:usage] })
+          else
+            out.header("Version A (v#{prompt_a[:version]})")
+            puts response_a[:content]
+            out.spacer
+            out.header("Version B (v#{prompt_b[:version]})")
+            puts response_b[:content]
+            content_a = response_a[:content].to_s
+            content_b = response_b[:content].to_s
+            if content_a != content_b
+              out.spacer
+              out.header('Diff (A vs B)')
+              puts diff_lines(content_a, content_b)
+            end
+          end
+        end
+
+        def fetch_prompt(name, version, client, out)
+          kwargs = { name: name }
+          kwargs[:version] = version if version
+          result = client.get_prompt(**kwargs)
+          if result[:error]
+            out.error("Prompt '#{name}': #{result[:error]}")
+            raise SystemExit, 1
+          end
+          result
+        end
+
+        def render_prompt(name, version, vars, client, out)
+          kwargs = { name: name, variables: vars }
+          kwargs[:version] = version if version
+          result = client.render_prompt(**kwargs)
+          if result.is_a?(Hash) && result[:error]
+            out.error("Render error for '#{name}': #{result[:error]}")
+            raise SystemExit, 1
+          end
+          result.is_a?(Hash) ? result[:rendered] : result
+        end
+
+        def display_usage(usage, out)
+          return unless usage && !usage.empty?
+
+          out.spacer
+          out.detail(usage)
+        end
       end
     end
   end

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.93
+  version: 1.4.95
 platform: ruby
 authors:
 - Esity
@@ -379,6 +379,7 @@ files:
 - lib/legion/api/nodes.rb
 - lib/legion/api/openapi.rb
 - lib/legion/api/org_chart.rb
+- lib/legion/api/prompts.rb
 - lib/legion/api/rbac.rb
 - lib/legion/api/relationships.rb
 - lib/legion/api/schedules.rb