lex-factory 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df3fc328fe57d371e7b812ac1285a75dd022e38c7c33612e21292ddabd15de4c
-  data.tar.gz: 7722b25f034cc3aaea6d8e6963f47907dec10bf27831d3afbf9bf633c12bc84f
+  metadata.gz: d9fd09964743d7a47df24981945f31c86bbceed1342f6d83e1d2f9e02c04e0a2
+  data.tar.gz: f3d00a404776a1da2f240dd8258159168765c08c7bd915df7cb22caed3cd101d
 SHA512:
-  metadata.gz: da95c3eedec07c08767cedf334bc7d96efbe4fe2aeeb3ce788c90121f8195cc697218b45f0624022bd7e6a60c868799f378ba6c79669cea31d647d870d74ec95
-  data.tar.gz: 692244c9e64ca57b461433dffb757122fa68cc7eb670cc7ac2fbedfdc9651a7f31c8dd65ba9179696a60ffba70dd70e4985fed389663b899bede586638ca9dff
+  metadata.gz: f7163419e296bbb0590ac07662ed89f40984aa24949dcc0ffdde31a73c67b5d4b4aefb727281dc4d22c767bd457f5839ef3c9467cdcd37aedda684bd892afebd
+  data.tar.gz: 9d3dc61bf03a503f86adab62f4329571e7c9e4b193734e697b42c43c78afce01a5227bae7f8a27538ef35d7fef84ceb9bd7318e7e806fffa42ac69e6d8c748cd

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.1.4] - 2026-03-30
+
+### Changed
+- update to rubocop-legion 0.1.7, resolve all offenses
+
+## [0.1.3] - 2026-03-29
+
+### Changed
+- `run_pipeline` and `pipeline_status` accept `**` for task system payload compatibility
+
+## [0.1.2] - 2026-03-28
+
+### Changed
+- Implement develop stage via real LLM code generation, delegating to `lex-codegen` `FromGap.generate`
+- Graceful fallback to stub strategy when lex-codegen is not loaded
+- Exclude `pipeline_runner.rb` from `Metrics/ClassLength` and `Metrics/AbcSize` in rubocop config
+
+## [0.1.1] - 2026-03-26
+
+### Changed
+- fix remote_invocable? to use class method for local dispatch
+
 ## [0.1.0] - 2026-03-24
 
 ### Added

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

@@ -9,9 +9,9 @@ module Legion
 
           SCORE_WEIGHTS = {
             completeness: 0.35,
-            correctness: 0.35,
-            quality: 0.20,
-            security: 0.10
+            correctness:  0.35,
+            quality:      0.20,
+            security:     0.10
           }.freeze
 
           DEFAULT_SATISFACTION_THRESHOLD = 0.8

data/lib/legion/extensions/factory/helpers/quality_gate.rb

@@ -11,9 +11,9 @@ module Legion
                     threshold: Constants::DEFAULT_SATISFACTION_THRESHOLD)
             scores = {
               completeness: clamp(completeness),
-              correctness: clamp(correctness),
-              quality: clamp(quality),
-              security: clamp(security)
+              correctness:  clamp(correctness),
+              quality:      clamp(quality),
+              security:     clamp(security)
             }
 
             aggregate = Constants::SCORE_WEIGHTS.sum do |dimension, weight|
@@ -21,10 +21,10 @@ module Legion
             end
 
             {
-              pass: aggregate >= threshold,
+              pass:      aggregate >= threshold,
               aggregate: aggregate.round(4),
               threshold: threshold,
-              scores: scores
+              scores:    scores
             }
           end
 

data/lib/legion/extensions/factory/helpers/spec_parser.rb

@@ -16,12 +16,12 @@ module Legion
             code_blocks = extract_code_blocks(content)
 
             {
-              success: true,
-              file_path: file_path,
-              title: title,
-              sections: sections,
+              success:     true,
+              file_path:   file_path,
+              title:       title,
+              sections:    sections,
               code_blocks: code_blocks,
-              raw: content
+              raw:         content
             }
           rescue StandardError => e
             { success: false, error: e.message }

