llmed 0.2.11 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4479a97e9e36926e4f7af8677a06268824c84563e441d2b14c862c8c07f648f1
-  data.tar.gz: daad9497943bb738f429fca0cb67a18858c9557657090af5878e803863c63fee
+  metadata.gz: 0a90029f77fd962cbec07534801ea73ed440c9e1f2e2d87a1d62827af44baf3e
+  data.tar.gz: 1e4d31b1dae583581d8fc9716419490a2901180862e03618cd09f189945a2384
 SHA512:
-  metadata.gz: d765dabbd6b724f8d37d21b36f8dcf7bf9a75b3ba73e3c635701f6ce5d716e6977447b8584291bb79ec97074519118cf3746a9be865fe4572f4d71387ba6295e
-  data.tar.gz: 0611b8c5c945ab1ec79252275646b11f8699ea22edfee23c5ba5ba09166732676fa4f45832d43035896377e0ccaaece993d32e2cccdbf2387c94abd36ddbd280
+  metadata.gz: 7d39d323d49f5952335372842244d532cf31129cf3bda5ebd19e2a4abe46510f6479927036a523aad50ec1373808311290f41a1da43940e4ab2b30bfbd16db53
+  data.tar.gz: e9b52e1af2fceca9d6ae84cc7882b9a34ca281f7558546e959f6cdac9ff2a95e93262e211c086151194613392620795cf5b781473d60db6f20a44923f5660199

data/README.md

