legionio 1.4.91 → 1.4.93

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e39fb298ff77ee509f8a7948c14455a48b4764503688ead869e48ea4108e72a0
-  data.tar.gz: 0266b0b3d36ecf72e7b2be8d2f0f42ae9737fd0a37add807b32a608dd7fcf5c0
+  metadata.gz: 318839858d16ecbaaf6c7db4a0d9562e1641ca24d174fda914b9d359f3f91e69
+  data.tar.gz: 91e1415070e2f547bc7c71646e79312f048f8973b2cb004045a8d546a0000387
 SHA512:
-  metadata.gz: 5edbd698137c046896280b44cd8af35580808068a24ee48a95dd495e48f57df5eb0976865e6ca8f60938bf96e0d3a969a0085f6ba18a93b8045c34f41958f119
-  data.tar.gz: 3048fe946eaade9f1e3ecb611d4eced9e78bb5e80126d09e73a55b5e7aa017df594e75f2e17fc3b88af87d9e1d960ee5c988dc0e7022d4260a2fa60ba3645b06
+  metadata.gz: e5cd6e2ff71cc11db2a1e8928aae0c53104f931c18829bf470658bbcac3e2f90a18aeb7c564dcc7eb3f113fa9c65b54bb165a0f322fc3b1021a0ebf98148bf66
+  data.tar.gz: ff3c9e796fef50d7ca2e7b1970c4516a2d839031f8bee6036fc43b758f0035d85b5bc80fd631c5e55d8a83ce28fe5a7ccfa55fa69b67237b868331d1606d3d34

data/.rubocop.yml

@@ -41,6 +41,7 @@ Metrics/BlockLength:
     - 'lib/legion/api/auth_human.rb'
     - 'lib/legion/cli/auth_command.rb'
     - 'lib/legion/cli/detect_command.rb'
+    - 'lib/legion/cli/prompt_command.rb'
     - 'lib/legion/api/acp.rb'
 
 Metrics/AbcSize:

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Legion Changelog
 
+## [1.4.93] - 2026-03-20
+
+### Added
+- `legion prompt` CLI subcommand for versioned LLM prompt template management (list, show, create, tag, diff)
+- `legion dataset` CLI subcommand for versioned dataset management (list, show, import, export)
+- Both commands wrap `lex-prompt` and `lex-dataset` extension clients via `begin/rescue LoadError` guards
+- Both commands guard with `Connection.ensure_data` and follow existing `with_*_client` pattern
+- Tab completion entries for `prompt` and `dataset` in `completions/legion.bash` and `completions/_legion`
+
+## [1.4.92] - 2026-03-20
+
+### Added
+- `--template` option on `legion lex create` to scaffold pattern-specific extensions: `llm-agent`, `service-integration`, `data-pipeline` (default: `basic`)
+- `--list-templates` option on `legion lex create` to display available templates with descriptions
+- `LexTemplates::TemplateOverlay` class renders ERB template files into the target extension directory
+- ERB scaffold templates under `lib/legion/cli/lex/templates/`: `llm_agent/`, `service_integration/`, `data_pipeline/`
+- `llm-agent` template: LLM runner with `Legion::LLM.chat` and structured output, helpers/client.rb with model/temperature kwargs, default prompt YAML, spec with LLM mock
+- `service-integration` template: CRUD runners (list/get/create/update/delete), Faraday HTTP client helper with api_key/bearer/basic auth, auth helper, specs with WebMock stubs
+- `data-pipeline` template: transform runner with validate/process/publish pattern, subscription ingest actor, transport exchange/queue/message scaffolds, runner and actor specs
+- Template registry extended with `data-pipeline`, `template_dir` class method, new `llm-agent`/`service-integration` entries with `template_dir` keys
+
 ## [1.4.91] - 2026-03-20
 
 ### Fixed

data/completions/_legion

@@ -45,6 +45,8 @@ _legion() {
         commit)     _legion_commit ;;
         pr)         _legion_pr ;;
         review)     _legion_review ;;
+        prompt)     _legion_prompt ;;
+        dataset)    _legion_dataset ;;
       esac
       ;;
   esac
