legionio 1.4.91 → 1.4.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e39fb298ff77ee509f8a7948c14455a48b4764503688ead869e48ea4108e72a0
-  data.tar.gz: 0266b0b3d36ecf72e7b2be8d2f0f42ae9737fd0a37add807b32a608dd7fcf5c0
+  metadata.gz: 0d9e1879209235490bdbd660fc1d57fcc57d9487b4a17b96fce351311682fabd
+  data.tar.gz: 05e9a1fea38e182e9d2d33df3decc365f6af12d5f1a58e7496e33dfdfd5431e4
 SHA512:
-  metadata.gz: 5edbd698137c046896280b44cd8af35580808068a24ee48a95dd495e48f57df5eb0976865e6ca8f60938bf96e0d3a969a0085f6ba18a93b8045c34f41958f119
-  data.tar.gz: 3048fe946eaade9f1e3ecb611d4eced9e78bb5e80126d09e73a55b5e7aa017df594e75f2e17fc3b88af87d9e1d960ee5c988dc0e7022d4260a2fa60ba3645b06
+  metadata.gz: 2d56827c6a9bd485fb2a1e72e4b9dcd651074c1222016e3f369eee43d22d580d3c7a369bb0a07d9f47e21c453b476bf7132ec217834c3fb06fefcc1f82079b7a
+  data.tar.gz: 72c7bf18dc56f721e290a576ac71798b9559e5a91aeab6db2a720d8b5e97125e2909d62f1489dd7aea2806009b84392db5ab7cac32618e7b7b24ccc53677bfa3

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Legion Changelog
 
+## [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/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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::<%= lex_class %>::Runners::<%= name_class %> do
+  subject { described_class }
+
+  let(:test_class) do
+    Class.new do
+      extend Legion::Extensions::<%= lex_class %>::Runners::<%= name_class %>
+    end
+  end
+
+  before do
+    stub_const('Legion::LLM', Module.new do
+      def self.chat(**_opts)
+        { success: true, content: 'mock response' }
+      end
+
+      def self.structured(**_opts)
+        { success: true, result: 'mock result' }
+      end
+    end)
+  end
+
+  it { should be_a Module }
+  it { is_expected.to respond_to(:run).with_any_keywords }
+
+  describe '#run' do
+    it 'returns success with a response' do
+      result = test_class.run(prompt: 'hello')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure when legion-llm is unavailable' do
+      hide_const('Legion::LLM')
+      result = test_class.run(prompt: 'hello')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to include('legion-llm')
+    end
+  end
+end

