llmed 0.4.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5733bac9f8a6d8c5465f487bda233c8997491d838c778b45194e3c15f9c14734
-  data.tar.gz: e606c3e377bc6d0bf75eed59dd6456773c02650e98118a0135814808195e2fb8
+  metadata.gz: c47ebb44059bae3a1ffc2d27dd064098036ebd390cb677a488761845e13d4b6b
+  data.tar.gz: 1442dec8d3c594b8610af95d7edfbdbdee8881ac00a046001cc6fd4eb9c2e68c
 SHA512:
-  metadata.gz: 3fc77a1b7b7ca6ba6c8bcb528e1ef702277588195c47e538cfa6a8432aef4ae7cb876b10537605866bfa7ea0a61ceacf1308cd52d3b5f0f2a7a4f51ef5b552ed
-  data.tar.gz: 94f66750f04e2c97d8e78125ac920c52037fd6bc5e5759cbd2e349402be599619fb5cb2dc92af0c519a0cc557333be022925abb556f09995460a0b0d936386c8
+  metadata.gz: 80a7c93eed1106305b848bae99b0fcce744c55bc933538465041e19329ed1e6fe01f398c38ec849f2ae4981ec260024d3a9ded96f1465224a0b9f60cc8924b53
+  data.tar.gz: 7c3df54bec3ee2e2f02bd7108c92004e6969bb8019ab5209bda32327cc916492ac2946948b2ce835325b93d33238292187870e68bc35bfa50feefb0b38164263

data/lib/llm.rb

@@ -56,7 +56,7 @@ class LLMed
           @logger.warn("POSSIBLE INCONSISTENCY COMPLETED TOKENS REACHED MAX TOKENS #{MAX_TOKENS}")
         end
       end
-      
+
       def llm_arguments(args)
         args
       end

data/lib/llmed/application.rb

@@ -1,6 +1,8 @@
 # Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
 # frozen_string_literal: true
 
+require 'set'
+
 class LLMed
   class Application
     attr_reader :contexts, :name, :language
@@ -29,6 +31,8 @@ class LLMed
     end
 
     def initialize(name:, language:, output_file:, block:, logger:, release:, release_dir:, output_dir:)
+      snapshot_file = Pathname.new(release_dir) + "#{output_file}.snapshot"
+
       @name = name
       @output_file = output_file
       @language = language.to_sym
@@ -39,6 +43,7 @@ class LLMed
       @release = release
       @release_dir = release_dir
       @output_dir = output_dir
+      @snapshot = Snapshot.new(snapshot_file)
     end
 
     # Example:
@@ -56,7 +61,113 @@ class LLMed
       instance_eval(&@block)
     end
 
