lex-planner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd1eacdf6999ca3ef644d70ed3ef96c836146f150f64ba695dc28382ba9cf3ce
+  data.tar.gz: bf663219e4f2a9b008a32932b7fcb38745e7b260b9d8b2ca01f9c3d2e085bafa
+SHA512:
+  metadata.gz: 559d4836a582609af5c74bdd6dbe8cb11f6bd285888301e5d724d6c513d071a9580c5518c5bf80392fcef0144c2260be9031d9564d69eda76e3f1736c19b589c
+  data.tar.gz: f223e47745de570b480322636dfa330d79ced9fe5f29777e040fbea331ceba9feb6618f7cdd626e1fe969fa10e7a41ce63033e8b28686f19a6fd244e342d0409

data/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+  schedule:
+    - cron: '0 9 * * 1'
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  excluded-files:
+    uses: LegionIO/.github/.github/workflows/excluded-files.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
+  stale:
+    if: github.event_name == 'schedule'
+    uses: LegionIO/.github/.github/workflows/stale.yml@main
+
+  release:
+    needs: [ci, excluded-files]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rspec_status

@@ -0,0 +1,40 @@
+example_id                                                               | status | run_time        |
+------------------------------------------------------------------------ | ------ | --------------- |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:1:1] | passed | 0.00047 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:1:2] | passed | 0.00105 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:1:3] | passed | 0.00005 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:1:4] | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:2:1] | passed | 0.00005 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:2:2] | passed | 0.00036 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:3:1] | passed | 0.00003 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:3:2] | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/helpers/context_gatherer_spec.rb[1:4:1] | passed | 0.00112 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:1:1]      | passed | 0.00003 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:1:2]      | passed | 0.00003 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:1:3]      | passed | 0.00002 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:1:4]      | passed | 0.00002 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:1:5]      | passed | 0.00022 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:1:6]      | passed | 0.00002 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:2:1]      | passed | 0.00048 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:2:2]      | passed | 0.00044 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:2:3]      | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/helpers/plan_schema_spec.rb[1:2:4]      | passed | 0.00003 seconds |
+./spec/legion/extensions/planner/helpers/spec_parser_spec.rb[1:1:1]      | passed | 0.00005 seconds |
+./spec/legion/extensions/planner/helpers/spec_parser_spec.rb[1:1:2]      | passed | 0.00005 seconds |
+./spec/legion/extensions/planner/helpers/spec_parser_spec.rb[1:1:3]      | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/helpers/spec_parser_spec.rb[1:1:4]      | passed | 0.00002 seconds |
+./spec/legion/extensions/planner/helpers/spec_parser_spec.rb[1:1:5]      | passed | 0.00003 seconds |
+./spec/legion/extensions/planner/helpers/spec_parser_spec.rb[1:2:1]      | passed | 0.00064 seconds |
+./spec/legion/extensions/planner/helpers/spec_parser_spec.rb[1:2:2]      | passed | 0.00003 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:1:1]          | passed | 0.00023 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:1:2]          | passed | 0.00005 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:1:3]          | passed | 0.00006 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:1:4]          | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:1:5]          | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:1:6]          | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:1:7]          | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:2:1]          | passed | 0.00005 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:2:2]          | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/runners/planner_spec.rb[1:2:3]          | passed | 0.00004 seconds |
+./spec/legion/extensions/planner/version_spec.rb[1:1]                    | passed | 0.00002 seconds |
+./spec/legion/extensions/planner/version_spec.rb[1:2]                    | passed | 0.00003 seconds |

data/.rubocop.yml

@@ -0,0 +1,11 @@
+inherit_gem:
+  rubocop-legion: config/lex.yml
+
+Legion/Extension/RunnerReturnHash:
+  Enabled: false
+
+Legion/HelperMigration/LoggingGuard:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false

data/CLAUDE.md

