add artifact versions table

Author: SamSaffron

app/models/ai_artifact.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 class AiArtifact < ActiveRecord::Base
+  has_many :versions, class_name: "AiArtifactVersion", dependent: :destroy
   belongs_to :user
   belongs_to :post
   validates :html, length: { maximum: 65_535 }
@@ -33,6 +34,38 @@ def self.unshare_publicly(id:)
   def url
     self.class.url(id)
   end
+
+  def apply_diff(html_diff: nil, css_diff: nil, js_diff: nil, change_description: nil)
+    differ = DiscourseAi::Utils::DiffUtils
+
+    html = html_diff ? differ.apply_hunk(self.html, html_diff) : self.html
+    css = css_diff ? differ.apply_hunk(self.css, css_diff) : self.css
+    js = js_diff ? differ.apply_hunk(self.js, js_diff) : self.js
+
+    create_new_version(html: html, css: css, js: js, change_description: change_description)
+  end
+
+  def create_new_version(html: nil, css: nil, js: nil, change_description: nil)
+    latest_version = versions.order(version_number: :desc).first
+    new_version_number = latest_version ? latest_version.version_number + 1 : 1
+
+    transaction do
+      # Create the version record
+      versions.create!(
+        version_number: new_version_number,
+        html: self.html,
+        css: self.css,
+        js: self.js,
+        change_description: change_description,
+      )
+
+      # Update the main artifact
+      self.html = html if html.present?
+      self.css = css if css.present?
+      self.js = js if js.present?
+      save!
+    end
+  end
 end
 
 # == Schema Information

db/migrate/20241130003808_add_artifact_versions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+class AddArtifactVersions < ActiveRecord::Migration[7.0]
+  def change
+    create_table :ai_artifact_versions do |t|
+      t.bigint :ai_artifact_id, null: false
+      t.integer :version_number, null: false
+      t.string :html, limit: 65535
+      t.string :css, limit: 65535
+      t.string :js, limit: 65535
+      t.jsonb :metadata
+      t.string :change_description
+      t.timestamps
+
+      t.index [:ai_artifact_id, :version_number], unique: true
+    end
+  end
+end

lib/utils/diff_utils.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+# Inspired by Aider https://github.com/Aider-AI/aider
+
+module DiscourseAi
+  module Utils
+    module DiffUtils
+      # Custom errors with detailed information for LLM feedback
+      class DiffError < StandardError
+        attr_reader :original_text, :diff_text, :context
+
+        def initialize(message, original_text:, diff_text:, context: {})
+          @original_text = original_text
+          @diff_text = diff_text
+          @context = context
+          super(message)
+        end
+
+        def to_llm_message
+          original_text = @original_text
+          if @original_text.length > 1000
+            original_text = @original_text[0..1000] + "..."
+          end
+
+          <<~MESSAGE
+            #{message}
+
+            Original text:
+            ```
+            #{original_text}
+            ```
+
+            Attempted diff:
+            ```
+            #{diff_text}
+            ```
+
+            #{context_message}
+
+            Please provide a corrected diff that:
+            1. Has the correct context lines
+            2. Contains all necessary removals (-) and additions (+)
+          MESSAGE
+        end
+
+        private
+
+        def context_message
+          return "" if context.empty?
+
+          context.map { |key, value| "#{key}: #{value}" }.join("\n")
+        end
+      end
+
+      class NoMatchingContextError < DiffError
+        def initialize(original_text:, diff_text:)
+          super(
+            "Could not find the context lines in the original text",
+            original_text: original_text,
+            diff_text: diff_text,
+          )
+        end
+      end
+
+      class AmbiguousMatchError < DiffError
+        def initialize(original_text:, diff_text:)
+          super(
+            "Found multiple possible locations for this change",
+            original_text: original_text,
+            diff_text: diff_text,
+          )
+        end
+      end
+
+      class MalformedDiffError < DiffError
+        def initialize(original_text:, diff_text:, issue:)
+          super(
+            "The diff format is invalid",
+            original_text: original_text,
+            diff_text: diff_text,
+            context: {
+              "Issue" => issue,
+            },
+          )
+        end
+      end
+
+      def self.apply_hunk(text, diff)
+        text = text.encode(universal_newline: true)
+        diff = diff.encode(universal_newline: true)
+        # we need this for matching
+        text = text + "\n" unless text.end_with?("\n")
+
+        diff_lines = parse_diff_lines(diff, text)
+
+        validate_diff_format!(text, diff, diff_lines)
+
+        lines_to_match = diff_lines.select { |marker, _| ["-", " "].include?(marker) }.map(&:last)
+        match_start, match_end = find_unique_match(text, lines_to_match, diff)
+        new_hunk = diff_lines.select { |marker, _| ["+", " "].include?(marker) }.map(&:last).join
+
+        new_hunk = +""
+
+        diff_lines_index = 0
+        text[match_start..match_end].lines.each do |line|
+          diff_marker, diff_content = diff_lines[diff_lines_index]
+
+          while diff_marker == "+"
+            new_hunk << diff_content
+            diff_lines_index += 1
+            diff_marker, diff_content = diff_lines[diff_lines_index]
+          end
+
+          if diff_marker == " "
+            new_hunk << line
+          end
+
+          diff_lines_index += 1
+        end
+
+        # leftover additions
+        diff_marker, diff_content = diff_lines[diff_lines_index]
+        while diff_marker == "+"
+          diff_lines_index += 1
+          new_hunk << diff_content
+          diff_marker, diff_content = diff_lines[diff_lines_index]
+        end
+
+        (text[0...match_start].to_s + new_hunk + text[match_end..-1].to_s).strip
+      end
+
+      private_class_method def self.parse_diff_lines(diff, text)
+        diff.lines.map do |line|
+          marker = line[0]
+          content = line[1..]
+
+          if !["-", "+", " "].include?(marker)
+            marker = " "
+            content = line
+          end
+
+          [marker, content]
+        end
+      end
+
+      private_class_method def self.validate_diff_format!(text, diff, diff_lines)
+        if diff_lines.empty?
+          raise MalformedDiffError.new(original_text: text, diff_text: diff, issue: "Diff is empty")
+        end
+
+        unless diff_lines.any? { |marker, _| %w[- +].include?(marker) }
+          raise MalformedDiffError.new(
+                  original_text: text,
+                  diff_text: diff,
+                  issue: "Diff must contain at least one change (+ or -)",
+                )
+        end
+      end
+
+      private_class_method def self.find_unique_match(text, context_lines, diff)
+        return 0 if context_lines.empty? && removals.empty?
+
+        pattern = context_lines.map { |line| "^\\s*" + Regexp.escape(line.strip) + "\s*$\n" }.join
+        matches =
+          text
+            .enum_for(:scan, /#{pattern}/m)
+            .map do
+              match = Regexp.last_match
+              [match.begin(0), match.end(0)]
+            end
+
+        case matches.length
+        when 0
+          raise NoMatchingContextError.new(original_text: text, diff_text: diff)
+        when 1
+          matches.first
+        else
+          raise AmbiguousMatchError.new(
+                  original_text: text,
+                  diff_text: diff,
+                )
+        end
+      end
+    end
+  end
+end

lib/utils/dns_srv.rb

@@ -19,7 +19,7 @@ def self.lookup(domain)
 
       def self.dns_srv_lookup_for_domain(domain)
         resolver = Resolv::DNS.new
-        resources = resolver.getresources(domain, Resolv::DNS::Resource::IN::SRV)
+        resolver.getresources(domain, Resolv::DNS::Resource::IN::SRV)
       end
 
       def self.select_server(resources)