orfeas_lyra 0.6.0

data/lib/tasks/lyra_schema.rake

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+namespace :lyra do
+  namespace :schema do
+    desc "Generate initial event schema from current model configuration"
+    task create: :environment do
+      require_lyra_schema
+
+      if Lyra::Schema::Store.exists?
+        puts "Schema already exists at #{Lyra::Schema::Store.schema_path}"
+        puts ""
+        puts "Options:"
+        puts "  - Run 'rake lyra:schema:update' to create a new version"
+        puts "  - Run 'rake lyra:schema:verify' to check for changes"
+        puts "  - Delete #{Lyra::Schema::Store.schema_path}/ to start fresh"
+        exit 1
+      end
+
+      if Lyra.config.monitored_models.empty?
+        puts "No models are configured for monitoring."
+        puts "Configure models with Lyra.config.monitor_model(YourModel) first."
+        exit 1
+      end
+
+      schema = Lyra::Schema::Generator.generate
+      file_path = Lyra::Schema::Store.save(schema)
+
+      puts ""
+      puts "=" * 60
+      puts "Lyra Event Schema Created"
+      puts "=" * 60
+      puts ""
+      puts "Version:    v#{schema[:version]}"
+      puts "File:       #{file_path}"
+      puts "Models:     #{schema[:summary][:models_count]}"
+      puts "Columns:    #{schema[:summary][:total_columns]}"
+      puts "Events:     #{schema[:summary][:events_count]}"
+      puts "PII Fields: #{schema[:summary][:pii_fields_count]}"
+      puts ""
+      puts "=" * 60
+      puts ""
+      puts "Next steps:"
+      puts "  - Commit #{Lyra::Schema::Store.schema_path}/ to version control"
+      puts "  - Run 'rake lyra:schema:report' to view mappings"
+      puts ""
+    end
+
+    desc "Update schema (creates new version with current configuration)"
+    task update: :environment do
+      require_lyra_schema
+
+      validator = Lyra::Schema::Validator.new
+
+      unless validator.schema_exists?
+        puts "No existing schema found."
+        puts "Run 'rake lyra:schema:create' first."
+        exit 1
+      end
+
+      if validator.valid?
+        puts "No changes detected. Schema is up to date."
+        puts ""
+        puts "Current version: v#{Lyra::Schema::Store.latest_version}"
+        puts "Fingerprint: #{Lyra::Schema::Store.load_current[:fingerprint]}"
+        exit 0
+      end
+
+      puts validator.report
+      puts ""
+
+      print "Create new schema version? [y/N] "
+      response = $stdin.gets&.chomp&.downcase
+
+      unless response == "y"
+        puts "Aborted."
+        exit 0
+      end
+
+      schema = Lyra::Schema::Generator.generate
+      file_path = Lyra::Schema::Store.save(schema)
+
+      puts ""
+      puts "New schema version created!"
+      puts "Version: v#{schema[:version]}"
+      puts "File: #{file_path}"
+      puts ""
+      puts "Don't forget to commit the new schema file."
+    end
+
+    desc "Verify current schema against stored schema"
+    task verify: :environment do
+      require_lyra_schema
+
+      validator = Lyra::Schema::Validator.new
+
+      unless validator.schema_exists?
+        puts "No schema found."
+        puts ""
+        puts "Run 'rake lyra:schema:create' to generate initial schema."
+        exit 1
+      end
+
+      if validator.valid?
+        current = Lyra::Schema::Store.load_current
+        puts "Schema verification PASSED"
+        puts ""
+        puts "Version:     v#{current[:version]}"
+        puts "Fingerprint: #{current[:fingerprint]}"
+        puts "No changes detected."
+        exit 0
+      else
+        puts validator.report
+        puts ""
+
+        if validator.breaking_changes?
+          puts "VERIFICATION FAILED: Breaking changes detected!"
+          puts ""
+          puts "To resolve:"
+          puts "  1. Run 'rake lyra:schema:update' to create a new version"
+          puts "  2. Or revert the model/database changes"
+          exit 1
+        else
+          puts "Non-breaking changes detected."
+          puts "Consider running 'rake lyra:schema:update' to update the schema."
+          exit 0
+        end
+      end
+    end
+
+    desc "Display current schema report (model->event mappings)"
+    task report: :environment do
+      require_lyra_schema
+
+      if Lyra.config.monitored_models.empty?
+        puts "No models are configured for monitoring."
+        puts "Configure models with Lyra.config.monitor_model(YourModel) first."
+        exit 1
+      end
+
+      reporter = Lyra::Schema::Reporter.new
+      puts reporter.to_s
+    end
+
+    desc "Show schema version history"
+    task history: :environment do
+      require_lyra_schema
+
+      history = Lyra::Schema::Store.history
+
+      if history.empty?
+        puts "No schema versions found."
+        puts ""
+        puts "Run 'rake lyra:schema:create' to generate initial schema."
+        exit 0
+      end
+
+      puts ""
+      puts "=" * 80
+      puts "Lyra Schema Version History"
+      puts "=" * 80
+      puts ""
+      puts "%-10s %-25s %-15s %-10s %-20s" % ["Version", "Created At", "Lyra Version", "Models", "File"]
+      puts "-" * 80
+
+      history.each do |h|
+        puts "%-10s %-25s %-15s %-10s %-20s" % [
+          "v#{h[:version]}",
+          h[:created_at],
+          h[:lyra_version],
+          h[:models_count],
+          h[:file]
+        ]
+      end
+
+      puts "-" * 80
+      puts ""
+      puts "Current version: v#{Lyra::Schema::Store.latest_version}"
+      puts "Schema path: #{Lyra::Schema::Store.schema_path}"
+      puts ""
+    end
+
+    desc "Compare two schema versions"
+    task :diff, [:v1, :v2] => :environment do |_t, args|
+      require_lyra_schema
+
+      v1 = args[:v1]&.to_i
+      v2 = args[:v2]&.to_i || Lyra::Schema::Store.latest_version
+
+      unless v1
+        puts "Usage: rake lyra:schema:diff[v1,v2]"
+        puts "Example: rake lyra:schema:diff[1,2]"
+        puts "         rake lyra:schema:diff[1]  (compare v1 to latest)"
+        exit 1
+      end
+
+      schema1 = Lyra::Schema::Store.load_version(v1)
+      schema2 = Lyra::Schema::Store.load_version(v2)
+
+      unless schema1
+        puts "Could not load schema version #{v1}"
+        exit 1
+      end
+
+      unless schema2
+        puts "Could not load schema version #{v2}"
+        exit 1
+      end
+
+      puts ""
+      puts "=" * 60
+      puts "Comparing v#{v1} -> v#{v2}"
+      puts "=" * 60
+      puts ""
+
+      differences = Lyra::Schema::Diff.compare(schema1, schema2)
+      report = Lyra::Schema::Diff.format_report(differences)
+
+      puts report
+    end
+
+    private
+
+    def require_lyra_schema
+      require "lyra/schema/store"
+      require "lyra/schema/generator"
+      require "lyra/schema/diff"
+      require "lyra/schema/validator"
+      require "lyra/schema/reporter"
+    end
+  end
+end