-    def prepare
+    class Snapshot
+      attr_reader :snapshot_file
+
+      def initialize(snapshot_file)
+        @snapshot_file = snapshot_file
+        @contexts = []
+      end
+
+      def sync(default)
+        load(default)
+        dump
+      end
+
+      def refresh(contexts)
+        @contexts = contexts.map{ |ctx| [ctx.name, {'name' => ctx.name, 'message' => ctx.raw}]}.to_h
+        dump
+      end
+
+      def diff(other_contexts)
+        diffs = {}
+        other_contexts.each do |other_ctx|
+          current_ctx = @contexts[other_ctx.name]
+          result = line_diff(current_ctx['message'], other_ctx.raw)
+          # omit not changes
+          if !result.all?{|op, line| op == '=:'}
+            diffs[other_ctx.name] = result
+          end
+        end
+
+        diffs
+      end
+
+      private
+
+      def line_diff(text1, text2)
+        lines1 = text1.split("\n")
+        lines2 = text2.split("\n")
+
+        result = []
+
+        i1 = 0
+        i2 = 0
+
+        while i1 < lines1.size || i2 < lines2.size
+          line1 = lines1[i1]
+          line2 = lines2[i2]
+
+          if i1 < lines1.size && i2 < lines2.size && line1 == line2
+            result << ["=:", line1]
+            i1 += 1
+            i2 += 1
+          elsif i1 < lines1.size && (i2 >= lines2.size || !lines2[i2..-1].include?(line1))
+            result << ["-:", line1]
+            i1 += 1
+          elsif i2 < lines2.size && (i1 >= lines1.size || !lines1[i1..-1].include?(line2))
+            result << ["+:", line2]
+            i2 += 1
+          else
+            # Try to find if one of the lines matches later
+            idx1 = lines1[i1+1..-1]&.index(line2)
+            idx2 = lines2[i2+1..-1]&.index(line1)
+
+            if !idx1.nil? && (idx2.nil? || idx1 <= idx2)
+              result << ["-:", line1]
+              i1 += 1
+            elsif !idx2.nil?
+              result << ["+:", line2]
+              i2 += 1
+            else
+              # Lines differ, treat both as deleted and added
+              result << ["-:", line1]
+              result << ["+:", line2]
+              i1 += 1
+              i2 += 1
+            end
+          end
+        end
+
+        result
+      end
+
+      def load(default)
+        if File.exist?(@snapshot_file)
+          File.open(@snapshot_file, 'r') do |f|
+            @contexts = JSON.load(f.read)['contexts']
+          end
+        else
+          @contexts = default.map{ |ctx| [ctx.name, {'name' => ctx.name, 'message' => ctx.raw}]}.to_h
+        end
+      end
+
+      def dump
+        File.open(@snapshot_file, 'w') do |file|
+          file.write(JSON.dump({'contexts' => @contexts}))
+        end
+      end
+    end
+
+    def prepare_snapshot
+      raise "snapshot preparation require contexts" if @contexts.empty?
+
+      @logger.info("APPLICATION #{@name} PREPARING SNAPSHOT #{@snapshot.snapshot_file}")
+
+      @snapshot.sync(@contexts)
+    end
+
+    def prepare_release
       @logger.info("APPLICATION #{@name} COMPILING FOR #{@language} RELEASE #{@release}")
       return unless @output_file.is_a?(String)
       return unless @release
@@ -64,9 +175,7 @@ class LLMed
       output_file = Pathname.new(@output_dir) + @output_file
 
       if @release && File.exist?(output_file) && !File.exist?(release_source_code)
-        FileUtils.cp(output_file, release_source_code)
-        FileUtils.cp(output_file, release_main_source_code)
-        @logger.info("APPLICATION #{@name} RELEASE FILE #{release_source_code}")
+
       elsif @release && !File.exist?(output_file) && File.exist?(release_main_source_code)
         FileUtils.mkdir_p(File.dirname(output_file))
         FileUtils.cp(release_main_source_code, output_file)
@@ -117,14 +226,35 @@ class LLMed
       output_file(@output_dir) do |file|
         file.write(output_content)
       end
+
+      # only update snapshot if changes are made
+      if !File.exist?(release_source_code)
+        @snapshot.refresh(@contexts)
+        @logger.info("APPLICATION #{@name} SNAPSHOT REFRESHED")
+      end
+
+      output_file = Pathname.new(@output_dir) + @output_file
+      FileUtils.cp(output_file, release_source_code)
+      FileUtils.cp(output_file, release_main_source_code)
+      @logger.info("APPLICATION #{@name} RELEASE FILE #{release_source_code}")
     end
 
     def system_prompt(configuration)
+      contexts_diffs = @snapshot.diff(contexts)
+      changes_of_contexts = ''
+      if contexts_diffs.any?
+        contexts_diffs.each do |context_name, diffs|
+          changes_of_contexts += "# Context: #{context_name}\n"
+          changes_of_contexts += diffs.map { |op, line| "#{op} #{line}" }.join("\n")
+        end
+      end
+
       configuration.prompt(language: language,
                            source_code: source_code,
                            code_comment_begin: @code_comment.begin,
                            code_comment_end: @code_comment.end,
-                           update_context_digests: digests_of_context_to_update)
+                           update_context_digests: digests_of_context_to_update,
+                           changes_of_contexts: changes_of_contexts)
     end
 
     def rebuild?
@@ -134,9 +264,8 @@ class LLMed
       !digests_of_context_to_update.tap do |digests|
         digests.each do |digest|
           context_by_digest = release_contexts.invert
-
           if context_by_digest[digest].nil?
