llmed 0.4.4 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48b4c352f5fd54aa841fe411fd7f5025f1c98f40b8a287589aeb46ad213def68
-  data.tar.gz: c53e2efec6164261d6985f9297b101b363d1e9da432123ddeac1e369a7f045d2
+  metadata.gz: 87fc5d9fa3991a03d2055b3da5f8ec1203af3e987c6ff711353a3d617f3a5add
+  data.tar.gz: e4b535f0353bc4c575d84cb0648a7d8d38bc62b3d585f87f9eb4fde18b36d835
 SHA512:
-  metadata.gz: 1b228350f691be1762449160bafde3f3c3eba0cc180fd918207f09a855939d0ec784f53861f72304a61d6c4c2adfd525d4e29cf868c1bc1d1dbfb9aa0ff7ad15
-  data.tar.gz: 7eea2cc52879f589c1b4612409c7c0923aa88135bcb705817966fb4827d449032cc528891140e37a088ff0145fe792982f068162b716785d41e5c3ac736a8bfd
+  metadata.gz: bf87dca2cc6babed42917e624511032e5f9747679244199a8340f6f2cbeca95bfa9a3fbf839a5ede32051138f7ae18affe154fe20177a9ae1ca20b03052e6cd7
+  data.tar.gz: 6243e74686ffc0aabfe27310216fab81a1dd5a6a7ea987da095b579eb6ba23323e6f68f26b948f4899d3b52c7f01ecf6ceb3ada1eaa8512c26b897c06eccf89a

data/README.md

@@ -17,6 +17,8 @@ In classic terms the LLM is the Compiler, Source Code is the Binary, the Program
 set_llm provider: :like_openai, api_key: ENV['TOGETHERAI_API_KEY'], model: 'Qwen/Qwen2.5-Coder-32B-Instruct', options: {uri_base: 'https://api.together.xyz/v1'}
 
 application "MINI COUNTER", release: nil, language: :node, output_file: "minicounter.ollmed" do
+  achieve('coding guidelines') { 'Add top comment with a technical summary of the implementation' }
+  
   # Most stable context: if this changes, all subsequent context will be recompiled.
   context "dependencies" do
     <<-LLM
@@ -66,12 +68,43 @@ add CORS endpoints.
 ```
 then compile using command `llmed.literate`.
 
+## HOWTO Programing using LLMED
+
+Programming with LLMED involves breaking down the problem into smaller contexts, where each context must be connected to the next, creating a chain of contexts that expresses the final solution (program/application/software). The final code will map each context to a block of code (module, function, or statements—this is determined by the LLM), so any changes to a context will be reflected in the source code. This is important to keep in mind. For example, it is not the same to write:
+
+```
+# Dependencies
+...
+# Application
+...
+```
+
+as
+
+```
+# Application
+...
+# Dependencies
+...
+```
+
+!!The LLM can do crazy things when trying to create working source code for that.
+
+At the top of the document, write the most stable concepts (the contexts that don't change frequently), going down to the most unstable (the contexts that are expected to change more frequently) concepts. The purpose of these two things:
+
+1. The map between context and code block.
+2. Rebuilding of contexts: LLMed assumes that there is a unique chain, so it will recompile from the changed context to the end of the chain.
+
+So, programming with LLMed means being aware of the technology (programming language, libraries, software architecture, tools, etc.). LLMed's job is to provide a free-form natural language programming compiler.
+
+
 ## Programming flow
 
-* Cycle
+1. Cycle
   * Edit application.
   * Once you agree with the current state of the application, increase the value of the `release` attribute
-* Commit the release file (.release) and the source code (.llmed).
+2. Commit the release file (.release) and the source code (.llmed) and the snapshot (.snapshot).
+3. Go to 1.
 
 # Usage
 

data/lib/#llm.rb#

@@ -0,0 +1,114 @@
+require 'openai'
+require 'langchain'
+
+Langchain.logger.level = Logger::ERROR
+
+class LLMed
+  module LLM
+    module Message
+      System = Struct.new(:content)
+      User = Struct.new(:content)
+    end
+
+    module Template
+      def self.build(template:, input_variables:)
+        Langchain::Prompt::PromptTemplate.new(template: template, input_variables: input_variables)
+      end
+    end
+
+    Response = Struct.new(:provider, :model, :source_code, :duration_seconds, :total_tokens, keyword_init: true)
+
+    class OpenAI
+
+      DEFAULT_URI_BASE = "https://api.openai.com/".freeze
+      MAX_TOKENS = 8192
+
+      def initialize(**args)
+        @logger = args.delete(:logger)
+        @llm = Langchain::LLM::OpenAI.new(**llm_arguments(args))
+      end
+
+      def chat(messages: [])
+        messages = messages.map do |m|
+          case messages
+          when Message::System
+            { role: 'system', content: m.content }
+          when Message::User
+            { role: 'user', content: m.content }
+          end
+        end
+        messages.e
+        start = Time.now
+        llm_response = @llm.chat(messages: messages, max_tokens: MAX_TOKENS)
+        warn_token_limits(llm_response)
+
+        stop = Time.now
+        Response.new({ provider: provider,
+                       model: @llm.chat_parameters[:model],
+                       duration_seconds: stop.to_i - start.to_i,
+                       source_code: source_code(llm_response.chat_completion),
+                       total_tokens: llm_response.total_tokens })
+      end
+
+      private
+      def warn_token_limits(llm_response)
+        if llm_response.completion_tokens >= MAX_TOKENS
+          @logger.warn("POSSIBLE INCONSISTENCY COMPLETED TOKENS REACHED MAX TOKENS #{MAX_TOKENS}")
+        end
+      end
+
+      def llm_arguments(args)
+        args
+      end
+
+      def provider
+        :openai
+      end
+
+      def source_code(content)
+        content.gsub('```', '').sub(/^(node(js)?|javascript|ruby|python(\d*)|elixir|bash|html|go|c(pp)?)([ \n])/, '')
+      end
+    end
+
+    class Anthropic < OpenAI
+      private
+
+      def llm_arguments(args)
+        @logger = args.delete(:logger)
+        args.merge({ llm_options: { uri_base: 'https://api.anthropic.com/v1/' } })
+      end
+
+      def provider
+        :anthropic
+      end
+    end
+
+    class LikeOpenAI < OpenAI
+      private
+
+      def llm_arguments(args)
+        args
+      end
+
+      def provider
+        :like_openai
+      end
+    end
+
+    class Test
+      def initialize
+        @output = ''
+      end
+
+      def chat(messages: [])
+        @output = messages.map { |m| m[:content] }.join("\n")
+
+        Response.new({ provider: :test,
+                       model: 'test',
+                       duration_seconds: 0,
+                       source_code: @output,
+                       total_tokens: 0 })
+      end
+    end
+  end
+end