@@ -62,6 +64,8 @@ _legion_commands() {
     'init:Interactive project setup wizard'
     'tty:Launch interactive TTY shell'
     'ask:Quick AI prompt (shortcut for chat prompt)'
+    'prompt:Manage versioned LLM prompt templates'
+    'dataset:Manage versioned datasets'
     'version:Show version information'
     'help:Show help'
   )
@@ -837,4 +841,123 @@ _legion_check() {
     '--no-color[Disable color output]'
 }
 
+_legion_prompt() {
+  local -a subcmds
+  subcmds=(
+    'list:List all prompts'
+    'show:Show a prompt template and parameters'
+    'create:Create a new prompt'
+    'tag:Tag a prompt version'
+    'diff:Show text diff between two versions of a prompt'
+  )
+
+  _arguments -C \
+    '--json[Output as JSON]' \
+    '--no-color[Disable color output]' \
+    '--help[Show help]' \
+    '1: :->cmd' \
+    '*:: :->args'
+
+  case $state in
+    cmd)  _describe 'prompt command' subcmds ;;
+    args)
+      case $words[1] in
+        list)
+          _arguments \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+        show)
+          _arguments \
+            ':prompt name:' \
+            '--version[Specific version number]:version:' \
+            '--tag[Tag name to resolve]:tag:' \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+        create)
+          _arguments \
+            ':prompt name:' \
+            '--template[Prompt template text]:template:' \
+            '--description[Short description]:desc:' \
+            '--model-params[Model parameters as JSON]:json:' \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+        tag)
+          _arguments \
+            ':prompt name:' \
+            ':tag name:' \
+            '--version[Version to tag]:version:' \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+        diff)
+          _arguments \
+            ':prompt name:' \
+            ':version 1:' \
+            ':version 2:' \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_legion_dataset() {
+  local -a subcmds
+  subcmds=(
+    'list:List all datasets'
+    'show:Show dataset info and first 10 rows'
+    'import:Import a dataset from a file'
+    'export:Export a dataset to a file'
+  )
+
+  _arguments -C \
+    '--json[Output as JSON]' \
+    '--no-color[Disable color output]' \
+    '--help[Show help]' \
+    '1: :->cmd' \
+    '*:: :->args'
+
+  case $state in
+    cmd)  _describe 'dataset command' subcmds ;;
+    args)
+      case $words[1] in
+        list)
+          _arguments \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+        show)
+          _arguments \
+            ':dataset name:' \
+            '--version[Specific version number]:version:' \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+        import)
+          _arguments \
+            ':dataset name:' \
+            ':file path:_files' \
+            '--format[File format]:format:(json csv jsonl)' \
+            '--description[Dataset description]:desc:' \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+        export)
+          _arguments \
+            ':dataset name:' \
+            ':output path:_files' \
+            '--format[File format]:format:(json csv jsonl)' \
+            '--version[Version to export]:version:' \
+            '--json[Output as JSON]' \
+            '--no-color[Disable color output]'
+          ;;
+      esac
+      ;;
+  esac
+}
+
 _legion "$@"

data/completions/legion.bash

@@ -26,7 +26,7 @@ _legion_complete() {
     cword=$COMP_CWORD
   }
 
-  local top_commands="chat commit pr review memory plan init tty ask version help"
+  local top_commands="chat commit pr review memory plan init tty ask prompt dataset version help"
   local global_flags="--json --no-color --verbose --config-dir --help"
 
   # Top-level command
