llmed 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcb6503e5c4ed7cf826c335f2ea016e6f99187b9b2ea9352267881bb5634ccbe
-  data.tar.gz: 45d1a3538aca0b6e4ed118eec14bfd08fe61445e5229558264d434d0739b34d9
+  metadata.gz: 48b4c352f5fd54aa841fe411fd7f5025f1c98f40b8a287589aeb46ad213def68
+  data.tar.gz: c53e2efec6164261d6985f9297b101b363d1e9da432123ddeac1e369a7f045d2
 SHA512:
-  metadata.gz: 63d03492ef70ede943c6e7b236158962527a4bce1e9ac4015d28c897a7326aa8ae0e016a8a96e52264cc6c2db286ed66c767311f77bdf344baaedf4f32a156c7
-  data.tar.gz: 8763511711a43d45e0682afb8cbb3352af6bea95baf9c765de259b2ca276fe40faad5647d2ef93a2e0ea747712ab6ec4c254df91553df5659feccefbe4acf67b
+  metadata.gz: 1b228350f691be1762449160bafde3f3c3eba0cc180fd918207f09a855939d0ec784f53861f72304a61d6c4c2adfd525d4e29cf868c1bc1d1dbfb9aa0ff7ad15
+  data.tar.gz: 7eea2cc52879f589c1b4612409c7c0923aa88135bcb705817966fb4827d449032cc528891140e37a088ff0145fe792982f068162b716785d41e5c3ac736a8bfd

data/exe/llmed.literate

@@ -9,12 +9,22 @@ output_dir = './llmed-out'
 release_dir = output_dir
 language = 'ruby'
 provider = :like_openai
-provider_api_key = ENV.fetch('LLMED_PROVIDER_API_KEY', nil)
+provider_api_key = ENV.fetch('LLMED_PROVIDER_API_KEY', '')
 provider_model = ENV.fetch('LLMED_PROVIDER_MODEL', 'Qwen/Qwen2.5-Coder-32B-Instruct')
 provider_uri_base = ENV.fetch('LLMED_PROVIDER_URI_BASE', 'https://api.together.xyz/v1')
 output_file = 'a.out.ollmed'
 
 template = <<~TMP
+#% Minimal example
+#% llm_provider : like_openai | openai | anthropic
+#!environment llm_provider like_openai
+#% llm_provider_model : depends provider
+#!environment llm_provider_model Qwen/Qwen2.5-Coder-32B-Instruct
+#% llm_provider_model : depends provider
+#!environment llm_provider_uri_base https://api.together.xyz/v1
+#!environment language ruby
+#!environment output_file demo.rb
+
 # Main
 
 Show to user 'hi world!'.
@@ -26,7 +36,26 @@ OptionParser.new do |parser|
     puts parser
     puts "\n# Website\nhttps://github.com/bit4bit/llm-labs/tree/main/llmed"
     puts "\n# Examples\nhttps://github.com/bit4bit/llm-labs/tree/main/llmed/examples"
-    puts "Environment vars:\nLLMED_PROVIDER_API_KEY\nLLMED_PROVIDER_MODEL=#{provider_model}\nLLMED_PROVIDER_URI_BASE=#{provider_uri_base}"
+    puts "\n# Current Environment\nLLMED_PROVIDER_API_KEY\nLLMED_PROVIDER_MODEL=#{provider_model}\nLLMED_PROVIDER_URI_BASE=#{provider_uri_base}"
+    puts <<~DOC
+
+    # A minimal example
+    <!--
+    #% Minimal example
+    #% llm_provider : like_openai | openai | anthropic
+    #!environment llm_provider like_openai
+    #% llm_provider_model : depends provider
+    #!environment llm_provider_model Qwen/Qwen2.5-Coder-32B-Instruct
+    #% llm_provider_model : depends provider
+    #!environment llm_provider_uri_base https://api.together.xyz/v1
+    #!environment language ruby
+    #!environment output_file fscalls.rb
+    -->
+
+    # Main
+
+    Show to user 'hi world!'.
+    DOC
     exit
   end
 
@@ -47,7 +76,7 @@ OptionParser.new do |parser|
     release_dir = path
   end
 
-  parser.on('-l', '--language LANGUAGE', String, 'Programming Language: ruby, python') do |lang|
+  parser.on('-l', '--language LANGUAGE', String, 'Programming Language: ruby, python (default: ruby)') do |lang|
     language = lang
   end
 
