journeybook 0.1.6.pre.alpha

data/app/models/journeybook/page.rb

@@ -0,0 +1,96 @@
+module Journeybook
+  class Page < ApplicationRecord
+    STATUSES = %w[draft published archived].freeze
+    PAGE_TYPES = %w[page blog_post kb_article glossary_term].freeze
+
+    belongs_to :site
+    belongs_to :parent, class_name: "Page", optional: true
+    has_many :children, class_name: "Page", foreign_key: :parent_id, inverse_of: :parent, dependent: :nullify
+    has_many :navigation_items, class_name: "NavigationItem", dependent: :nullify
+
+    before_validation :generate_slug
+    before_validation :normalize_path
+
+    validates :title, :slug, :path, :markdown, :status, :locale, :page_type, presence: true
+    validates :status, inclusion: { in: STATUSES }
+    validates :page_type, inclusion: { in: PAGE_TYPES }
+    validates :slug, uniqueness: { scope: %i[site_id locale] }
+    validates :path, uniqueness: { scope: %i[site_id locale] }
+    validate :parent_is_valid_knowledge_base_article
+    validate :published_components_are_valid
+
+    scope :published, -> { where(status: "published").where("published_at IS NULL OR published_at <= ?", Time.current) }
+    scope :draft, -> { where(status: "draft") }
+    scope :by_slug, ->(slug) { where(slug: slug) }
+    scope :by_path, ->(path) { where(path: path) }
+    scope :by_page_type, ->(type) { where(page_type: type) }
+    scope :blog_posts, -> { by_page_type("blog_post") }
+    scope :kb_articles, -> { by_page_type("kb_article") }
+    scope :glossary_terms, -> { by_page_type("glossary_term") }
+    scope :root_kb_articles, -> { kb_articles.where(parent_id: nil) }
+    scope :ordered, -> { order(:position, :title) }
+
+    def published?
+      status == "published" && (published_at.blank? || published_at <= Time.current)
+    end
+
+    def blog_post?
+      page_type == "blog_post"
+    end
+
+    def kb_article?
+      page_type == "kb_article"
+    end
+
+    def glossary_term?
+      page_type == "glossary_term"
+    end
+
+    def layout_name
+      layout.presence || site.layout_name
+    end
+
+    def component_validation_errors
+      ComponentValidator.new.errors_for(self)
+    end
+
+    private
+
+    def published_components_are_valid
+      return unless status == "published"
+
+      component_validation_errors.each { |message| errors.add(:markdown, message) }
+    end
+
+    def parent_is_valid_knowledge_base_article
+      return unless parent
+
+      errors.add(:parent, "cannot be the page itself") if parent == self
+      errors.add(:parent, "must belong to the same site") if parent.site_id != site_id
+      errors.add(:parent, "can only be set for knowledge base articles") unless kb_article?
+      errors.add(:parent, "must be a knowledge base article") unless parent.kb_article?
+      errors.add(:parent, "cannot create a circular hierarchy") if parent_ancestor?(self)
+    end
+
+    def parent_ancestor?(candidate)
+      ancestor = parent
+      while ancestor
+        return true if ancestor == candidate
+
+        ancestor = ancestor.parent
+      end
+      false
+    end
+
+    def generate_slug
+      self.slug = title.to_s.parameterize if slug.blank?
+    end
+
+    def normalize_path
+      self.path = "/" if path.blank?
+      self.path = "/#{path}" unless path.start_with?("/")
+      self.path = path.squeeze("/")
+      self.path = path.delete_suffix("/") unless path == "/"
+    end
+  end
+end

data/app/models/journeybook/redirect.rb