@@ -264,6 +264,33 @@ _legion_complete() {
       COMPREPLY=($(compgen -W "--json --no-color --help" -- "${cur}"))
       ;;
 
+    prompt)
+      if [[ $cword -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "list show create tag diff" -- "${cur}"))
+      else
+        case "${words[2]}" in
+          list)   COMPREPLY=($(compgen -W "--json --no-color --help" -- "${cur}")) ;;
+          show)   COMPREPLY=($(compgen -W "--version --tag --json --no-color --help" -- "${cur}")) ;;
+          create) COMPREPLY=($(compgen -W "--template --description --model-params --json --no-color --help" -- "${cur}")) ;;
+          tag)    COMPREPLY=($(compgen -W "--version --json --no-color --help" -- "${cur}")) ;;
+          diff)   COMPREPLY=($(compgen -W "--json --no-color --help" -- "${cur}")) ;;
+        esac
+      fi
+      ;;
+
+    dataset)
+      if [[ $cword -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "list show import export" -- "${cur}"))
+      else
+        case "${words[2]}" in
+          list)   COMPREPLY=($(compgen -W "--json --no-color --help" -- "${cur}")) ;;
+          show)   COMPREPLY=($(compgen -W "--version --json --no-color --help" -- "${cur}")) ;;
+          import) COMPREPLY=($(compgen -W "--format --description --json --no-color --help" -- "${cur}")) ;;
+          export) COMPREPLY=($(compgen -W "--format --version --json --no-color --help" -- "${cur}")) ;;
+        esac
+      fi
+      ;;
+
     dream)
       COMPREPLY=($(compgen -W "--wait --json --no-color --help" -- "${cur}"))
       ;;

