lizarb 1.0.4 → 1.0.6

data/lib/app.rb

@@ -1,61 +1,153 @@
 class App
   class Error < StandardError; end
-  class SystemNotFound < Error; end
 
   #
 
   def self.log s
-    puts s.bold
-  end
-
-  def self.logv s
-    log s if $VERBOSE
+    puts s
   end
 
   # called from exe/lizarb
   def self.call argv
-    puts
-    Liza[:DevBox][:command].call argv
-    puts
+    log "#{$boot_time.diff}s to boot" if defined? $log_boot_low
+
+    should_log = log_level >= 4
+    puts if should_log
+    log "#{self}.#{__method__}(#{argv.inspect})" if should_log
+    args = argv.dup
+    argv.clear
+
+    if args[0]
+      return _call_class_command(args) if args[0][0..1] == "--"
+      return _call_instance_command(args) if args[0][0] == "-"
+    end
+
+    Liza::DevBox.configuration.command args
+    puts if should_log
+  end
+
+  def self._call_class_command(args)
+    method_name = "call_#{args.shift[2..]}"
+    send(method_name, *args)
+  rescue NoMethodError
+    raise Error, "Invalid App Command `#{args[0]}`. Define a class-method named `#{method_name}` on App", caller[1..], cause: nil
+  end
+
+  def self._call_instance_command(args)
+    method_name = "call_#{args.shift[1..]}"
+    new.send(method_name, *args)
+  rescue NoMethodError
+    raise Error, "Invalid App Command `#{args[0]}`. Define an instance-method named `#{method_name}` on App", caller[1..], cause: nil
   end
 
   def self.root
-    Pathname Dir.pwd
+    Lizarb.root
   end
 
-  # loaders
+  def self.filename
+    root.join "#{$APP}.rb"
+  end
 
-  @loaders = []
-  @mutex = Mutex.new
+  def self.file
+    filename
+  end
 
-  def self.loaders
-    @loaders
+  def self.call_version
+    puts "LizaRB v#{Lizarb::VERSION}"
   end
 
-  def self.reload &block
-    @mutex.synchronize do
-      @loaders.map &:reload
-      yield if block_given?
+  def call_v
+    puts "LizaRB v#{Lizarb::VERSION}"
+  end
+
+  # directory
+
+  def self.directory(directory = nil, systems: nil)
+    if directory
+      @directory_name = directory
+      @directory = directory
+      @relative_path = directory
+      @path = "#{Lizarb.app_dir}/#{directory}"
+      self.systems_directory systems if systems
+    else
+      @directory
+    end
+  end
+
+  def self.systems_directory(systems_directory = nil)
+    raise "locked" if @locked
+    if systems_directory
+      @systems_directory = systems_directory
+      @systems_directory_name = systems_directory
+    else
+      @systems_directory
     end
+  end
 
-    true
+  def self.directory_name () = @directory_name
+
+  def self.systems_directory_name () = @systems_directory_name ||= "lib"
+
+  def self.path
+    @path
   end
 
-  def self.load_all
-    Lizarb.load_all
+  def self.relative_path
+    @relative_path or raise "@relative_path not set"
   end
 
-  # modes
+  # name
+
+  def self.name(name = nil)
+    raise "locked" if @locked
+    if name
+      @name = name
+    else
+      @name
+    end
+  end
 
-  @modes = []
+  # gemfile
+
+  def self.gemfile(gemfile = :unset, &block)
+    raise "locked" if @locked
+    if block_given?
+      @gemfile = block
+    elsif gemfile != :unset
+      @gemfile = gemfile
+    else
+      @gemfile
+    end
+  end
+
+  # mode
 
   def self.mode mode = nil
-    return $MODE if mode.nil?
-    @modes << mode.to_sym
+    if mode
+      @mode = mode.to_sym
+    else
+      @mode ||= (ENV["MODE"] || :code).to_sym
+    end
+  end
+
+  def self.coding?
+    mode == :code
+  end
+
+  # env_vars
+
+  def self.env_vars *files, mandatory: false
+    @env_vars ||= []
+    if files.any?
+      mode = self.mode.to_s
+      @env_vars += files.map { _1.sub(":directory", directory).sub(":mode", mode) }
+      @env_vars_mandatory = mandatory
+    end
+    @env_vars
   end
 
