lcp 0.1.0 → 0.2.0

data/lib/lcp_ruby/presenter/field_value_resolver.rb

@@ -12,20 +12,35 @@ module LcpRuby
 
       # Resolve a field value from a record using various path types.
       #
+      # Enum fields return the **raw** stored key (e.g. `"mcp_server"`) by
+      # default — not the humanized label. Renderers that need the label
+      # read it from `options["label"]`, injected by
+      # `DisplayHelper#render_display_value`; the no-renderer display path
+      # runs through `format_enum_display`. This separation lets renderers
+      # like `badge` look up `color_map[raw_key]` without reverse-mapping
+      # a humanized string. (Audit #18.)
+      #
+      # Callers that want the humanized enum label directly — display
+      # templates (`display_template "{status}"`), interpolated template
+      # strings — pass `humanize_enums: true`. `resolve_template` does this
+      # internally regardless of the keyword passed at the top level,
+      # because template interpolation is always a display context.
+      #
       # @param record [ActiveRecord::Base] the record to resolve from
       # @param field_path [String] field name, dot-path, or template
       # @param fk_map [Hash] FK field name => AssociationDefinition (for backward compat)
-      # @param raw [Boolean] when true, return raw enum keys instead of i18n
-      #   labels (used by raw `.json` / `.csv` endpoints).
+      # @param humanize_enums [Boolean] when true, route enum-typed terminal
+      #   values through `Metadata::EnumLabelResolver` (returns the localized
+      #   label). Default false — renderers and view dispatch get the raw key.
       # @return [Object, nil] resolved value
-      def resolve(record, field_path, fk_map: {}, raw: false)
+      def resolve(record, field_path, fk_map: {}, humanize_enums: false)
         field_path = field_path.to_s
         return nil if field_path.blank?
 
         if self.class.template_field?(field_path)
           resolve_template(record, field_path, fk_map: fk_map)
         elsif self.class.dot_path?(field_path)
-          resolve_dot_path(record, field_path, raw: raw)
+          resolve_dot_path(record, field_path, humanize_enums: humanize_enums)
         elsif virtual_column_field?(field_path)
           resolve_virtual_column(record, field_path)
         elsif fk_map.key?(field_path)
@@ -33,7 +48,7 @@ module LcpRuby
         elsif (assoc = model_definition.find_belongs_to(field_path))
           resolve_association_record(record, assoc.name)
         else
-          resolve_simple(record, field_path, raw: raw)
+          resolve_simple(record, field_path, humanize_enums: humanize_enums)
         end
       end
 
@@ -60,30 +75,32 @@ module LcpRuby
         model_definition.name
       end
 
+      # Template interpolation is always a display context — humanize enums
+      # so `"{status}"` renders the localized label, not the raw enum key.
       def resolve_template(record, template, fk_map: {})
         template.gsub(/\{([^}]+)\}/) do |_match|
           ref = Regexp.last_match(1).strip
-          resolve_ref(record, ref, fk_map: fk_map).to_s
+          resolve_ref(record, ref, fk_map: fk_map, humanize_enums: true).to_s
         end
       end
 
-      def resolve_ref(record, ref, fk_map: {})
+      def resolve_ref(record, ref, fk_map: {}, humanize_enums: false)
         if self.class.dot_path?(ref)
-          resolve_dot_path(record, ref)
+          resolve_dot_path(record, ref, humanize_enums: humanize_enums)
         elsif fk_map.key?(ref)
           resolve_fk(record, fk_map[ref])
         else
-          resolve_simple(record, ref)
+          resolve_simple(record, ref, humanize_enums: humanize_enums)
         end
       end
 
-      def resolve_dot_path(record, field_path, raw: false)
+      def resolve_dot_path(record, field_path, humanize_enums: false)
         parts = field_path.split(".")
 
         # Custom fields use dot-path notation (custom_fields.nickname) but are not associations —
         # the field name is a dynamic accessor on the record itself.
         if parts.first == "custom_fields" && parts.length == 2