data/lib/legion/extensions/factory/pipeline_runner.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require 'json'
+require 'legion/json'
 require 'fileutils'
 
 module Legion
   module Extensions
     module Factory
       class PipelineRunner
+        include Legion::JSON::Helper
+        include Legion::Logging::Helper
+
         attr_reader :spec_path, :output_dir
 
         def initialize(spec_path:, output_dir: nil, threshold: nil, max_retries: nil)
@@ -34,20 +37,21 @@ module Legion
           end
 
           {
-            success: true,
+            success:          true,
             stages_completed: @context[:completed_stages].size,
-            output_dir: @output_dir
+            output_dir:       @output_dir
           }
         rescue StandardError => e
+          log.error "PipelineRunner#run failed at stage #{@context[:current_stage]}: #{e.message}"
           save_state
           { success: false, error: e.message, last_stage: @context[:current_stage] }
         end
 
         def status
           {
-            spec_path: @spec_path,
-            output_dir: @output_dir,
-            current_stage: @context[:current_stage],
+            spec_path:        @spec_path,
+            output_dir:       @output_dir,
+            current_stage:    @context[:current_stage],
             completed_stages: @context[:completed_stages] || []
           }
         end
@@ -59,9 +63,9 @@ module Legion
           ctx[:spec]     = parsed
           ctx[:raw_spec] = Helpers::SpecParser.raw_content(file_path: @spec_path)
           ctx[:discover] = {
-            title: parsed[:title],
-            sections: parsed[:sections],
-            code_blocks: parsed[:code_blocks],
+            title:        parsed[:title],
+            sections:     parsed[:sections],
+            code_blocks:  parsed[:code_blocks],
             requirements: extract_requirements(parsed)
           }
           ctx
@@ -70,7 +74,7 @@ module Legion
         def stage_define(ctx)
           requirements = ctx.dig(:discover, :requirements) || []
           ctx[:define] = {
-            tasks: requirements.map.with_index(1) { |req, i| { id: i, requirement: req, status: :pending } },
+            tasks:      requirements.map.with_index(1) { |req, i| { id: i, requirement: req, status: :pending } },
             task_count: requirements.size
           }
           ctx
@@ -78,11 +82,14 @@ module Legion
 
         def stage_develop(ctx)
           tasks = ctx.dig(:define, :tasks) || []
-          tasks.each { |t| t[:status] = :completed }
-          ctx[:develop] = {
-            tasks_completed: tasks.size,
-            tasks_failed: 0
-          }
+
+          if codegen_available?
+            develop_with_codegen(ctx, tasks)
+          else
+            tasks.each { |t| t[:status] = :completed }
+            ctx[:develop] = { tasks_completed: tasks.size, tasks_failed: 0, strategy: :stub }
+          end
+
           ctx
         end
 
@@ -93,19 +100,72 @@ module Legion
 
           gate_result = Helpers::QualityGate.score(
             completeness: completeness,
-            correctness: 1.0,
-            quality: 1.0,
-            security: 1.0,
-            threshold: @threshold
+            correctness:  1.0,
+            quality:      1.0,
+            security:     1.0,
+            threshold:    @threshold
           )
 
           ctx[:deliver] = {
             gate_result: gate_result,
-            summary: "Pipeline complete: #{tasks_completed}/#{tasks_total} tasks"
+            summary:     "Pipeline complete: #{tasks_completed}/#{tasks_total} tasks"
           }
           ctx
         end
 