data/lib/llm.rb~

@@ -0,0 +1,114 @@
+require 'openai'
+require 'langchain'
+
+Langchain.logger.level = Logger::ERROR
+
+class LLMed
+  module LLM
+    module Message
+      System = Struct.new(:content)
+      User = Struct.new(:content)
+    end
+
+    module Template
+      def self.build(template:, input_variables:)
+        Langchain::Prompt::PromptTemplate.new(template: template, input_variables: input_variables)
+      end
+    end
+
+    Response = Struct.new(:provider, :model, :source_code, :duration_seconds, :total_tokens, keyword_init: true)
+
+    class OpenAI
+
+      DEFAULT_URI_BASE = "https://api.openai.com/".freeze
+      MAX_TOKENS = 8192
+
+      def initialize(**args)
+        @logger = args.delete(:logger)
+        @llm = Langchain::LLM::OpenAI.new(**llm_arguments(args))
+      end
+
+      def chat(messages: [])
+        messages = messages.map do |m|
+          case m
+          when Message::System
+            { role: 'system', content: m.content }
+          when Message::User
+            { role: 'user', content: m.content }
+          end
+        end
+
+        start = Time.now
+        llm_response = @llm.chat(messages: messages, max_tokens: MAX_TOKENS)
+        warn_token_limits(llm_response)
+
+        stop = Time.now
+        Response.new({ provider: provider,
+                       model: @llm.chat_parameters[:model],
+                       duration_seconds: stop.to_i - start.to_i,
+                       source_code: source_code(llm_response.chat_completion),
+                       total_tokens: llm_response.total_tokens })
+      end
+
+      private
+      def warn_token_limits(llm_response)
+        if llm_response.completion_tokens >= MAX_TOKENS
+          @logger.warn("POSSIBLE INCONSISTENCY COMPLETED TOKENS REACHED MAX TOKENS #{MAX_TOKENS}")
+        end
+      end
+
+      def llm_arguments(args)
+        args
+      end
+
+      def provider
+        :openai
+      end
+
+      def source_code(content)
+        content.gsub('```', '').sub(/^(node(js)?|javascript|ruby|python(\d*)|elixir|bash|html|go|c(pp)?)([ \n])/, '')
+      end
+    end
+
+    class Anthropic < OpenAI
+      private
+
+      def llm_arguments(args)
+        @logger = args.delete(:logger)
+        args.merge({ llm_options: { uri_base: 'https://api.anthropic.com/v1/' } })
+      end
+
+      def provider
+        :anthropic
+      end
+    end
+
+    class LikeOpenAI < OpenAI
+      private
+
+      def llm_arguments(args)
+        args
+      end
+
+      def provider
+        :like_openai
+      end
+    end
+
+    class Test
+      def initialize
+        @output = ''
+      end
+
+      def chat(messages: [])
+        @output = messages.map { |m| m[:content] }.join("\n")
+
+        Response.new({ provider: :test,
+                       model: 'test',
+                       duration_seconds: 0,
+                       source_code: @output,
+                       total_tokens: 0 })
+      end
+    end
+  end
+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,16 +31,20 @@ 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
       @code_comment = CodeComment.new(language)
       @block = block
       @contexts = []
