lex-adapter 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9ad72da4328d17f6ff4ea47db389e0fd7657f4e136ed9eb6b1ff8c65b74b83a1
+  data.tar.gz: dbb87f253a93eb5c3bcdd0671ad6d65eb016f641a1836558af94e9b199fb5a01
+SHA512:
+  metadata.gz: ab80d58bf48b68dafb888814da2eba3dc013502543ac3daf7631c8f7b8ec7d4668158d425cc81cd5f2c111bd5e5df62bd35beba029e25705359c4018bb5e02ac
+  data.tar.gz: ff414d8ca634fee1047177dc4a1475f6d867fbfc451357b416eaf1a5bf253fcc3bbf5cebccd279793a3f7644d269b8d5647b32511b27451f7040f86e2773fc0c

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [0.1.0] - 2026-03-20
+
+### Added
+- Base adapter interface with `invoke`, `available?`, and `validate_options`
+- Registry for adapter registration and lookup
+- GenericProcess adapter for CLI tool invocation via stdin/stdout
+- GenericHTTP adapter for REST API endpoint invocation
+- ClaudeCode adapter for Anthropic Claude Code sessions
+- Codex adapter for OpenAI Codex CLI sessions
+- Runner module for framework-integrated invocation
+- 25 specs with 90.2% line coverage

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LegionIO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# lex-adapter
+
+External agent adapter abstraction for LegionIO. Provides a standardized interface for invoking external AI agents via CLI, process, or HTTP.
+
+## Adapters
+
+| Adapter | Transport | Use Case |
+|---|---|---|
+| `GenericProcess` | stdin/stdout | Any CLI tool that accepts input and returns output |
+| `GenericHTTP` | HTTP POST | REST API endpoints |
+| `ClaudeCode` | CLI subprocess | Anthropic Claude Code sessions |
+| `Codex` | CLI subprocess | OpenAI Codex CLI sessions |
+
+## Usage
+
+```ruby
+require 'legion/extensions/adapter'
+
+# Register a custom adapter
+Legion::Extensions::Adapter::Registry.register(:my_adapter, MyAdapter)
+
+# Invoke via runner
+result = Legion::Extensions::Adapter::Runners::Adapter.invoke(
+  adapter: :claude_code,
+  prompt: "Explain this code",
+  options: { model: "claude-sonnet-4-20250514" }
+)
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lib/legion/extensions/adapter/adapters/claude_code.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'securerandom'
+require 'timeout'
+
+module Legion
+  module Extensions
+    module Adapter
+      module Adapters
+        class ClaudeCode < GenericProcess
+          BINARY = 'claude'
+
+          def initialize(**)
+            super(command: BINARY, **)
+          end
+
+          def invoke(task:, timeout: 120, **)
+            prompt = task.is_a?(Hash) ? (task[:prompt] || task[:input] || task.to_json) : task.to_s
+            handle = SecureRandom.uuid
+            start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+            stdout, stderr, status = Timeout.timeout(timeout) do
+              Open3.capture3(BINARY, '-p', prompt, '--output-format', 'json')
+            end
+
+            duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time
+            @handles[handle] = { stdout: stdout, stderr: stderr, exit_code: status.exitstatus }
+
+            { success: status.success?, output: stdout, duration: duration, handle: handle }
+          rescue Timeout::Error
+            { success: false, output: nil, duration: timeout.to_f, handle: handle, reason: :timeout }
+          rescue StandardError => e
+            { success: false, output: nil, duration: 0.0, handle: handle, reason: :error, message: e.message }
+          end
+
+          def status
+            available = system("which #{BINARY}", out: File::NULL, err: File::NULL) || false
+            version = available ? `#{BINARY} --version 2>/dev/null`.strip : nil
+            { available: available, version: version, binary: BINARY }
+          end
+        end
+      end
+    end
+  end
+end
+
+Legion::Extensions::Adapter::Registry.register('claude_code',
+                                               Legion::Extensions::Adapter::Adapters::ClaudeCode)