-  def self.modes
-    @modes
+  def self.env_vars_mandatory?
+    @env_vars_mandatory
   end
 
   # systems
@@ -71,66 +163,60 @@ class App
     @systems
   end
 
-  def self.require_system key
-    t = Time.now
-    logv "App.system :#{key}"
-    require key
-    logv "App.system :#{key} takes #{t.diff}s"
-  rescue LoadError => e
-    def e.backtrace; []; end
-    raise SystemNotFound, "FILE #{key}.rb not found on $LOAD_PATH", []
-  end
-
-  # parts
+  # settings
 
-  def self.connect_part part_klass, key, system
-    t = Time.now
-    string = "CONNECTING PART #{part_klass.to_s.rjust 25}.part :#{key}"
-    logv string
+  DEFAULT_LOG_LEVEL = 4
 
-    klass = if system.nil?
-              Liza.const "#{key}_part"
-            else
-              Liza.const("#{system}_system")
-                  .const "#{key}_part"
-            end
+  LOG_LEVELS = {
+    :highest => 7,
+    :higher  => 6,
+    :high    => 5,
+    :normal  => 4,
+    :low     => 3,
+    :lower   => 2,
+    :lowest  => 1,
+  }
+  @log_boot = DEFAULT_LOG_LEVEL
+  @log_level = DEFAULT_LOG_LEVEL
 
-    if klass.insertion
-      part_klass.class_exec(&klass.insertion)
-    end
+  def self.log_boot level = nil
+    return @log_boot if level.nil?
+    level = LOG_LEVELS[level] if level.is_a? Symbol
+    raise Error, "invalid log level `#{level}`", caller unless LOG_LEVELS.values.include? level
 
-    if klass.extension
-      klass.const_set :Extension, Class.new(Liza::PartExtension)
-      klass::Extension.class_exec(&klass.extension)
-    end
-    logv "#{string} takes #{t.diff}s"
+    @log_boot = level
   end
 
-  # systems
+  def self.log_level level = nil
+    return @log_level if level.nil?
+    level = LOG_LEVELS[level] if level.is_a? Symbol
+    raise Error, "invalid log level `#{level}`", caller unless LOG_LEVELS.values.include? level
 
-  def self.connect_system key, system_klass
-    t = Time.now
+    @log_level = level
+  end
 
-    color_system_klass = system_klass.to_s.colorize system_klass.log_color
+  # helpers
 
-    registrar_index = 0
-    system_klass.registrar.each do |string, target_block|
-      reg_type, _sep, reg_target = string.to_s.lpartition "_"
+  def self.global?
+    $APP == "app_global"
+  end
 
-      registrar_index += 1
+  #
 
-      target_klass = Liza.const reg_target
+  def self.type
+    Lizarb.setup_type
+  end
 
-      if reg_type == "insertion"
-        target_klass.class_exec(&target_block)
-      else
-        raise "TODO: decide and implement system extension"
-      end
+  def self.sfa?
+    type == :sfa
+  end
 
-      log "CONNECTING SYSTEM PART          #{color_system_klass}.#{reg_type} #{target_klass}"
+  def self.project?
+    type == :project
+  end
 
-    end
-    log "CONNECTING SYSTEM - #{t.diff}s for #{color_system_klass} to connect to #{registrar_index} system parts"
+  def self.script?
+    type == :script
   end
 
 end

data/lib/art_system/art_box.rb

@@ -0,0 +1,5 @@
+class ArtSystem::ArtBox < Liza::Box
+  
+  #
+
+end

data/lib/art_system/art_box_test.rb

@@ -0,0 +1,8 @@
+class ArtSystem::ArtBoxTest < Liza::BoxTest
+  
+  test :subject_class, :subject do
+    assert_equality ArtSystem::ArtBox, subject_class
+    assert_equality ArtSystem::ArtBox, subject.class
+  end
+
+end

data/lib/art_system/art_system_test.rb

@@ -0,0 +1,3 @@
+class ArtSystem::ArtSystemTest < Liza::SystemTest
+
+end

data/lib/art_system/commands/chatgpt_command.rb