data/lib/legion/cli/lex/templates/service_integration/helpers/auth.rb.erb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Helpers
+        module Auth
+          # Build an auth hash from settings or explicit kwargs.
+          # Supports three methods:
+          #   api_key  — { method: :api_key,  key: '...', header: 'X-API-Key' }
+          #   bearer   — { method: :bearer,   token: '...' }
+          #   basic    — { method: :basic,    username: '...', password: '...' }
+          def self.from_settings(settings = {})
+            return {} if settings.nil? || settings.empty?
+
+            auth = settings[:auth] || settings['auth'] || {}
+            return {} if auth.empty?
+
+            auth
+          end
+
+          def self.api_key(key, header: 'X-API-Key')
+            { method: :api_key, key: key, header: header }
+          end
+
+          def self.bearer(token)
+            { method: :bearer, token: token }
+          end
+
+          def self.basic(username, password)
+            { method: :basic, username: username, password: password }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module Legion
+  module Extensions
+    module <%= lex_class %>
+      module Helpers
+        class Client
+          DEFAULT_TIMEOUT = 30
+
+          class << self
+            def connection(base_url: nil, timeout: DEFAULT_TIMEOUT, auth: {}, **)
+              raise ArgumentError, 'base_url is required' if base_url.nil? || base_url.empty?
+
+              Faraday.new(url: base_url) do |conn|
+                conn.options.timeout      = timeout
+                conn.options.open_timeout = timeout
+                conn.headers['Content-Type'] = 'application/json'
+                conn.headers['Accept']       = 'application/json'
+
+                apply_auth(conn, auth)
+
+                conn.response :json, content_type: /\bjson$/
+                conn.adapter Faraday.default_adapter
+              end
+            end
+
+            private
+
+            def apply_auth(conn, auth)
+              method = auth[:method] || auth['method']
+
+              case method&.to_sym
+              when :api_key
+                header = auth[:header] || auth['header'] || 'X-API-Key'
+                conn.headers[header] = auth[:key] || auth['key']
+              when :bearer
+                token = auth[:token] || auth['token']
+                conn.headers['Authorization'] = "Bearer #{token}"
+              when :basic
+                conn.request :authorization, :basic,
+                             auth[:username] || auth['username'],
+                             auth[:password] || auth['password']
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# 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 list(**opts)
+            client = Helpers::Client.connection(**settings.merge(opts))
+            response = client.get('/')
+            { success: true, data: response.body }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          def get(id:, **)
+            client = Helpers::Client.connection(**settings)
+            response = client.get("/#{id}")
+            { success: true, data: response.body }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          def create(**payload)
+            client = Helpers::Client.connection(**settings)
+            response = client.post('/') { |req| req.body = payload.to_json }
+            { success: true, data: response.body }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          def update(id:, **payload)
+            client = Helpers::Client.connection(**settings)
+            response = client.put("/#{id}") { |req| req.body = payload.to_json }
+            { success: true, data: response.body }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          def delete(id:, **)
+            client = Helpers::Client.connection(**settings)
+            response = client.delete("/#{id}")
+            { success: true, status: response.status }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          private
+
+          def settings
+            return {} unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:extensions, :<%= lex_name %>) || {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/service_integration/spec/helpers/client_spec.rb.erb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+RSpec.describe Legion::Extensions::<%= lex_class %>::Helpers::Client do
+  let(:base_url) { 'https://api.example.com' }
+
+  before { WebMock.enable! }
+  after  { WebMock.disable! }
+
+  describe '.connection' do
+    it 'raises ArgumentError when base_url is missing' do
+      expect { described_class.connection }.to raise_error(ArgumentError, /base_url/)
+    end
+
+    it 'returns a Faraday connection' do
+      conn = described_class.connection(base_url: base_url)
+      expect(conn).to be_a(Faraday::Connection)
+    end
+
+    it 'sets Content-Type header to application/json' do
+      conn = described_class.connection(base_url: base_url)
+      expect(conn.headers['Content-Type']).to eq('application/json')
+    end
+
+    context 'with api_key auth' do
+      it 'sets the API key header' do
+        conn = described_class.connection(
+          base_url: base_url,
+          auth: { method: :api_key, key: 'secret', header: 'X-API-Key' }
+        )
+        expect(conn.headers['X-API-Key']).to eq('secret')
+      end
+    end
+
+    context 'with bearer auth' do
+      it 'sets Authorization header' do
+        conn = described_class.connection(
+          base_url: base_url,
+          auth: { method: :bearer, token: 'mytoken' }
+        )
+        expect(conn.headers['Authorization']).to eq('Bearer mytoken')
+      end
+    end
+  end
+end

data/lib/legion/cli/lex/templates/service_integration/spec/runners/%name%_spec.rb.erb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+RSpec.describe Legion::Extensions::<%= lex_class %>::Runners::<%= name_class %> do
+  subject { described_class }
+
+  let(:base_url) { 'https://api.example.com' }
+  let(:test_class) do
+    Class.new do
+      extend Legion::Extensions::<%= lex_class %>::Runners::<%= name_class %>
+
+      def self.settings
+        { base_url: 'https://api.example.com' }
+      end
+    end
+  end
+
+  before { WebMock.enable! }
+  after  { WebMock.disable! }
+
+  it { should be_a Module }
+  it { is_expected.to respond_to(:list).with_any_keywords }
+  it { is_expected.to respond_to(:get).with_any_keywords }
+  it { is_expected.to respond_to(:create).with_any_keywords }
+  it { is_expected.to respond_to(:update).with_any_keywords }
+  it { is_expected.to respond_to(:delete).with_any_keywords }
+
+  describe '#list' do
+    before do
+      stub_request(:get, "#{base_url}/")
+        .to_return(status: 200, body: '[]', headers: { 'Content-Type' => 'application/json' })
+    end
+
+    it 'returns success' do
+      result = test_class.list
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#get' do
+    before do
+      stub_request(:get, "#{base_url}/42")
+        .to_return(status: 200, body: '{"id":42}', headers: { 'Content-Type' => 'application/json' })
+    end
+
+    it 'returns success with data' do
+      result = test_class.get(id: 42)
+      expect(result[:success]).to be true
+    end
+  end
+end

data/lib/legion/cli/lex_command.rb

@@ -3,6 +3,7 @@
 require 'fileutils'
 require 'legion/extensions/helpers/segments'
 require 'legion/cli/lex_cli_manifest'
+require 'legion/cli/lex_templates'
 
 module Legion
   module CLI
@@ -96,14 +97,34 @@ module Legion
       method_option :bundle_install, type: :boolean, default: true, desc: 'Run bundle install'
       method_option :category, type: :string, default: nil,
                                desc: 'Extension category (agentic, ai, gaia). Determines namespace nesting and gem prefix.'
-      def create(name)
+      method_option :template, type: :string, default: 'basic',
+                               desc: 'Scaffold template: basic, llm-agent, service-integration, data-pipeline'
+      method_option :list_templates, type: :boolean, default: false,
+                                     desc: 'List available scaffold templates and exit'
+      def create(name = nil)
         out = formatter
 
+        if options[:list_templates]
+          render_template_list(out)
+          return
+        end
+
+        unless name
+          out.error('NAME is required. Usage: legion lex create NAME [--template TEMPLATE]')
+          return
+        end
+
         if options[:category] && options[:category] !~ /\A[a-z][a-z0-9_-]*\z/
           out.error('--category must be lowercase letters, numbers, underscores, or hyphens')
           return
         end
 
+        template_name = options[:template] || 'basic'
+        unless LexTemplates.valid?(template_name)
+          out.warn("Unknown template '#{template_name}', falling back to 'basic'. Run `legion lex create --list-templates` to see available templates.")
+          template_name = 'basic'
+        end
+
         gem_name = options[:category] ? "lex-#{options[:category]}-#{name}" : "lex-#{name}"
         target_dir = gem_name
 
@@ -119,11 +140,11 @@ module Legion
 
         Legion::Extensions.check_reserved_words(gem_name, known_org: false)
 
-        out.success("Creating #{gem_name}...")
+        out.success("Creating #{gem_name} (template: #{template_name})...")
 
         vars = { filename: target_dir, class_name: name.split('_').map(&:capitalize).join, lex: name }
 
-        generator = LexGenerator.new(name, vars, options, gem_name: gem_name)
+        generator = LexGenerator.new(name, vars, options, gem_name: gem_name, template: template_name)
         generator.generate(out)
 
         out.spacer
@@ -267,6 +288,17 @@ module Legion
           )
         end
 