+      @goals = []
       @logger = logger
       @release = release
       @release_dir = release_dir
       @output_dir = output_dir
+      @snapshot = Snapshot.new(snapshot_file)
     end
 
     # Example:
@@ -52,11 +58,127 @@ class LLMed
       @contexts << ctx
     end
 
+    def achieve(name, **opts, &block)
+      opts[:release_dir] = @release_dir
+      goal = Goal.new(name: name, options: opts)
+      output = goal.instance_eval(&block)
+      goal.llm(output) unless goal.message?
+
+      @goals << goal
+    end
+
     def evaluate
       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 = if current_ctx.nil?
+                     other_ctx.raw.split("\n").map { |line| ["+:", line] }
+                   else
+                     line_diff(current_ctx['message'], other_ctx.raw)
+                   end
+          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
+      @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 +186,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)
@@ -96,6 +216,7 @@ class LLMed
     end
 
     def patch_or_create(output)
+
       output_content = output
 
       if @release && File.exist?(release_source_code) && !release_contexts.empty?
@@ -117,14 +238,37 @@ 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
+
+      return unless @output_file.is_a?(String)
+      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,
+                           goals: goals)
     end
 
     def rebuild?
@@ -169,6 +313,10 @@ class LLMed
 
     private
 
+    def goals
+      @goals.map(&:message).join("\n")
+    end
+
     def digests_of_context_to_update
       update_context_digest = []
 

data/lib/llmed/configuration.rb

@@ -7,36 +7,67 @@ 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 must only modify the following source code:
-```{language}
-{source_code}
-```
-
-Only generate source code of the context who digest belongs to {update_context_digests}.
-
-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}
-
-!!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])
+        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.
+
+        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}.
+
+        Always include the escaped literal comment token LLMED-COMPILED somewhere in the generated code.
+
+        You must only modify the following source code that is provided between the code fences:
+        ```{language}
+        {source_code}
+        ```
+
+        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) also a technical description with the reasons 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).
+        7. Absolute goal precedence: Before generating code, always merge the goals with the context. If any context conflicts with a goal, the goal must override the context's intended purpose, not its implementation details.
+        8. All user-facing strings, messages, and output must comply with the goals. This overrides literal instructions in context descriptions if there is a conflict.
+        9. Step-by-step plan to follow:
+          a. Read goals and extract all global rules (e.g., language, style, behavior).
+          b. Read the context descriptions.
+          c. Merge context with the goal; if there is any conflict, modify the context output to satisfy the goal.
+          d. Generate code fully complying with both the merged specification and the required context wrapper format.
+
+        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>
+
+
+        <goals>
+        {goals}
+        <goals>
+
+        Goals and context are orthogonal: goals orient the context.
+
+        Plan: Before writing any code, ensure you fully integrate both the overarching specifications (goal sections) and the context-level descriptions during code generation.
+
+        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 goals])
     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: '', goals: '')
       @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,
+                     goals: goals)
     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/goal.rb

@@ -0,0 +1,26 @@
+# Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
+# frozen_string_literal: true
+
+class LLMed
+  class Goal
+    attr_reader :name, :options
+
+    def initialize(name:, options: {})
+      @name = name
+      @options = options
+
+    end
+
+    def llm(message)
+      @message = message
+    end
+
+    def message
+      "<goal name=\"#{@name}\">#{@message}</goal>"
+    end
+
+    def message?
+       !(@message.nil? || @message.empty?)
+    end
+  end
+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?
@@ -91,6 +93,7 @@ end
 require_relative 'llm'
 require_relative 'llmed/configuration'
 require_relative 'llmed/context'
+require_relative 'llmed/goal'
 require_relative 'llmed/release'
 require_relative 'llmed/application'
 require_relative 'llmed/deployment'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llmed
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.6.1
 platform: ruby
 authors:
 - Jovany Leandro G.C
@@ -93,12 +93,15 @@ files:
 - README.md
 - exe/llmed
 - exe/llmed.literate
+- lib/#llm.rb#
 - lib/llm.rb
+- lib/llm.rb~
 - lib/llmed.rb
 - lib/llmed/application.rb
 - lib/llmed/configuration.rb
 - lib/llmed/context.rb
 - lib/llmed/deployment.rb
+- lib/llmed/goal.rb
 - lib/llmed/literate_programming.rb
 - lib/llmed/literate_programming/markdown.rb
 - lib/llmed/literate_programming/markdown.rb.release