-          return resolve_simple(record, parts.last, raw: raw)
+          return resolve_simple(record, parts.last, humanize_enums: humanize_enums)
         end
 
         current_record = record
@@ -103,7 +120,7 @@ module LcpRuby
             end
 
             # Terminal field — check permission on current model and read value
-            return read_terminal_value(current_record, part, current_model_def, raw: raw)
+            return read_terminal_value(current_record, part, current_model_def, humanize_enums: humanize_enums)
           else
             # Association traversal
             assoc = current_model_def.associations.find { |a| a.name == part }
@@ -124,7 +141,7 @@ module LcpRuby
 
             if assoc.type == "has_many"
               # For has_many, resolve the remaining path on each related record
-              return resolve_has_many(current_record, part, parts[(index + 1)..], next_model_def, raw: raw)
+              return resolve_has_many(current_record, part, parts[(index + 1)..], next_model_def, humanize_enums: humanize_enums)
             end
 
             # belongs_to / has_one — traverse
@@ -147,7 +164,7 @@ module LcpRuby
         current
       end
 
-      def resolve_has_many(record, assoc_name, remaining_parts, target_model_def, raw: false)
+      def resolve_has_many(record, assoc_name, remaining_parts, target_model_def, humanize_enums: false)
         return nil unless record.respond_to?(assoc_name)
 
         related = record.public_send(assoc_name)
@@ -157,18 +174,18 @@ module LcpRuby
 
         related.map do |related_record|
           sub_resolver = self.class.new(target_model_def, build_evaluator_for(target_model_def.name))
-          sub_resolver.resolve(related_record, remaining_path, raw: raw)
+          sub_resolver.resolve(related_record, remaining_path, humanize_enums: humanize_enums)
         end.compact
       end
 
-      def read_terminal_value(record, field_name, current_model_def, raw: false)
+      def read_terminal_value(record, field_name, current_model_def, humanize_enums: false)
         return nil if record.nil?
 
         evaluator = build_evaluator_for(current_model_def.name)
         return nil unless evaluator.field_readable?(field_name)
 
         value = record.respond_to?(field_name) ? record.public_send(field_name) : nil
-        return value if raw
+        return value unless humanize_enums
 
         Metadata::EnumLabelResolver.resolve(value, lookup_field(current_model_def, field_name),
                                             model_name: current_model_def.name)
@@ -180,9 +197,9 @@ module LcpRuby
         self.class.association_label(record.public_send(assoc.name))
       end
 
-      def resolve_simple(record, field_name, raw: false)
+      def resolve_simple(record, field_name, humanize_enums: false)
         value = record.respond_to?(field_name) ? record.public_send(field_name) : nil
-        return value if raw
+        return value unless humanize_enums
 
         # `lookup_field` returns nil for unregistered names (e.g., custom
         # fields), letting EnumLabelResolver pass them through unchanged.

data/lib/lcp_ruby/schemas/page.json