data/lib/legion/cli/dataset_command.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Legion
+  module CLI
+    class Dataset < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json,       type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color,   type: :boolean, default: false, desc: 'Disable color output'
+      class_option :verbose,    type: :boolean, default: false, aliases: ['-V'], desc: 'Verbose logging'
+      class_option :config_dir, type: :string,                  desc: 'Config directory path'
+
+      desc 'list', 'List all datasets'
+      def list
+        out = formatter
+        with_dataset_client do |client|
+          datasets = client.list_datasets
+          if options[:json]
+            out.json(datasets)
+          elsif datasets.empty?
+            out.warn('No datasets found')
+          else
+            rows = datasets.map do |d|
+              [d[:name].to_s, (d[:description] || '').to_s,
+               (d[:latest_version] || '-').to_s, (d[:row_count] || 0).to_s]
+            end
+            out.table(%w[name description version row_count], rows)
+          end
+        end
+      end
+      default_task :list
+
+      desc 'show NAME', 'Show dataset info and first 10 rows'
+      option :version, type: :numeric, desc: 'Specific version number'
+      def show(name)
+        out = formatter
+        with_dataset_client do |client|
+          kwargs = { name: name }
+          kwargs[:version] = options[:version] if options[:version]
+          result = client.get_dataset(**kwargs)
+          if result[:error]
+            out.error("Dataset '#{name}': #{result[:error]}")
+            raise SystemExit, 1
+          end
+
+          if options[:json]
+            out.json(result)
+          else
+            out.header("Dataset: #{result[:name]}")
+            out.spacer
+            out.detail({ version: result[:version], row_count: result[:row_count] })
+            out.spacer
+            preview = (result[:rows] || []).first(10)
+            if preview.empty?
+              out.warn('No rows in this dataset version')
+            else
+              rows = preview.map do |r|
+                [r[:row_index].to_s, r[:input].to_s.slice(0, 60), (r[:expected_output] || '').to_s.slice(0, 60)]
+              end
+              out.table(%w[index input expected_output], rows)
+              remaining = result[:row_count].to_i - preview.size
+              out.warn("... #{remaining} more rows not shown") if remaining.positive?
+            end
+          end
+        end
+      end
+
+      desc 'import NAME PATH', 'Import a dataset from a file'
+      option :format,      type: :string, default: 'json', enum: %w[json csv jsonl], desc: 'File format'
+      option :description, type: :string, desc: 'Dataset description'
+      def import(name, path)
+        out = formatter
+        with_dataset_client do |client|
+          unless File.exist?(path)
+            out.error("File not found: #{path}")
+            raise SystemExit, 1
+          end
+
+          result = client.import_dataset(
+            name:        name,
+            path:        path,
+            format:      options[:format],
+            description: options[:description]
+          )
+          if options[:json]
+            out.json(result)
+          else
+            out.success("Imported '#{result[:name]}' v#{result[:version]} (#{result[:row_count]} rows)")
+          end
+        end
+      end
+
+      desc 'export NAME PATH', 'Export a dataset to a file'
+      option :format,  type: :string,  default: 'json', enum: %w[json csv jsonl], desc: 'File format'
+      option :version, type: :numeric, desc: 'Version to export'
+      def export(name, path)
+        out = formatter
+        with_dataset_client do |client|
+          kwargs = { name: name, path: path, format: options[:format] }
+          kwargs[:version] = options[:version] if options[:version]
+          result = client.export_dataset(**kwargs)
+          if options[:json]
+            out.json(result)
+          else
+            out.success("Exported #{result[:row_count]} rows to #{result[:path]}")
+          end
+        end
+      end
+
+      no_commands do
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        def with_dataset_client
+          Connection.config_dir = options[:config_dir] if options[:config_dir]
+          Connection.log_level  = options[:verbose] ? 'debug' : 'error'
+          Connection.ensure_data
+
+          begin
+            require 'legion/extensions/dataset'
+            require 'legion/extensions/dataset/runners/dataset'
+            require 'legion/extensions/dataset/client'
+          rescue LoadError
+            formatter.error('lex-dataset gem is not installed (gem install lex-dataset)')
+            raise SystemExit, 1
+          end
+
+          db = Legion::Data.db
+          client = Legion::Extensions::Dataset::Client.new(db: db)
+          yield client
+        rescue CLI::Error => e
+          formatter.error(e.message)
+          raise SystemExit, 1
+        ensure
+          Connection.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/data_pipeline/actors/ingest.rb.erb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Actors
+        class Ingest < Legion::Extensions::Actors::Subscription
+          include Legion::Extensions::<%= lex_class %>::Runners::Transform
+
+          QUEUE    = 'legion.<%= lex_name %>.ingest'
+          EXCHANGE = 'legion.<%= lex_name %>'
+
+          def self.queue
+            QUEUE
+          end
+
+          def self.exchange
+            EXCHANGE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/data_pipeline/runners/transform.rb.erb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Runners
+        module Transform
+          extend Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?('Helpers::Lex')
+
+          # Main transform entry point. Receives a payload hash, returns transformed output.
+          def transform(payload:, options: {}, **)
+            validated = validate_input(payload)
+            return validated unless validated[:success]
+
+            result = process(validated[:data], options)
+            publish_output(result) if defined?(Legion::Transport)
+
+            { success: true, data: result }
+          rescue StandardError => e
+            handle_error(e, payload)
+          end
+
+          private
+
+          def validate_input(payload)
+            return { success: false, reason: 'payload is required' } if payload.nil?
+            return { success: false, reason: 'payload must be a Hash' } unless payload.is_a?(Hash)
+
+            { success: true, data: payload }
+          end
+
+          def process(data, _options)
+            # TODO: implement transformation logic
+            data
+          end
+
+          def publish_output(result)
+            return unless defined?(Legion::Transport)
+
+            Legion::Transport::Messages::<%= name_class %>Output.new(data: result).publish
+          rescue StandardError
+            nil
+          end
+
+          def handle_error(error, payload)
+            {
+              success: false,
+              reason:  error.message,
+              payload: payload
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/data_pipeline/spec/actors/ingest_spec.rb.erb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::<%= lex_class %>::Actors::Ingest do
+  it 'inherits from Subscription actor' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Actors::Subscription)
+  end
+
+  it 'includes the Transform runner' do
+    expect(described_class.ancestors).to include(Legion::Extensions::<%= lex_class %>::Runners::Transform)
+  end
+
+  it 'defines a queue name' do
+    expect(described_class::QUEUE).to include('<%= lex_name %>')
+  end
+
+  it 'defines an exchange name' do
+    expect(described_class::EXCHANGE).to include('<%= lex_name %>')
+  end
+end