@@ -0,0 +1,31 @@
+module Journeybook
+  class Redirect < ApplicationRecord
+    VALID_STATUS_CODES = [ 301, 302, 307, 308 ].freeze
+
+    before_validation :normalize_paths
+
+    validates :from, :to, :status_code, presence: true
+    validates :from, uniqueness: true
+    validates :from, :to, format: { with: %r{\A/(?!/)} }
+    validates :status_code, inclusion: { in: VALID_STATUS_CODES }
+
+    def self.for_path(path)
+      find_by(from: normalize_path(path))
+    end
+
+    def self.normalize_path(path)
+      value = path.to_s.strip
+      value = "/#{value}" unless value.start_with?("/")
+      value = value.squeeze("/")
+      value = value.delete_suffix("/") unless value == "/"
+      value.presence || "/"
+    end
+
+    private
+
+    def normalize_paths
+      self.from = self.class.normalize_path(from)
+      self.to = self.class.normalize_path(to)
+    end
+  end
+end

data/app/models/journeybook/site.rb

@@ -0,0 +1,62 @@
+module Journeybook
+  class Site < ApplicationRecord
+    has_many :pages, dependent: :destroy
+    has_many :navigation_menus, dependent: :destroy
+
+    before_validation :normalize_context_fields
+
+    validates :name, :key, :host, :path_prefix, presence: true
+    validates :key, uniqueness: true
+    validates :path_prefix, uniqueness: { scope: :host }
+    validates :default_locale, presence: true
+
+    scope :for_host, ->(host) { where(host: host) }
+    scope :by_longest_prefix, -> { order(Arel.sql("LENGTH(path_prefix) DESC")) }
+
+    def layout_name
+      layout.presence || Journeybook.configuration.default_layout
+    end
+
+    def relative_path_for(request_path)
+      path = normalize_path(request_path)
+      prefix = normalize_path(path_prefix)
+
+      return path if prefix == "/"
+      return unless path == prefix || path.start_with?("#{prefix}/")
+
+      relative = path.delete_prefix(prefix)
+      relative.presence || "/"
+    end
+
+    def matches_path?(request_path)
+      relative_path_for(request_path).present?
+    end
+
+    def public_path_for(page)
+      return unless page
+
+      prefix = normalize_path(path_prefix)
+      path = normalize_path(page.path)
+      return path if prefix == "/"
+      return prefix if path == "/"
+
+      "#{prefix}#{path}"
+    end
+
+    private
+
+    def normalize_context_fields
+      self.key = key.presence || name.to_s.parameterize(separator: "_")
+      self.key = key.to_s.strip.underscore
+      self.path_prefix = normalize_path(path_prefix.presence || "/")
+    end
+
+    def normalize_path(value)
+      path = value.to_s.strip
+      path = "/#{path}" unless path.start_with?("/")
+      path = path.squeeze("/")
+      path = path.delete_suffix("/") unless path == "/"
+      path.presence || "/"
+    end
+  end
+end

data/app/services/journeybook/ai/markdown_generator.rb

@@ -0,0 +1,15 @@
+module Journeybook
+  module Ai
+    class MarkdownGenerator
+      def initialize(site: nil, style_prompt: nil, template: nil, prompt_builder: nil, client: OpenaiClient.new)
+        prompt_builder ||= PromptBuilder.new(components: Journeybook.components.for_site(site), site: site, style_prompt: style_prompt, template: template)
+        @prompt_builder = prompt_builder
+        @client = client
+      end
+
+      def generate(prompt:)
+        @client.complete(@prompt_builder.build(user_prompt: prompt))
+      end
+    end
+  end
+end

data/app/services/journeybook/ai/openai_client.rb

