completion-kit 0.28.46 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f620811d2032fa4aad51754dcee5aa92657cc193c890587845cb0c185060ef18
-  data.tar.gz: ea6426877ef769569438a48f3f2cc7848569e02c395db53e629898cda4c01545
+  metadata.gz: d1da0c4306c55de2ce239393e22ce0512a051e9c85285165fa363b746bbf4a09
+  data.tar.gz: e9f2adb520737b42f5b9a51841cf32b0e5249bb74b5c13bedc3758c17dbca29a
 SHA512:
-  metadata.gz: c6f1a8afbf36d89f1dbd42919fc870732e6f5aeb14164303e62d68644489837f845fc50b19d5ea9735e55b5e1876e743f67ced221e9d3d720f08726d24b4f4f8
-  data.tar.gz: 4cf7b53081569d22ddb471e6b40418baeba32e3fcd11e284df14cd582810603f7e132165603e169cb19f3655fefc7b5f69a9fe437ee687be181d7dc4ced95447
+  metadata.gz: 226c925a5fa2e048acbb20d0c71bf63c02af14102073875d7c42858da7e9a36c6a6f4ad87eb570a5a18d977e25a16e104ec95e37f2a1424f1ddadd3a7a3e0c69
+  data.tar.gz: 64638c834849310c7f818bd2db14bf0a682447e4b52409bd5f9656ec0fe14b732a08dea84d8c414adb36e509e807b7869945271aa6ee8aca8c7396c99a78c324

data/app/assets/javascripts/completion_kit/application.js

@@ -8,6 +8,8 @@ document.addEventListener("turbo:load", function() {
   if (ckDiscoveringInDom()) ckStartDiscoveryPolling(0);
 });
 
+document.addEventListener("turbo:render", ckAutoFocusFirstError);
+
 document.addEventListener("input", function(e) {
   if (!e.target || e.target.id !== "tag_name") return;
   var text = document.getElementById("tag-pill-text");
@@ -214,37 +216,56 @@ document.addEventListener("click", function(e) {
   });
 });
 
-var CK_CHECK_FIELDS = {
-  contains: ["value", "case_sensitive", "trim"],
-  not_contains: ["value", "case_sensitive", "trim"],
-  equals: ["value", "case_sensitive", "trim"],
-  regex: ["pattern", "case_sensitive", "multiline"],
-  valid_json: [],
-  json_path_equals: ["json_path", "expected"],
-  length_bounds: ["min", "max"]
-};
+function ckCheckEditor(scope) {
+  if (!scope) return null;
+  if (scope.matches && scope.matches("[data-ck-check-form]")) return scope;
+  return scope.querySelector ? scope.querySelector("[data-ck-check-form]") : null;
+}
 