@@ -0,0 +1,91 @@
+class ArtSystem::ChatgptCommand < DevSystem::SimpleCommand
+
+  section :filters
+
+  def before
+    super
+    @t = Time.now
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+
+  def after
+    super
+    log "#{ @t.diff }s | done"
+  end
+
+  section :actions
+
+  # liza chatgpt s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_default
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    call_chat
+  end
+
+  # liza chatgpt:chat s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_chat
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    # log stick :red, :white, "Not implemented yet"
+    set_default_arg(0, "Hello!")
+    content = simple_args.join(" ")
+
+    set_default_string :model, "gpt-4o"
+    model = simple_string(:model)
+
+    shell = OpenaiShell.new
+    client = shell.client
+    response = client.chat(
+      parameters: {
+        model: model,
+        messages: [{ role: "user", content: content}],
+        temperature: 0.7
+      }
+    )
+    log response
+    puts response.dig("choices", 0, "message", "content")
+
+  rescue => e
+    log "#{e.class}: #{e.message}"
+    binding.irb
+  end
+
+  # liza chatgpt:image s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_image
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    set_default_arg(0, "A green lizard sitting atop a big red ruby")
+    prompt = simple_args.join(" ")
+
+    n = 1
+    size = '512x512'
+
+    shell = OpenaiShell.new
+    client = shell.client
+    response = client.images.generate(
+      parameters: {
+        prompt:,
+        n:,
+        size:
+      }
+    )
+    image_url = response['data'][0]['url']
+    log "Image URL: #{image_url}"
+    # Download and save the image from image_url
+    `wget "#{image_url}" -O chatgpt_image_#{@t.to_i}..png`
+
+  rescue => e
+    log "#{e.class}: #{e.message}"
+    binding.irb
+  end
+
+  # liza chatgpt:audio s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_audio
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    log stick :red, :white, "Not implemented yet"
+  end
+
+end

data/lib/art_system/commands/chatgpt_command_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::ChatgptCommandTest < DevSystem::SimpleCommandTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::ChatgptCommand
+    assert_equality subject.class, ArtSystem::ChatgptCommand
+  end
+
+end

data/lib/art_system/commands/deepseek_command.rb

@@ -0,0 +1,58 @@
+class ArtSystem::DeepseekCommand < DevSystem::SimpleCommand
+
+
+  section :filters
+
+  def before
+    super
+    @t = Time.now
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+
+  def after
+    super
+    log "#{ time_diff @t }s | done"
+  end
+
+  section :actions
+
+  # liza deepseek s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_default
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+    call_chat
+
+  rescue => e
+    log "rescued from (#{e.class}) #{e.message}"
+    binding.irb
+  end
+
+  # liza deepseek:chat s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_chat
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    set_default_arg(0, "Hello!")
+    content = simple_args.join(" ")
+
+    set_default_string :model, "deepseek-chat"
+    model = simple_string(:model)
+
+    shell = DeepseekShell.new
+    client = shell.client
+    response = client.chat(
+      parameters: {
+        model: model,
+        messages: [{ role: "user", content: content}],
+        temperature: 0.7
+      }
+    )
+    log response
+    puts response.dig("choices", 0, "message", "content")
+
+  rescue => e
+    log "#{e.class}: #{e.message}"
+    binding.irb
+  end
+
+end

data/lib/art_system/commands/deepseek_command_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::DeepseekCommandTest < DevSystem::SimpleCommandTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::DeepseekCommand
+    assert_equality subject.class, ArtSystem::DeepseekCommand
+  end
+
+end

data/lib/art_system/commands/ollama_command.rb

@@ -0,0 +1,69 @@
+class ArtSystem::OllamaCommand < DevSystem::SimpleCommand
+
+  section :filters
+
+  def before
+    super
+    @t = Time.now
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+  
+  def after
+    super
+    log "#{ time_diff @t }s | done"
+  end
+
+  section :actions
+
+  # liza ollama s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_default
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    call_chat
+  end
+
+  # liza ollama:chat s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_chat
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    content = args.join(" ")
+    content = "Hello!" if content.empty?
+    log "content: #{ content }"
+
+    # model = "llama3.3"
+    # model = "deepseek"
+    model = "tinyllama"
+    messages = [{ role: "user", content: content}]
+    temperature = 0.7
+
+    shell = OllamaShell.new
+    client = shell.client
+    response = client.chat(
+      parameters: {
+        model:,
+        messages:,
+        temperature:,
+      }
+    )
+    log response
+    puts response.dig("choices", 0, "message", "content")
+
+  rescue => e
+    log "rescued from (#{e.class}) #{e.message}"
+
+    log "consider running these commands"
+
+    puts
+    puts "docker ps"
+    puts "docker exec -it CONTAINER_ID sh"
+    puts "docker exec -it CONTAINER_ID ollama list"
+    puts "docker exec -it CONTAINER_ID ollama pull tinyllama"
+    puts "docker exec -it CONTAINER_ID ollama pull deepseek"
+    puts
+
+    binding.irb
+  end
+
+end