data/lib/legion/cli/lex/templates/data_pipeline/spec/runners/transform_spec.rb.erb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::<%= lex_class %>::Runners::Transform do
+  subject { described_class }
+
+  let(:test_class) do
+    Class.new do
+      extend Legion::Extensions::<%= lex_class %>::Runners::Transform
+    end
+  end
+
+  it { should be_a Module }
+  it { is_expected.to respond_to(:transform).with_any_keywords }
+
+  describe '#transform' do
+    it 'returns success for a valid payload' do
+      result = test_class.transform(payload: { key: 'value' })
+      expect(result[:success]).to be true
+      expect(result[:data]).to be_a(Hash)
+    end
+
+    it 'returns failure when payload is nil' do
+      result = test_class.transform(payload: nil)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to include('required')
+    end
+
+    it 'returns failure when payload is not a Hash' do
+      result = test_class.transform(payload: 'not a hash')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to include('Hash')
+    end
+
+    it 'handles unexpected errors gracefully' do
+      allow(test_class).to receive(:process).and_raise(StandardError, 'unexpected')
+      result = test_class.transform(payload: { key: 'value' })
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq('unexpected')
+    end
+  end
+end

data/lib/legion/cli/lex/templates/data_pipeline/transport/exchanges/%name%.rb.erb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Transport
+        module Exchanges
+          class <%= name_class %> < Legion::Transport::Exchange
+            EXCHANGE_NAME = 'legion.<%= lex_name %>'
+            EXCHANGE_TYPE = :direct
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/data_pipeline/transport/messages/%name%_output.rb.erb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Transport
+        module Messages
+          class <%= name_class %>Output < Legion::Transport::Message
+            EXCHANGE_NAME = 'legion.<%= lex_name %>'
+            ROUTING_KEY   = 'output'
+
+            attr_accessor :data
+
+            def initialize(data:)
+              @data = data
+              super()
+            end
+
+            def to_payload
+              { data: @data }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/data_pipeline/transport/queues/ingest.rb.erb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Transport
+        module Queues
+          class Ingest < Legion::Transport::Queue
+            QUEUE_NAME   = 'legion.<%= lex_name %>.ingest'
+            EXCHANGE_NAME = 'legion.<%= lex_name %>'
+            ROUTING_KEY  = 'ingest'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/llm_agent/helpers/client.rb.erb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Helpers
+        class Client
+          attr_reader :model, :temperature, :max_tokens
+
+          def initialize(model: nil, temperature: 0.7, max_tokens: 1024, **)
+            @model       = model
+            @temperature = temperature
+            @max_tokens  = max_tokens
+          end
+
+          def chat(prompt:, **override)
+            return { success: false, reason: 'legion-llm not available' } unless defined?(Legion::LLM)
+
+            opts = { prompt: prompt, temperature: @temperature, max_tokens: @max_tokens }
+            opts[:model] = @model if @model
+            opts.merge!(override)
+
+            Legion::LLM.chat(**opts)
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          def structured(prompt:, schema:, **override)
+            return { success: false, reason: 'legion-llm not available' } unless defined?(Legion::LLM)
+
+            opts = { prompt: prompt, schema: schema }
+            opts[:model] = @model if @model
+            opts.merge!(override)
+
+            Legion::LLM.structured(**opts)
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/llm_agent/prompts/default.yml.erb

@@ -0,0 +1,14 @@
+---
+# Default prompt template for <%= gem_name %>
+# Customize system and user prompts for your use case.
+
+system: |
+  You are a helpful assistant for <%= lex_class %>.
+  Respond concisely and accurately.
+
+user: |
+  <%= '{{input}}' %>
+
+examples:
+  - input: "What can you help me with?"
+    expected: "I can help you with <%= lex_class.downcase %>-related tasks."

data/lib/legion/cli/lex/templates/llm_agent/runners/%name%.rb.erb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Runners
+        module <%= name_class %>
+          extend Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?('Helpers::Lex')
+
+          def run(prompt:, model: nil, temperature: nil, structured: false, schema: nil, **)
+            llm_opts = { prompt: prompt }
+            llm_opts[:model] = model if model
+            llm_opts[:temperature] = temperature if temperature
+
+            if structured && defined?(Legion::LLM)
+              response = Legion::LLM.structured(prompt: prompt, schema: schema || default_schema)
+            elsif defined?(Legion::LLM)
+              response = Legion::LLM.chat(**llm_opts)
+            else
+              return { success: false, reason: 'legion-llm not available' }
+            end
+
+            { success: true, response: response }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          private
+
+          def default_schema
+            { type: 'object', properties: { result: { type: 'string' } } }
+          end
+        end
+      end
+    end
+  end
+end