@@ -137,6 +137,8 @@
           "oneOf": [
             { "$ref": "#/$defs/kpi_card_widget" },
             { "$ref": "#/$defs/text_widget" },
+            { "$ref": "#/$defs/rich_text_widget" },
+            { "$ref": "#/$defs/markdown_widget" },
             { "$ref": "#/$defs/list_widget" },
             { "$ref": "#/$defs/chart_widget" },
             { "$ref": "#/$defs/embed_widget" },
@@ -362,7 +364,7 @@
 
     "text_widget": {
       "type": "object",
-      "description": "Text widget displaying translated content.",
+      "description": "Text widget displaying translated content as plain (HTML-escaped) text. For formatted content, use the rich_text_widget (raw HTML) or markdown_widget (CommonMark) instead.",
       "properties": {
         "type": { "type": "string", "const": "text" },
         "content_key": {
@@ -375,6 +377,36 @@
       "additionalProperties": false
     },
 
+    "rich_text_widget": {
+      "type": "object",
+      "description": "Rich text widget — renders the i18n-resolved content as raw HTML (so the translation can contain `<h2>`, `<a>`, etc.). Trust model: locale files are author-controlled, the same trust level as any engine view using `raw`. When the translation pipeline involves external translators outside code review, prefer the markdown_widget (sanitized output) instead.",
+      "properties": {
+        "type": { "type": "string", "const": "rich_text" },
+        "content_key": {
+          "type": "string",
+          "description": "i18n key whose value contains HTML.",
+          "examples": ["lcp_ruby.pages.home.welcome_html"]
+        }
+      },
+      "required": ["type", "content_key"],
+      "additionalProperties": false
+    },
+
+    "markdown_widget": {
+      "type": "object",
+      "description": "Markdown widget — i18n source is parsed as CommonMark (Commonmarker without `unsafe:`, so raw HTML in the source is stripped at parse time) and the rendered HTML is then sanitized against the same allow-list as the model-level :markdown renderer. Friendlier authoring than HTML for welcome blurbs and dashboard intros.",
+      "properties": {
+        "type": { "type": "string", "const": "markdown" },
+        "content_key": {
+          "type": "string",
+          "description": "i18n key whose value is Markdown source.",
+          "examples": ["lcp_ruby.pages.home.welcome_md"]
+        }
+      },
+      "required": ["type", "content_key"],
+      "additionalProperties": false
+    },
+
     "list_widget": {
       "type": "object",
       "description": "List widget displaying recent records from a model.",

data/lib/lcp_ruby/search/custom_field_filter.rb

@@ -132,6 +132,11 @@ module LcpRuby
           prefix = negate ? "NOT " : ""
           if LcpRuby.postgresql?
             "#{expr} #{prefix}ILIKE #{conn.quote(pattern)}"
+          elsif LcpRuby.mysql?
+            # In MySQL/MariaDB string literals the backslash is itself an escape
+            # character, so the escape clause needs a doubled backslash ('\\')
+            # where PostgreSQL/SQLite accept a single one ('\').
+            "#{expr} #{prefix}LIKE #{conn.quote(pattern)} ESCAPE '\\\\'"
           else
             "#{expr} #{prefix}LIKE #{conn.quote(pattern)} ESCAPE '\\'"
           end

data/lib/lcp_ruby/skills_installer.rb

@@ -4,20 +4,33 @@ require "fileutils"
 require_relative "gem_paths"
 
 module LcpRuby
-  # Installs (copies/refreshes) the gem-bundled `lcp-*` Claude Code skills into a
-  # target `.claude/skills/` directory. Rails-free.
+  # Installs (copies/refreshes) the gem-bundled `lcp-*` AI authoring skills into
+  # a target agent skills directory (for example `.claude/skills/` or
+  # `.codex/skills/`). Rails-free.
   #
   # Refresh is an exact mirror of the gem's `lcp-*` set: each shipped skill dir
   # is replaced wholesale, orphaned `lcp-*` dirs are pruned (when `prune: true`),
   # and non-`lcp-*` skills are NEVER touched. The installer does no I/O logging —
   # the caller (CLI prints, generator maps to Thor `say`) reports from {Result}.
   class SkillsInstaller
+    AGENT_DIRECTORIES = {
+      "claude" => ".claude",
+      "codex" => ".codex"
+    }.freeze
+    DEFAULT_AGENTS = AGENT_DIRECTORIES.keys.freeze
+
     Result = Struct.new(:created, :updated, :removed, keyword_init: true) do
       def any_changes?
         created.any? || updated.any? || removed.any?
       end
     end
 
+    def self.agent_skill_targets(root:, agents: DEFAULT_AGENTS)
+      agents.each_with_object({}) do |agent, targets|
+        targets[agent] = File.join(root, AGENT_DIRECTORIES.fetch(agent), "skills")
+      end
+    end
+
     def initialize(target:, source: LcpRuby::GemPaths.skills, prune: true)
       @target = target
       @source = source

data/lib/lcp_ruby/tasks/doctor.rb

@@ -194,14 +194,19 @@ module LcpRuby
           end
         end
 
-        skills_dir = File.join(@destination_root, ".claude", "skills")
-        lcp_skills = Dir.exist?(skills_dir) ? Dir.children(skills_dir).count { |c| c.start_with?("lcp-") } : 0
-        if lcp_skills.zero?
-          add_finding(:info, :agent_affordances,
-                      "no lcp-* skills installed in .claude/skills/",
-                      hint: "rails generate lcp_ruby:agent_setup")
-        else
-          add_finding(:info, :agent_affordances, "✅ #{lcp_skills} lcp-* skill(s) installed")
+        {
+          ".claude/skills" => "Claude Code",
+          ".codex/skills" => "Codex"
+        }.each do |relative_dir, label|
+          skills_dir = File.join(@destination_root, relative_dir)
+          lcp_skills = Dir.exist?(skills_dir) ? Dir.children(skills_dir).count { |c| c.start_with?("lcp-") } : 0
+          if lcp_skills.zero?
+            add_finding(:info, :agent_affordances,
+                        "no lcp-* skills installed in #{relative_dir}/",
+                        hint: "rails generate lcp_ruby:agent_setup")
+          else
+            add_finding(:info, :agent_affordances, "✅ #{lcp_skills} #{label} lcp-* skill(s) installed")
+          end
         end
 
         # Bundled assets ship with the gem; if these don't resolve the package

data/lib/lcp_ruby/version.rb

@@ -1,3 +1,3 @@
 module LcpRuby
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/lcp_ruby/widgets/data_resolver.rb

@@ -1,3 +1,5 @@
+require "commonmarker"
+
 module LcpRuby
   module Widgets
     class DataResolver
@@ -6,13 +8,18 @@ module LcpRuby
       WidgetScope = Struct.new(:model_class, :model_def, :evaluator, :base_scope, :scope, keyword_init: true)
 
       def initialize(zone, user:, scope_context: nil,
-                     filter_form: nil, scope_filter_set: nil, record: nil)
+                     filter_form: nil, scope_filter_set: nil, record: nil, trusted: true)
         @zone = zone
         @user = user
         @scope_context = scope_context || {}
         @filter_form = filter_form
         @scope_filter_set = scope_filter_set
         @record = record
+        # Whether the owning page may emit raw (unsanitized) HTML — false for
+        # end-user-editable DB pages, which sanitize rich_text at render.
+        # Defaults true so YAML/auto pages and non-page callers keep raw
+        # pass-through.
+        @trusted = trusted
       end
 
       def resolve
@@ -22,6 +29,8 @@ module LcpRuby
         case widget["type"]
         when "kpi_card" then resolve_kpi_card(widget)
         when "text"     then resolve_text(widget)
+        when "rich_text" then resolve_rich_text(widget)
+        when "markdown" then resolve_markdown(widget)
         when "list"     then resolve_list(widget)
         when "chart"    then resolve_chart(widget)
         when "embed"    then resolve_embed(widget)
@@ -108,6 +117,38 @@ module LcpRuby
         }
       end
 
+      # Rich text widget — same i18n content lookup as :text, but the
+      # template emits the resolved string as raw HTML (`<h2>`, `<a>`,
+      # etc. render as tags). Trust model: `content_key` resolves through
+      # author-controlled locale files — same surface as any other engine
+      # view that uses `raw`. Parallel to the model-level :rich_text field
+      # type. Use :markdown widget instead when the source is author-written
+      # markdown — safer XSS surface and friendlier authoring.
+      def resolve_rich_text(widget)
+        content_key = widget["content_key"]
+        {
+          content: I18n.t(content_key, default: content_key),
+          # On untrusted (DB-defined) pages the partial sanitizes instead of
+          # raw()-ing — render-time defense behind the save-time validator.
+          trusted: @trusted
+        }
+      end
+
+      # Markdown widget — i18n content lookup, then Commonmarker → HTML
+      # (sanitize runs in the partial where view_context.sanitize is
+      # available). Commonmarker options + the downstream tag/attribute
+      # allow-list live on `Display::MarkdownSanitize` so on-page and
+      # in-table markdown render identically (same parser opts, same
+      # sanitize list). `unsafe:` deliberately omitted — raw HTML in
+      # the source is stripped at parse time.
+      def resolve_markdown(widget)
+        content_key = widget["content_key"]
+        source = I18n.t(content_key, default: content_key)
+        html = Commonmarker.to_html(source.to_s,
+          options: LcpRuby::Display::MarkdownSanitize::COMMONMARKER_OPTIONS)
+        { html: html }
+      end
+
       def resolve_list(widget)
         ws = build_widget_scope(widget)
         return { hidden: true } unless ws

data/lib/lcp_ruby/widgets/date_grouper.rb

@@ -26,6 +26,8 @@ module LcpRuby
       def date_trunc_sql
         if LcpRuby.postgresql?
           Arel.sql("DATE_TRUNC('#{@period}', #{quoted_field})")
+        elsif LcpRuby.mysql?
+          mysql_trunc
         else
           sqlite_trunc
         end
@@ -46,6 +48,23 @@ module LcpRuby
         end
       end
 
+      # MySQL/MariaDB: DATE_FORMAT yields the same period-key strings the
+      # SQLite branch does, so DataResolver's parse/zero-fill stays adapter-agnostic.
+      def mysql_trunc
+        case @period
+        when "quarter"
+          Arel.sql("CONCAT(YEAR(#{quoted_field}), '-Q', QUARTER(#{quoted_field}))")
+        else
+          format = case @period
+          when "day"   then "%Y-%m-%d"
+          when "week"  then "%Y-%u"
+          when "month" then "%Y-%m"
+          when "year"  then "%Y"
+          end
+          Arel.sql("DATE_FORMAT(#{quoted_field}, '#{format}')")
+        end
+      end
+
       def quoted_field
         @scope.connection.quote_column_name(@field)
       end

data/lib/lcp_ruby/workflow/contract_validator.rb

@@ -3,7 +3,7 @@ module LcpRuby
     class ContractValidator
       REQUIRED_FIELDS = {
         "name" => "string",
-        "model_name" => "string",
+        "target_model" => "string",
         "field_name" => "string",
         "states" => "json",
         "transitions" => "json",

data/lib/lcp_ruby/workflow/model_source.rb

@@ -8,7 +8,7 @@ module LcpRuby
         return [] unless model_class
 
         fields = field_mapping
-        records = model_class.where(fields["model_name"] => model_name.to_s, fields["active"] => true)
+        records = model_class.where(fields["target_model"] => model_name.to_s, fields["active"] => true)
         records.map { |r| record_to_definition(r) }
       rescue LcpRuby::Error, ActiveRecord::StatementInvalid => e
         LcpRuby.record_error(e, subsystem: "workflow", model: model_name.to_s)
@@ -47,7 +47,7 @@ module LcpRuby
 
         hash = {
           "name" => record.send(fields["name"]),
-          "model" => record.send(fields["model_name"]),
+          "model" => record.send(fields["target_model"]),
           "field" => record.send(fields["field_name"]),
           "version" => record.send(fields["version"]),
           "audit_log" => record.respond_to?(fields["audit_log"]) ? record.send(fields["audit_log"]) : false,

data/lib/lcp_ruby.rb

@@ -123,6 +123,7 @@ require "lcp_ruby/model_factory/virtual_column_applicator"
 require "lcp_ruby/model_factory/aggregate_applicator"
 require "lcp_ruby/model_factory/array_type"
 require "lcp_ruby/model_factory/array_type_applicator"
+require "lcp_ruby/model_factory/json_type_applicator"
 require "lcp_ruby/model_factory/workflow_applicator"
 require "lcp_ruby/model_factory/sequence_applicator"
 require "lcp_ruby/model_factory/builder"
@@ -335,6 +336,15 @@ module LcpRuby
   class SchemaError < Error; end
   class ServiceError < Error; end
   class ConditionError < Error; end
+  # Raised at boot when the host's asset pipeline can't serve LCP's
+  # JS/CSS. LCP ships ~50 JS files glued together by Sprockets `//= require`
+  # directives in `app/assets/javascripts/lcp_ruby/application.js`. On
+  # Rails 8 the default is Propshaft, which doesn't understand those
+  # directives — the layout's `<script src=…>` either 404s (Propshaft can't
+  # resolve) or returns the 58-line manifest source as-is. Either failure
+  # mode is silent (no console errors, no logs), so we fail loud at boot
+  # instead. See docs/reference/asset-pipeline.md.
+  class AssetPipelineError < Error; end
   # Raised when path-template resolution fails at render time
   # (nil mid-chain, missing method on current_user, etc.). Boot-time
   # template shape errors raise MetadataError instead.
@@ -648,6 +658,14 @@ module LcpRuby
       ActiveRecord::Base.connection.adapter_name.downcase.include?("postgresql")
     end
 
+    # True for MySQL and MariaDB (both report adapter_name "Mysql2" via the
+    # mysql2 gem, "Trilogy" via trilogy). Used to pick MySQL-flavoured SQL
+    # where it differs from SQLite (e.g. DATE_FORMAT vs strftime).
+    def mysql?
+      name = ActiveRecord::Base.connection.adapter_name.downcase
+      name.include?("mysql") || name.include?("trilogy")
+    end
+
     def json_column_type
       postgresql? ? :jsonb : :json
     end

data/lib/tasks/lcp_ruby_db.rake

@@ -69,8 +69,15 @@ end
 # `db:setup`): `db:setup` invokes `db:seed` as part of its dependency
 # chain, so a post-action of `db:setup` runs AFTER `db:seed` — too
 # late if `db:seed` itself needs the tables. Prerequisite of
-# `db:seed` covers `db:setup`, `db:reset`, `db:prepare`, and a bare
+# `db:seed` covers `db:setup`, `db:reset`, and a bare
 # `bin/rails db:seed` uniformly.
+#
+# NOT covered: `db:prepare`. It seeds a freshly-initialized DB via
+# `DatabaseTasks.load_seed` (see Rails' `prepare_all`) — the module
+# method, not the `db:seed` Rake task — so this enhancement never
+# fires. Run `db:setup` (or `db:reset`) when you need the seed-safe
+# path on a fresh DB; `db:prepare` only seeds when it *creates* the DB,
+# so on an existing DB it just migrates and is safe.
 if Rake::Task.task_defined?("db:seed")
   Rake::Task["db:seed"].enhance([ "lcp_ruby:ensure_tables" ])
 end

data/lib/tasks/lcp_ruby_i18n_check.rake

@@ -18,6 +18,14 @@ end
 namespace :lcp_ruby do
   desc "Audit host metadata for missing translations and DSL literals"
   task :i18n_check, [ :format ] => :environment do |_t, args|
+    # `=> :environment` boots Rails autoloaders but does NOT trigger
+    # `to_prepare`, so LcpRuby.loader is empty in dev/test invocations.
+    # Without these two lines the runner walks zero presenters/pages
+    # and reports `0 offense(s)` even when hundreds are missing.
+    # Mirrors `lcp_ruby:invariant_check`.
+    LcpRuby::Engine.ensure_active_record_loaded!
+    LcpRuby::Engine.load_metadata!
+
     exit lcp_ruby_i18n_check_runner_with_host_config.run(format: args[:format])
   end
 end