+        def render_template_list(out)
+          templates = LexTemplates.list
+          if options[:json]
+            out.json(templates)
+          else
+            out.header('Available scaffold templates')
+            rows = templates.map { |t| [t[:name], t[:description]] }
+            out.table(%w[template description], rows)
+          end
+        end
+
         def render_flat_table(out, rows)
           table_rows = rows.map do |l|
             [l[:name], l[:version], l[:category].to_s, l[:tier].to_s, out.status(l[:status]), l[:runners].to_s, l[:actors].to_s]
@@ -399,16 +431,18 @@ module Legion
 
     # Thin generator class that wraps the template logic
     class LexGenerator
-      def initialize(name, vars, options, gem_name: nil)
-        @name    = name
-        @vars    = vars
-        @options = options
-        @gem_name = gem_name || "lex-#{name}"
-        @target = @gem_name
+      def initialize(name, vars, options, gem_name: nil, template: 'basic')
+        @name      = name
+        @vars      = vars
+        @options   = options
+        @gem_name  = gem_name || "lex-#{name}"
+        @target    = @gem_name
+        @template  = template || 'basic'
       end
 
       def generate(out)
         create_structure(out)
+        apply_template_overlay(out) unless @template == 'basic'
         init_git(out) if @options[:git_init]
         run_bundle(out) if @options[:bundle_install]
       end
@@ -515,6 +549,18 @@ module Legion
         File.write(path, content)
       end
 
+      def apply_template_overlay(out)
+        segs       = Legion::Extensions::Helpers::Segments.derive_segments(@gem_name)
+        lex_class  = segs.map(&:capitalize).join('::')
+        lex_name   = @name
+        name_class = @name.split(/[_-]/).map(&:capitalize).join
+        gem_name   = @gem_name
+
+        vars = { lex_class: lex_class, lex_name: lex_name, name_class: name_class, gem_name: gem_name }
+        overlay = LexTemplates::TemplateOverlay.new(@template, @target, vars)
+        overlay.apply(out)
+      end
+
       def init_git(out)
         Dir.chdir(@target) do
           system('git init -q')

data/lib/legion/cli/lex_templates.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require 'erb'
+require 'fileutils'
+
 module Legion
   module CLI
     module LexTemplates
