lex-codegen 0.1.1

data/lib/legion/extensions/codegen/helpers/constants.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Codegen
+      module Helpers
+        module Constants
+          TEMPLATE_TYPES = %i[gemspec gemfile rubocop ci rspec gitignore license version entry_point spec_helper runner client].freeze
+          DEFAULT_RUBY_VERSION = '3.4'
+          DEFAULT_LICENSE      = 'MIT'
+          DEFAULT_AUTHOR       = 'Esity'
+          DEFAULT_EMAIL        = 'matthewdiverson@gmail.com'
+          DEFAULT_GEM_VERSION  = '0.1.0'
+
+          GEMSPEC_TEMPLATE = <<~'ERB'
+            # frozen_string_literal: true
+
+            require_relative 'lib/legion/extensions/<%= gem_name_underscored %>/version'
+
+            Gem::Specification.new do |spec|
+              spec.name          = '<%= gem_name %>'
+              spec.version       = Legion::Extensions::<%= module_name %>::VERSION
+              spec.authors       = ['<%= author %>']
+              spec.email         = ['<%= email %>']
+
+              spec.summary       = 'Legion::Extensions::<%= module_name %>'
+              spec.description   = '<%= description %>'
+              spec.homepage      = 'https://github.com/LegionIO/<%= gem_name %>'
+              spec.license       = '<%= license %>'
+              spec.required_ruby_version = '>= <%= ruby_version %>'
+
+              spec.metadata['homepage_uri']          = spec.homepage
+              spec.metadata['source_code_uri']       = 'https://github.com/LegionIO/<%= gem_name %>'
+              spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/<%= gem_name %>'
+              spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/<%= gem_name %>'
+              spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/<%= gem_name %>/issues'
+              spec.metadata['rubygems_mfa_required'] = 'true'
+
+              spec.files = Dir.chdir(File.expand_path(__dir__)) do
+                `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+              end
+              spec.require_paths = ['lib']
+
+              spec.add_dependency 'legionio'
+            <% extra_deps.each do |dep| -%>
+              spec.add_dependency '<%= dep %>'
+            <% end -%>
+
+              spec.add_development_dependency 'rake'
+              spec.add_development_dependency 'rspec', '~> 3.13'
+              spec.add_development_dependency 'rspec_junit_formatter'
+              spec.add_development_dependency 'rubocop', '~> 1.75'
+              spec.add_development_dependency 'rubocop-rspec'
+              spec.add_development_dependency 'simplecov'
+            end
+          ERB
+
+          GEMFILE_TEMPLATE = <<~ERB
+            # frozen_string_literal: true
+
+            source 'https://rubygems.org'
+            gemspec
+
+            group :test do
+              gem 'rake'
+              gem 'rspec', '~> 3.13'
+              gem 'rspec_junit_formatter'
+              gem 'rubocop', '~> 1.75'
+              gem 'rubocop-rspec'
+              gem 'simplecov'
+            end
+          ERB
+
+          RUBOCOP_TEMPLATE = <<~ERB
+            AllCops:
+              TargetRubyVersion: <%= ruby_version %>
+              NewCops: enable
+              SuggestExtensions: false
+
+            Layout/LineLength:
+              Max: 160
+
+            Layout/SpaceAroundEqualsInParameterDefault:
+              EnforcedStyle: space
+
+            Layout/HashAlignment:
+              EnforcedHashRocketStyle: table
+              EnforcedColonStyle: table
+
+            Metrics/MethodLength:
+              Max: 50
+
+            Metrics/ClassLength:
+              Max: 1500
+
+            Metrics/ModuleLength:
+              Max: 1500
+
+            Metrics/BlockLength:
+              Max: 40
+
+            Metrics/AbcSize:
+              Max: 60
+
+            Metrics/CyclomaticComplexity:
+              Max: 15
+
+            Metrics/PerceivedComplexity:
+              Max: 17
+
+            Style/Documentation:
+              Enabled: false
+
+            Style/SymbolArray:
+              Enabled: true
+
+            Style/FrozenStringLiteralComment:
+              Enabled: true
+              EnforcedStyle: always
+
+            Naming/FileName:
+              Enabled: false
+
+            Naming/PredicateMethod:
+              Enabled: false
+
+            Naming/PredicatePrefix:
+              Enabled: false
+          ERB
+
+          CI_TEMPLATE = <<~ERB
+            name: CI
+            on: [push, pull_request]
+            jobs:
+              ci:
+                uses: LegionIO/.github/.github/workflows/ci.yml@main
+          ERB
+
+          RSPEC_TEMPLATE = <<~ERB
+            --format documentation
+            --color
+            --require spec_helper
+          ERB
+
+          GITIGNORE_TEMPLATE = <<~ERB
+            /.bundle/
+            /.yardoc
+            /_yardoc/
+            /coverage/
+            /doc/
+            /pkg/
+            /spec/reports/
+            /tmp/
+
+            # rspec failure tracking
+            .rspec_status
+          ERB
+
+          LICENSE_TEMPLATE = <<~ERB
+            MIT License
+
+            Copyright (c) 2024 <%= author %>
+
+            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.
+          ERB
+
+          VERSION_TEMPLATE = <<~ERB
+            # frozen_string_literal: true
+
+            module Legion
+              module Extensions
+                module <%= module_name %>
+                  VERSION = '<%= gem_version %>'
+                end
+              end
+            end
+          ERB
+
+          ENTRY_POINT_TEMPLATE = <<~ERB
+            # frozen_string_literal: true
+
+            require 'securerandom'
+            require_relative '<%= gem_name_underscored %>/version'
+            require_relative '<%= gem_name_underscored %>/helpers/constants'
+            <% helpers.each do |h| -%>
+            require_relative '<%= gem_name_underscored %>/helpers/<%= h %>'
+            <% end -%>
+            <% runner_names.each do |r| -%>
+            require_relative '<%= gem_name_underscored %>/runners/<%= r %>'
+            <% end -%>
+            require_relative '<%= gem_name_underscored %>/client'
+
+            module Legion
+              module Extensions
+                module <%= module_name %>
+                  extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+                end
+              end
+            end
+          ERB
+
+          SPEC_HELPER_TEMPLATE = <<~ERB
+            # frozen_string_literal: true
+
+            require 'bundler/setup'
+            require 'legion/extensions/<%= gem_name_underscored %>'
+
+            # Stub Legion::Logging when running standalone
+            unless defined?(Legion::Logging)
+              module Legion
+                module Logging
+                  def self.info(*); end
+                  def self.debug(*); end
+                  def self.warn(*); end
+                  def self.error(*); end
+                end
+              end
+            end
+
+            RSpec.configure do |config|
+              config.example_status_persistence_file_path = '.rspec_status'
+              config.disable_monkey_patching!
+              config.expect_with(:rspec) { |c| c.syntax = :expect }
+            end
+          ERB
+
+          RUNNER_TEMPLATE = <<~ERB
+            # frozen_string_literal: true
+
+            module Legion
+              module Extensions
+                module <%= module_name %>
+                  module Runners
+                    module <%= runner_class %>
+                      extend self
+            <% methods.each do |m| -%>
+
+                      def <%= m[:name] %>(<%= m[:params].join(', ') %><%= m[:params].empty? ? '**' : ', **' %>)
+                        Legion::Logging.debug "[<%= gem_name_underscored %>] <%= m[:name] %> called"
+                        { success: true }
+                      end
+            <% end -%>
+                    end
+                  end
+                end
+              end
+            end
+          ERB
+
+          CLIENT_TEMPLATE = <<~ERB
+            # frozen_string_literal: true
+
+            module Legion
+              module Extensions
+                module <%= module_name %>
+                  class Client
+            <% runner_names.each do |r| -%>
+                    include Runners::<%= r.split('_').map(&:capitalize).join %>
+            <% end -%>
+
+                    def initialize(base_path: Dir.pwd)
+                      @base_path = base_path
+                    end
+                  end
+                end
+              end
+            end
+          ERB
+
+          TEMPLATE_MAP = {
+            gemspec:     GEMSPEC_TEMPLATE,
+            gemfile:     GEMFILE_TEMPLATE,
+            rubocop:     RUBOCOP_TEMPLATE,
+            ci:          CI_TEMPLATE,
+            rspec:       RSPEC_TEMPLATE,
+            gitignore:   GITIGNORE_TEMPLATE,
+            license:     LICENSE_TEMPLATE,
+            version:     VERSION_TEMPLATE,
+            entry_point: ENTRY_POINT_TEMPLATE,
+            spec_helper: SPEC_HELPER_TEMPLATE,
+            runner:      RUNNER_TEMPLATE,
+            client:      CLIENT_TEMPLATE
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/codegen/helpers/file_writer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Legion
+  module Extensions
+    module Codegen
+      module Helpers
+        class FileWriter
+          def initialize(base_path:)
+            @base_path = base_path
+          end
+
+          def write(relative_path, content)
+            full_path = ::File.join(@base_path, relative_path)
+            ::FileUtils.mkdir_p(::File.dirname(full_path))
+            ::File.write(full_path, content)
+            { path: full_path, bytes: content.bytesize }
+          end
+
+          def write_all(files)
+            files.map { |path, content| write(path, content) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/codegen/helpers/spec_generator.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Codegen
+      module Helpers
+        class SpecGenerator
+          def initialize
+            # no state needed
+          end
+
+          def generate_runner_spec(module_name:, runner_name:, methods: [])
+            runner_class = runner_name.split('_').map(&:capitalize).join
+            lines = [
+              '# frozen_string_literal: true',
+              '',
+              "RSpec.describe Legion::Extensions::#{module_name}::Runners::#{runner_class} do",
+              '  subject(:runner) { described_class }',
+              ''
+            ]
+
+            methods.each do |m|
+              method_name = m[:name]
+              lines << "  describe '.#{method_name}' do"
+              lines << "    it 'responds to #{method_name}' do"
+              lines << "      expect(runner).to respond_to(:#{method_name})"
+              lines << '    end'
+              lines << ''
+              lines << "    it 'returns a hash with success key' do"
+
+              call_args = build_call_args(m[:params])
+              lines << "      result = runner.#{method_name}(#{call_args})"
+              lines << '      expect(result).to be_a(Hash)'
+              lines << '      expect(result).to have_key(:success)'
+              lines << '    end'
+              lines << '  end'
+              lines << ''
+            end
+
+            lines << 'end'
+            "#{lines.join("\n")}\n"
+          end
+
+          def generate_client_spec(module_name:, runner_name: nil, methods: []) # rubocop:disable Lint/UnusedMethodArgument
+            lines = [
+              '# frozen_string_literal: true',
+              '',
+              "RSpec.describe Legion::Extensions::#{module_name}::Client do",
+              '  subject(:client) { described_class.new }',
+              ''
+            ]
+
+            lines << "  it 'instantiates successfully' do"
+            lines << '    expect(client).to be_a(described_class)'
+            lines << '  end'
+            lines << ''
+
+            methods.each do |m|
+              lines << "  it 'responds to #{m[:name]}' do"
+              lines << "    expect(client).to respond_to(:#{m[:name]})"
+              lines << '  end'
+              lines << ''
+            end
+
+            lines << 'end'
+            "#{lines.join("\n")}\n"
+          end
+
+          def generate_helper_spec(module_name:, helper_name:, methods: [])
+            helper_class = helper_name.split('_').map(&:capitalize).join
+            lines = [
+              '# frozen_string_literal: true',
+              '',
+              "RSpec.describe Legion::Extensions::#{module_name}::Helpers::#{helper_class} do",
+              '  subject(:helper) { described_class.new }',
+              ''
+            ]
+
+            lines << "  it 'instantiates successfully' do"
+            lines << '    expect(helper).to be_a(described_class)'
+            lines << '  end'
+            lines << ''
+
+            methods.each do |m|
+              lines << "  it 'responds to #{m[:name]}' do"
+              lines << "    expect(helper).to respond_to(:#{m[:name]})"
+              lines << '  end'
+              lines << ''
+            end
+
+            lines << 'end'
+            "#{lines.join("\n")}\n"
+          end
+
+          private
+
+          def build_call_args(params)
+            return '' if params.nil? || params.empty?
+
+            keyword_params = params.reject { |p| ['**', '*args'].include?(p) }
+            return '' if keyword_params.empty?
+
+            keyword_params.map do |p|
+              name = p.to_s.gsub(/[:\s].*/, '').chomp(':')
+              "#{name}: nil"
+            end.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/codegen/helpers/template_engine.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Legion
+  module Extensions
+    module Codegen
+      module Helpers
+        class TemplateEngine
+          def initialize
+            # no state needed
+          end
+
+          def render(template_type, variables = {})
+            key = template_type.to_sym
+            raise ArgumentError, "Unknown template type: #{template_type}" unless Constants::TEMPLATE_MAP.key?(key)
+
+            render_string(Constants::TEMPLATE_MAP[key], variables)
+          end
+
+          def render_string(template_string, variables = {})
+            ERB.new(template_string, trim_mode: '-').result(binding_with(variables))
+          end
+
+          private
+
+          def binding_with(variables)
+            ctx = Object.new
+            variables.each do |key, value|
+              ctx.instance_variable_set(:"@#{key}", value)
+              ctx.define_singleton_method(key) { instance_variable_get(:"@#{key}") }
+            end
+            ctx.instance_eval { binding }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/codegen/runners/generate.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Codegen
+      module Runners
+        module Generate
+          extend self
+
+          def scaffold_extension(name:, module_name:, description:, category: :cognition, # rubocop:disable Lint/UnusedMethodArgument
+                                 helpers: [], runner_methods: [], base_path: nil, **)
+            base_path ||= ::Dir.pwd
+            ext_path   = ::File.join(base_path, "lex-#{name}")
+            gem_name   = "lex-#{name}"
+            underscored = name.to_s.gsub('-', '_')
+            runner_names = runner_methods.map { |r| r[:name] }
+
+            engine  = Helpers::TemplateEngine.new
+            writer  = Helpers::FileWriter.new(base_path: ext_path)
+            spec_gen = Helpers::SpecGenerator.new
+
+            variables = build_variables(
+              gem_name:     gem_name,
+              underscored:  underscored,
+              module_name:  module_name,
+              description:  description,
+              helpers:      helpers.map { |h| h.is_a?(Hash) ? h[:name] : h.to_s },
+              runner_names: runner_names,
+              extra_deps:   []
+            )
+
+            files = build_scaffold_files(engine, variables, helpers, runner_methods, spec_gen, module_name, underscored, runner_names)
+            writer.write_all(files)
+
+            Legion::Logging.info "[codegen] scaffolded #{gem_name} with #{files.size} files at #{ext_path}"
+            { success: true, path: ext_path, files_created: files.size, name: gem_name }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def generate_file(template_type:, output_path:, variables: {}, **)
+            engine = Helpers::TemplateEngine.new
+            content = engine.render(template_type, variables)
+            ::FileUtils.mkdir_p(::File.dirname(output_path))
+            ::File.write(output_path, content)
+            { success: true, path: output_path, bytes: content.bytesize }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def build_variables(gem_name:, underscored:, module_name:, description:, helpers:, runner_names:, extra_deps:)
+            {
+              gem_name:             gem_name,
+              gem_name_underscored: underscored,
+              module_name:          module_name,
+              description:          description,
+              author:               Helpers::Constants::DEFAULT_AUTHOR,
+              email:                Helpers::Constants::DEFAULT_EMAIL,
+              ruby_version:         Helpers::Constants::DEFAULT_RUBY_VERSION,
+              gem_version:          Helpers::Constants::DEFAULT_GEM_VERSION,
+              license:              Helpers::Constants::DEFAULT_LICENSE,
+              helpers:              helpers,
+              runner_names:         runner_names,
+              extra_deps:           extra_deps
+            }
+          end
+
+          def build_scaffold_files(engine, variables, helpers, runner_methods, spec_gen, module_name, underscored, runner_names)
+            files = {}
+
+            files["#{variables[:gem_name]}.gemspec"] = engine.render(:gemspec, variables)
+            files['Gemfile']                                    = engine.render(:gemfile, variables)
+            files['.rubocop.yml']                               = engine.render(:rubocop, variables)
+            files['.github/workflows/ci.yml'] = engine.render(:ci, variables)
+            files['.rspec']                                     = engine.render(:rspec, variables)
+            files['.gitignore']                                 = engine.render(:gitignore, variables)
+            files['LICENSE']                                    = engine.render(:license, variables)
+            files["lib/legion/extensions/#{underscored}/version.rb"] = engine.render(:version, variables)
+            files["lib/legion/extensions/#{underscored}.rb"] = engine.render(:entry_point, variables)
+            files['spec/spec_helper.rb'] = engine.render(:spec_helper, variables)
+            files["lib/legion/extensions/#{underscored}/client.rb"] = engine.render(:client, variables.merge(runner_names: runner_names))
+
+            helpers.each do |helper|
+              helper_name = helper.is_a?(Hash) ? helper[:name] : helper.to_s
+              helper_methods = helper.is_a?(Hash) ? (helper[:methods] || []) : []
+              files["lib/legion/extensions/#{underscored}/helpers/#{helper_name}.rb"] =
+                generate_helper_stub(module_name, helper_name, helper_methods)
+              files["spec/legion/extensions/#{underscored}/helpers/#{helper_name}_spec.rb"] =
+                spec_gen.generate_helper_spec(module_name: module_name, helper_name: helper_name, methods: helper_methods)
+            end
+
+            runner_methods.each do |runner|
+              r_name = runner[:name]
+              r_methods = runner.is_a?(Hash) ? [runner] : []
+              r_class = r_name.split('_').map(&:capitalize).join
+              files["lib/legion/extensions/#{underscored}/runners/#{r_name}.rb"] =
+                engine.render(:runner, variables.merge(runner_class: r_class, methods: [runner]))
+              files["spec/legion/extensions/#{underscored}/runners/#{r_name}_spec.rb"] =
+                spec_gen.generate_runner_spec(module_name: module_name, runner_name: r_name, methods: r_methods)
+            end
+
+            files["spec/legion/extensions/#{underscored}/client_spec.rb"] =
+              spec_gen.generate_client_spec(module_name: module_name, runner_name: 'client', methods: [])
+
+            files
+          end
+
+          def generate_helper_stub(module_name, helper_name, methods)
+            helper_class = helper_name.split('_').map(&:capitalize).join
+            method_lines = methods.map do |m|
+              params = Array(m[:params])
+              param_str = params.empty? ? '**' : "#{params.join(', ')}, **"
+              "          def #{m[:name]}(#{param_str})\n            { success: true }\n          end"
+            end.join("\n\n")
+
+            <<~RUBY
+              # frozen_string_literal: true
+
+              module Legion
+                module Extensions
+                  module #{module_name}
+                    module Helpers
+                      class #{helper_class}
+                        def initialize
+                          # no state needed
+                        end
+
+              #{method_lines}
+                      end
+                    end
+                  end
+                end
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/codegen/runners/template.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Codegen
+      module Runners
+        module Template
+          extend self # rubocop:disable Style/ModuleFunction
+
+          TEMPLATE_REQUIRED_VARS = {
+            gemspec:     %i[gem_name module_name description author email ruby_version license extra_deps],
+            gemfile:     [],
+            rubocop:     %i[ruby_version],
+            ci:          [],
+            rspec:       [],
+            gitignore:   [],
+            license:     %i[author],
+            version:     %i[module_name gem_version],
+            entry_point: %i[gem_name_underscored module_name helpers runner_names],
+            spec_helper: %i[gem_name_underscored],
+            runner:      %i[module_name runner_class methods gem_name_underscored],
+            client:      %i[module_name runner_names]
+          }.freeze
+
+          def list_templates(**)
+            { success: true, templates: Helpers::Constants::TEMPLATE_TYPES }
+          end
+
+          def render_template(template_type:, variables: {}, **)
+            engine  = Helpers::TemplateEngine.new
+            content = engine.render(template_type, variables)
+            { success: true, content: content, template_type: template_type }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def template_variables(template_type:, **)
+            key = template_type.to_sym
+            return { success: false, error: "Unknown template type: #{template_type}" } unless Helpers::Constants::TEMPLATE_TYPES.include?(key)
+
+            required = TEMPLATE_REQUIRED_VARS.fetch(key, [])
+            { success: true, template_type: key, required_variables: required }
+          end
+        end
+      end
+    end
+  end
+end