lex-rfp 0.1.0

data/lib/legion/extensions/rfp/analytics/runners/win_rates.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Analytics
+        module Runners
+          module WinRates
+            extend Legion::Extensions::Rfp::Analytics::Helpers::Client
+
+            def overall_win_rate(proposals:, **)
+              decided = proposals.select { |p| %i[won lost].include?(p[:outcome]) }
+              return { result: 0.0, decided: 0, total: proposals.length } if decided.empty?
+
+              won = decided.count { |p| p[:outcome] == :won }
+              { result: (won.to_f / decided.length).round(4), won: won, decided: decided.length }
+            end
+
+            def win_rate_by_source(proposals:, **)
+              grouped = proposals.group_by { |p| p[:rfp_source] }
+              rates = grouped.transform_values do |group|
+                decided = group.select { |p| %i[won lost].include?(p[:outcome]) }
+                next { rate: 0.0, decided: 0 } if decided.empty?
+
+                won = decided.count { |p| p[:outcome] == :won }
+                { rate: (won.to_f / decided.length).round(4), won: won, decided: decided.length }
+              end
+
+              { result: rates }
+            end
+
+            def win_rate_by_template(proposals:, **)
+              grouped = proposals.group_by { |p| p[:template] }
+              rates = grouped.transform_values do |group|
+                decided = group.select { |p| %i[won lost].include?(p[:outcome]) }
+                next { rate: 0.0, decided: 0 } if decided.empty?
+
+                won = decided.count { |p| p[:outcome] == :won }
+                { rate: (won.to_f / decided.length).round(4), won: won, decided: decided.length }
+              end
+
+              { result: rates }
+            end
+
+            def trend(proposals:, period: :monthly, **)
+              sorted = proposals.sort_by { |p| p[:submitted_at] || '' }
+              grouped = case period
+                        when :monthly
+                          sorted.group_by { |p| p[:submitted_at]&.slice(0, 7) }
+                        when :quarterly
+                          sorted.group_by { |p| quarter_key(p[:submitted_at]) }
+                        else
+                          sorted.group_by { |p| p[:submitted_at]&.slice(0, 4) }
+                        end
+
+              trend_data = grouped.transform_values do |group|
+                decided = group.select { |p| %i[won lost].include?(p[:outcome]) }
+                won = decided.count { |p| p[:outcome] == :won }
+                {
+                  total:   group.length,
+                  decided: decided.length,
+                  won:     won,
+                  rate:    decided.empty? ? 0.0 : (won.to_f / decided.length).round(4)
+                }
+              end
+
+              { result: trend_data, period: period }
+            end
+
+            private
+
+            def quarter_key(date_str)
+              return nil unless date_str
+
+              year = date_str[0, 4]
+              month = date_str[5, 2].to_i
+              quarter = ((month - 1) / 3) + 1
+              "#{year}-Q#{quarter}"
+            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/analytics.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/rfp/analytics/helpers/client'
+require 'legion/extensions/rfp/analytics/runners/metrics'
+require 'legion/extensions/rfp/analytics/runners/win_rates'
+require 'legion/extensions/rfp/analytics/runners/quality'
+require 'legion/extensions/rfp/analytics/client'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Analytics
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/drafts'
+require_relative 'runners/sections'
+require_relative 'runners/templates'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Generate
+        class Client
+          include Helpers::Client
+          include Runners::Drafts
+          include Runners::Sections
+          include Runners::Templates
+
+          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/generate/helpers/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Generate
+        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/generate/runners/drafts.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Generate
+        module Runners
+          module Drafts
+            extend Legion::Extensions::Rfp::Generate::Helpers::Client
+
+            def generate_full_draft(rfp_text:, context: {}, model: nil, **)
+              questions = parse_rfp(rfp_text)
+              responses = questions.map do |question|
+                generate_section_response(question: question[:question], section: question[:section], context: context,
+                                          model: model)
+              end
+
+              draft = responses.map { |r| r[:result] }.join("\n\n---\n\n")
+              { result: draft, sections: responses.length, questions_answered: responses.length }
+            end
+
+            def generate_response(question:, context: {}, model: nil, scope: :all, **)
+              retrieved = retrieve_context(question: question, scope: scope)
+              prompt = build_prompt(question: question, context: context, retrieved: retrieved)
+
+              answer = call_llm(prompt: prompt, model: model)
+              { result: answer, context_used: retrieved.length, question: question }
+            end
+
+            def regenerate(question:, previous_answer:, feedback:, context: {}, model: nil, **)
+              prompt = build_revision_prompt(
+                question: question,
+                previous: previous_answer,
+                feedback: feedback,
+                context:  context
+              )
+
+              answer = call_llm(prompt: prompt, model: model)
+              { result: answer, question: question, revision: true }
+            end
+
+            private
+
+            def parse_rfp(text)
+              obj = Object.new
+              obj.extend(Legion::Extensions::Rfp::Ingest::Runners::Parser)
+              parsed = obj.parse_rfp_questions(text: text)
+              parsed[:result]
+            end
+
+            def retrieve_context(question:, scope:)
+              return [] unless defined?(Legion::Apollo)
+
+              result = Legion::Apollo.retrieve(query: question, scope: scope, limit: 5)
+              result.is_a?(Array) ? result : []
+            end
+
+            def build_prompt(question:, context:, retrieved:)
+              parts = ['You are an expert proposal writer for a healthcare organization.']
+              parts << 'Use the following reference material to craft your response:'
+
+              retrieved.each_with_index do |doc, idx|
+                parts << "\n--- Reference #{idx + 1} ---\n#{doc[:content] || doc['content']}"
+              end
+
+              parts << "\nAdditional context: #{context.inspect}" unless context.empty?
+              parts << "\nQuestion: #{question}"
+              parts << "\nProvide a professional, detailed response suitable for an RFP submission."
+              parts.join("\n")
+            end
+
+            def build_revision_prompt(question:, previous:, feedback:, context:)
+              parts = ['You are revising an RFP response based on reviewer feedback.']
+              parts << "\nOriginal question: #{question}"
+              parts << "\nPrevious answer:\n#{previous}"
+              parts << "\nReviewer feedback: #{feedback}"
+              parts << "\nAdditional context: #{context.inspect}" unless context.empty?
+              parts << "\nProvide an improved response incorporating the feedback."
+              parts.join("\n")
+            end
+
+            def call_llm(prompt:, model: nil) # rubocop:disable Lint/UnusedMethodArgument
+              if defined?(Legion::LLM)
+                result = Legion::LLM.ask(message: prompt)
+                result.is_a?(Hash) ? (result[:content] || result[:result] || result.to_s) : result.to_s
+              else
+                "[LLM not available] Prompt: #{prompt[0..100]}..."
+              end
+            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/generate/runners/sections.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Generate
+        module Runners
+          module Sections
+            extend Legion::Extensions::Rfp::Generate::Helpers::Client
+
+            def generate_section_response(question:, section: nil, context: {}, model: nil, scope: :all, **)
+              retrieved = retrieve_section_context(question: question, section: section, scope: scope)
+              prompt = build_section_prompt(question: question, section: section, context: context,
+                                            retrieved: retrieved)
+
+              answer = call_section_llm(prompt: prompt, model: model)
+              {
+                result:       answer,
+                section:      section,
+                question:     question,
+                context_used: retrieved.length
+              }
+            end
+
+            def generate_executive_summary(rfp_text:, company_context: {}, model: nil, **)
+              prompt = build_executive_summary_prompt(rfp_text: rfp_text, company_context: company_context)
+              answer = call_section_llm(prompt: prompt, model: model)
+              { result: answer, type: :executive_summary }
+            end
+
+            def generate_compliance_matrix(requirements:, capabilities: {}, model: nil, **)
+              prompt = build_compliance_prompt(requirements: requirements, capabilities: capabilities)
+              answer = call_section_llm(prompt: prompt, model: model)
+              { result: answer, type: :compliance_matrix, requirements_count: requirements.length }
+            end
+
+            private
+
+            def retrieve_section_context(question:, section:, scope:)
+              return [] unless defined?(Legion::Apollo)
+
+              query = [section, question].compact.join(' - ')
+              result = Legion::Apollo.retrieve(query: query, scope: scope, limit: 5)
+              result.is_a?(Array) ? result : []
+            end
+
+            def build_section_prompt(question:, section:, context:, retrieved:)
+              parts = ['You are writing a specific section of an RFP response.']
+              parts << "Section: #{section}" if section
+
+              retrieved.each_with_index do |doc, idx|
+                parts << "\n--- Reference #{idx + 1} ---\n#{doc[:content] || doc['content']}"
+              end
+
+              parts << "\nAdditional context: #{context.inspect}" unless context.empty?
+              parts << "\nQuestion: #{question}"
+              parts << "\nProvide a focused, professional response for this section."
+              parts.join("\n")
+            end
+
+            def build_executive_summary_prompt(rfp_text:, company_context:)
+              parts = ['Write an executive summary for the following RFP response.']
+              parts << "\nCompany context: #{company_context.inspect}" unless company_context.empty?
+              parts << "\nRFP overview:\n#{rfp_text[0..2000]}"
+              parts << "\nWrite a compelling 2-3 paragraph executive summary."
+              parts.join("\n")
+            end
+
+            def build_compliance_prompt(requirements:, capabilities:)
+              parts = ['Generate a compliance matrix for the following requirements.']
+              parts << "\nCapabilities: #{capabilities.inspect}" unless capabilities.empty?
+
+              requirements.each_with_index do |req, idx|
+                parts << "#{idx + 1}. #{req[:text] || req}"
+              end
+
+              parts << "\nFor each requirement, indicate: Compliant, Partially Compliant, or Non-Compliant with explanation."
+              parts.join("\n")
+            end
+
+            def call_section_llm(prompt:, model: nil) # rubocop:disable Lint/UnusedMethodArgument
+              if defined?(Legion::LLM)
+                result = Legion::LLM.ask(message: prompt)
+                result.is_a?(Hash) ? (result[:content] || result[:result] || result.to_s) : result.to_s
+              else
+                "[LLM not available] Prompt: #{prompt[0..100]}..."
+              end
+            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/generate/runners/templates.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Generate
+        module Runners
+          module Templates
+            extend Legion::Extensions::Rfp::Generate::Helpers::Client
+
+            DEFAULT_TEMPLATES = {
+              standard:   { sections: %i[executive_summary company_overview approach timeline pricing], tone: :formal },
+              government: { sections: %i[executive_summary compliance technical_approach management staffing pricing],
+                            tone:     :formal },
+              healthcare: { sections: %i[executive_summary clinical_approach quality_measures compliance network
+                                         implementation pricing], tone: :formal }
+            }.freeze
+
+            def list_templates(**)
+              { result: DEFAULT_TEMPLATES.keys, count: DEFAULT_TEMPLATES.keys.length }
+            end
+
+            def get_template(name:, **)
+              template = DEFAULT_TEMPLATES[name.to_sym]
+              return { result: nil, error: "Template not found: #{name}" } unless template
+
+              { result: template, name: name }
+            end
+
+            def apply_template(name:, rfp_data:, **)
+              template = DEFAULT_TEMPLATES[name.to_sym]
+              return { result: nil, error: "Template not found: #{name}" } unless template
+
+              outline = template[:sections].map do |section|
+                { section: section, tone: template[:tone], content: rfp_data[section] }
+              end
+
+              { result: outline, template: name, sections: outline.length }
+            end
+
+            def suggest_template(rfp_text:, **)
+              text_lower = rfp_text.downcase
+              suggested = if text_lower.match?(/\b(?:medicare|medicaid|clinical|hipaa|phi|health)\b/)
+                            :healthcare
+                          elsif text_lower.match?(/\b(?:federal|government|agency|cfr|far|dfars)\b/)
+                            :government
+                          else
+                            :standard
+                          end
+
+              { result: suggested, confidence: :heuristic }
+            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/generate.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/rfp/generate/helpers/client'
+require 'legion/extensions/rfp/generate/runners/drafts'
+require 'legion/extensions/rfp/generate/runners/sections'
+require 'legion/extensions/rfp/generate/runners/templates'
+require 'legion/extensions/rfp/generate/client'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Generate
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/documents'
+require_relative 'runners/corpus'
+require_relative 'runners/parser'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Ingest
+        class Client
+          include Helpers::Client
+          include Runners::Documents
+          include Runners::Corpus
+          include Runners::Parser
+
+          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/ingest/helpers/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Ingest
+        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/ingest/runners/corpus.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Ingest
+        module Runners
+          module Corpus
+            extend Legion::Extensions::Rfp::Ingest::Helpers::Client
+
+            def ingest_document(file_path:, tags: [], metadata: {}, **)
+              supported = supported?(file_path: file_path)
+              return { result: nil, error: "Unsupported format: #{file_path}" } unless supported[:result]
+
+              extracted = extract_text(file_path: file_path)
+              chunked = chunk_text(text: extracted[:result])
+
+              ingested = chunked[:result].map.with_index do |chunk, idx|
+                {
+                  content:  chunk[:text],
+                  source:   file_path,
+                  chunk_id: idx,
+                  tags:     tags,
+                  metadata: metadata.merge(format: extracted[:format], offset: chunk[:offset])
+                }
+              end
+
+              { result: ingested, count: ingested.length, source: file_path }
+            end
+
+            def ingest_directory(directory:, tags: [], recursive: true, **)
+              pattern = recursive ? ::File.join(directory, '**', '*') : ::File.join(directory, '*')
+              files = Dir.glob(pattern).select { |f| ::File.file?(f) }
+
+              results = files.filter_map do |file_path|
+                next unless supported?(file_path: file_path)[:result]
+
+                ingest_document(file_path: file_path, tags: tags)
+              end
+
+              { result: results, files_processed: results.length, total_chunks: results.sum { |r| r[:count] } }
+            end
+
+            def ingest_to_apollo(chunks:, scope: :global, **)
+              return { result: nil, error: 'Apollo not available' } unless defined?(Legion::Apollo)
+
+              ingested = chunks.map do |chunk|
+                Legion::Apollo.ingest(
+                  content:  chunk[:content],
+                  tags:     chunk[:tags] || [],
+                  metadata: chunk[:metadata] || {},
+                  scope:    scope
+                )
+              end
+
+              { result: ingested, count: ingested.length }
+            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/runners/documents.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Ingest
+        module Runners
+          module Documents
+            extend Legion::Extensions::Rfp::Ingest::Helpers::Client
+
+            SUPPORTED_FORMATS = %w[pdf docx md markdown xlsx html htm].freeze
+
+            def supported?(file_path:, **)
+              ext = ::File.extname(file_path.to_s).delete('.').downcase
+              { result: SUPPORTED_FORMATS.include?(ext), format: ext }
+            end
+
+            def extract_text(file_path:, format: nil, **)
+              fmt = format || ::File.extname(file_path.to_s).delete('.').downcase
+              content = case fmt
+                        when 'pdf'      then extract_pdf(file_path)
+                        when 'docx'     then extract_docx(file_path)
+                        when 'md', 'markdown' then ::File.read(file_path)
+                        when 'xlsx' then extract_xlsx(file_path)
+                        when 'html', 'htm' then extract_html(file_path)
+                        else raise ArgumentError, "Unsupported format: #{fmt}"
+                        end
+              { result: content, format: fmt, size: content.length }
+            end
+
+            def chunk_text(text:, chunk_size: 1000, overlap: 200, **)
+              return { result: [], count: 0 } if text.nil? || text.empty?
+
+              chunks = []
+              pos = 0
+              while pos < text.length
+                chunk = text[pos, chunk_size]
+                chunks << { text: chunk, offset: pos, length: chunk.length }
+                pos += (chunk_size - overlap)
+              end
+              { result: chunks, count: chunks.length }
+            end
+
+            private
+
+            def extract_pdf(file_path)
+              if defined?(Legion::Data::Extract)
+                Legion::Data::Extract.call(file_path, :pdf)
+              else
+                "[PDF extraction requires legion-data] #{file_path}"
+              end
+            end
+
+            def extract_docx(file_path)
+              if defined?(Legion::Data::Extract)
+                Legion::Data::Extract.call(file_path, :docx)
+              else
+                "[DOCX extraction requires legion-data] #{file_path}"
+              end
+            end
+
+            def extract_xlsx(file_path)
+              if defined?(Legion::Data::Extract)
+                Legion::Data::Extract.call(file_path, :xlsx)
+              else
+                "[Excel extraction requires legion-data] #{file_path}"
+              end
+            end
+
+            def extract_html(file_path)
+              content = ::File.read(file_path)
+              content.gsub(%r{<script[^>]*>.*?</script>}mi, '')
+                     .gsub(%r{<style[^>]*>.*?</style>}mi, '')
+                     .gsub(/<[^>]+>/, ' ')
+                     .gsub(/\s+/, ' ')
+                     .strip
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end