+      TEMPLATES_DIR = File.join(File.dirname(__FILE__), 'lex', 'templates').freeze
+
       REGISTRY = {
         'basic'               => {
           runners:      ['default'],
@@ -18,7 +23,8 @@ module Legion
           tools:        %w[process analyze],
           client:       true,
           dependencies: ['legion-llm'],
-          description:  'LLM-powered agent extension'
+          description:  'LLM-powered agent extension',
+          template_dir: 'llm_agent'
         },
         'service-integration' => {
           runners:      ['operations'],
@@ -26,7 +32,17 @@ module Legion
           tools:        [],
           client:       true,
           dependencies: [],
-          description:  'External service integration with standalone client'
+          description:  'External service integration with standalone client',
+          template_dir: 'service_integration'
+        },
+        'data-pipeline'       => {
+          runners:      ['transform'],
+          actors:       ['ingest'],
+          tools:        [],
+          client:       false,
+          dependencies: [],
+          description:  'Event-driven data processing pipeline',
+          template_dir: 'data_pipeline'
         },
         'scheduled-task'      => {
           runners:      ['executor'],
@@ -58,6 +74,62 @@ module Legion
         def valid?(name)
           REGISTRY.key?(name.to_s)
         end
+
+        def template_dir(name)
+          config = REGISTRY[name.to_s]
+          return nil unless config
+
+          dir_key = config[:template_dir]
+          return nil unless dir_key
+
+          File.join(TEMPLATES_DIR, dir_key)
+        end
+      end
+
+      # Renders and writes template-specific overlay files into the target extension directory.
+      class TemplateOverlay
+        PLACEHOLDER = '%name%'
+
+        # vars: { gem_name:, lex_name:, lex_class:, name_class: }
+        def initialize(template_name, target_dir, vars)
+          @template_name = template_name
+          @target_dir    = target_dir
+          @vars          = vars
+        end
+
+        def apply(out = nil)
+          src = LexTemplates.template_dir(@template_name)
+          return unless src && Dir.exist?(src)
+
+          each_template_file(src) do |abs_src, rel_path|
+            dest_rel = rel_path.gsub(PLACEHOLDER, @vars[:lex_name])
+            dest_rel = dest_rel.sub(/\.erb$/, '')
+            dest_abs = File.join(@target_dir, dest_rel)
+
+            FileUtils.mkdir_p(File.dirname(dest_abs))
+            rendered = render_erb(File.read(abs_src))
+            File.write(dest_abs, rendered)
+            out&.success("  [#{@template_name}] #{dest_rel}")
+          end
+        end
+
+        private
+
+        def each_template_file(src_dir, &block)
+          Dir.glob("#{src_dir}/**/*.erb").each do |abs_src|
+            rel_path = abs_src.sub("#{src_dir}/", '')
+            block.call(abs_src, rel_path)
+          end
+        end
+
+        def render_erb(template_text)
+          lex_class  = @vars[:lex_class]
+          lex_name   = @vars[:lex_name]
+          name_class = @vars[:name_class]
+          gem_name   = @vars[:gem_name]
+
+          ERB.new(template_text, trim_mode: '-').result(binding)
+        end
       end
     end
   end

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.91
+  version: 1.4.92
 platform: ruby
 authors:
 - Esity
@@ -494,8 +494,19 @@ files:
 - lib/legion/cli/lex/templates/base/rubocop.yml.erb
 - lib/legion/cli/lex/templates/base/spec_helper.rb.erb
 - lib/legion/cli/lex/templates/base/version.erb
+- lib/legion/cli/lex/templates/data_pipeline/actors/ingest.rb.erb
+- lib/legion/cli/lex/templates/data_pipeline/runners/transform.rb.erb
+- lib/legion/cli/lex/templates/data_pipeline/spec/actors/ingest_spec.rb.erb
+- lib/legion/cli/lex/templates/data_pipeline/spec/runners/transform_spec.rb.erb
+- lib/legion/cli/lex/templates/data_pipeline/transport/exchanges/%name%.rb.erb
+- lib/legion/cli/lex/templates/data_pipeline/transport/messages/%name%_output.rb.erb
+- lib/legion/cli/lex/templates/data_pipeline/transport/queues/ingest.rb.erb
 - lib/legion/cli/lex/templates/exchange.erb
 - lib/legion/cli/lex/templates/exchange_spec.erb
+- lib/legion/cli/lex/templates/llm_agent/helpers/client.rb.erb
+- lib/legion/cli/lex/templates/llm_agent/prompts/default.yml.erb
+- lib/legion/cli/lex/templates/llm_agent/runners/%name%.rb.erb
+- lib/legion/cli/lex/templates/llm_agent/spec/runners/%name%_spec.rb.erb
 - lib/legion/cli/lex/templates/message.erb
 - lib/legion/cli/lex/templates/message_spec.erb
 - lib/legion/cli/lex/templates/queue.erb
@@ -503,6 +514,11 @@ files:
 - lib/legion/cli/lex/templates/queue_spec.erb
 - lib/legion/cli/lex/templates/runner.erb
 - lib/legion/cli/lex/templates/runner_spec.erb
+- lib/legion/cli/lex/templates/service_integration/helpers/auth.rb.erb
+- lib/legion/cli/lex/templates/service_integration/helpers/client.rb.erb
+- lib/legion/cli/lex/templates/service_integration/runners/%name%.rb.erb
+- lib/legion/cli/lex/templates/service_integration/spec/helpers/client_spec.rb.erb
+- lib/legion/cli/lex/templates/service_integration/spec/runners/%name%_spec.rb.erb
 - lib/legion/cli/lex_cli_manifest.rb
 - lib/legion/cli/lex_command.rb
 - lib/legion/cli/lex_templates.rb