@@ -0,0 +1,54 @@
+require "json"
+require "net/http"
+
+module Journeybook
+  module Ai
+    class OpenaiClient
+      class Error < Journeybook::Error; end
+
+      ENDPOINT = URI("https://api.openai.com/v1/responses")
+
+      def initialize(api_key: Journeybook.configuration.openai_api_key.presence || ENV["OPENAI_API_KEY"], model: Journeybook.configuration.openai_model)
+        @api_key = api_key
+        @model = model
+      end
+
+      def complete(prompt)
+        raise Error, "OpenAI API key is missing. Set config.openai_api_key or OPENAI_API_KEY." if @api_key.blank?
+
+        response = Net::HTTP.start(ENDPOINT.host, ENDPOINT.port, use_ssl: true) do |http|
+          http.request(build_request(prompt))
+        end
+
+        body = JSON.parse(response.body)
+        raise Error, openai_error(body, response) unless response.is_a?(Net::HTTPSuccess)
+
+        extract_text(body)
+      rescue JSON::ParserError
+        raise Error, "OpenAI returned an invalid JSON response."
+      end
+
+      private
+
+      def build_request(prompt)
+        request = Net::HTTP::Post.new(ENDPOINT)
+        request["Authorization"] = "Bearer #{@api_key}"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({ model: @model, input: prompt })
+        request
+      end
+
+      def extract_text(body)
+        text = body["output_text"].presence || body.fetch("output", []).flat_map { |item| item.fetch("content", []) }.filter_map { |content| content["text"] }.join("\n")
+        text = text.to_s.strip
+        raise Error, "OpenAI returned an empty response." if text.blank?
+
+        text
+      end
+
+      def openai_error(body, response)
+        body.dig("error", "message").presence || "OpenAI request failed with HTTP #{response.code}."
+      end
+    end
+  end
+end

data/app/services/journeybook/ai/prompt_builder.rb