data/lib/legion/extensions/adapter/adapters/codex.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'securerandom'
+require 'timeout'
+
+module Legion
+  module Extensions
+    module Adapter
+      module Adapters
+        class Codex < GenericProcess
+          BINARY = 'codex'
+
+          def initialize(**)
+            super(command: BINARY, **)
+          end
+
+          def invoke(task:, timeout: 120, **)
+            prompt = task.is_a?(Hash) ? (task[:prompt] || task[:input] || task.to_json) : task.to_s
+            handle = SecureRandom.uuid
+            start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+            stdout, stderr, status = Timeout.timeout(timeout) do
+              Open3.capture3(BINARY, '--quiet', prompt)
+            end
+
+            duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time
+            @handles[handle] = { stdout: stdout, stderr: stderr, exit_code: status.exitstatus }
+
+            { success: status.success?, output: stdout, duration: duration, handle: handle }
+          rescue Timeout::Error
+            { success: false, output: nil, duration: timeout.to_f, handle: handle, reason: :timeout }
+          rescue StandardError => e
+            { success: false, output: nil, duration: 0.0, handle: handle, reason: :error, message: e.message }
+          end
+
+          def status
+            available = system("which #{BINARY}", out: File::NULL, err: File::NULL) || false
+            version = available ? `#{BINARY} --version 2>/dev/null`.strip : nil
+            { available: available, version: version, binary: BINARY }
+          end
+        end
+      end
+    end
+  end
+end
+
+Legion::Extensions::Adapter::Registry.register('codex',
+                                               Legion::Extensions::Adapter::Adapters::Codex)

data/lib/legion/extensions/adapter/adapters/generic_http.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'securerandom'
+require 'json'
+require 'uri'
+
+module Legion
+  module Extensions
+    module Adapter
+      module Adapters
+        class GenericHttp < Base
+          def initialize(url: nil, headers: {}, **opts)
+            super()
+            @url = url
+            @headers = { 'Content-Type' => 'application/json' }.merge(headers)
+            @opts = opts
+          end
+
+          def invoke(task:, timeout: 30, **)
+            handle = SecureRandom.uuid
+            start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+            uri = URI(@url)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == 'https'
+            http.open_timeout = timeout
+            http.read_timeout = timeout
+
+            request = Net::HTTP::Post.new(uri.path.empty? ? '/' : uri.path, @headers)
+            request.body = task.is_a?(String) ? task : task.to_json
+
+            response = http.request(request)
+            duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time
+
+            { success: response.is_a?(Net::HTTPSuccess), output: response.body,
+              status: response.code.to_i, duration: duration, handle: handle }
+          rescue StandardError => e
+            duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time
+            { success: false, output: nil, duration: duration, handle: handle,
+              reason: :error, message: e.message }
+          end
+
+          def status
+            { available: !@url.nil?, url: @url }
+          end
+
+          def cancel(handle:)
+            { success: false, reason: :not_supported }
+          end
+
+          def output(handle:)
+            { stdout: nil, stderr: nil, exit_code: nil }
+          end
+        end
+      end
+    end
+  end
+end
+
+Legion::Extensions::Adapter::Registry.register('generic_http',
+                                               Legion::Extensions::Adapter::Adapters::GenericHttp)

data/lib/legion/extensions/adapter/adapters/generic_process.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'securerandom'
+require 'timeout'
+
+module Legion
+  module Extensions
+    module Adapter
+      module Adapters
+        class GenericProcess < Base
+          def initialize(command: nil, **opts)
+            super()
+            @command = command
+            @opts = opts
+            @handles = {}
+          end
+
+          def invoke(task:, timeout: 30, **)
+            handle = SecureRandom.uuid
+            start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            input = if task.is_a?(Hash)
+                      begin
+                        task.to_json
+                      rescue StandardError
+                        task.to_s
+                      end
+                    else
+                      task.to_s
+                    end
+
+            stdout, stderr, status = Timeout.timeout(timeout) do
+              Open3.capture3(@command, stdin_data: input)
+            end
+
+            duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time
+            @handles[handle] = { stdout: stdout, stderr: stderr, exit_code: status.exitstatus }
+
+            { success: status.success?, output: stdout, duration: duration, handle: handle }
+          rescue Timeout::Error
+            { success: false, output: nil, duration: timeout.to_f, handle: handle, reason: :timeout }
+          rescue StandardError => e
+            { success: false, output: nil, duration: 0.0, handle: handle, reason: :error, message: e.message }
+          end
+
+          def status
+            available = system("which #{@command}", out: File::NULL, err: File::NULL) || false
+            { available: available, command: @command }
+          end
+
+          def cancel(handle:)
+            return { success: false, reason: :not_found } unless @handles.key?(handle)
+
+            { success: true }
+          end
+
+          def output(handle:)
+            @handles[handle] || { stdout: nil, stderr: nil, exit_code: nil }
+          end
+        end
+      end
+    end
+  end
+end
+
+Legion::Extensions::Adapter::Registry.register('generic_process',
+                                               Legion::Extensions::Adapter::Adapters::GenericProcess)