data/lib/tasks/lyra_workflows.rake

@@ -0,0 +1,452 @@
+# frozen_string_literal: true
+
+namespace :lyra do
+  namespace :workflows do
+    desc "Generate verification workflow models from Lyra implementation via metaprogramming"
+    task generate: :environment do
+      require "fileutils"
+
+      unless Lyra.petri_flow_available?
+        puts "Error: PetriFlow gem is required"
+        puts "Add 'petri_flow' to your Gemfile and run 'bundle install'"
+        exit 1
+      end
+
+      require "lyra/verification/workflow_generator"
+
+      # Parse mode argument: MODE=monitor or MODE=all (default)
+      requested_mode = ENV["MODE"]&.to_sym
+      if requested_mode && requested_mode != :all
+        unless Lyra::Verification::WorkflowGenerator::AVAILABLE_MODES.include?(requested_mode)
+          puts "Error: Invalid mode '#{requested_mode}'"
+          puts "Available modes: #{Lyra::Verification::WorkflowGenerator::AVAILABLE_MODES.join(', ')}, all"
+          exit 1
+        end
+      end
+
+      # Determine Lyra gem root using multiple strategies
+      lyra_gem_root = Gem.loaded_specs['lyra']&.gem_dir
+      lyra_gem_root ||= Lyra::Engine.root.to_s if defined?(Lyra::Engine)
+      lyra_gem_root ||= begin
+        # Find lyra.gemspec by traversing up from Rails.root
+        dir = Rails.root
+        while dir.to_s != "/"
+          if File.exist?(File.join(dir, 'lyra.gemspec'))
+            break dir.to_s
+          end
+          dir = dir.parent
+        end
+      end
+
+      # Determine output directory
+      # Both Lyra gem and applications use app/workflows with top-level constants
+      # This is Zeitwerk-compatible: app/workflows/monitor_mode_workflow.rb -> MonitorModeWorkflow
+      is_lyra_context = lyra_gem_root && (
+        Rails.root.to_s.start_with?(lyra_gem_root) ||
+        File.exist?(File.join(Rails.root, 'lyra.gemspec'))
+      )
+
+      if is_lyra_context && lyra_gem_root
+        # Lyra gem context - use app/workflows in the gem root
+        workflows_dir = File.join(lyra_gem_root, 'app', 'workflows')
+      else
+        # Normal application
+        workflows_dir = Rails.root.join('app', 'workflows')
+      end
+
+      # Always use top-level constants for Zeitwerk compatibility
+      @use_lyra_namespace = false
+
+      reports_dir = Rails.root.join('reports')
+
+      FileUtils.mkdir_p(workflows_dir)
+      FileUtils.mkdir_p(reports_dir)
+
+      puts "Analyzing Lyra implementation..."
+      puts "Mode: #{requested_mode || 'all'}"
+      puts "Workflows directory: #{workflows_dir}"
+      puts "Reports directory: #{reports_dir}"
+      puts ""
+
+      generator = Lyra::Verification::WorkflowGenerator.new
+      result = if requested_mode && requested_mode != :all
+                 generator.generate!(mode: requested_mode)
+               else
+                 generator.generate!
+               end
+
+      # Output analysis results
+      puts "=" * 60
+      puts "LYRA IMPLEMENTATION ANALYSIS"
+      puts "=" * 60
+      puts ""
+
+      analysis = result[:analysis]
+
+      # Modes
+      puts "MODES:"
+      puts "  Current mode: #{analysis[:current_mode] || 'not set'}"
+      puts "  Available modes: #{analysis[:modes].join(', ')}"
+      puts ""
+
+      # Callbacks
+      puts "CALLBACKS DETECTED:"
+      hooks = analysis[:callback_hooks]
+      if hooks[:after].any?
+        puts "  After callbacks:"
+        hooks[:after].each { |h| puts "    - after_#{h[:type]} :#{h[:method]}" }
+      end
+      if hooks[:before].any?
+        puts "  Before callbacks:"
+        hooks[:before].each { |h| puts "    - before_#{h[:type]} :#{h[:method]}" }
+      end
+      puts ""
+
+      # Monitored models
+      puts "MONITORED MODELS: #{analysis[:models].count}"
+      analysis[:models].each do |model|
+        puts "  - #{model[:name]}"
+        puts "    Event prefix: #{model[:event_prefix]}" if model[:event_prefix]
+        if model[:callbacks]&.any?
+          puts "    Callbacks:"
+          model[:callbacks].each { |k, v| puts "      #{k}: #{v.join(', ')}" }
+        end
+      end
+      puts ""
+
+      # Event types
+      puts "EVENT TYPES:"
+      analysis[:event_types].each { |e| puts "  - #{e[:name]}" }
+      puts ""
+
+      # Generated workflows
+      puts "=" * 60
+      puts "GENERATED WORKFLOWS"
+      puts "=" * 60
+      puts ""
+
+      lifecycle = result[:lifecycle_workflow]
+      if lifecycle
+        puts "LIFECYCLE WORKFLOW: #{lifecycle[:name]}"
+        puts "  Places: #{lifecycle[:places].join(' -> ')}"
+        puts "  Initial: #{lifecycle[:initial_place]}"
+        puts "  Terminal: #{lifecycle[:terminal_places].join(', ')}"
+        puts "  Transitions:"
+        lifecycle[:transitions].each do |t|
+          puts "    #{t[:from]} --[#{t[:name]}]--> #{t[:to]}"
+          puts "      trigger: #{t[:trigger]}"
+        end
+        puts ""
+      end
+
+      # Single mode workflow (when specific mode requested)
+      if result[:mode_workflow]
+        print_workflow(result[:mode_workflow])
+      end
+
+      # Multiple mode workflows (when all modes requested)
+      if result[:mode_workflows]
+        result[:mode_workflows].each do |_mode, workflow|
+          puts "-" * 40
+          print_workflow(workflow)
+        end
+      end
+
+      # Save workflow files
+      generated_files = []
+
+      # Generate lifecycle workflow file
+      if result[:lifecycle_workflow]
+        lifecycle_file = File.join(workflows_dir, "lifecycle_workflow.rb")
+        File.write(lifecycle_file, generate_workflow_file(result[:lifecycle_workflow], "LifecycleWorkflow", use_lyra_namespace: @use_lyra_namespace))
+        generated_files << lifecycle_file
+        puts "Generated: #{lifecycle_file}"
+      end
+
+      # Generate individual mode workflow files
+      if result[:mode_workflow]
+        # Single mode requested
+        mode_name = result[:mode_workflow][:name].downcase.gsub(/\s+/, '_').gsub(/[^a-z0-9_]/, '')
+        mode_file = File.join(workflows_dir, "#{mode_name}.rb")
+        class_name = workflow_class_name(result[:mode_workflow][:name])
+        File.write(mode_file, generate_workflow_file(result[:mode_workflow], class_name, use_lyra_namespace: @use_lyra_namespace))
+        generated_files << mode_file
+        puts "Generated: #{mode_file}"
+      elsif result[:mode_workflows]
+        # All modes - generate separate files for each
+        result[:mode_workflows].each do |mode, workflow|
+          mode_file = File.join(workflows_dir, "#{mode}_mode_workflow.rb")
+          class_name = "#{mode.to_s.split('_').map(&:capitalize).join}ModeWorkflow"
+          File.write(mode_file, generate_workflow_file(workflow, class_name, use_lyra_namespace: @use_lyra_namespace))
+          generated_files << mode_file
+          puts "Generated: #{mode_file}"
+        end
+      end
+
+      # Generate Markdown report
+      timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+      md_file = reports_dir.join("workflow_analysis_#{timestamp}.md")
+      File.write(md_file, generate_markdown_report(result))
+      puts "Generated analysis report: #{md_file}"
+
+      # Also generate a "latest" report
+      latest_md = reports_dir.join("workflow_analysis_latest.md")
+      File.write(latest_md, generate_markdown_report(result))
+      puts "Generated latest report: #{latest_md}"
+
+      puts ""
+      puts "Generated #{generated_files.count} workflow files in #{workflows_dir}"
+    end
+
+    desc "Verify generated workflows with PetriFlow"
+    task verify: :environment do
+      unless Lyra.petri_flow_available?
+        puts "Error: PetriFlow gem is required"
+        exit 1
+      end
+
+      require "lyra/verification/workflow_generator"
+
+      generator = Lyra::Verification::WorkflowGenerator.new
+      result = generator.generate!
+
+      puts "=" * 60
+      puts "PETRIFLOW VERIFICATION"
+      puts "=" * 60
+      puts ""
+
+      if result[:mode_workflows]
+        result[:mode_workflows].each do |mode, wf_data|
+          puts "Verifying #{mode} mode workflow..."
+
+          # Create a PetriFlow workflow from the data
+          workflow_class = Class.new(PetriFlow::Workflow) do
+            workflow_name wf_data[:name]
+            places(*wf_data[:places])
+            initial_place wf_data[:initial_place]
+            terminal_places(*wf_data[:terminal_places])
+
+            wf_data[:transitions].each do |t|
+              transition t[:name], from: t[:from], to: t[:to]
+            end
+          end
+
+          workflow = workflow_class.new
+          results = workflow.verify!
+
+          reachability = results[:reachability]
+          boundedness = results[:boundedness]
+          liveness = results[:liveness]
+
+          puts "  Reachable states: #{reachability[:total_reachable_states]}"
+          puts "  Terminal states: #{reachability[:terminal_states]}"
+          puts "  Is safe (1-bounded): #{boundedness[:is_safe]}"
+          puts "  Is bounded: #{boundedness[:is_bounded]}"
+          puts "  Max tokens: #{boundedness[:max_tokens]}"
+          puts "  Deadlock-free: #{liveness[:deadlock_free]}"
+          puts "  Liveness score: #{liveness[:liveness_score]}"
+          puts ""
+        end
+      else
+        puts "No workflows generated"
+      end
+    end
+
+    # Helper methods
+    def print_workflow(workflow)
+      return unless workflow
+
+      puts "MODE WORKFLOW: #{workflow[:name]}"
+      puts "  #{workflow[:description]}" if workflow[:description]
+      puts "  Places: #{workflow[:places].join(' -> ')}"
+      puts "  Initial: #{workflow[:initial_place]}"
+      puts "  Terminal: #{workflow[:terminal_places].join(', ')}"
+      puts "  Transitions:"
+      workflow[:transitions].each do |t|
+        puts "    #{t[:from]} --[#{t[:name]}]--> #{t[:to]}"
+        puts "      trigger: #{t[:trigger]}"
+      end
+      puts ""
+    end
+
+    def workflow_class_name(name)
+      name.to_s.gsub(/[^a-zA-Z0-9]/, ' ').split.map(&:capitalize).join + "Workflow"
+    end
+
+    def generate_workflow_file(workflow, class_name, use_lyra_namespace: true)
+      lines = []
+      lines << "# frozen_string_literal: true"
+      lines << "# Auto-generated by Lyra::Verification::WorkflowGenerator"
+      lines << "# Generated at: #{Time.current}"
+      lines << ""
+
+      if use_lyra_namespace
+        # Lyra gem context - nested namespace
+        lines << "module Lyra"
+        lines << "  module Verification"
+        lines << "    module Generated"
+        lines << ""
+        lines << generate_workflow_class(workflow, class_name, indent: 6)
+        lines << ""
+        lines << "    end"
+        lines << "  end"
+        lines << "end"
+      else
+        # Application context - top-level class for Zeitwerk compatibility
+        lines << generate_workflow_class(workflow, class_name, indent: 0)
+      end
+
+      lines.join("\n")
+    end
+
+    def generate_workflow_class(workflow, class_name, indent: 6)
+      pad = " " * indent
+      lines = []
+      lines << "#{pad}# #{workflow[:name]}"
+      lines << "#{pad}# #{workflow[:description]}" if workflow[:description]
+      lines << "#{pad}class #{class_name} < PetriFlow::Workflow"
+      lines << "#{pad}  workflow_name #{workflow[:name].inspect}"
+      lines << ""
+      lines << "#{pad}  places #{workflow[:places].map(&:inspect).join(', ')}"
+      lines << "#{pad}  initial_place #{workflow[:initial_place].inspect}"
+      lines << "#{pad}  terminal_places #{workflow[:terminal_places].map(&:inspect).join(', ')}"
+      lines << ""
+      workflow[:transitions].each do |t|
+        lines << "#{pad}  transition #{t[:name].inspect},"
+        lines << "#{pad}             from: #{t[:from].inspect},"
+        lines << "#{pad}             to: #{t[:to].inspect},"
+        lines << "#{pad}             trigger: #{t[:trigger].inspect}"
+        lines << ""
+      end
+      lines << "#{pad}end"
+      lines.join("\n")
+    end
+
+    def generate_markdown_report(result)
+      analysis = result[:analysis]
+      lifecycle = result[:lifecycle_workflow]
+
+      md = []
+      md << "# Lyra Verification Workflow Analysis"
+      md << ""
+      md << "**Generated:** #{Time.current}"
+      md << "**Method:** Metaprogramming introspection of Lyra implementation"
+      md << ""
+
+      md << "## Implementation Analysis"
+      md << ""
+
+      md << "### Lyra Modes"
+      md << ""
+      md << "| Mode | Available |"
+      md << "|------|-----------|"
+      analysis[:modes].each do |mode|
+        md << "| #{mode} | Yes |"
+      end
+      md << ""
+      md << "**Current mode:** `#{analysis[:current_mode] || 'not configured'}`"
+      md << ""
+
+      md << "### Detected Callbacks"
+      md << ""
+      hooks = analysis[:callback_hooks]
+      if hooks[:after].any? || hooks[:before].any?
+        md << "| Timing | Type | Method |"
+        md << "|--------|------|--------|"
+        hooks[:before].each { |h| md << "| before | #{h[:type]} | `#{h[:method]}` |" }
+        hooks[:after].each { |h| md << "| after | #{h[:type]} | `#{h[:method]}` |" }
+      else
+        md << "*No callbacks detected in source*"
+      end
+      md << ""
+
+      md << "### Monitored Models"
+      md << ""
+      if analysis[:models].any?
+        analysis[:models].each do |model|
+          md << "#### #{model[:name]}"
+          md << ""
+          md << "- **Table:** `#{model[:table_name]}`" if model[:table_name]
+          md << "- **Event prefix:** `#{model[:event_prefix]}`" if model[:event_prefix]
+          md << ""
+        end
+      else
+        md << "*No models currently monitored*"
+      end
+      md << ""
+
+      if lifecycle
+        md << generate_workflow_markdown(lifecycle, "Lifecycle")
+      end
+
+      # Single mode workflow
+      if result[:mode_workflow]
+        md << generate_workflow_markdown(result[:mode_workflow], result[:mode_workflow][:name])
+      end
+
+      # Multiple mode workflows
+      if result[:mode_workflows]
+        md << "## Mode-Specific Workflows"
+        md << ""
+        result[:mode_workflows].each do |_mode, workflow|
+          md << generate_workflow_markdown(workflow, workflow[:name])
+        end
+      end
+
+      md << "---"
+      md << "*Generated by Lyra::Verification::WorkflowGenerator via metaprogramming*"
+
+      md.join("\n")
+    end
+
+    def generate_workflow_markdown(workflow, title)
+      md = []
+      md << "## #{title}"
+      md << ""
+      md << "**Name:** #{workflow[:name]}"
+      md << ""
+      md << "**Description:** #{workflow[:description]}" if workflow[:description]
+      md << ""
+      md << "### State Machine"
+      md << ""
+      md << "```"
+      md << "Initial: [#{workflow[:initial_place]}]"
+      md << "Terminal: [#{workflow[:terminal_places].join(', ')}]"
+      md << ""
+      md << "Places: #{workflow[:places].join(' -> ')}"
+      md << "```"
+      md << ""
+      md << "### Transitions"
+      md << ""
+      md << "| From | Transition | To | Trigger |"
+      md << "|------|------------|-----|---------|"
+      workflow[:transitions].each do |t|
+        md << "| #{t[:from]} | #{t[:name]} | #{t[:to]} | #{t[:trigger]} |"
+      end
+      md << ""
+
+      # Generate Mermaid diagram
+      md << "### Petri Net Diagram"
+      md << ""
+      md << "```mermaid"
+      md << "flowchart TB"
+      workflow[:places].each do |place|
+        md << "  #{place}((\"#{place.to_s.gsub('_', ' ').split.map(&:capitalize).join(' ')}\"))"
+      end
+      workflow[:transitions].each do |t|
+        md << "  t_#{t[:name]}[\"#{t[:name]}\"]"
+        md << "  #{t[:from]} --> t_#{t[:name]}"
+        md << "  t_#{t[:name]} --> #{t[:to]}"
+      end
+      md << "```"
+      md << ""
+
+      md.join("\n")
+    end
+
+  end
+
+  # Aliases for convenience
+  desc "Generate workflows (alias for lyra:workflows:generate)"
+  task generate_workflows: "lyra:workflows:generate"
+end