@@ -63,6 +92,34 @@ end
 
 llmed = LLMed.new(logger: logger, output_dir: output_dir, release_dir: release_dir)
 llmed.set_language language
-llmed.set_llm provider: provider, api_key: provider_api_key, model: provider_model, options: {uri_base: provider_uri_base}
-LLMed::LiterateProgramming.execute(llmed, 'literate_programming', source_code, output_file: output_file)
+LLMed::LiterateProgramming.execute(source_code, output_file: output_file) do |contexts, application_args, environment|
+  environment.each do |k, v|
+    case k
+    when 'llm_provider'
+      provider = v
+    when 'llm_provider_model'
+      provider_model = v
+    when 'llm_provider_uri_base'
+      provider_uri_base = v
+    when 'language'
+      language = v
+    end
+  end
+
+  if provider_api_key.strip.empty?
+    logger.error "LLMED_PROVIDER_API_KEY is not set. Please set the environment variable and try again."
+    exit 1
+  end
+
+  logger.info "Compiling for language: #{language}"
+  logger.info "LLM Provider: #{provider} Model: #{provider_model} URI Base: #{provider_uri_base}"
+
+  llmed.set_llm provider: provider, api_key: provider_api_key, model: provider_model, options: {uri_base: provider_uri_base}
+  llmed.application('literate_programming', **application_args) do
+    contexts.each do |lcontext|
+      context(lcontext[:title]) { lcontext[:content] }
+    end
+  end
+end
+
 llmed.compile()

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

@@ -134,9 +134,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 +187,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 +213,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

@@ -12,22 +12,22 @@ Don't make any assumptions/expectations or wait for implementations, always impl
 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 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='context name' digest='....' after='digest next context'>{code_comment_end}
+{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 no additional text or comments, and you must ensure that runs correctly on the first attempt.
+!!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])
     end
 

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,7 +60,7 @@ class LLMed
     end
 
     def digest
-      Digest::SHA256.hexdigest "#{@name}.#{@message}"
+      @fixed_digest || Digest::SHA256.hexdigest("#{@name}.#{@message}")
     end
 
     def message

data/lib/llmed/literate_programming.rb

@@ -2,9 +2,10 @@ require 'open-uri'
 
 class LLMed
   class LiterateProgramming
-    def self.execute(llmed, application_name, code, **application_args)
+    def self.execute(code, **application_args)
       md = LLMed::LiterateProgramming::Markdown.new()
       contexts = []
+      environment = {}
 
       md.parse(code).each do |item|
         context = {}
@@ -17,12 +18,14 @@ class LLMed
               value = item_content[:value].strip
               if [:language, :release, :output_file, :output_dir, :release_dir].include?(name) && !value.empty?
                 application_args[name] = value
+              else
+                environment[name] = value
               end
             end
           end
           next
         end
-        
+
         case item[:type]
         when :context
           context[:title] = item[:title]
@@ -42,11 +45,7 @@ class LLMed
         end
       end
 
-      llmed.application(application_name, **application_args) do
-        contexts.each do |lcontext|
-          context(lcontext[:title]) { lcontext[:content] }
-        end
-      end
+      yield contexts, application_args, environment
     end
   end
 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,53 @@ 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
+        rewire_code_contexts(contexts_iter, user_contexts_iter)
+        contexts_sorted = contexts_iter
       end
 
-      @contexts = contexts_sorted.sort {|a,b|
+      @contexts = contexts_sorted.sort do |a, b|
         if a.digest == b.after
           1
         else
           0
         end
-      }
+      end
+
       self
     end
 
     private
 
+    def rewire_code_contexts(code_contexts, user_contexts)
+      user_contexts.each_with_next do |user_context, next_user_context|
+        ctx = code_contexts.find { |ctx| ctx.digest == user_context.digest }
+        if ctx
+          ctx.after = '' if user_contexts.count > 1
+          ctx.after = next_user_context.digest if next_user_context
+        end
+      end
+    end
+
     def initialize(origin, code_comment)
       @origin = origin
       @content = ''
@@ -142,7 +154,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?
                   ''

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: llmed
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - Jovany Leandro G.C
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: langchainrb
@@ -94,34 +93,23 @@ files:
 - README.md
 - exe/llmed
 - exe/llmed.literate