data/lib/legion/extensions/adapter/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Adapter
+      class Base
+        def invoke(task:, timeout: 30, **)
+          raise NotImplementedError, "#{self.class}#invoke not implemented"
+        end
+
+        def status
+          raise NotImplementedError, "#{self.class}#status not implemented"
+        end
+
+        def cancel(handle:)
+          raise NotImplementedError, "#{self.class}#cancel not implemented"
+        end
+
+        def output(handle:)
+          raise NotImplementedError, "#{self.class}#output not implemented"
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/adapter/registry.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Adapter
+      class Registry
+        @adapters = {}
+
+        class << self
+          def register(name, klass)
+            @adapters[name.to_s] = klass
+          end
+
+          def find(name)
+            @adapters[name.to_s]
+          end
+
+          def all
+            @adapters.dup
+          end
+
+          def names
+            @adapters.keys
+          end
+
+          def reset!
+            @adapters = {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/adapter/runners/adapter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Adapter
+      module Runners
+        module Adapter
+          def invoke_adapter(adapter_name:, task:, timeout: 30, **)
+            klass = Registry.find(adapter_name)
+            return { success: false, reason: :adapter_not_found } unless klass
+
+            adapter = klass.new(**)
+            adapter.invoke(task: task, timeout: timeout)
+          end
+
+          def list_adapters(**)
+            { success: true, adapters: Registry.names, count: Registry.names.size }
+          end
+
+          def adapter_status(adapter_name:, **)
+            klass = Registry.find(adapter_name)
+            return { success: false, reason: :adapter_not_found } unless klass
+
+            adapter = klass.new(**)
+            { success: true, adapter: adapter_name, status: adapter.status }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/adapter/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Adapter
+      VERSION = '0.1.1'
+    end
+  end
+end

data/lib/legion/extensions/adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/adapter/version'
+require 'legion/extensions/adapter/base'
+require 'legion/extensions/adapter/registry'
+require 'legion/extensions/adapter/adapters/generic_process'
+require 'legion/extensions/adapter/adapters/generic_http'
+require 'legion/extensions/adapter/adapters/claude_code'
+require 'legion/extensions/adapter/adapters/codex'
+require 'legion/extensions/adapter/runners/adapter'
+
+module Legion
+  module Extensions
+    module Adapter
+      class << self
+        def remote_invocable? = false
+        def data_required? = false
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: lex-adapter
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Matthew Iverson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Standardized interface for invoking external AI agents via CLI, process,
+  or HTTP
+email:
+- matt@legionio.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/legion/extensions/adapter.rb
+- lib/legion/extensions/adapter/adapters/claude_code.rb
+- lib/legion/extensions/adapter/adapters/codex.rb
+- lib/legion/extensions/adapter/adapters/generic_http.rb
+- lib/legion/extensions/adapter/adapters/generic_process.rb
+- lib/legion/extensions/adapter/base.rb
+- lib/legion/extensions/adapter/registry.rb
+- lib/legion/extensions/adapter/runners/adapter.rb
+- lib/legion/extensions/adapter/version.rb
+homepage: https://github.com/LegionIO/lex-adapter
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: External agent adapter abstraction for LegionIO
+test_files: []