@@ -16,7 +16,7 @@ In classic terms the LLM is the Compiler, Source Code is the Binary, the Program
 ```ruby
 set_llm provider: :openai, api_key: ENV['OPENAI_API_KEY'], model: 'gpt-4o-mini'
 
-application "hola mundo ruby", language: :ruby, output_file: "holamundo-ruby.ollmed" do
+application "hola mundo ruby", release: nil, language: :ruby, output_file: "holamundo-ruby.ollmed" do
   # More stable context: if this changes, all subsequent context will be recompiled.
   context "variables" do
     <<-LLM

data/lib/llmed/application.rb

@@ -39,11 +39,16 @@ class LLMed
       return unless @release
 
       output_file = Pathname.new(@output_dir) + @output_file
-      if @release && !File.exist?(release_source_code)
+
+      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.cp(release_main_source_code, output_file)
+        return
       end
+
       @logger.info("APPLICATION #{@name} INPUT RELEASE FILE #{release_main_source_code}")
     end
 
@@ -70,34 +75,18 @@ class LLMed
       output_content = output
 
       if @release && File.exist?(release_source_code) && !release_contexts.empty?
-        release_source_code_content = File.read(release_source_code)
-        output_contexts = output.scan(%r{<llmed-code context='(.+?)' digest='(.+?)'>(.+?)</llmed-code>}im)
-
-        output_contexts.each do |match|
-          name, digest, new_code = match
-          new_digest = digest
-          @contexts.each do |ctx|
-            if ctx.name == name
-              new_digest = ctx.digest
-              break
-            end
-          end
-
-          release_source_code_content = release_source_code_content.sub(%r{(.*?)(<llmed-code context='#{name}' digest='.*?'>)(.+?)(</llmed-code>)(.*?)}m) do
-            "#{::Regexp.last_match(1)}<llmed-code context='#{name}' digest='#{new_digest}'>#{new_code}#{::Regexp.last_match(4)}#{::Regexp.last_match(5)}"
-          end
-
-          if release_contexts[name].nil?
-            @logger.info("APPLICATION #{@name} ADDING NEW CONTEXT #{name}")
-            release_source_code_content += "<llmed-code context='#{name}' digest='#{new_digest}'>
-#{new_code}
-#{code_comment}</llmed-code>"
-          else
-            @logger.info("APPLICATION #{@name} PATCHING CONTEXT #{name} \n\tFROM #{digest}\n\tTO DIGEST #{new_digest}")
+        output_release = Release.load(File.read(release_source_code), code_comment)
+        input_release = Release.load(output, code_comment)
+        output_content = output_release.merge!(input_release).content
+        output_release.changes do |change|
+          action, ctx = change
+          case action
+          when :added
+            @logger.info("APPLICATION #{@name} PATCH ADDING NEW CONTEXT #{ctx.name}")
+          when :updated
+            @logger.info("APPLICATION #{@name} PATCH UPDATING CONTEXT #{ctx.name} TO DIGEST #{ctx.digest}")
           end
         end
-
-        output_content = release_source_code_content
       end
 
       output_file(@output_dir) do |file|
@@ -154,38 +143,37 @@ class LLMed
     private
 
     def code_comment
-      { ruby: '#' }.fetch(@language.to_sym)
+      { ruby: '#', node: '//' }.fetch(@language.to_sym)
     end
 
     def digests_of_context_to_update
       update_context_digest = []
 
-      unless release_contexts.empty?
+      unless release_instance.empty?
         # rebuild context from top to down
         # we are expecting:
         # - top the most stable concepts
         # - buttom the most inestable concepts
         update_rest = false
         @contexts.each do |ctx|
-          release_context_digest = release_contexts[ctx.name]
+          release_context = release_instance.context_by(ctx.name)
+
+          if update_rest
+            update_context_digest << release_context.digest
+            next
+          end
 
           # added new context
-          if release_context_digest.nil? and !user_contexts[ctx.name].nil?
+          if !release_context.digest? && !user_contexts[ctx.name].nil?
             update_context_digest << user_contexts[ctx.name]
             next
-          elsif release_context_digest.nil?
+          elsif release_context.digest? && !ctx.same_digest?(release_context.digest)
+            update_rest = true
+            update_context_digest << release_context.digest
+          elsif release_context.digest?
             # maybe the context is not connected to the source code
             next
           end
-
-          if update_rest
-            update_context_digest << release_context_digest
-            next
-          end
-          next if ctx.same_digest?(release_context_digest)
-
-          update_rest = true
-          update_context_digest << release_context_digest
         end
       end
 
@@ -211,7 +199,15 @@ class LLMed
 
       return {} unless File.exist?(release_source_code)
 
-      File.read(release_source_code).scan(/context='(.+)' digest='(.+)'/).to_h
+      File.read(release_source_code).scan(/context='(.+?)' digest='(.+?)'/).to_h
+    end
+
+    def release_instance
+      if File.exist?(release_source_code)
+        Release.load(File.read(release_source_code), code_comment)
+      else
+        Release.empty
+      end
     end
   end
 end

data/lib/llmed/configuration.rb

@@ -7,6 +7,7 @@ class LLMed
       @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, and design highly isolated components.
 The contexts are declarations of how the source code will be, ensure to follow this always.
+The contexts are connected as a linked list.
 Your response must contain only the generated source code, with no additional text.
 All source code must be written in a single file, and you must ensure it runs correctly on the first attempt.
 There is always a one-to-one correspondence between context and source code.
@@ -18,7 +19,7 @@ You must only modify the following source code:
 Only generate source code of the context who digest belongs to {update_context_digests} or a is a new context.
 
 Wrap with comment every code that belongs to the indicated context, example in ruby:
-#<llmed-code context='context name' digest='....'>
+#<llmed-code context='context name' digest='....' after='digest next context'>
 ...
 #</llmed-code>
 ", input_variables: %w[language source_code update_context_digests])

data/lib/llmed/release.rb

@@ -0,0 +1,119 @@
+# Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
+# frozen_string_literal: true
+
+class LLMed
+  class Release
+    ContextCode = Struct.new(:name, :digest, :code, :after) do
+      def to_llmed_code(code_comment)
+        "#{code_comment}<llmed-code context='#{name}' digest='#{digest}' after='#{after}'>#{code}#{code_comment}</llmed-code>"
+      end
+
+      def digest?
+        return false if digest.nil?
+        return false if digest.empty?
+
+        true
+      end
+    end
+
+    def self.load(origin, code_comment)
+      new(origin, code_comment)
+    end
+
+    def self.empty
+      new('', '')
+    end
+
+    def content
+      out = ''
+
+      @contexts.each do |ctx|
+        out += ctx.to_llmed_code(@code_comment)
+        out += "\n"
+      end
+
+      out.strip!
+
+      out
+    end
+
+    def empty?
+      @origin.empty?
+    end
+
+    attr_reader :contexts
+
+    def changes
+      changes = @changes.dup
+      @changes.clear
+      changes
+    end
+
+    def context_by(name)
+      @contexts.each do |ctx|
+        return ctx if ctx.name == name
+      end
+
+      ContextCode.new('', '', '', '')
+    end
+
+    def has_context?(name)
+      context_by(name).digest?
+    end
+
+    def merge!(release)
+      contexts = []
+
+      # updates
+      @contexts.each do |ctx|
+        new_ctx = release.context_by(ctx.name)
+        if release.has_context?(ctx.name)
+          contexts << new_ctx
+          @changes << [:updated, new_ctx]
+        else
+          contexts << ctx
+        end
+      end
+
+      # insertions
+      insertions = []
+      release.contexts.each do |new_ctx|
+        next if has_context?(new_ctx.name)
+
+        contexts.each_with_index do |current_ctx, idx|
+          if current_ctx.digest == new_ctx.after
+            insertions << [idx, current_ctx.digest, new_ctx]
+            break
+          end
+        end
+      end
+
+      insertions.each do |action|
+        idx, old_digest, new_ctx = action
+        contexts.each do |ctx|
+          ctx.after = new_ctx.digest if ctx.after == old_digest
+        end
+        contexts.insert(idx, new_ctx)
+        @changes << [:added, new_ctx]
+      end
+
+      @contexts = contexts
+      self
+    end
+
+    private
+
+    def initialize(origin, code_comment)
+      @origin = origin
+      @content = ''
+      @changes = []
+      @code_comment = code_comment
+      @contexts = []
+
+      @origin.scan(%r{<llmed-code context='(.+?)' digest='(.+?)' after='(.*?)'>(.+?)#{@code_comment}+\s*</llmed-code>}im).each do |match|
+        name, digest, after, code = match
+        @contexts << ContextCode.new(name, digest, code, after)
+      end
+    end
+  end
+end

data/lib/llmed/release.rb~

@@ -0,0 +1,31 @@
+# Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
+# frozen_string_literal: true
+
+class LLMed
+  class Release
+
+    ContextCode = Struct.new(:name, :digest, :code)
+
+    def read(path)
+      @origin = File.read(path)
+      @changes = []
+    end
+
+    def contexts
+      contexts = []
+      @origin.scan(%r{<llmed-code context='(.+?)' digest='(.+?)'>(.+?)</llmed-code>}im).each do |match|
+        name, digest, code = match
+        contexts << ContextCode.new(name, digest, code)
+      end
+    end
+
+    def merge(release)
+      content = ""
+      release.contexts.each do |ctx|
+        content = content.sub(%r{(.*?)(<llmed-code context='#{ctx.name}' digest='.*?'>)(.+?)(</llmed-code>)(.*?)}m) do
+          "#{::Regexp.last_match(1)}<llmed-code context='#{ctx.name}' digest='#{ctx.digest}'>#{ctx.code}#{::Regexp.last_match(4)}#{::Regexp.last_match(5)}"
+        end
+      end
+    end
+  end
+end

data/lib/llmed.rb

@@ -83,4 +83,5 @@ end
 require_relative 'llm'
 require_relative 'llmed/configuration'
 require_relative 'llmed/context'
+require_relative 'llmed/release'
 require_relative 'llmed/application'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llmed
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.3.1
 platform: ruby
 authors:
 - Jovany Leandro G.C
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-08 00:00:00.000000000 Z
+date: 2025-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: langchainrb
@@ -102,6 +102,8 @@ files:
 - lib/llmed/configuration.rb~
 - lib/llmed/context.rb
 - lib/llmed/context.rb~
+- lib/llmed/release.rb
+- lib/llmed/release.rb~
 homepage: https://github.com/bit4bit/llmed
 licenses:
 - GPL-3.0