@@ -0,0 +1,154 @@
+require "json"
+
+module Journeybook
+  module Ai
+    class PromptBuilder
+      def initialize(components: Journeybook.components, site: nil, style_prompt: nil, template: nil, media_assets: MediaAsset.order(created_at: :desc).limit(25))
+        @components = components
+        @site = site
+        @style_prompt = style_prompt
+        @template = template
+        @media_assets = media_assets
+      end
+
+      def build(user_prompt:)
+        <<~PROMPT
+          You are designing a Journeybook CMS page for a Rails website.
+
+          Return exactly one complete Markdown document. Do not wrap it in code fences. Do not explain the result.
+
+          User request:
+          #{user_prompt}
+
+          Style instructions:
+          #{style_instructions}
+
+           Current Journeybook context:
+           #{site_context}
+
+           Template instructions:
+           #{template_instructions}
+
+           Available Journeybook components:
+          #{component_reference}
+
+          Available image library:
+          #{image_library_reference}
+
+          Rules:
+          - Use component tags only for page content.
+          - Do not write Markdown headings, paragraphs, lists, links, raw HTML, or standalone text outside component tags.
+          - The only allowed non-component content is frontmatter, if frontmatter is needed.
+          - Copy/text may appear inside component prop values.
+          - Use only the registered components listed above.
+          - Component syntax is: {{ component_name prop="value" other_prop="value" }}
+          - Do not invent unsupported component names.
+          - Use image library URLs only when a registered component has a suitable image prop.
+          - Prefer matching alt text from the image library.
+          - Do not invent image URLs.
+          - Do not output raw Markdown image syntax.
+          - Fill component props with concise production-ready copy.
+          - Keep the page coherent and ready for a public website.
+        PROMPT
+      end
+
+      private
+
+      def style_instructions
+        @style_prompt.presence || "No additional style instructions."
+      end
+
+      def site_context
+        return "No site context selected." unless @site
+
+        <<~TEXT
+          - Name: #{@site.name}
+          - Key: #{@site.key}
+          - Path prefix: #{@site.path_prefix}
+          - Layout: #{@site.layout_name}
+        TEXT
+      end
+
+      def component_reference
+        components = available_components
+        return "No components are registered. Return only frontmatter or an empty document." if components.none?
+
+        components.map do |component|
+          props = component.normalized_props
+          prop_lines = props.map do |name, prop|
+            collection_reference(name, prop) || "    - #{name} (#{prop_type_reference(prop)}): #{prop[:description].presence || prop[:label]}"
+          end.join("\n")
+
+          <<~TEXT
+            - #{component.name}
+              Description: #{component.metadata.fetch(:description, "No description provided")}
+              Props:
+          #{prop_lines.presence || "    - none"}
+              Example: {{ #{component.name} #{props.map { |name, prop| prop_example(name, prop) }.join(" ")} }}
+          TEXT
+        end.join("\n")
+      end
+
+      def template_instructions
+        return "No template selected. Choose the component layout that best fits the request." unless @template
+
+        <<~TEXT
+          - Template: #{@template.name}
+          - Editorial purpose: #{@template.description}
+          - Page type: #{@template.page_type}
+          - Use only the template components, in exactly this order, and include each one exactly once.
+          - Replace starter copy with production-ready content that answers the user request.
+          - Do not add, remove, or reorder components.
+          Template layout:
+          #{@template.markdown}
+        TEXT
+      end
+
+      def available_components
+        return @components unless @template
+
+        names = ComponentParser.new.parse(@template.markdown).map(&:name).uniq
+        @components.select { |component| component.name.in?(names) }
+      end
+
+      def collection_reference(name, prop)
+        return unless prop[:type] == :collection
+
+        item_props = prop[:item].map do |item_name, item_prop|
+          "#{item_name} (#{prop_type_reference(item_prop)})"
+        end.join(", ")
+        count = prop[:max] ? "#{prop[:min]}-#{prop[:max]}" : "at least #{prop[:min]}"
+        "    - #{name} (collection, #{count} items): #{item_props}"
+      end
+
+      def prop_example(name, prop)
+        return %(#{name}="#{prop[:options]&.first || "..."}") unless prop[:type] == :collection
+
+        item = prop[:item].each_with_object({}) do |(item_name, item_prop), values|
+          values[item_name] = item_prop[:options]&.first || "..."
+        end
+        %(#{name}='#{JSON.generate([ item ])}')
+      end
+
+      def prop_type_reference(prop)
+        return prop[:type].to_s unless prop[:type] == :select
+
+        "select: #{prop[:options].join(", ")}"
+      end
+
+      def image_library_reference
+        assets = @media_assets.to_a
+        return "No images are available." if assets.none?
+
+        assets.map do |asset|
+          <<~TEXT
+            - Title: #{asset.title}
+              Alt text: #{asset.alt_text.presence || "No alt text provided"}
+              URL: #{asset.public_url}
+              Tags: #{asset.tags.presence || "none"}
+          TEXT
+        end.join("\n")
+      end
+    end
+  end
+end

data/app/services/journeybook/ai/template_validator.rb

@@ -0,0 +1,17 @@
+module Journeybook
+  module Ai
+    class TemplateValidator
+      def initialize(parser: ComponentParser.new)
+        @parser = parser
+      end
+
+      def errors_for(markdown, template)
+        expected = @parser.parse(template.markdown).map(&:name)
+        actual = @parser.parse(markdown).map(&:name)
+        return [] if actual == expected
+
+        [ "AI draft must use the #{template.name} template components in the approved order." ]
+      end
+    end
+  end
+end

data/app/services/journeybook/component_parser.rb

@@ -0,0 +1,53 @@
+module Journeybook
+  class ComponentParser
+    HIDDEN_PROP = :journeybook_hidden
+
+    ParsedComponent = Data.define(:name, :props, :source, :token) do
+      def hidden?
+        props[ComponentParser::HIDDEN_PROP] == "true"
+      end
+    end
+
+    COMPONENT_PATTERN = /\{\{\s*(.*?)\s*\}\}/m
+    NAME_PATTERN = /\A([a-zA-Z][\w-]*)/
+    PROP_PATTERN = /([a-zA-Z_]\w*)\s*=\s*(?:"([^"]*)"|'([^']*)')/
+
+    # @param markdown [String]
+    # @return [Array<ParsedComponent>]
+    def parse(markdown)
+      markdown.to_s.scan(COMPONENT_PATTERN).each_with_index.filter_map do |(body), index|
+        build_component(body, index)
+      end
+    end
+
+    # @param markdown [String]
+    # @return [Array(String, Array<ParsedComponent>)]
+    def extract(markdown)
+      components = []
+      extracted = markdown.to_s.gsub(COMPONENT_PATTERN) do |source|
+        component = build_component(Regexp.last_match(1), components.length, source: source)
+        next source unless component
+
+        components << component
+        component.token
+      end
+
+      [ extracted, components ]
+    end
+
+    private
+
+    def build_component(body, index, source: nil)
+      match = body.match(NAME_PATTERN)
+      return unless match
+
+      name = match[1].tr("-", "_").to_sym
+      props = body.scan(PROP_PATTERN).each_with_object({}) do |(name, double_quoted, single_quoted), parsed|
+        parsed[name.to_sym] = double_quoted || single_quoted
+      end
+      token = "JOURNEYBOOKCOMPONENT#{index}END"
+
+      ParsedComponent.new(name, props, source || "{{#{body}}}", token)
+    end
+  end
+end

data/app/services/journeybook/component_renderer.rb

@@ -0,0 +1,108 @@
+require "json"
+
+module Journeybook
+  class ComponentRenderer
+    # @param registry [Journeybook::ComponentRegistry]
+    def initialize(registry: Journeybook.components)
+      @registry = registry
+    end
+
+    # @param component [Journeybook::ComponentParser::ParsedComponent]
+    # @return [String]
+    def render(component, page: nil)
+      return "" if component.hidden?
+
+      registration = @registry.registered(component.name)
+      component_class = @registry.fetch(component.name)
+      schema = registration.normalized_props
+      props = coerce_props(component.props.except(ComponentParser::HIDDEN_PROP), schema, page)
+      link_targets = link_targets(component.props, schema, page)
+
+      html = if component_class.respond_to?(:render)
+        if accepts_keyword?(component_class.method(:render), :page)
+          component_class.render(**props, page: page).to_s
+        else
+          component_class.render(**props).to_s
+        end
+      elsif accepts_keyword?(component_class.instance_method(:initialize), :page)
+        component_class.new(**props, page: page).render.to_s
+      else
+        component_class.new(**props).render.to_s
+      end
+      apply_link_targets(html, link_targets)
+    end
+
+    private
+
+    def coerce_props(props, schema, page)
+        props.each_with_object({}) do |(name, value), coerced|
+          next if target_prop?(name, schema)
+
+          config = schema[name]
+          coerced[name] = if config&.fetch(:type) == :collection
+            collection_value(value, config[:item], page)
+          elsif config&.fetch(:type) == :url
+            resolve_url(value, page)
+          else
+            value
+          end
+        end
+      end
+
+      def collection_value(value, item_schema, page)
+        JSON.parse(value).map do |item|
+          item.deep_symbolize_keys.each_with_object({}) do |(name, item_value), props|
+            props[name] = item_schema[name]&.fetch(:type) == :url ? resolve_url(item_value, page) : item_value
+          end
+        end
+      rescue JSON::ParserError, NoMethodError
+        []
+      end
+
+      def link_targets(props, schema, page)
+        props.each_with_object({}) do |(name, value), targets|
+          config = schema[name]
+          if config&.fetch(:type) == :url && props["#{name}_target".to_sym] == "open_new_window"
+            targets[resolve_url(value, page)] = "_blank"
+          elsif config&.fetch(:type) == :collection
+            collection_value(value, config[:item], page).each do |item|
+              target = item[:href_target]
+              targets[item[:href]] = "_blank" if target == "open_new_window" && item[:href].present?
+            end
+          end
+        end
+      end
+
+      def apply_link_targets(html, targets)
+        return html if targets.empty?
+
+        fragment = Nokogiri::HTML5.fragment(html)
+        fragment.css("a[href]").each do |link|
+          next unless targets[link["href"]] == "_blank"
+
+          link["target"] = "_blank"
+          link["rel"] = "noopener noreferrer"
+        end
+        fragment.to_html
+      end
+
+      def resolve_url(value, page)
+        match = value.to_s.match(%r{\Ajourneybook://page/(\d+)\z})
+        return value unless match && page
+
+        page.site.pages.find_by(id: match[1])&.path || value
+      end
+
+      def target_prop?(name, schema)
+        name.to_s.end_with?("_target") && schema.key?(name.to_s.delete_suffix("_target").to_sym)
+      end
+
+      def accepts_keyword?(method, name)
+        return false unless method.respond_to?(:parameters)
+
+        method.parameters.any? do |type, param|
+          param == name && %i[keyreq key keyrest].include?(type)
+        end
+      end
+  end
+end