@@ -0,0 +1,37 @@
+# lex-planner: Fleet Pipeline Planning
+
+**Level 3 Documentation**
+- **Parent**: `CLAUDE.md` (monorepo root)
+
+## Purpose
+
+Second stage of the Fleet Pipeline. Receives assessed work items, gathers repo context (file tree, documentation, relevant source files), decomposes work into structured implementation plans using LLM structured output, and routes to the developer stage. Supports multi-solver planning (Dr. Zero pattern) when `config.planning.solvers > 1`.
+
+**Gem**: `lex-planner`
+**Version**: 0.1.0
+**Namespace**: `Legion::Extensions::Planner`
+
+## Runners
+
+### `Runners::Planner`
+- `plan(work_item:, **)` -- Gather context, generate LLM plan, validate, return planned work item
+- `gather_context(work_item:, **)` -- Fetch repo file tree, docs, and relevant files; cache in Redis
+
+## Helpers
+
+- `Helpers::PlanSchema` -- LLM structured output schema for plans + validation
+- `Helpers::SpecParser` -- Markdown spec/requirements parsing (absorbed from lex-factory)
+- `Helpers::ContextGatherer` -- Fetch and cache repo context (file tree, docs, relevant files)
+
+## Transport
+
+- Exchange: `lex.planner` (topic, durable)
+- Queue: `lex.planner.runners.planner` (durable, routing key `lex.planner.runners.planner.#`)
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```

data/Gemfile

@@ -0,0 +1,14 @@
+# 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-legion', '~> 0.1', require: false
+  gem 'rubocop-rspec'
+  gem 'simplecov'
+end

data/lex-planner.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/planner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-planner'
+  spec.version       = Legion::Extensions::Planner::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Legion::Extensions::Planner'
+  spec.description   = 'Fleet pipeline planning: decompose work items into implementation plans'
+  spec.homepage      = 'https://github.com/LegionIO/lex-planner'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']          = spec.homepage
+  spec.metadata['source_code_uri']       = 'https://github.com/LegionIO/lex-planner'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-planner'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-planner'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-planner/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 'legion-cache',     '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',     '>= 1.4.9'
+  spec.add_dependency 'legion-data',      '>= 1.4.17'
+  spec.add_dependency 'legion-json',      '>= 1.2.1'
+  spec.add_dependency 'legion-logging',   '>= 1.3.2'
+  spec.add_dependency 'legion-settings',  '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
+
+  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

data/lib/legion/extensions/planner/actors/planner.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+return unless defined?(Legion::Extensions::Actors::Subscription)
+
+module Legion
+  module Extensions
+    module Planner
+      module Actor
+        class Planner < Legion::Extensions::Actors::Subscription
+          def runner_function
+            'plan'
+          end
+
+          def check_subtask?
+            true
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/planner/helpers/context_gatherer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Planner
+      module Helpers
+        # rubocop:disable Legion/HelperMigration/DirectJson, Legion/HelperMigration/DirectCache
+        module ContextGatherer
+          extend self
+
+          DOC_FILE_NAMES = %w[CLAUDE.md README.md AGENTS.md CONTRIBUTING.md CHANGELOG.md].freeze
+          CACHE_PREFIX = 'fleet:context:'
+          DEFAULT_TTL = 86_400 # 24 hours
+
+          def gather(repo:, config:, work_item_id:, keywords: [], **)
+            context = {
+              file_tree:      config[:load_file_tree] ? fetch_file_tree(repo: repo) : [],
+              docs:           config[:load_repo_docs] ? fetch_docs(repo: repo) : {},
+              relevant_files: fetch_relevant_files(
+                repo:      repo,
+                keywords:  keywords,
+                max_files: config[:max_context_files] || 50
+              )
+            }
+
+            cache_key = store_context!(work_item_id: work_item_id, context: context)
+            context.merge(context_ref: cache_key)
+          end
+
+          def store_context!(work_item_id:, context:)
+            key = "#{CACHE_PREFIX}#{work_item_id}"
+            serialized = json_dump(context)
+            cache_set(key, serialized, ttl: DEFAULT_TTL)
+            key
+          end
+
+          def load_context(context_ref:)
+            raw = cache_get(context_ref)
+            return nil if raw.nil?
+
+            json_load(raw)
+          end
+
+          def doc_file_names
+            DOC_FILE_NAMES
+          end
+
+          private
+
+          def json_dump(obj)
+            Legion::JSON.dump(obj)
+          end
+
+          def json_load(str)
+            Legion::JSON.load(str)
+          end
+
+          def cache_set(key, value, ttl: nil)
+            Legion::Cache.set(key, value, ttl: ttl)
+          end
+
+          def cache_get(key)
+            Legion::Cache.get(key)
+          end
+
+          def fetch_file_tree(repo:) # rubocop:disable Lint/UnusedMethodArgument
+            # In production, calls lex-github or lex-exec to get the file tree.
+            # Stubbed here — implementation depends on WS-01 (lex-exec) and WS-02 (lex-github).
+            []
+          end
+
+          def fetch_docs(repo:) # rubocop:disable Lint/UnusedMethodArgument
+            # In production, fetches CLAUDE.md, README.md, AGENTS.md from the repo.
+            # Stubbed here — implementation depends on WS-02 (lex-github).
+            {}
+          end
+
+          def fetch_relevant_files(repo:, keywords:, max_files:) # rubocop:disable Lint/UnusedMethodArgument
+            # In production, searches repo files by keyword relevance.
+            # Stubbed here — implementation depends on WS-01/WS-02.
+            []
+          end
+        end
+        # rubocop:enable Legion/HelperMigration/DirectJson, Legion/HelperMigration/DirectCache
+      end
+    end
+  end
+end

data/lib/legion/extensions/planner/helpers/plan_schema.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Planner
+      module Helpers
+        module PlanSchema
+          extend self
+
+          SCHEMA = {
+            type:       :object,
+            properties: {
+              approach:          { type: :string },
+              files_to_modify:   {
+                type:  :array,
+                items: {
+                  type:       :object,
+                  properties: {
+                    path:   { type: :string },
+                    action: { type: :string, enum: %w[modify create delete] },
+                    reason: { type: :string }
+                  },
+                  required:   %i[path action reason]
+                }
+              },
+              files_to_read:     { type: :array, items: { type: :string } },
+              test_strategy:     { type: :string },
+              estimated_changes: { type: :integer }
+            },
+            required:   %i[approach files_to_modify test_strategy estimated_changes]
+          }.freeze
+
+          def schema
+            SCHEMA
+          end
+
+          def validate_plan(plan:)
+            errors = []
+            SCHEMA[:required].each do |field|
+              errors << "Missing required field: #{field}" unless plan.key?(field) && !plan[field].nil?
+            end
+
+            errors << 'files_to_modify must not be empty' if plan[:files_to_modify].is_a?(Array) && plan[:files_to_modify].empty?
+
+            errors << 'estimated_changes must be an integer' if plan.key?(:estimated_changes) && !plan[:estimated_changes].is_a?(Integer)
+
+            { valid: errors.empty?, errors: errors }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Planner
+      module Helpers
+        module SpecParser
+          extend self
+
+          def parse(content:)
+            return { title: nil, sections: {} } if content.nil? || content.strip.empty?
+
+            lines = content.lines.map(&:rstrip)
+            title = extract_title(lines)
+            sections = extract_sections(lines)
+
+            { title: title, sections: sections }
+          end
+
+          def extract_requirements(content:)
+            parsed = parse(content: content)
+            section = parsed[:sections]['Requirements']
+            return [] if section.nil?
+
+            section.lines
+                   .map(&:strip)
+                   .select { |line| line.start_with?('- ') }
+                   .map { |line| line.sub(/\A-\s*/, '') }
+          end
+
+          private
+
+          def extract_title(lines)
+            title_line = lines.find { |l| l.match?(/\A#\s+/) }
+            return nil unless title_line
+
+            title_line.sub(/\A#\s+/, '').strip
+          end
+
+          def extract_sections(lines)
+            sections = {}
+            current_section = nil
+            current_content = []
+
+            lines.each do |line|
+              if line.match?(/\A##\s+/)
+                sections[current_section] = current_content.join("\n").strip if current_section
+                current_section = line.sub(/\A##\s+/, '').strip
+                current_content = []
+              elsif current_section
+                current_content << line
+              end
+            end
+
+            sections[current_section] = current_content.join("\n").strip if current_section
+
+            sections
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Planner
+      module Runners
+        module Planner
+          extend self
+
+          def plan(results: nil, work_item: nil, args: nil, **)
+            results = json_load(results) if results.is_a?(String)
+            work_item ||= results&.dig(:work_item) || args&.dig(:work_item)
+            raise ArgumentError, "work_item is nil in #{__method__}" if work_item.nil?
+
+            max_iterations = work_item.dig(:config, :planning, :max_iterations) ||
+                             Legion::Settings.dig(:fleet, :planning, :max_iterations) || 5
+
+            context = Helpers::ContextGatherer.gather(
+              repo:         work_item[:repo],
+              config:       work_item[:config][:context] || {},
+              work_item_id: work_item[:work_item_id],
+              keywords:     extract_keywords(work_item)
+            )
+
+            plan_result = nil
+            validation = nil
+            max_iterations.times do
+              plan_result = generate_plan(work_item: work_item, context: context)
+              validation = Helpers::PlanSchema.validate_plan(plan: plan_result)
+              break if validation[:valid]
+            end
+
+            unless validation[:valid]
+              return { success: false, reason: :invalid_plan, errors: validation[:errors],
+                       work_item: work_item }
+            end
+
+            work_item = work_item.merge(
+              pipeline: work_item[:pipeline].merge(
+                stage:       'planned',
+                plan:        plan_result,
+                context_ref: context[:context_ref],
+                trace:       work_item[:pipeline][:trace] + [build_trace_entry]
+              )
+            )
+
+            { success: true, work_item: work_item }
+          end
+
+          def gather_context(results: nil, work_item: nil, args: nil, **)
+            results = json_load(results) if results.is_a?(String)
+            work_item ||= results&.dig(:work_item) || args&.dig(:work_item)
+            raise ArgumentError, "work_item is nil in #{__method__}" if work_item.nil?
+
+            context = Helpers::ContextGatherer.gather(
+              repo:         work_item[:repo],
+              config:       work_item[:config][:context] || {},
+              work_item_id: work_item[:work_item_id],
+              keywords:     extract_keywords(work_item)
+            )
+
+            { success: true, context: context, context_ref: context[:context_ref] }
+          end
+
+          private
+
+          def generate_plan(work_item:, context:)
+            prompt = build_plan_prompt(work_item: work_item, context: context)
+            exclude = build_model_exclusions(work_item)
+
+            Legion::LLM::Prompt.dispatch(
+              prompt,
+              schema:  Helpers::PlanSchema::SCHEMA,
+              tools:   [],
+              exclude: exclude,
+              intent:  { capability: difficulty_to_capability(work_item) }
+            )
+          end
+
+          def build_model_exclusions(work_item)
+            exclude = {}
+            work_item[:pipeline][:trace].each do |t|
+              next unless t[:model]
+
+              (exclude[t[:provider]&.to_sym] ||= []) << t[:model]
+            end
+            exclude.each_value(&:uniq!)
+            exclude
+          end
+
+          def build_plan_prompt(work_item:, context:)
+            <<~PROMPT
+              You are a software architect planning an implementation for a coding task.
+
+              ## Work Item
+              Title: #{work_item[:title]}
+              Description: #{work_item[:description]}
+              Source: #{work_item[:source_ref]}
+              Language: #{work_item.dig(:repo, :language) || 'unknown'}
+              Repository: #{work_item.dig(:repo, :owner)}/#{work_item.dig(:repo, :name)}
+
+              ## Repository Context
+              File tree: #{context[:file_tree]&.first(100)&.join("\n") || 'Not available'}
+              Documentation: #{context[:docs]&.map { |k, v| "#{k}:\n#{v}" }&.join("\n\n") || 'Not available'}
+
+              ## Task
+              Create a detailed implementation plan. Specify which files to modify/create/delete,
+              the overall approach, a test strategy, and estimated number of file changes.
+            PROMPT
+          end
+
+          def extract_keywords(work_item)
+            text = "#{work_item[:title]} #{work_item[:description]}"
+            text.downcase.scan(/[a-z_]+/).uniq.reject { |w| w.length < 4 }
+          end
+
+          def difficulty_to_capability(work_item)
+            difficulty = work_item.dig(:config, :estimated_difficulty) || 0.5
+            case difficulty
+            when 0.0...0.3 then :basic
+            when 0.3...0.6 then :moderate
+            else :reasoning
+            end
+          end
+
+          def build_trace_entry
+            {
+              stage:        'planner',
+              node:         node_name,
+              model:        nil,
+              provider:     nil,
+              started_at:   ::Time.now.utc.iso8601,
+              completed_at: ::Time.now.utc.iso8601,
+              token_usage:  nil
+            }
+          end
+
+          def node_name
+            if defined?(Legion::Settings)
+              Legion::Settings.dig(:node, :name) || 'unknown'
+            else
+              'unknown'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/planner/transport/exchanges/planner.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Planner
+      module Transport
+        module Exchanges
+          class Planner < Legion::Transport::Exchange
+            def exchange_name
+              'lex.planner'
+            end
+
+            def exchange_options
+              { type: 'topic', durable: true }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/planner/transport/queues/planner.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Planner
+      module Transport
+        module Queues
+          class Planner < Legion::Transport::Queue
+            def queue_name
+              'lex.planner.runners.planner'
+            end
+
+            def queue_options
+              { durable: true }
+            end
+
+            def routing_key
+              'lex.planner.runners.planner.#'
+            end
+
+            def exchange
+              Exchanges::Planner
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/planner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'planner/version'
+require_relative 'planner/helpers/plan_schema'
+require_relative 'planner/helpers/spec_parser'
+require_relative 'planner/helpers/context_gatherer'
+require_relative 'planner/runners/planner'
+
+if defined?(Legion::Transport::Exchange)
+  require_relative 'planner/transport/exchanges/planner'
+  require_relative 'planner/transport/queues/planner'
+end
+
+require_relative 'planner/actors/planner'
+
+module Legion
+  module Extensions
+    module Planner
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+
+      def self.llm_required?
+        true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,231 @@
+--- !ruby/object:Gem::Specification
+name: lex-planner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  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: '1.75'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+- !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: 'Fleet pipeline planning: decompose work items into implementation plans'
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rspec_status"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- lex-planner.gemspec
+- lib/legion/extensions/planner.rb
+- lib/legion/extensions/planner/actors/planner.rb
+- lib/legion/extensions/planner/helpers/context_gatherer.rb
+- lib/legion/extensions/planner/helpers/plan_schema.rb
+- lib/legion/extensions/planner/helpers/spec_parser.rb
+- lib/legion/extensions/planner/runners/planner.rb
+- lib/legion/extensions/planner/transport/exchanges/planner.rb
+- lib/legion/extensions/planner/transport/queues/planner.rb
+- lib/legion/extensions/planner/version.rb
+homepage: https://github.com/LegionIO/lex-planner
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-planner
+  source_code_uri: https://github.com/LegionIO/lex-planner
+  changelog_uri: https://github.com/LegionIO/lex-planner
+  documentation_uri: https://github.com/LegionIO/lex-planner
+  bug_tracker_uri: https://github.com/LegionIO/lex-planner/issues
+  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: Legion::Extensions::Planner
+test_files: []