-- lib/literate_programming.llmed~
 - lib/llm.rb
-- lib/llm.rb~
 - lib/llmed.rb
-- lib/llmed.rb~
 - lib/llmed/application.rb
-- lib/llmed/application.rb~
 - lib/llmed/configuration.rb
-- lib/llmed/configuration.rb~
 - lib/llmed/context.rb
-- lib/llmed/context.rb~
 - lib/llmed/deployment.rb
-- lib/llmed/deployment.rb~
 - lib/llmed/literate_programming.rb
-- lib/llmed/literate_programming.rb~
 - lib/llmed/literate_programming/markdown.rb
-- lib/llmed/literate_programming/markdown.rb.r1ruby.cache
 - lib/llmed/literate_programming/markdown.rb.release
 - lib/llmed/literate_programming/markdown.rb.statistics
 - lib/llmed/release.rb
-- lib/llmed/release.rb~
 homepage: https://github.com/bit4bit/llmed
 licenses:
 - GPL-3.0
 metadata:
   source_code_uri: https://github.com/bit4bit/llmed
   allowed_push_host: https://rubygems.org
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -136,8 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.7
 requirements: []
-rubygems_version: 3.3.15
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: LLM Execution Development
 test_files: []

data/lib/literate_programming.llmed~

@@ -1,39 +0,0 @@
-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 "Literate Programming Markdown", release: nil, language: :ruby, output_file: "markdown.rb", output_dir: "literate_programming" do
-  context "Library LLmed::LiterateProgramming::Markdown" do
-    <<-LLM
-    Exports a function call `parse(input: String)`.
-
-    ###  Example of usage
-
-    ```ruby
-    md = LLmed::LiteratePrograming::Markdown.new()
-    md.parse("
-    # Context A
-    Contenido
-    [link](http://link)
-    ## SubContexto A
-    SubContenido
-
-    # Contexto 3
-    Contenido 3
-    
-    ") == [{type: :context,
-            title: "Context A",
-            content: [
-              {type: :string, content: "Contenido\n"},
-              {type: :link, content: "link", reference: "http://link"},
-              {type: :string, content: "##SubContexto A\nSubContenido\n\n"}
-            ]},
-           {type: :context,
-            title: "Contexto 3",
-            content: [
-              {type: :string, content: "Contenido 3\n\n"}
-            ]}]
-    ```
-
-    
-LLM
-  end
-end

data/lib/llmed/application.rb~