-            @logger.info("APPLICATION #{@name} ADDING CONTEXT #{user_contexts.invert[digest]}")
+            @logger.info("APPLICATION #{@name} ADDING CONTEXT #{user_contexts.by_digest(digest).name}")
           else
             @logger.info("APPLICATION #{@name} REBUILDING CONTEXT #{context_by_digest[digest]}")
           end
@@ -188,8 +317,8 @@ class LLMed
           end
 
           # added new context
-          if !release_context.digest? && !user_contexts[ctx.name].nil?
-            update_context_digest << user_contexts[ctx.name]
+          if !release_context.digest? && !user_contexts.by_name(ctx.name).nil?
+            update_context_digest << user_contexts.by_name(ctx.name).digest
             next
           elsif release_context.digest? && !ctx.same_digest?(release_context.digest)
             update_rest = true
@@ -214,9 +343,7 @@ class LLMed
     end
 
     def user_contexts
-      @contexts.map do |ctx|
-        [ctx.name, ctx.digest]
-      end.to_h
+      UserContexts.new(@contexts)
     end
 
     def release_contexts

data/lib/llmed/configuration.rb

@@ -7,36 +7,50 @@ class LLMed
       @logger = logger
       # Manual tested, pass 5 times execution
       @prompt = LLMed::LLM::Template.build(template: "
-You are a software developer with knowledge only of the programming language {language}, following the SOLID principles strictly, you always use only imperative and functional programming, design highly isolated components.
-Don't make any assumptions/expectations or wait for implementations, always implement the necessary.
-The contexts are declarations of how the source code will be (not a file) ensure to follow this always.
-The contexts are connected as a flat linked list.
-All the contexts represent one source code.
-There is always a one-to-one correspondence between context and source code.
-Always include the properly escaped comment: LLMED-COMPILED.
+        You are a software developer specialized in the programming language {language}. Follow SOLID principles strictly. Use only imperative and functional programming styles and design highly isolated components. You have full access to the standard library and third-party packages only if explicitly allowed.
+        Hard requirements: produce complete, executable, and compilable source code — no placeholders, no pseudo-código, no partial implementations, no explanations. If anything below cannot be satisfied, produce a runtime error implementation that clearly fails fast.
 
-You must only modify the following source code:
-```
-{source_code}
-```
+        The input contexts are functional sections of a single large source file (not separate files). Contexts are linked as a flat linked list. There must be a one-to-one correspondence between each context and the code generated for that context. You must only generate source code for the context(s) whose digest is listed in {update_context_digests}.
 
-Only generate source code of the context who digest belongs to {update_context_digests}.
+        Always include the escaped literal comment token LLMED-COMPILED somewhere in the generated code.
 
-Wrap with comment every code that belongs to the indicated context, example in {language}:
-{code_comment_begin}<llmed-code context='context name' digest='....' after='digest next context'>{code_comment_end}
-...
-{code_comment_begin}</llmed-code>{code_comment_end}
+        You must only modify the following source code that is provided between the code fences:
+        ```{language}
+        {source_code}
+        ```
 
-!!Your response must contain only the generated source code, with no additional text or comments, and you must ensure that runs correctly on the first attempt.
-", input_variables: %w[language source_code code_comment_begin code_comment_end update_context_digests])
+        Strict formatting for context wrappers: wrap every context implementation with the exact comment markers below. Use the literal placeholders {code_comment_begin} and {code_comment_end} replaced with the exact comment open/close strings for the target language. Example wrapper (replace placeholders when running the prompt):
+        {code_comment_begin}<llmed-code context='context name' digest='CURRENT_DIGEST' link-digest='NEXT_DIGEST' after='NEXT_DIGEST'>{code_comment_end}
+        ... COMPLETE, RUNNABLE implementation for that context ...
+        {code_comment_begin}</llmed-code>{code_comment_end}
+
+        Behavioral rules (must be obeyed):
+        1. No comments-only outputs. If your natural answer would be comments, instead implement executable code that performs the described behavior. Do not output explanatory text outside code blocks — output only source code for the indicated contexts.
+        2. All functions/methods must have bodies implementing the intended behavior. If external information is missing, implement a reasonable, deterministic default rather than leaving a stub.
+        3. Fail-fast fallback: if the requested context genuinely cannot be implemented, include a clear runtime failure function implementation_impossible() that raises/prints a single machine-readable error (e.g. throws an exception with message IMPLEMENTATION-IMPOSSIBLE) and still compiles.
+        4. One-to-one mapping: produce exactly one code block per digest requested. Do not add unrelated helper contexts unless they are wrapped and linked to an indicated digest; if helpers are necessary, include them inside the same context wrapper.
+        5. Include the literal LLMED-COMPILED comment somewhere inside the code.
+        6. Do not output any text outside the source code. The assistant response must be only source code for the requested context(s).
+
+        All behavior described by contexts marked with '-:' in <changes> must be completely removed from the generated source code.
+        Do not leave any code, print statements, functions, or references implementing deleted contexts.
+        Each context listed in '+:' or '=:' must be implemented exactly according to its description.
+        Behavior from removed contexts must not appear anywhere in the output, even indirectly.
+        <changes>
+        {changes_of_contexts}
+        </changes>
+
+        Output requirement: your response must contain only the generated source code for the indicated context(s), with the required wrapper comments and the test harness; nothing else.
+", input_variables: %w[language source_code code_comment_begin code_comment_end update_context_digests changes_of_contexts])
     end
 
-    def prompt(language:, source_code:, code_comment_begin:, code_comment_end:, update_context_digests: [])
+    def prompt(language:, source_code:, code_comment_begin:, code_comment_end:, update_context_digests: [], changes_of_contexts: '')
       @prompt.format(language: language,
                      source_code: source_code,
                      code_comment_begin: code_comment_begin,
                      code_comment_end: code_comment_end,
-                     update_context_digests: update_context_digests.join(','))
+                     update_context_digests: update_context_digests.join(','),
+                     changes_of_contexts: changes_of_contexts)
     end
 
     # Change the default prompt, input variables: language, source_code

