decision_agent 0.2.0 → 0.3.0

data/lib/decision_agent/web/server.rb

@@ -12,6 +12,10 @@ require_relative "../testing/test_coverage_analyzer"
 require_relative "../evaluators/json_rule_evaluator"
 require_relative "../agent"
 
+# DMN components
+require_relative "../dmn/importer"
+require_relative "../dmn/exporter"
+
 # Auth components
 require_relative "../auth/user"
 require_relative "../auth/role"
@@ -1157,8 +1161,469 @@ module DecisionAgent
         "User management page not found"
       end
 
+      # DMN Editor Routes
+
+      # GET /dmn/editor - DMN Editor UI page
+      get "/dmn/editor" do
+        send_file File.join(settings.public_folder, "dmn-editor.html")
+      rescue StandardError
+        status 404
+        "DMN Editor page not found"
+      end
+
+      # API: List all DMN models
+      get "/api/dmn/models" do
+        content_type :json
+        dmn_editor.list_models.to_json
+      end
+
+      # API: Create new DMN model
+      post "/api/dmn/models" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          model = dmn_editor.create_model(
+            name: data["name"],
+            namespace: data["namespace"]
+          )
+
+          status 201
+          model.to_json
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Get DMN model
+      get "/api/dmn/models/:id" do
+        content_type :json
+
+        model = dmn_editor.get_model(params[:id])
+        if model
+          model.to_json
+        else
+          status 404
+          { error: "Model not found" }.to_json
+        end
+      end
+
+      # API: Update DMN model
+      put "/api/dmn/models/:id" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          model = dmn_editor.update_model(
+            params[:id],
+            name: data["name"],
+            namespace: data["namespace"]
+          )
+
+          if model
+            model.to_json
+          else
+            status 404
+            { error: "Model not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Delete DMN model
+      delete "/api/dmn/models/:id" do
+        content_type :json
+
+        result = dmn_editor.delete_model(params[:id])
+        { success: result }.to_json
+      end
+
+      # API: Add decision to model
+      post "/api/dmn/models/:model_id/decisions" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          decision = dmn_editor.add_decision(
+            model_id: params[:model_id],
+            decision_id: data["decision_id"],
+            name: data["name"],
+            type: data["type"] || "decision_table"
+          )
+
+          if decision
+            status 201
+            decision.to_json
+          else
+            status 404
+            { error: "Model not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Update decision
+      put "/api/dmn/models/:model_id/decisions/:decision_id" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          decision = dmn_editor.update_decision(
+            model_id: params[:model_id],
+            decision_id: params[:decision_id],
+            name: data["name"],
+            logic: data["logic"]
+          )
+
+          if decision
+            decision.to_json
+          else
+            status 404
+            { error: "Decision not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Delete decision
+      delete "/api/dmn/models/:model_id/decisions/:decision_id" do
+        content_type :json
+
+        result = dmn_editor.delete_decision(
+          model_id: params[:model_id],
+          decision_id: params[:decision_id]
+        )
+
+        { success: result }.to_json
+      end
+
+      # API: Add input column
+      post "/api/dmn/models/:model_id/decisions/:decision_id/inputs" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          input = dmn_editor.add_input(
+            model_id: params[:model_id],
+            decision_id: params[:decision_id],
+            input_id: data["input_id"],
+            label: data["label"],
+            type_ref: data["type_ref"],
+            expression: data["expression"]
+          )
+
+          if input
+            status 201
+            input.to_json
+          else
+            status 404
+            { error: "Decision not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Add output column
+      post "/api/dmn/models/:model_id/decisions/:decision_id/outputs" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          output = dmn_editor.add_output(
+            model_id: params[:model_id],
+            decision_id: params[:decision_id],
+            output_id: data["output_id"],
+            label: data["label"],
+            type_ref: data["type_ref"],
+            name: data["name"]
+          )
+
+          if output
+            status 201
+            output.to_json
+          else
+            status 404
+            { error: "Decision not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Add rule
+      post "/api/dmn/models/:model_id/decisions/:decision_id/rules" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          rule = dmn_editor.add_rule(
+            model_id: params[:model_id],
+            decision_id: params[:decision_id],
+            rule_id: data["rule_id"],
+            input_entries: data["input_entries"],
+            output_entries: data["output_entries"],
+            description: data["description"]
+          )
+
+          if rule
+            status 201
+            rule.to_json
+          else
+            status 404
+            { error: "Decision not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Update rule
+      put "/api/dmn/models/:model_id/decisions/:decision_id/rules/:rule_id" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          rule = dmn_editor.update_rule(
+            model_id: params[:model_id],
+            decision_id: params[:decision_id],
+            rule_id: params[:rule_id],
+            input_entries: data["input_entries"],
+            output_entries: data["output_entries"],
+            description: data["description"]
+          )
+
+          if rule
+            rule.to_json
+          else
+            status 404
+            { error: "Rule not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Delete rule
+      delete "/api/dmn/models/:model_id/decisions/:decision_id/rules/:rule_id" do
+        content_type :json
+
+        result = dmn_editor.delete_rule(
+          model_id: params[:model_id],
+          decision_id: params[:decision_id],
+          rule_id: params[:rule_id]
+        )
+
+        { success: result }.to_json
+      end
+
+      # API: Validate DMN model
+      get "/api/dmn/models/:id/validate" do
+        content_type :json
+        dmn_editor.validate_model(params[:id]).to_json
+      end
+
+      # API: Export DMN model to XML
+      get "/api/dmn/models/:id/export" do
+        content_type :xml
+
+        xml = dmn_editor.export_to_xml(params[:id])
+        if xml
+          xml
+        else
+          status 404
+          "Model not found"
+        end
+      end
+
+      # API: Import DMN model from XML
+      post "/api/dmn/models/import" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          model = dmn_editor.import_from_xml(data["xml"], name: data["name"])
+
+          if model
+            status 201
+            model.to_json
+          else
+            status 400
+            { error: "Failed to import model" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # API: Visualize decision tree
+      get "/api/dmn/models/:model_id/decisions/:decision_id/visualize/tree" do
+        format = params[:format] || "svg"
+
+        visualization = dmn_editor.visualize_tree(
+          model_id: params[:model_id],
+          decision_id: params[:decision_id],
+          format: format
+        )
+
+        if visualization
+          content_type format == "svg" ? "image/svg+xml" : :text
+          visualization
+        else
+          status 404
+          "Decision not found or not a tree"
+        end
+      end
+
+      # API: Visualize decision graph
+      get "/api/dmn/models/:id/visualize/graph" do
+        format = params[:format] || "svg"
+
+        visualization = dmn_editor.visualize_graph(
+          model_id: params[:id],
+          format: format
+        )
+
+        if visualization
+          content_type format == "svg" ? "image/svg+xml" : :text
+          visualization
+        else
+          status 404
+          "Model not found"
+        end
+      end
+
+      # API: Import DMN file (uploads and imports to versioning system)
+      post "/api/dmn/import" do
+        content_type :json
+
+        begin
+          # Check if request has multipart form data (file upload)
+          if params[:file] && params[:file][:tempfile]
+            # File upload
+            file = params[:file][:tempfile]
+            xml_content = file.read
+            ruleset_name = params[:ruleset_name] || params[:file][:filename]&.gsub(/\.dmn$/i, "")
+            created_by = @current_user ? @current_user.id.to_s : params[:created_by] || "system"
+          elsif request.content_type&.include?("application/json")
+            # JSON body with XML content
+            request_body = request.body.read
+            data = JSON.parse(request_body)
+            xml_content = data["xml"] || data["content"]
+            ruleset_name = data["ruleset_name"] || data["name"]
+            created_by = @current_user ? @current_user.id.to_s : data["created_by"] || "system"
+          elsif request.content_type&.include?("application/xml") || request.content_type&.include?("text/xml")
+            # Direct XML upload
+            xml_content = request.body.read
+            ruleset_name = params[:ruleset_name] || "imported_dmn"
+            created_by = @current_user ? @current_user.id.to_s : params[:created_by] || "system"
+          else
+            status 400
+            return { error: "Invalid request. Expected file upload, JSON with 'xml' field, or XML content." }.to_json
+          end
+
+          raise ArgumentError, "DMN XML content is required" if xml_content.nil? || xml_content.strip.empty?
+
+          # Import using DMN Importer
+          importer = Dmn::Importer.new(version_manager: version_manager)
+          result = importer.import_from_xml(
+            xml_content,
+            ruleset_name: ruleset_name,
+            created_by: created_by
+          )
+
+          status 201
+          {
+            success: true,
+            ruleset_name: ruleset_name,
+            decisions_imported: result[:decisions_imported],
+            model: {
+              id: result[:model].id,
+              name: result[:model].name,
+              namespace: result[:model].namespace,
+              decisions: result[:model].decisions.map do |d|
+                {
+                  id: d.id,
+                  name: d.name
+                }
+              end
+            },
+            versions: result[:versions].map do |v|
+              {
+                version: v[:version],
+                rule_id: v[:rule_id],
+                created_by: v[:created_by],
+                created_at: v[:created_at]
+              }
+            end
+          }.to_json
+        rescue Dmn::InvalidDmnModelError, Dmn::DmnParseError => e
+          status 400
+          { error: "DMN validation error", message: e.message }.to_json
+        rescue StandardError => e
+          status 500
+          { error: "Import failed", message: e.message }.to_json
+        end
+      end
+
+      # API: Export ruleset as DMN XML
+      get "/api/dmn/export/:ruleset_id" do
+        content_type :xml
+
+        begin
+          ruleset_id = params[:ruleset_id]
+          exporter = Dmn::Exporter.new(version_manager: version_manager)
+          dmn_xml = exporter.export(ruleset_id)
+
+          headers["Content-Disposition"] = "attachment; filename=\"#{ruleset_id}.dmn\""
+          dmn_xml
+        rescue Dmn::InvalidDmnModelError => e
+          status 404
+          content_type :json
+          { error: "Ruleset not found", message: e.message }.to_json
+        rescue StandardError => e
+          status 500
+          content_type :json
+          { error: "Export failed", message: e.message }.to_json
+        end
+      end
+
       private
 
+      def dmn_editor
+        @dmn_editor ||= DmnEditor.new
+      end
+
       def version_manager
         @version_manager ||= DecisionAgent::Versioning::VersionManager.new
       end

data/spec/ab_testing/ab_testing_agent_spec.rb

@@ -1,4 +1,6 @@
 require "spec_helper"
+require "decision_agent/versioning/file_storage_adapter"
+require "decision_agent/ab_testing/storage/memory_adapter"
 
 RSpec.describe DecisionAgent::ABTesting::ABTestingAgent do
   let(:version_manager) { double("VersionManager") }
@@ -478,4 +480,176 @@ RSpec.describe DecisionAgent::ABTesting::ABTestingAgent do
       expect(evaluator.decision).to eq("reject")
     end
   end
+
+  describe "integration tests with real version manager" do
+    let(:temp_dir) { Dir.mktmpdir }
+    let(:file_storage_adapter) do
+      DecisionAgent::Versioning::FileStorageAdapter.new(storage_path: temp_dir)
+    end
+    let(:real_version_manager) do
+      DecisionAgent::Versioning::VersionManager.new(adapter: file_storage_adapter)
+    end
+    let(:storage_adapter) { DecisionAgent::ABTesting::Storage::MemoryAdapter.new }
+    let(:real_ab_test_manager) do
+      DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: storage_adapter,
+        version_manager: real_version_manager
+      )
+    end
+
+    before do
+      # Create test versions with real rules
+      @champion_version = real_version_manager.save_version(
+        rule_id: "approval_rule",
+        rule_content: {
+          version: "1.0",
+          ruleset: "approval",
+          rules: [{
+            id: "rule_1",
+            if: { field: "amount", op: "gt", value: 100 },
+            then: { decision: "approve", weight: 0.9, reason: "Champion rule" }
+          }]
+        },
+        created_by: "spec",
+        changelog: "Champion version"
+      )
+
+      @challenger_version = real_version_manager.save_version(
+        rule_id: "approval_rule",
+        rule_content: {
+          version: "1.0",
+          ruleset: "approval",
+          rules: [{
+            id: "rule_1",
+            if: { field: "amount", op: "gt", value: 200 },
+            then: { decision: "approve", weight: 0.95, reason: "Challenger rule" }
+          }]
+        },
+        created_by: "spec",
+        changelog: "Challenger version"
+      )
+
+      @ab_test = real_ab_test_manager.create_test(
+        name: "Approval Threshold Test",
+        champion_version_id: @champion_version[:id],
+        challenger_version_id: @challenger_version[:id],
+        traffic_split: { champion: 50, challenger: 50 }
+      )
+    end
+
+    after do
+      FileUtils.rm_rf(temp_dir)
+    end
+
+    it "uses real version manager to get version content" do
+      agent = described_class.new(
+        ab_test_manager: real_ab_test_manager,
+        version_manager: real_version_manager
+      )
+
+      result = agent.decide(
+        context: { amount: 150 },
+        ab_test_id: @ab_test.id,
+        user_id: "user_1"
+      )
+
+      expect(result[:decision]).to eq("approve")
+      expect(result[:ab_test]).not_to be_nil
+      expect(result[:ab_test][:test_id]).to eq(@ab_test.id)
+    end
+
+    it "builds real JsonRuleEvaluator from version content" do
+      agent = described_class.new(
+        ab_test_manager: real_ab_test_manager,
+        version_manager: real_version_manager
+      )
+
+      # Test with amount that matches champion (100 < amount < 200)
+      result = agent.decide(
+        context: { amount: 150 },
+        ab_test_id: @ab_test.id,
+        user_id: "user_1"
+      )
+
+      expect(result[:decision]).to eq("approve")
+      expect(result[:confidence]).to be > 0
+    end
+
+    it "handles variant assignment with real version manager" do
+      agent = described_class.new(
+        ab_test_manager: real_ab_test_manager,
+        version_manager: real_version_manager
+      )
+
+      # Make multiple decisions to test variant assignment
+      # Use amount 250 which will match both champion (> 100) and challenger (> 200) rules
+      results = []
+      10.times do |i|
+        result = agent.decide(
+          context: { amount: 250 },
+          ab_test_id: @ab_test.id,
+          user_id: "user_#{i}"
+        )
+        results << result
+      end
+
+      # At least one decision should have been made
+      expect(results.size).to eq(10)
+      # All should have ab_test information
+      expect(results.all? { |r| r[:ab_test] }).to be true
+    end
+
+    it "records decisions with real ab_test_manager" do
+      agent = described_class.new(
+        ab_test_manager: real_ab_test_manager,
+        version_manager: real_version_manager
+      )
+
+      result = agent.decide(
+        context: { amount: 150 },
+        ab_test_id: @ab_test.id,
+        user_id: "user_1"
+      )
+
+      # Verify decision was recorded (check that results are available)
+      expect(result[:decision]).to eq("approve")
+      expect(result[:ab_test]).not_to be_nil
+    end
+
+    it "handles version with evaluators configuration" do
+      version_with_evaluators = real_version_manager.save_version(
+        rule_id: "test_evaluator_rule",
+        rule_content: {
+          evaluators: [{
+            type: "static",
+            decision: "approve",
+            weight: 0.8,
+            reason: "Static evaluator from version"
+          }]
+        },
+        created_by: "spec",
+        changelog: "Version with evaluators"
+      )
+
+      static_test = real_ab_test_manager.create_test(
+        name: "Static Evaluator Test",
+        champion_version_id: @champion_version[:id],
+        challenger_version_id: version_with_evaluators[:id],
+        traffic_split: { champion: 50, challenger: 50 }
+      )
+
+      agent = described_class.new(
+        ab_test_manager: real_ab_test_manager,
+        version_manager: real_version_manager
+      )
+
+      result = agent.decide(
+        context: { amount: 50 }, # Low amount that won't match champion rule
+        ab_test_id: static_test.id,
+        user_id: "user_1"
+      )
+
+      expect(result[:decision]).to eq("approve")
+    end
+  end
 end