-var CK_VALUE_KINDS = ["contains", "not_contains", "equals"];
+function ckCheckForm(editor) {
+  try {
+    return JSON.parse(editor.getAttribute("data-ck-check-form"));
+  } catch (e) {
+    return null;
+  }
+}
+
+function ckApplyCheckLabels(editor, form, kind) {
+  var labels = form.labels[kind] || {};
+  var hints = form.hints[kind] || {};
+  editor.querySelectorAll("[data-ck-check-label]").forEach(function(node) {
+    var key = node.getAttribute("data-ck-check-label");
+    node.textContent = labels[key] || form.defaultLabels[key] || "";
+  });
+  editor.querySelectorAll("[data-ck-check-hint]").forEach(function(node) {
+    var key = node.getAttribute("data-ck-check-hint");
+    node.textContent = hints[key] || form.defaultHints[key] || "";
+  });
+}
 
 function ckApplyCheckFields(scope) {
-  if (!scope) return;
-  var kindSelect = scope.querySelector('[name="metric[check_config][check_kind]"]');
+  var editor = ckCheckEditor(scope);
+  if (!editor) return;
+  var form = ckCheckForm(editor);
+  if (!form) return;
+  var kindSelect = editor.querySelector('[name="metric[check_config][check_kind]"]');
   if (!kindSelect) return;
   var kind = kindSelect.value;
-  var visible = (CK_CHECK_FIELDS[kind] || []).slice();
-  var targetSelect = scope.querySelector('[name="metric[check_config][target]"]');
+  var visible = (form.fields[kind] || []).slice();
+  var targetSelect = editor.querySelector('[name="metric[check_config][target]"]');
   var targetIsJsonPath = !!(targetSelect && targetSelect.value === "json_path");
+  var expectedKey = form.expected[kind];
 
-  if (CK_VALUE_KINDS.indexOf(kind) !== -1) {
+  if (expectedKey) {
     visible.push("compare_to");
-    var comparison = scope.querySelector('[name="metric[check_config][compare_to]"]:checked');
+    var comparison = editor.querySelector('[name="metric[check_config][compare_to]"]:checked');
     if (comparison && comparison.value === "expected") {
-      visible = visible.filter(function(key) { return key !== "value"; });
+      visible = visible.filter(function(key) { return key !== expectedKey; });
       visible.push("expected_path");
     }
   }
 
-  scope.querySelectorAll("[data-ck-check-field]").forEach(function(field) {
+  editor.querySelectorAll("[data-ck-check-field]").forEach(function(field) {
     var key = field.getAttribute("data-ck-check-field");
     var show;
     if (key === "target_path") {
@@ -254,6 +275,8 @@ function ckApplyCheckFields(scope) {
     }
     field.hidden = !show;
   });
+
+  ckApplyCheckLabels(editor, form, kind);
 }
 
 function ckApplyMetricType(group) {
@@ -271,14 +294,17 @@ function ckApplyMetricType(group) {
   ckApplyCheckFields(scope);
 }
 
-document.addEventListener("turbo:load", function() {
+function ckApplyMetricForms() {
   document.querySelectorAll("[data-ck-metric-type]").forEach(function(group) {
     ckApplyMetricType(group);
   });
-  document.querySelectorAll('[data-ck-metric-editor="check"]').forEach(function(editor) {
+  document.querySelectorAll("[data-ck-check-form]").forEach(function(editor) {
     ckApplyCheckFields(editor);
   });
-});
+}
+
+document.addEventListener("turbo:load", ckApplyMetricForms);
+document.addEventListener("turbo:render", ckApplyMetricForms);
 
 document.addEventListener("change", function(e) {
   var target = e.target;
@@ -305,11 +331,14 @@ function ckApplyProviderFields(scope) {
   });
 }
 
-document.addEventListener("turbo:load", function() {
+function ckApplyProviderForms() {
   document.querySelectorAll("[data-ck-provider-select]").forEach(function(select) {
     ckApplyProviderFields(select.closest("form") || document);
   });
-});
+}
+
+document.addEventListener("turbo:load", ckApplyProviderForms);
+document.addEventListener("turbo:render", ckApplyProviderForms);
 
 document.addEventListener("change", function(e) {
   var target = e.target;

data/app/assets/stylesheets/completion_kit/application.css

@@ -2053,6 +2053,10 @@ label.ck-checkbox[hidden] {
   flex: 1;
 }
 
+.ck-field-row:not(:has(> .ck-field:not([hidden]))) {
+  display: none;
+}
+
 .ck-metric-type-chip {
   text-transform: uppercase;
   letter-spacing: 0.04em;
@@ -2060,32 +2064,42 @@ label.ck-checkbox[hidden] {
 }
 
 .ck-check-spec {
-  display: flex;
-  flex-direction: column;
-  gap: 0.4rem;
+  display: grid;
+  grid-template-columns: max-content minmax(0, 1fr);
+  column-gap: 1rem;
+  row-gap: 0.4rem;
   margin: 0.5rem 0 0;
 }
 
 .ck-check-spec__row {
-  display: flex;
-  gap: 0.75rem;
+  display: grid;
+  grid-column: 1 / -1;
+  grid-template-columns: subgrid;
   align-items: baseline;
 }
 
 .ck-check-spec__term {
-  flex: 0 0 7rem;
   margin: 0;
   font-size: 0.8rem;
   text-transform: uppercase;
   letter-spacing: 0.04em;
+  white-space: nowrap;
   color: var(--ck-muted);
 }
 
 .ck-check-spec__val {
   margin: 0;
+  min-width: 0;
+  overflow-wrap: anywhere;
   color: var(--ck-text);
 }
 
+@media (max-width: 640px) {
+  .ck-check-spec { grid-template-columns: minmax(0, 1fr); row-gap: 0.6rem; }
+  .ck-check-spec__row { grid-template-columns: minmax(0, 1fr); row-gap: 0.15rem; }
+  .ck-check-spec__term { white-space: normal; }
+}
+
 .ck-check-spec__code {
   font-family: var(--ck-mono);
   font-size: 0.85rem;
@@ -2098,6 +2112,7 @@ label.ck-checkbox[hidden] {
 
 .ck-select {
   position: relative;
+  min-width: 0;
 }
 
 .ck-select__trigger {
@@ -3271,13 +3286,13 @@ select.ck-input {
 
 .ck-run-compare-table td { vertical-align: top; }
 
-.ck-table-scroll { overflow-x: auto; }
+.ck-table-scroll { position: relative; overflow-x: auto; }
 
 .ck-run-compare-table th { white-space: nowrap; }
 .ck-run-compare-table th:nth-child(1) { width: 7rem; }
-.ck-run-compare-table th:nth-child(2) { width: 15rem; }
-.ck-run-compare-table th:nth-child(3) { width: 12rem; }
-.ck-run-compare-table th:nth-child(4) { width: 8rem; }
+.ck-run-compare-table th:nth-child(2) { width: 12rem; }
+.ck-run-compare-table th:nth-child(3) { width: 16rem; text-align: center; }
+.ck-run-compare-table th:nth-child(4) { width: 9rem; }
 .ck-run-compare-table th:nth-child(5) { width: auto; }
 
 .ck-run-compare-table th.ck-num,
@@ -3292,13 +3307,26 @@ select.ck-input {
   font-weight: 500;
 }
 
-.ck-cmp-score__pair { display: inline-flex; align-items: center; gap: 0.45rem; }
+.ck-cmp-score__pair {
+  display: grid;
+  grid-template-columns: minmax(max-content, 1fr) auto minmax(max-content, 1fr);
+  align-items: center;
+  gap: 0.45rem;
+  width: 100%;
+}
+.ck-cmp-score__pair > :first-child { justify-self: end; }
+.ck-cmp-score__pair > :last-child { justify-self: start; }
+@media (max-width: 640px) {
+  .ck-cmp-score__pair { display: inline-grid; width: auto; }
+}
+.ck-cmp-score__pair .ck-badge { white-space: nowrap; }
 .ck-cmp-score__arrow { color: var(--ck-dim); font-size: 0.78rem; }
 .ck-cmp-score__link { display: inline-flex; text-decoration: none; border-radius: 7px; transition: box-shadow 0.12s ease; }
 .ck-cmp-score__link:hover { box-shadow: 0 0 0 1px var(--ck-accent); }
 .ck-cmp-score__none { color: var(--ck-dim); }
 
-.ck-cmp-delta .ck-delta { display: inline-flex; align-items: baseline; gap: 0.2rem; }
+.ck-cmp-delta .ck-delta { display: inline-flex; align-items: baseline; gap: 0.2rem; white-space: nowrap; }
+.ck-cmp-delta__pair { display: inline-flex; align-items: baseline; justify-content: flex-end; gap: 0.35rem; }
 .ck-delta__arrow { font-size: 0.72rem; }
 
 .ck-cmp-ver__one, .ck-cmp-ver__pair {
@@ -5185,12 +5213,14 @@ a.tag-mark {
 
 
 .ck-input--error,
-.ck-input[aria-invalid="true"] {
+.ck-input[aria-invalid="true"],
+.ck-select__trigger[aria-invalid="true"] {
   border-color: var(--ck-danger);
   background-color: rgba(248, 113, 113, 0.05);
 }
 .ck-input--error:focus,
-.ck-input[aria-invalid="true"]:focus {
+.ck-input[aria-invalid="true"]:focus,
+.ck-select__trigger[aria-invalid="true"]:focus-visible {
   box-shadow: 0 0 0 3px rgba(248, 113, 113, 0.15);
   border-color: var(--ck-danger);
 }

data/app/controllers/completion_kit/api/v1/metric_versions_controller.rb

@@ -16,6 +16,8 @@ module CompletionKit
         def publish
           @version.publish!
           render json: @version.reload
+        rescue ActiveRecord::RecordInvalid => e
+          render_validation_errors(e.record)
         end
 
         def destroy

data/app/controllers/completion_kit/api/v1/metrics_controller.rb

@@ -70,7 +70,7 @@ module CompletionKit
         def metric_params
           params.permit(:name, :instruction, :metric_type,
             rubric_bands: [:stars, :description],
-            check_config: %i[check_kind target target_path compare_to value pattern json_path expected expected_path min max case_sensitive multiline trim],
+            check_config: [*%i[check_kind target target_path compare_to value pattern json_path expected expected_path min max score_by tolerance case_sensitive multiline trim], { value: [] }],
             tag_names: [])
         end
       end

data/app/controllers/completion_kit/api/v1/runs_controller.rb

@@ -112,9 +112,12 @@ module CompletionKit
                   right_score: r_review ? r_review.ai_score : nil,
                   left_passed: l_review&.passed,
                   right_passed: r_review&.passed,
+                  left_check_score: l_review&.check_score&.to_f,
+                  right_check_score: r_review&.check_score&.to_f,
                   left_metric_version_id: l_review&.metric_version_id,
                   right_metric_version_id: r_review&.metric_version_id,
-                  delta: (l_review&.ai_score && r_review&.ai_score) ? (r_review.ai_score.to_f - l_review.ai_score.to_f).round(2) : nil,
+                  delta: CompletionKit::RunComparison.score_delta(l_review&.ai_score, r_review&.ai_score),
+                  check_score_delta: CompletionKit::RunComparison.score_delta(l_review&.check_score, r_review&.check_score),
                   result_change: CompletionKit::RunComparison.result_change(l_review&.passed, r_review&.passed)
                 }
               end.compact

data/app/controllers/completion_kit/metrics_controller.rb

@@ -61,7 +61,9 @@ module CompletionKit
       @published_metric_version = MetricVersion.published.where(metric_id: @metric.id, current: true).first
       @improve_disagreement_count = @metric.check? ? 0 : Agreement.where(metric_id: @metric.id, verdict: "disagree", run_id: CompletionKit::Run.visible_run_ids).count
 
-      if @edit_draft
+      if @edit_draft&.check?
+        @metric.check_config = @edit_draft.check_config
+      elsif @edit_draft
         @metric.instruction = @edit_draft.instruction
         @metric.rubric_bands = @edit_draft.rubric_bands
       end
@@ -78,17 +80,12 @@ module CompletionKit
     end
 
     def update
-      meta_attrs = metric_params.except(:instruction, :rubric_bands, :check_config)
-
-      unless @metric.update(meta_attrs)
-        return render(:edit, status: :unprocessable_entity)
-      end
+      attrs = metric_params
+      @metric.assign_attributes(attrs.except(:instruction, :rubric_bands, :check_config))
+      return update_check_definition(attrs.to_unsafe_h[:check_config]) if @metric.check?
+      return render(:edit, status: :unprocessable_entity) unless @metric.save
 
-      if @metric.check?
-        update_check_definition
-      else
-        update_judge_definition
-      end
+      update_judge_definition
     end
 
     def destroy
@@ -157,7 +154,11 @@ module CompletionKit
       reverting = was_published_already && !version.current?
       previously_current = MetricVersion.current.find_by(metric_id: @metric.id)
 
-      version.publish!
+      begin
+        version.publish!
+      rescue ActiveRecord::RecordInvalid => e
+        return redirect_to(metric_path(@metric), alert: "#{version.version_label} was not published. #{e.record.errors.full_messages.to_sentence}.")
+      end
 
       if reverting
         redirect_to metric_path(@metric),
@@ -207,28 +208,28 @@ module CompletionKit
       end
     end
 
-    def update_check_definition
-      raw = metric_params[:check_config]
-      proposed = raw.nil? ? nil : normalize_check_config(raw)
+    def update_check_definition(proposed)
+      live = @metric.check_config
+      changed = !proposed.nil? && CompletionKit::Checks::Registry.canonical(proposed) != CompletionKit::Checks::Registry.canonical(live)
+      @metric.check_config = proposed if changed
+      return render(:edit, status: :unprocessable_entity) unless @metric.valid?
+      return save_check_draft(live, proposed) if changed && @metric.reviews.exists?
 
-      unless !proposed.nil? && proposed != @metric.check_config
-        return redirect_to(metric_path(@metric), notice: "Metric was successfully updated.")
-      end
+      @metric.save!
+      MetricVersion.published.find_by(metric_id: @metric.id, current: true)&.update!(metric_type: "check", check_config: proposed) if changed
+      redirect_to metric_path(@metric), notice: "Metric was successfully updated."
+    end
 
-      if @metric.reviews.exists?
-        MetricVersion.drafts.where(metric_id: @metric.id, source: "edit").destroy_all
-        draft = MetricVersion.create!(
-          metric: @metric, metric_type: "check", check_config: proposed,
-          state: "draft", source: "edit", current: false
-        )
-        redirect_to edit_metric_path(@metric),
-                    notice: "Saved as draft #{draft.version_label}. Publish to make these changes the metric's live version."
-      else
-        @metric.update!(check_config: proposed)
-        current_pub = MetricVersion.published.where(metric_id: @metric.id, current: true).first
-        current_pub&.update!(metric_type: "check", check_config: proposed)
-        redirect_to metric_path(@metric), notice: "Metric was successfully updated."
-      end
+    def save_check_draft(live, proposed)
+      @metric.check_config = live
+      @metric.save!(validate: false)
+      MetricVersion.drafts.where(metric_id: @metric.id, source: "edit").destroy_all
+      draft = MetricVersion.create!(
+        metric: @metric, metric_type: "check", check_config: proposed,
+        state: "draft", source: "edit", current: false
+      )
+      redirect_to edit_metric_path(@metric),
+                  notice: "Saved as draft #{draft.version_label}. Publish to make these changes the metric's live version."
     end
 
     def set_metric
@@ -247,7 +248,7 @@ module CompletionKit
     def metric_params
       permitted = params.require(:metric).permit(:name, :instruction, :metric_type,
         rubric_bands: [:stars, :description],
-        check_config: %i[check_kind target target_path compare_to value pattern json_path expected expected_path min max case_sensitive multiline trim],
+        check_config: %i[check_kind target target_path compare_to value pattern json_path expected expected_path min max score_by tolerance case_sensitive multiline trim],
         tag_names: [])
       permitted[:check_config] = normalize_check_config(permitted[:check_config]) if permitted.key?(:check_config)
       permitted
@@ -255,22 +256,23 @@ module CompletionKit
 
     def normalize_check_config(config)
       hash = config.to_unsafe_h.stringify_keys
-      %w[min max].each { |key| hash[key] = hash[key].to_i if hash[key].present? }
+      %w[min max tolerance].each { |key| hash[key] = coerce_number(hash[key]) if hash[key].present? }
       %w[case_sensitive multiline trim].each { |key| hash[key] = ActiveModel::Type::Boolean.new.cast(hash[key]) if hash.key?(key) }
-      hash["expected"] = coerce_scalar(hash["expected"]) if hash["expected"].present?
-      if hash["compare_to"] == "expected"
-        hash.delete("value")
-      else
-        hash.delete("compare_to")
-        hash.delete("expected_path")
-      end
-      hash.reject { |_, value| value.nil? || value == "" }
+      hash["expected"] = CompletionKit::Checks::Registry.parse_json(hash["expected"]) if hash["expected"].present?
+      prune_check_config(hash.except(*CompletionKit::Checks::Registry.unused_keys(hash)))
     end
 
-    def coerce_scalar(value)
-      JSON.parse(value)
-    rescue JSON::ParserError
-      value
+    def prune_check_config(hash)
+      allowed = CompletionKit::Checks::Registry::SHARED_KEYS +
+                CompletionKit::Checks::Registry.config_keys(hash["check_kind"])
+      hash.slice(*allowed).reject { |_, value| value.nil? || value == "" }
+    end
+
+    def coerce_number(value)
+      number = CompletionKit::Checks::NumericValue.parse(value)
+      return value if number.nil?
+
+      number == number.to_i ? number.to_i : number
     end
 
     def normalize_rubric_bands_for_update(bands)

data/app/controllers/completion_kit/runs_controller.rb

@@ -202,9 +202,12 @@ module CompletionKit
               right_score: r_review ? r_review.ai_score : nil,
               left_passed: l_review&.passed,
               right_passed: r_review&.passed,
+              left_check_score: l_review&.check_score&.to_f,
+              right_check_score: r_review&.check_score&.to_f,
               left_version_label: version_label_for(l_review, metric_versions),
               right_version_label: version_label_for(r_review, metric_versions),
-              delta: (l_review&.ai_score && r_review&.ai_score) ? (r_review.ai_score.to_f - l_review.ai_score.to_f).round(2) : nil,
+              delta: RunComparison.score_delta(l_review&.ai_score, r_review&.ai_score),
+              check_score_delta: RunComparison.score_delta(l_review&.check_score, r_review&.check_score),
               result_change: RunComparison.result_change(l_review&.passed, r_review&.passed)
             }
           end.compact

data/app/helpers/completion_kit/application_helper.rb

@@ -204,11 +204,52 @@ module CompletionKit
       :low
     end
 
-    def ck_check_badge(passed)
+    def ck_percent_points(fraction)
+      (BigDecimal(fraction.to_s) * 100).round
+    end
+
+    def ck_percent(fraction)
+      "#{ck_percent_points(fraction)}%"
+    end
+
+    def ck_check_verdict(passed, score = nil)
+      verdict = passed ? "Pass" : "Fail"
+      score.nil? ? verdict : "#{verdict} #{ck_percent(score)}"
+    end
+
+    def ck_check_average(summary)
+      ck_percent(summary[:avg_check_score] || summary[:pass_rate])
+    end
+
+    def ck_check_average_label(name, summary)
+      pass_rate = "#{ck_percent(summary[:pass_rate])} pass rate"
+      return "#{name} #{pass_rate}" unless summary[:avg_check_score]
+
+      "#{name} average score #{ck_percent(summary[:avg_check_score])}, #{pass_rate}"
+    end
+
+    def ck_check_score_change(left, right)
+      return nil if left.nil? || right.nil?
+
+      ck_percent_points(right) - ck_percent_points(left)
+    end
+
+    def ck_delta_chip(delta, unit = "")
+      tone, arrow = if delta.positive? then %w[positive ▲]
+                    elsif delta.negative? then %w[negative ▼]
+                    else %w[zero =]
+                    end
+      content_tag(:span, class: "ck-delta ck-delta--#{tone}") do
+        content_tag(:span, arrow, class: "ck-delta__arrow", "aria-hidden": "true") + "#{"+" if delta.positive?}#{delta}#{unit}"
+      end
+    end
+
+    def ck_check_badge(passed, score = nil)
+      suffix = score.nil? ? "" : " #{ck_percent(score)}"
       if passed == true
-        content_tag(:span, "Pass", class: ck_badge_classes(:high))
+        content_tag(:span, "Pass#{suffix}", class: ck_badge_classes(:high))
       elsif passed == false
-        content_tag(:span, "Fail", class: ck_badge_classes(:low))
+        content_tag(:span, "Fail#{suffix}", class: ck_badge_classes(:low))
       else
         content_tag(:span, "Pending", class: ck_badge_classes(:pending))
       end
@@ -232,58 +273,71 @@ module CompletionKit
       {heading: heading, judge_model: judge ? judge_model.presence : nil}
     end
 
-    CHECK_KIND_LABELS = {
-      "contains" => "Contains a phrase",
-      "not_contains" => "Does not contain a phrase",
-      "equals" => "Equals exactly",
-      "regex" => "Matches a pattern",
-      "valid_json" => "Is valid JSON",
-      "json_path_equals" => "A JSON field equals a value",
-      "length_bounds" => "Length is within a range"
-    }.freeze
-
-    CHECK_COMPARE_TO_LABELS = {
-      "constant" => "A value you type",
-      "expected" => "Each row's expected value"
-    }.freeze
-
-    CHECK_TARGET_LABELS = {
-      "response_text" => "The response text",
-      "input_data" => "The input row",
-      "json_path" => "A value from the response JSON"
-    }.freeze
-
-    CHECK_FIELD_LABELS = {
-      "value" => "Text to look for",
-      "pattern" => "Pattern",
-      "json_path" => "JSON path",
-      "expected" => "Expected value",
-      "expected_path" => "Field in the answer key",
-      "compare_to" => "Compare against",
-      "target_path" => "Path into the JSON",
-      "min" => "Shortest allowed",
-      "max" => "Longest allowed",
-      "case_sensitive" => "Case sensitive",
-      "multiline" => "Multiline",
-      "trim" => "Trim whitespace"
-    }.freeze
-
     def ck_check_kind_label(kind)
-      CHECK_KIND_LABELS.fetch(kind.to_s) { kind.to_s.humanize }
+      CompletionKit::Checks::Labels.kind(kind)
     end
 
     def ck_check_target_label(target)
-      CHECK_TARGET_LABELS.fetch(target.to_s) { target.to_s.humanize }
+      CompletionKit::Checks::Labels.target(target)
+    end
+
+    def ck_check_field_label(key, kind = nil)
+      CompletionKit::Checks::Labels.field(key, kind)
     end
 
-    def ck_check_field_label(key)
-      CHECK_FIELD_LABELS.fetch(key.to_s) { key.to_s.humanize }
+    def ck_check_field_hint(key, kind = nil)
+      CompletionKit::Checks::Labels.hint(key, kind)
     end
 
     def ck_check_field_value(key, value)
-      return CHECK_COMPARE_TO_LABELS.fetch(value.to_s, value) if key.to_s == "compare_to"
+      CompletionKit::Checks::Labels.value(key, value)
+    end
+
+    def ck_check_input_value(value)
+      value.is_a?(Array) || value.is_a?(Hash) ? value.to_json : value
+    end
+
+    def ck_check_expected_input_value(value)
+      return value if value.nil? || (value.is_a?(String) && CompletionKit::Checks::Registry.parse_json(value) == value)
+
+      value.to_json
+    end
+
+    def ck_check_spec_fields(config)
+      shown = config.except("check_kind", "target").reject do |key, _value|
+        CompletionKit::Checks::Registry::FLAG_KEYS.include?(key) && !CompletionKit::Checks::Flag.on?(config, key)
+      end
+      CompletionKit::Checks::Labels.in_form_order(shown)
+    end
+
+    def ck_check_spec_value(key, value)
+      return "Yes" if CompletionKit::Checks::Registry::FLAG_KEYS.include?(key.to_s)
+      return ck_check_field_value(key, value) if CompletionKit::Checks::Labels.worded?(key)
+
+      shown = key.to_s == "expected" ? ck_check_expected_input_value(value) : ck_check_input_value(value)
+      content_tag(:code, shown.to_s, class: "ck-check-spec__code")
+    end
+
+    def ck_check_field_invalid?(metric, key)
+      metric.check_error_keys.include?(key)
+    end
+
+    def ck_check_field_aria(metric, key)
+      ck_check_field_invalid?(metric, key) ? { "aria-invalid" => "true" } : {}
+    end
+
+    def ck_check_score_by_options
+      CompletionKit::Checks::Labels::SCORE_BY.to_a
+    end
 
-      value
+    def ck_check_form_data
+      labels = CompletionKit::Checks::Labels
+      {
+        fields: CompletionKit::Checks::Registry::CONFIG_KEYS,
+        expected: CompletionKit::Checks::Registry::EXPECTED_KEYS,
+        labels: labels::FIELDS_BY_KIND, defaultLabels: labels::FIELDS,
+        hints: labels::HINTS_BY_KIND, defaultHints: labels::HINTS
+      }
     end
 
     def ck_result_change_badge(change)