data/lib/llmed/context.rb

@@ -1,14 +1,53 @@
 # Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
 # frozen_string_literal: true
+
 require 'erb'
 
 class LLMed
+  class UserContexts
+    def initialize(contexts)
+      @contexts = contexts.dup
+    end
+
+    def each(&block)
+      @contexts.each(&block)
+    end
+
+    def empty?
+      @contexts.empty?
+    end
+
+    def [](idx)
+      @contexts[idx]
+    end
+
+    def each_with_next(&block)
+      @contexts.each_with_index do |ctx, idx|
+        next_ctx = @contexts[idx + 1]
+        block.call(ctx, next_ctx)
+      end
+    end
+
+    def count
+      @contexts.count
+    end
+
+    def by_name(name)
+      @contexts.find { |ctx| ctx.name == name }
+    end
+
+    def by_digest(digest)
+      @contexts.find { |ctx| ctx.same_digest?(digest) }
+    end
+  end
+
   class Context
     attr_reader :name
 
-    def initialize(name:, options: {})
+    def initialize(name:, digest: nil, options: {})
       @name = name
       @skip = options[:skip] || false
+      @fixed_digest = digest || nil
       @release_dir = options[:release_dir]
     end
 
@@ -21,13 +60,17 @@ class LLMed
     end
 
     def digest
-      Digest::SHA256.hexdigest "#{@name}.#{@message}"
+      @fixed_digest || Digest::SHA256.hexdigest("#{@name}.#{@message}")
     end
 
     def message
       "# Context: \"#{@name}\" Digest: #{digest}\n\n#{@message}"
     end
 
+    def raw
+      @message
+    end
+
     def llm(message)
       @message = message
     end

data/lib/llmed/release.rb

@@ -5,7 +5,8 @@ class LLMed
   class Release
     ContextCode = Struct.new(:name, :digest, :code, :after) do
       def to_llmed_code(code_comment)
-        "#{code_comment.begin}<llmed-code context='#{name}' digest='#{digest}' after='#{after}'>#{code_comment.end}#{code}#{code_comment.begin}</llmed-code>#{code_comment.end}"
+        close_newline = "\n" if code.strip.empty?
+        "#{code_comment.begin}<llmed-code context='#{name}' digest='#{digest}' after='#{after}'>#{code_comment.end}#{code}#{close_newline}#{code_comment.begin}</llmed-code>#{code_comment.end}"
       end
 
       def digest?