@@ -1,182 +0,0 @@
-# Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
-# frozen_string_literal: true
-
-class LLMed
-  class Application
-    attr_reader :contexts, :name, :language
-
-    def initialize(name:, language:, output_file:, block:, logger:, release:, release_dir:, output_dir:)
-      raise 'required language' if language.nil?
-
-      @name = name
-      @output_file = output_file
-      @language = language
-      @block = block
-      @contexts = []
-      @logger = logger
-      @release = release
-      @release_dir = release_dir
-      @output_dir = output_dir
-    end
-
-    # Example:
-    # application { context "demo" { "content" } }
-    def context(name, **opts, &block)
-      opts[:release_dir] = @release_dir
-      ctx = Context.new(name: name, options: opts)
-      output = ctx.instance_eval(&block)
-      ctx.llm(output) unless ctx.message?
-
-      @contexts << ctx
-    end
-
-    def evaluate
-      instance_eval(&@block)
-    end
-
-    def source_code
-      return unless @output_file.is_a?(String)
-      return unless @release
-
-      output_file = Pathname.new(@output_dir) + @output_file
-      if @release && !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}")
-      end
-      @logger.info("APPLICATION #{@name} INPUT RELEASE FILE #{release_main_source_code}")
-      File.read(release_source_code)
-    end
-
-    def output_file(output_dir, mode = 'w', &block)
-      if @output_file.respond_to? :write
-        yield @output_file
-      else
-        path = Pathname.new(output_dir) + @output_file
-        FileUtils.mkdir_p(File.dirname(path))
-
-        @logger.info("APPLICATION #{@name} OUTPUT FILE #{path}")
-
-        File.open(path, mode, &block)
-      end
-    end
-
-    def patch_or_create(output)
-      release_source_code_path = Pathname.new(@release_dir) + "#{@output_file}.r#{@release}#{@language}.cache"
-      output_content = output
-      if @release && File.exist?(release_source_code_path)
-        release_source_code = File.read(release_source_code_path)
-        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
-
-          @logger.info("APPLICATION #{@name} PATCHING CONTEXT #{name} \n\tFROM #{digest}\n\tTO DIGEST #{new_digest}")
-          release_source_code = release_source_code.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
-        end
-
-        output_content = release_source_code
-      end
-
-      output_file(@output_dir) do |file|
-        file.write(output_content)
-      end
-    end
-
-    def system_prompt(configuration)
-      configuration.prompt(language: language,
-                           source_code: source_code,
-                           update_context_digests: digests_of_context_to_update)
-    end
-
-    def rebuild?
-      return true unless @release
-
-      !digests_of_context_to_update.tap do |digests|
-        digests.each do |digest|
-          context_by_digest = release_contexts.invert
-          @logger.info("APPLICATION #{@name} REBUILDING CONTEXT #{context_by_digest[digest]}")
-        end
-      end.empty?
-    end
-
-    def write_statistics(response)
-      return unless @output_file.is_a?(String)
-
-      statistics_file = Pathname.new(@release_dir) + "#{@output_file}.statistics"
-
-      File.open(statistics_file, 'a') do |file|
-        stat = {
-          inserted_at: Time.now.to_i,
-          name: @name,
-          provider: response.provider,
-          model: response.model,
-          release: @release,
-          total_tokens: response.total_tokens,
-          duration_seconds: response.duration_seconds
-        }
-        file.puts stat.to_json
-      end
-      @logger.info("APPLICATION #{@name} WROTE STATISTICS FILE #{statistics_file}")
-    end
-
-    def notify(message)
-      Notify.notify("APPLICATION #{@name}", message)
-    end
-
-    private
-
-    def digests_of_context_to_update
-      update_context_digest = []
-
-      unless release_contexts.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]
-          # maybe the context is not connected to the source code
-          next if release_context_digest.nil?
-
-          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
-
-      update_context_digest
-    end
-
-    def release_source_code
-      Pathname.new(@release_dir) + "#{@output_file}.r#{@release}#{@language}.cache"
-    end
-
-    def release_main_source_code
-      Pathname.new(@release_dir) + "#{@output_file}.release"
-    end
-
-    def release_contexts
-      return {} unless @release
-
-      return {} unless File.exist?(release_source_code)
-
-      File.read(release_source_code).scan(/context='(.+)' digest='(.+)'/).to_h
-    end
-  end
-end

data/lib/llmed/configuration.rb~

