lex-rfp 0.1.0

data/lib/legion/extensions/rfp/ingest/runners/parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Ingest
+        module Runners
+          module Parser
+            extend Legion::Extensions::Rfp::Ingest::Helpers::Client
+
+            def parse_rfp_questions(text:, **)
+              questions = []
+              current_section = nil
+
+              text.each_line do |line|
+                stripped = line.strip
+                next if stripped.empty?
+
+                if stripped.match?(/\A(?:section|part|category)\s+/i) || stripped.match?(/\A[A-Z][A-Z\s]{2,}[A-Z]\z/)
+                  current_section = stripped
+                elsif stripped.match?(/\A\d+[.)]\s/) || stripped.match?(/\A[a-z][.)]\s/i)
+                  questions << {
+                    section:  current_section,
+                    question: stripped.sub(/\A[\da-z][.)]\s*/i, ''),
+                    raw:      stripped
+                  }
+                end
+              end
+
+              { result: questions, count: questions.length }
+            end
+
+            def extract_requirements(text:, **)
+              requirements = []
+
+              text.each_line do |line|
+                stripped = line.strip
+                next if stripped.empty?
+
+                if stripped.match?(/\b(?:must|shall|required|mandatory)\b/i)
+                  requirements << { text: stripped, type: :mandatory }
+                elsif stripped.match?(/\b(?:should|preferred|desired|optional)\b/i)
+                  requirements << { text: stripped, type: :preferred }
+                end
+              end
+
+              { result: requirements, mandatory: requirements.count { |r| r[:type] == :mandatory },
+                preferred: requirements.count { |r| r[:type] == :preferred } }
+            end
+
+            def extract_sections(text:, **)
+              sections = []
+              current_title = nil
+              current_content = []
+
+              text.each_line do |line|
+                stripped = line.strip
+                if stripped.match?(/\A(?:#{section_heading_pattern})/)
+                  sections << { title: current_title, content: current_content.join("\n").strip } if current_title
+                  current_title = stripped
+                  current_content = []
+                else
+                  current_content << line
+                end
+              end
+
+              sections << { title: current_title, content: current_content.join("\n").strip } if current_title
+              { result: sections, count: sections.length }
+            end
+
+            private
+
+            def section_heading_pattern
+              '(?:section|part|category|chapter)\s+\d|[A-Z][A-Z\s]{2,}[A-Z]|\d+\.\s+[A-Z]'
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/ingest.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/rfp/ingest/helpers/client'
+require 'legion/extensions/rfp/ingest/runners/documents'
+require 'legion/extensions/rfp/ingest/runners/corpus'
+require 'legion/extensions/rfp/ingest/runners/parser'
+require 'legion/extensions/rfp/ingest/client'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Ingest
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/review/client.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/workflows'
+require_relative 'runners/comments'
+require_relative 'runners/approvals'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Review
+        class Client
+          include Helpers::Client
+          include Runners::Workflows
+          include Runners::Comments
+          include Runners::Approvals
+
+          attr_reader :opts
+
+          def initialize(base_url: nil, token: nil, **)
+            @opts = { base_url: base_url, token: token }.compact
+          end
+
+          def client(**override)
+            super(**@opts, **override)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/review/helpers/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Review
+        module Helpers
+          module Client
+            def client(base_url: 'http://localhost:4567', token: nil, **)
+              Faraday.new(url: base_url) do |conn|
+                conn.request :json
+                conn.response :json, content_type: /\bjson$/
+                conn.headers['Content-Type'] = 'application/json'
+                conn.headers['Authorization'] = "Bearer #{token}" if token
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/review/runners/approvals.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Review
+        module Runners
+          module Approvals
+            extend Legion::Extensions::Rfp::Review::Helpers::Client
+
+            def approve_section(workflow_id:, section_name:, approved_by:, notes: nil, **)
+              {
+                result: {
+                  workflow_id: workflow_id,
+                  section:     section_name,
+                  status:      :approved,
+                  approved_by: approved_by,
+                  notes:       notes,
+                  approved_at: Time.now.iso8601
+                }
+              }
+            end
+
+            def reject_section(workflow_id:, section_name:, rejected_by:, reason:, **)
+              {
+                result: {
+                  workflow_id: workflow_id,
+                  section:     section_name,
+                  status:      :rejected,
+                  rejected_by: rejected_by,
+                  reason:      reason,
+                  rejected_at: Time.now.iso8601
+                }
+              }
+            end
+
+            def approve_proposal(workflow_id:, approved_by:, notes: nil, **)
+              {
+                result: {
+                  workflow_id: workflow_id,
+                  status:      :approved,
+                  approved_by: approved_by,
+                  notes:       notes,
+                  approved_at: Time.now.iso8601
+                }
+              }
+            end
+
+            def check_readiness(sections:, **)
+              all_approved = sections.all? { |s| s[:status] == :approved }
+              pending = sections.reject { |s| s[:status] == :approved }
+
+              {
+                result: {
+                  ready:            all_approved,
+                  total_sections:   sections.length,
+                  approved:         sections.count { |s| s[:status] == :approved },
+                  pending_sections: pending.map { |s| s[:name] }
+                }
+              }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/review/runners/comments.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Review
+        module Runners
+          module Comments
+            extend Legion::Extensions::Rfp::Review::Helpers::Client
+
+            def add_comment(workflow_id:, section_name:, author:, body:, type: :general, **)
+              comment = {
+                id:          generate_comment_id,
+                workflow_id: workflow_id,
+                section:     section_name,
+                author:      author,
+                body:        body,
+                type:        type.to_sym,
+                created_at:  Time.now.iso8601
+              }
+              { result: comment }
+            end
+
+            def list_comments(workflow_id:, section_name: nil, **)
+              {
+                result:      [],
+                workflow_id: workflow_id,
+                section:     section_name,
+                error:       'Persistence requires legion-data'
+              }
+            end
+
+            def resolve_comment(comment_id:, resolved_by:, **)
+              {
+                result: {
+                  id:          comment_id,
+                  resolved:    true,
+                  resolved_by: resolved_by,
+                  resolved_at: Time.now.iso8601
+                }
+              }
+            end
+
+            def request_revision(workflow_id:, section_name:, author:, reason:, **)
+              comment = add_comment(
+                workflow_id:  workflow_id,
+                section_name: section_name,
+                author:       author,
+                body:         reason,
+                type:         :revision_request
+              )
+
+              {
+                result: {
+                  comment:     comment[:result],
+                  section:     section_name,
+                  new_status:  :revision_requested,
+                  workflow_id: workflow_id
+                }
+              }
+            end
+
+            private
+
+            def generate_comment_id
+              "rfp-cmt-#{Time.now.to_i}-#{rand(10_000)}"
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/review/runners/workflows.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Review
+        module Runners
+          module Workflows
+            extend Legion::Extensions::Rfp::Review::Helpers::Client
+
+            STATUSES = %i[draft in_review revision_requested approved rejected finalized].freeze
+
+            def create_workflow(proposal_id:, sections: [], reviewers: [], **)
+              workflow = {
+                id:          generate_workflow_id,
+                proposal_id: proposal_id,
+                status:      :draft,
+                sections:    sections.map { |s| { name: s, status: :draft, reviewer: nil, comments: [] } },
+                reviewers:   reviewers,
+                created_at:  Time.now.iso8601,
+                updated_at:  Time.now.iso8601
+              }
+              { result: workflow }
+            end
+
+            def get_workflow(workflow_id:, **)
+              { result: { id: workflow_id, status: :draft }, error: 'Persistence requires legion-data' }
+            end
+
+            def update_status(workflow_id:, status:, **)
+              status_sym = status.to_sym
+              return { result: nil, error: "Invalid status: #{status}. Valid: #{STATUSES.join(', ')}" } unless STATUSES.include?(status_sym)
+
+              { result: { id: workflow_id, status: status_sym, updated_at: Time.now.iso8601 } }
+            end
+
+            def update_section_status(workflow_id:, section_name:, status:, reviewer: nil, **)
+              status_sym = status.to_sym
+              return { result: nil, error: "Invalid status: #{status}" } unless STATUSES.include?(status_sym)
+
+              {
+                result: {
+                  workflow_id: workflow_id,
+                  section:     section_name,
+                  status:      status_sym,
+                  reviewer:    reviewer,
+                  updated_at:  Time.now.iso8601
+                }
+              }
+            end
+
+            def submit_for_review(workflow_id:, reviewers:, **)
+              {
+                result: {
+                  workflow_id:  workflow_id,
+                  status:       :in_review,
+                  reviewers:    reviewers,
+                  submitted_at: Time.now.iso8601
+                }
+              }
+            end
+
+            def finalize(workflow_id:, **)
+              {
+                result: {
+                  workflow_id:  workflow_id,
+                  status:       :finalized,
+                  finalized_at: Time.now.iso8601
+                }
+              }
+            end
+
+            private
+
+            def generate_workflow_id
+              "rfp-wf-#{Time.now.to_i}-#{rand(10_000)}"
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/review.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/rfp/review/helpers/client'
+require 'legion/extensions/rfp/review/runners/workflows'
+require 'legion/extensions/rfp/review/runners/comments'
+require 'legion/extensions/rfp/review/runners/approvals'
+require 'legion/extensions/rfp/review/client'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Review
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/rfp.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/rfp/version'
+require_relative 'rfp/ingest'
+require_relative 'rfp/generate'
+require_relative 'rfp/review'
+require_relative 'rfp/analytics'
+
+module Legion
+  module Extensions
+    module Rfp
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: lex-rfp
+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: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Generative AI-powered RFP and proposal automation for LegionIO. Ingests
+  past proposals into Apollo, generates draft responses via LLM pipeline with RAG,
+  and provides human-in-the-loop review workflows with analytics.
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Dockerfile
+- Gemfile
+- LICENSE
+- README.md
+- lex-rfp.gemspec
+- lib/legion/extensions/rfp.rb
+- lib/legion/extensions/rfp/analytics.rb
+- lib/legion/extensions/rfp/analytics/client.rb
+- lib/legion/extensions/rfp/analytics/helpers/client.rb
+- lib/legion/extensions/rfp/analytics/runners/metrics.rb
+- lib/legion/extensions/rfp/analytics/runners/quality.rb
+- lib/legion/extensions/rfp/analytics/runners/win_rates.rb
+- lib/legion/extensions/rfp/generate.rb
+- lib/legion/extensions/rfp/generate/client.rb
+- lib/legion/extensions/rfp/generate/helpers/client.rb
+- lib/legion/extensions/rfp/generate/runners/drafts.rb
+- lib/legion/extensions/rfp/generate/runners/sections.rb
+- lib/legion/extensions/rfp/generate/runners/templates.rb
+- lib/legion/extensions/rfp/ingest.rb
+- lib/legion/extensions/rfp/ingest/client.rb
+- lib/legion/extensions/rfp/ingest/helpers/client.rb
+- lib/legion/extensions/rfp/ingest/runners/corpus.rb
+- lib/legion/extensions/rfp/ingest/runners/documents.rb
+- lib/legion/extensions/rfp/ingest/runners/parser.rb
+- lib/legion/extensions/rfp/review.rb
+- lib/legion/extensions/rfp/review/client.rb
+- lib/legion/extensions/rfp/review/helpers/client.rb
+- lib/legion/extensions/rfp/review/runners/approvals.rb
+- lib/legion/extensions/rfp/review/runners/comments.rb
+- lib/legion/extensions/rfp/review/runners/workflows.rb
+- lib/legion/extensions/rfp/version.rb
+homepage: https://github.com/LegionIO/lex-rfp
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-rfp
+  source_code_uri: https://github.com/LegionIO/lex-rfp
+  documentation_uri: https://github.com/LegionIO/lex-rfp
+  changelog_uri: https://github.com/LegionIO/lex-rfp/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-rfp/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: LEX Rfp
+test_files: []