@@ -99,42 +100,64 @@ class LLMed
 
       # fix user contexts digest
       contexts.each do |ctx|
-        user_context_digest = user_contexts[ctx.name]
-        ctx.digest = user_context_digest unless user_context_digest.nil?
+        user_context = user_contexts.by_name(ctx.name)
+        ctx.digest = user_context.digest unless user_context.nil?
       end
 
       # insertions missed user contexts
-      user_contexts.each do |name, digest|
-        next if contexts.any? { |ctx| ctx.name == name }
-        code = release.context_by(name).code
-        new_ctx = ContextCode.new(name, digest, code, '')
+      user_contexts.each do |user_context|
+        next if contexts.any? { |ctx| ctx.name == user_context.name }
+
+        code = release.context_by(user_context.name).code
+        new_ctx = ContextCode.new(user_context.name, user_context.digest, code, '')
         contexts.prepend(new_ctx)
         @changes << [:added, new_ctx]
       end
 
-      contexts_sorted = []
-      # prioritize user order
-      user_contexts.each do |name, _digest|
-        contexts.each do |ctx|
-          if ctx.name == name
-            contexts_sorted << ctx
-            break
-          end
-        end
+      # code context must have the same order as user contexts
+      if user_contexts.empty?
+        contexts_sorted = contexts
+      else
+        user_contexts_iter = user_contexts.dup
+        contexts_iter = contexts.dup
+        order_digests = rewire_code_contexts(contexts_iter, user_contexts_iter)
+
+        contexts_on_digests = order_digests.map { |digest| contexts_iter.find { |ctx| ctx.digest == digest } }
+        contexts_missing_digests = contexts_iter.select { |ctx| !order_digests.include?(ctx.digest) }
+        contexts_sorted = contexts_on_digests + contexts_missing_digests
       end
 
-      @contexts = contexts_sorted.sort {|a,b|
-        if a.digest == b.after
+      # Sort contexts so that the latest digest (the one whose 'after' is empty) comes last
+      @contexts = contexts_sorted.sort do |a, b|
+        if a.after.empty? && !b.after.empty?
           1
+        elsif !a.after.empty? && b.after.empty?
+          -1
         else
           0
         end
-      }
+      end
+
       self
     end
 
     private
 
+    def rewire_code_contexts(code_contexts, user_contexts)
+      order_digests = []
+      user_contexts.each_with_next do |user_context, next_user_context|
+        ctx = code_contexts.find { |ctx| ctx.name == user_context.name }
+        if ctx
+          ctx.digest = user_context.digest
+          order_digests << user_context.digest
+          ctx.after = '' if user_contexts.count > 1
+          ctx.after = next_user_context.digest if next_user_context
+        end
+      end
+
+      order_digests
+    end
+
     def initialize(origin, code_comment)
       @origin = origin
       @content = ''
@@ -142,7 +165,7 @@ class LLMed
       @code_comment = code_comment
       @contexts = []
 
-      @origin.scan(%r{<llmed-code context='(.+?)' digest='(.+?)'\s*(after='.*?')?>#{@code_comment.end}(.+?)#{@code_comment.begin}+\s*<?/?llmed-code}im).each do |match|
+      @origin.scan(%r{<llmed-code context='(.+?)' digest='(.+?)'(?:\s+[^>]*?)?(after='.*?')?>#{@code_comment.end}(.+?)#{@code_comment.begin}+\s*<?/?llmed-code}im).each do |match|
         name, digest, after_block, code = match
         after = if after_block.nil?
                   ''

data/lib/llmed.rb

@@ -66,10 +66,12 @@ class LLMed
   def compile_application(app)
     app.notify('COMPILE START')
 
-    app.prepare
+    app.prepare_release
     app.evaluate
+    app.prepare_snapshot
     if app.rebuild?
       llm = @configuration.llm
+
       messages = [LLMed::LLM::Message::System.new(app.system_prompt(@configuration))]
       app.contexts.each do |ctx|
         next if ctx.skip?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llmed
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Jovany Leandro G.C