@@ -1,76 +0,0 @@
-class LLMed
-  module LLM
-    class Configuration
-      def initialize
-        @prompt = LLMed::LLM::Template.build(template: "
-You are a software developer with knowledge only of the programming language {language}. Follow the SOLID principles strictly, you must use only imperative and functional programming, and design highly isolated components.
-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.
-Always include the properly escaped comment: LLMED-COMPILED.
-
-You must only modify the following source code:
-{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 ruby:
-#<llmed-code context='context name' digest='....'>
-...
-#</llmed-code>
-
-", input_variables: %w[language source_code update_context_digests])
-      end
-
-      def prompt(language:, source_code:, update_context_digests: [])
-        @prompt.format(language: language, source_code: source_code,
-                       update_context_digests: update_context_digests.join(','))
-      end
-
-      # Change the default prompt, input variables: language, source_code
-      # Example:
-      #  set_prompt "my new prompt"
-      def set_prompt(*arg, input_variables: %w[language source_code], **args)
-        input_variables = {} if args[:file]
-        prompt = File.read(args[:file]) if args[:file]
-        prompt ||= arg.first
-        @prompt = LLMed::LLM::Template.build(template: prompt, input_variables: input_variables)
-      end
-
-      # Set default language used for all applications.
-      # Example:
-      #  set_langugage :ruby
-      def set_language(language)
-        @language = language
-      end
-
-      def set_llm(provider:, api_key:, model:)
-        @provider = provider
-        @provider_api_key = api_key
-        @provider_model = model
-      end
-
-      def language(main)
-        lang = main || @language
-        raise 'Please assign a language to the application or general with the function set_languag' if lang.nil?
-
-        lang
-      end
-
-      def llm
-        case @provider
-        when :openai
-          LLMed::LLM::OpenAI.new(
-            api_key: @provider_api_key,
-            default_options: { temperature: 0.7, chat_model: @provider_model }
-          )
-        when :test
-          LLMed::LLM::Test.new
-        when nil
-          raise 'Please set the provider with `set_llm(provider, api_key, model)`'
-        else
-          raise "not implemented provider #{@provider}"
-        end
-      end
-    end
-  end
-end

data/lib/llmed/context.rb~

@@ -1,62 +0,0 @@
-# Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
-class LLMed
-  class Context
-    attr_reader :name
-
-    def initialize(name:, options: {})
-      @name = name
-      @skip = options[:skip] || false
-      @release_dir = options[:release_dir]
-    end
-
-    def skip?
-      @skip
-    end
-
-    def same_digest?(val)
-      digest == val
-    end
-
-    def digest
-      Digest::SHA256.hexdigest "#{@name}.#{@message}"
-    end
-
-    def message
-      "# Context: #{@name} Digest: #{digest}\n\n#{@message}"
-    end
-
-    def llm(message)
-      @message = message
-    end
-
-    def message?
-      !(@message.nil? || @message.empty?)
-    end
-
-    # Example:
-    #  context("files") { sh "ls /etc" }
-    def sh(cmd)
-      `#{cmd}`
-    end
-
-    # Example:
-    #  context("application") { from_file("application.cllmed") }
-    def from_file(path)
-      File.read(path)
-    end
-
-    # Example:
-    #  context("source") { from_source_code("sourcepathtoinclude") }
-    def from_source_code(path)
-      code = File.read(path)
-      " Given the following source code: #{code}\n\n\n"
-    end
-
-    # Example:
-    #  context("source") { from_release("file in release dir") }
-    def from_release(path)
-      code = File.read(Pathname.new(@release_dir) + path)
-      " Given the following source code: #{code}\n\n\n"
-    end
-  end
-end

data/lib/llmed/deployment.rb~

@@ -1,16 +0,0 @@
-# Copyright 2025 Jovany Leandro G.C <bit4bit@riseup.net>
-# frozen_string_literal: true
-
-class LLMed
-  class Deployment
-    def initialize(name:, output_dir:, block:)
-      @name = name
-      @output_dir = output_dir
-      @block = block
-    end
-
-    def execute()
-      self.instance_eval(@block)
-    end
-  end
-end

data/lib/llmed/literate_programming/markdown.rb.r1ruby.cache

@@ -1,24 +0,0 @@
-#<llmed-code context='Library LLMed::LiterateProgramming::Markdown' digest='18aa5391a8a334f24a80542620a277bb9c085762cb88b7dbcafa26a532a48027' after=''>
-class LLMed::LiterateProgramming::Markdown
-  def parse(input)
-    contexts = []
-    current_context = { type: :context, title: "_default", content: [] }
-    
-    input.each_line do |line|
-      if line.strip =~ /^# (.+)$/
-        contexts << current_context unless current_context[:content].empty?
-        current_context = { type: :context, title: Regexp.last_match(1), content: [] }
-      elsif line.strip =~ /^\[(.+)\]\((.+)\)$/
-        current_context[:content] << { type: :link, content: Regexp.last_match(1), reference: Regexp.last_match(2) }
-      elsif line.strip =~ /^#% (.+)$/
-        current_context[:content] << { type: :comment, content: Regexp.last_match(1) + "\n" }
-      else
-        current_context[:content] << { type: :string, content: line }
-      end
-    end
-
-    contexts << current_context unless current_context[:content].empty?
-    contexts
-  end
-end
-#</llmed-code>

data/lib/llmed/literate_programming.rb~

@@ -1 +0,0 @@
-require_relative 'literater_programming/markdown'

data/lib/llmed/release.rb~

@@ -1,31 +0,0 @@
-# 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~

@@ -1,190 +0,0 @@
-require 'pp'
-require 'langchain'
-require 'pathname'
-require 'fileutils'
-require 'forwardable'
-
-Langchain.logger.level = Logger::ERROR
-
-class LLMed
-  extend Forwardable
-
-  class Context
-    attr_reader :message, :name
-
-    def initialize(name:, options: {})
-      @name = name
-      @skip = options[:skip] || false
-    end
-
-    def skip?
-      @skip
-    end
-
-    def llm(message)
-      @message = message
-    end
-
-    def message?
-      not (@message.nil? || @message.empty?)
-    end
-
-
-    def from_file(path)
-      File.read(path)
-    end
-
-    def from_source_code(path)
-      code = File.read(path)
-      "Dado el codigo fuente: #{code}\n\n\n"
-    end
-  end
-
-  class Configuration
-    def initialize
-      @prompt = Langchain::Prompt::PromptTemplate.new(template: "
-Eres desarrollador de software y solo conoces del lenguage de programacion {language}.
-La respuesta no debe contener texto adicional al codigo fuente generado.
-Todo el codigo fuente se genera en un unico archivo.
-Siempre adicionas el comentario de codigo correctamente escapado LLMED-COMPILED.
-
-", input_variables: ["language"])
-    end
-
-    def prompt(language:)
-      @prompt.format(language: language)
-    end
-
-    def set_prompt(prompt)
-      @prompt = Langchain::Prompt::PromptTemplate.new(template: prompt, input_variables: ["language"])
-    end
-
-    def set_language(language)
-      @language = language
-    end
-
-    def set_llm(provider:, api_key:, model:)
-      @provider = provider
-      @provider_api_key = api_key
-      @provider_model = model
-    end
-
-    def language(main)
-      lang = main || @language
-      raise "Please assign a language to the application or general with the function set_languag" if lang.nil?
-      lang
-    end
-
-    def llm()
-      case @provider
-      when :openai
-        Langchain::LLM::OpenAI.new(
-          api_key: @provider_api_key,
-          default_options: { temperature: 0.7, chat_model: @provider_model}
-        )
-      when nil
-        raise "Please set the provider with `set_llm(provider, api_key, model)`"
-      else
-        raise "not implemented provider #{@provider}"
-      end
-    end
-  end
-
-  class Application
-    attr_reader :contexts, :name, :language
-
-    def initialize(name:, language:, output_file:, block:, logger:)
-      raise "required language" if language.nil?
-
-      @name = name
-      @output_file = output_file
-      @language = language
-      @block = block
-      @contexts = []
-      @logger = logger
-    end
-
-    def context(name, **opts, &block)
-      ctx = Context.new(name: name, options: opts)
-      output = ctx.instance_eval(&block)
-      unless ctx.message?
-        ctx.llm(output)
-      end
-
-      @contexts << ctx
-    end
-
-    def evaluate
-      self.instance_eval(&@block)
-    end
-
-    def output_file(output_dir)
-      if @output_file.respond_to? :write
-        yield @output_file
-      else
-        path = Pathname.new(output_dir) + @output_file
-        FileUtils.mkdir_p(File.dirname(path))
-
-        @logger.info("APPLICATION #{@name} OUTPUT FILE #{@output_file}")
-
-        File.open(path, 'w') do |file|
-          yield file
-        end
-      end
-    end
-  end
-
-  def initialize(logger:)
-    @logger = logger
-    @applications = []
-    @configuration = Configuration.new()
-  end
-
-  def eval_source(code)
-    self.instance_eval(code)
-  end
-
-  # changes default language
-  def_delegator :@configuration, :set_language, :set_language
-  # changes default llm
-  def_delegator :@configuration, :set_llm, :set_llm
-  # changes default prompt
-  def_delegator :@configuration, :set_prompt, :set_prompt
-
-  def application(name, language: nil, output_file:, &block)
-    @app = Application.new(name: name, language: @configuration.language(language), output_file: output_file, block: block, logger: @logger)
-    @applications << @app
-  end
-
-  def compile(output_dir:)
-    @applications.each do |app|
-      llm = @configuration.llm()
-
-      messages = [
-        {role: "system", content: @configuration.prompt(language: app.language)},
-      ]
-      app.evaluate
-      app.contexts.each do |ctx|
-        next if ctx.skip?
-        messages << {role: "user", content: ctx.message}
-      end
-
-      llm_response = llm.chat(messages: messages)
-      response = llm_response.chat_completion
-      @logger.info("APPLICATION #{app.name} TOTAL TOKENS #{llm_response.total_tokens}")
-      write_output(app, output_dir, source_code(response))
-    end
-  end
-
-  private
-  def source_code(content)
-    # TODO: by provider?
-    content.gsub('```', '').sub(/^(ruby|python(\d*)|elixir|c(pp)?)/, '')
-  end
-
-  def write_output(app, output_dir, output)
-    app.output_file(output_dir) do |file|
-      file.write(output)
-    end
-  end
-end