data/lib/art_system/commands/ollama_command_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::OllamaCommandTest < DevSystem::SimpleCommandTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::OllamaCommand
+    assert_equality subject.class, ArtSystem::OllamaCommand
+  end
+
+end

data/lib/art_system/gem_shells/ruby_openai_gem_shell.rb

@@ -0,0 +1,32 @@
+class ArtSystem::RubyOpenaiGemShell < DevSystem::GemShell
+  require "openai"
+  # gem install ruby-openai
+
+  section :use_case_1
+
+  def self.count_tokens(text)
+    call({})
+    c = OpenAI.rough_token_count(text)
+    log "count_tokens: #{ c }"
+    c
+  end
+
+  section :use_case_2
+
+  def self.get_client(client_options = {})
+    call({})
+    client_options = get_default_configuration.merge(client_options)
+    OpenAI::Client.new(client_options) do |faraday|
+      faraday.response :logger, Logger.new($stdout), bodies: true if log? :high
+    end
+  end
+
+  def self.get_default_configuration
+    {
+      log_errors: $coding,
+      # uri_base: "https://api.openai.com/v1",
+      # access_token: ENV.fetch("OPENAI_ACCESS_TOKEN")
+    }
+  end
+
+end

data/lib/art_system/gem_shells/ruby_openai_gem_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::RubyOpenaiGemShellTest < DevSystem::GemShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::RubyOpenaiGemShell
+    assert_equality subject.class, ArtSystem::RubyOpenaiGemShell
+  end
+
+end

data/lib/art_system/shells/deepseek_shell.rb

@@ -0,0 +1,15 @@
+class ArtSystem::DeepseekShell < DevSystem::Shell
+
+  attr_accessor :client
+
+  def initialize(access_token: nil, uri_base: nil)
+    access_token ||= ENV.fetch 'DEEPSEEK_ACCESS_TOKEN'
+    uri_base ||= ENV.fetch 'DEEPSEEK_URI_BASE'
+
+    client_options = {access_token:, uri_base:}
+
+
+    self.client = RubyOpenaiGemShell.get_client(client_options)
+  end
+
+end

data/lib/art_system/shells/deepseek_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::DeepseekShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::DeepseekShell
+    assert_equality subject.class, ArtSystem::DeepseekShell
+  end
+
+end

data/lib/art_system/shells/ollama_shell.rb

@@ -0,0 +1,12 @@
+class ArtSystem::OllamaShell < DevSystem::Shell
+
+  attr_accessor :client
+
+  def initialize(access_token: nil, uri_base: nil)
+    uri_base ||= ENV.fetch "OLLAMA_URI_BASE"
+    client_options = {access_token:, uri_base:}
+
+    self.client = RubyOpenaiGemShell.get_client(client_options)
+  end
+
+end

data/lib/art_system/shells/ollama_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::OllamaShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::OllamaShell
+    assert_equality subject.class, ArtSystem::OllamaShell
+  end
+
+end

data/lib/art_system/shells/openai_shell.rb

@@ -0,0 +1,13 @@
+class ArtSystem::OpenaiShell < DevSystem::Shell
+
+  attr_accessor :client
+
+  def initialize(access_token: nil, uri_base: nil)
+    access_token ||= ENV.fetch "OPENAI_ACCESS_TOKEN"
+    uri_base ||= ENV["OPENAI_URI_BASE"]
+    client_options = {access_token:, uri_base:}
+
+    self.client = RubyOpenaiGemShell.get_client(client_options)
+  end
+
+end

data/lib/art_system/shells/openai_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::OpenaiShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::OpenaiShell
+    assert_equality subject.class, ArtSystem::OpenaiShell
+  end
+
+end