llmed 0.4.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48b4c352f5fd54aa841fe411fd7f5025f1c98f40b8a287589aeb46ad213def68
-  data.tar.gz: c53e2efec6164261d6985f9297b101b363d1e9da432123ddeac1e369a7f045d2
+  metadata.gz: c47ebb44059bae3a1ffc2d27dd064098036ebd390cb677a488761845e13d4b6b
+  data.tar.gz: 1442dec8d3c594b8610af95d7edfbdbdee8881ac00a046001cc6fd4eb9c2e68c
 SHA512:
-  metadata.gz: 1b228350f691be1762449160bafde3f3c3eba0cc180fd918207f09a855939d0ec784f53861f72304a61d6c4c2adfd525d4e29cf868c1bc1d1dbfb9aa0ff7ad15
-  data.tar.gz: 7eea2cc52879f589c1b4612409c7c0923aa88135bcb705817966fb4827d449032cc528891140e37a088ff0145fe792982f068162b716785d41e5c3ac736a8bfd
+  metadata.gz: 80a7c93eed1106305b848bae99b0fcce744c55bc933538465041e19329ed1e6fe01f398c38ec849f2ae4981ec260024d3a9ded96f1465224a0b9f60cc8924b53
+  data.tar.gz: 7c3df54bec3ee2e2f02bd7108c92004e6969bb8019ab5209bda32327cc916492ac2946948b2ce835325b93d33238292187870e68bc35bfa50feefb0b38164263

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?

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.
-Always exists 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:
-```{language}
-{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='here context name' digest='....' link-digest='next digest' after='here same value of attribute link-digest'>{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 all indicated contexts, 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

@@ -67,6 +67,10 @@ class LLMed
       "# Context: \"#{@name}\" Digest: #{digest}\n\n#{@message}"
     end
 
+    def raw
+      @message
+    end
+
     def llm(message)
       @message = message
     end

data/lib/llmed/release.rb

@@ -120,13 +120,19 @@ class LLMed
       else
         user_contexts_iter = user_contexts.dup
         contexts_iter = contexts.dup
-        rewire_code_contexts(contexts_iter, user_contexts_iter)
-        contexts_sorted = contexts_iter
+        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
 
+      # Sort contexts so that the latest digest (the one whose 'after' is empty) comes last
       @contexts = contexts_sorted.sort do |a, b|
-        if a.digest == b.after
+        if a.after.empty? && !b.after.empty?
           1
+        elsif !a.after.empty? && b.after.empty?
+          -1
         else
           0
         end
@@ -138,13 +144,18 @@ class LLMed
     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.digest == user_context.digest }
+        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)

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.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Jovany Leandro G.C