+        def codegen_available?
+          defined?(Legion::Extensions::Codegen::Runners::FromGap) &&
+            Legion::Extensions::Codegen::Runners::FromGap.respond_to?(:generate)
+        end
+
+        def develop_with_codegen(ctx, tasks)
+          counters  = { completed: 0, failed: 0 }
+          artifacts = []
+
+          tasks.each { |task| run_codegen_task(task, counters, artifacts) }
+
+          ctx[:develop] = build_develop_context(ctx, counters, artifacts)
+        end
+
+        def run_codegen_task(task, counters, artifacts)
+          result = Legion::Extensions::Codegen::Runners::FromGap.generate(
+            gap: { id: task[:id], type: :runner_method, intent: task[:requirement] }
+          )
+          apply_task_result(task, result, counters, artifacts)
+        rescue StandardError => e
+          log.error "PipelineRunner#run_codegen_task failed for task #{task[:id]}: #{e.message}"
+          task[:status] = :failed
+          task[:reason] = e.message
+          counters[:failed] += 1
+        end
+
+        def apply_task_result(task, result, counters, artifacts)
+          if result[:success]
+            task[:status]        = :completed
+            task[:generation_id] = result[:generation_id]
+            task[:file_path]     = result[:file_path]
+            artifacts << result
+            counters[:completed] += 1
+          else
+            task[:status] = :failed
+            task[:reason] = result[:reason]
+            counters[:failed] += 1
+          end
+        end
+
+        def build_develop_context(ctx, counters, artifacts)
+          {
+            tasks_completed: counters[:completed],
+            tasks_failed:    counters[:failed],
+            strategy:        :codegen,
+            spec_title:      ctx.dig(:discover, :title) || 'unknown',
+            spec_length:     (ctx[:raw_spec] || '').length,
+            artifacts:       artifacts.map do |a|
+              { generation_id: a[:generation_id], tier: a[:tier], file_path: a[:file_path] }
+            end
+          }
+        end
+
         def extract_requirements(parsed)
           return [] unless parsed[:success]
 
@@ -120,19 +180,21 @@ module Legion
 
         def save_state
           ::FileUtils.mkdir_p(@output_dir)
-          File.write(state_file_path, ::JSON.generate(serialize_context(@context)))
-        rescue StandardError
+          File.write(state_file_path, json_dump(serialize_context(@context)))
+        rescue StandardError => e
+          log.warn "PipelineRunner#save_state failed: #{e.message}"
           nil
         end
 
         def load_state
           return default_context unless File.exist?(state_file_path)
 
-          data = ::JSON.parse(File.read(state_file_path), symbolize_names: true)
+          data = json_load(File.read(state_file_path))
           data[:completed_stages] = (data[:completed_stages] || []).map(&:to_sym)
           data[:current_stage] = data[:current_stage]&.to_sym
           data
-        rescue StandardError
+        rescue StandardError => e
+          log.warn "PipelineRunner#load_state failed: #{e.message}"
           default_context
         end
 
@@ -161,7 +223,8 @@ module Legion
           return {} unless defined?(Legion::Settings) && !Legion::Settings[:factory].nil?
 
           Legion::Settings[:factory] || {}
-        rescue StandardError
+        rescue StandardError => e
+          log.debug "PipelineRunner#factory_settings failed: #{e.message}"
           {}
         end
       end

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

@@ -4,10 +4,10 @@ module Legion
   module Extensions
     module Factory
       module Runners
-        module Factory
+        module Factory # rubocop:disable Legion/Extension/RunnerIncludeHelpers
           module_function
 
-          def run_pipeline(spec_path:, output_dir: nil)
+          def run_pipeline(spec_path:, output_dir: nil, **)
             return { success: false, error: 'spec file not found' } unless ::File.exist?(spec_path)
 
             runner = PipelineRunner.new(spec_path: spec_path, output_dir: output_dir)
@@ -16,7 +16,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def pipeline_status(output_dir:)
+          def pipeline_status(output_dir:, **)
             runner = PipelineRunner.new(spec_path: '', output_dir: output_dir)
             status = runner.status
             { success: true, **status }

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Factory
-      VERSION = '0.1.0'
+      VERSION = '0.1.4'
     end
   end
 end

data/lib/legion/extensions/factory.rb

@@ -10,7 +10,7 @@ require_relative 'factory/runners/factory'
 module Legion
   module Extensions
     module Factory
-      extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core)
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core, false)
 
       class << self
         def data_required?
@@ -20,6 +20,10 @@ module Legion
         def llm_required?
           true
         end
+
+        def remote_invocable?
+          false
+        end
       end
     end
   end

metadata

@@ -1,14 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: lex-factory
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Esity
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: Double Diamond pipeline that takes a specification and produces working
   code with tests
 email: