elelem 0.9.2 → 0.11.0

data/lib/elelem/input.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "reline"
+
+module Elelem
+  class Input
+    def initialize(commands: [])
+      @commands = commands
+      Reline.autocompletion = true
+      Reline.completion_proc = ->(target, preposing) { complete(target, preposing) }
+    end
+
+    def ask(prompt)
+      Reline.readline(prompt, true)&.strip
+    end
+
+    def interactive?
+      $stdin.tty?
+    end
+
+    private
+
+    def complete(target, preposing)
+      line = "#{preposing}#{target}"
+
+      if line.start_with?("/") && !preposing.include?(" ")
+        return command_names.select { |c| c.start_with?(line) }
+      end
+
+      if preposing.start_with?("/") && preposing.include?(" ")
+        cmd_name = preposing.delete_prefix("/").split(" ", 2).first
+        return complete_command_args(cmd_name, target)
+      end
+
+      complete_files(target)
+    end
+
+    def command_names
+      @commands.respond_to?(:names) ? @commands.names : @commands
+    end
+
+    def complete_command_args(cmd_name, partial)
+      return [] unless @commands.respond_to?(:completions_for)
+
+      @commands.completions_for(cmd_name, partial)
+    end
+
+    def complete_files(target)
+      output, = Open3.capture2("bash", "-c", "compgen -f #{Shellwords.escape(target)}")
+      output.lines.map(&:strip).first(20)
+    end
+  end
+end

data/lib/elelem/null_input.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Elelem
+  class NullInput
+    def ask(_prompt) = nil
+    def interactive? = false
+  end
+end

data/lib/elelem/null_output.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Elelem
+  class NullOutput < Output
+    def say(*, **) = nil
+  end
+end

data/lib/elelem/null_tool.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Elelem
+  class NullTool
+    def initialize(name, available: [])
+      @name = name
+      @available = available
+    end
+
+    def name
+      "#{@name}?"
+    end
+
+    def validate(_args)
+      ["unknown tool: #{@name.inspect}. Available: #{@available.join(", ")}."]
+    end
+  end
+end

data/lib/elelem/output.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Output
+    def initialize(stream: $stdout, **)
+      @stream = stream
+    end
+
+    def say(text, as: nil)
+      return if blank?(text)
+
+      write "#{render(text, as)}\n"
+    end
+
+    def print(text)
+      return if blank?(text)
+
+      write text
+    end
+
+    def thinking(text)
+      print("\e[2;3m#{text}\e[0m") unless blank?(text)
+    end
+
+    def doing(name, args, state: "+")
+      say "#{state} \e[36m#{name}\e[0m(#{args})"
+    end
+
+    def waiting
+    end
+
+    def display_file(path, fallback: nil)
+      say(fallback || path)
+    end
+
+    private
+
+    def render(text, as)
+      case as
+      when :error
+        return "error: #{text}"
+      when :markdown
+        "```\n" + text + "\n```\n"
+      else
+        text
+      end
+    end
+
+    def write(text)
+      @stream.print text
+    end
+
+    def blank?(text)
+      text.nil? || text.to_s.strip.empty?
+    end
+  end
+end

data/lib/elelem/plugins.rb

@@ -1,26 +1,21 @@
 # frozen_string_literal: true
 
 module Elelem
-  module Plugins
+  class Plugins
     LOAD_PATHS = [
-      File.expand_path("plugins", __dir__),
-      "~/.elelem/plugins",
-      ".elelem/plugins"
+      "~/.agents/plugins",
+      ".agents/plugins"
     ].freeze
 
-    def self.setup!(toolbox)
-      load_plugins
-      registry.each_value { |plugin| plugin.call(toolbox) }
+    def initialize(load_paths: LOAD_PATHS)
+      @loaded = false
+      @load_paths = load_paths
     end
 
-    def self.reload!(toolbox)
-      @registry = {}
-      load_plugins
-      registry.each_value { |plugin| plugin.call(toolbox) }
-    end
+    def load!(force: false)
+      return if @loaded && !force
 
-    def self.load_plugins
-      LOAD_PATHS.each do |path|
+      @load_paths.each do |path|
         dir = File.expand_path(path)
         next unless File.directory?(dir)
 
@@ -30,14 +25,8 @@ module Elelem
           warn "elelem: failed to load plugin #{file}: #{e.message}"
         end
       end
-    end
-
-    def self.register(name, &block)
-      (@registry ||= {})[name] = block
-    end
 
-    def self.registry
-      @registry ||= {}
+      @loaded = true
     end
   end
 end

data/lib/elelem/prompts/default.erb

@@ -0,0 +1,3 @@
+You are a terminal coding agent.
+
+<%= agents_md %>

data/lib/elelem/registration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Registration
+    attr_reader :providers, :setups, :factories
+
+    def initialize
+      @providers = {}
+      @setups = {}
+      @factories = {}
+    end
+
+    def provider(name, &factory)
+      @providers[name.to_s] = factory
+      self
+    end
+
+    def setup(name, &block)
+      @setups[name.to_s] = block
+      self
+    end
+
+    def input(&factory)
+      @factories[:input] = factory
+      self
+    end
+
+    def output(&factory)
+      @factories[:output] = factory
+      self
+    end
+
+    def clear_setups!
+      @setups.clear
+    end
+  end
+end

data/lib/elelem/registry.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Registry
+    def initialize(plugins: Plugins.new)
+      @registration = Registration.new
+      @plugins = plugins
+    end
+
+    def configure
+      yield @registration
+      self
+    end
+
+    def build_provider(name)
+      @plugins.load!
+      @registration.providers.fetch(name.to_s) { require_gem(name) }.call
+    end
+
+    def apply(agent)
+      @plugins.load!
+      @registration.setups.each_value { |block| block.call(agent) }
+    end
+
+    def reload(agent)
+      @registration.clear_setups!
+      agent.toolbox.clear!
+      agent.commands.clear!
+      @plugins.load!(force: true)
+      apply(agent)
+    end
+
+    def names
+      @registration.providers.keys
+    end
+
+    def build_agent(provider, toolbox: Toolbox.new, input: nil, output: nil)
+      commands = Commands.new
+      agent = Agent.new(
+        build_provider(provider),
+        toolbox: toolbox,
+        commands: commands,
+        input: input || build_input(commands: commands),
+        output: output || build_output,
+      )
+      apply(agent)
+      agent
+    end
+
+    private
+
+    def build_input(**opts)
+      @plugins.load!
+      (@registration.factories[:input] || ->(**o) { Input.new(**o) }).call(**opts)
+    end
+
+    def build_output(**opts)
+      @plugins.load!
+      (@registration.factories[:output] || ->(**o) { Output.new(**o) }).call(**opts)
+    end
+
+    def require_gem(name)
+      require "elelem/#{name}"
+      @registration.providers.fetch(name.to_s) { raise "elelem-#{name} did not register a provider named #{name.inspect}" }
+    rescue LoadError
+      raise "unknown provider: #{name.inspect}. Available: #{names.join(", ")}. Run: gem install elelem-#{name}"
+    end
+  end
+end

data/lib/elelem/result.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Elelem
+  class Result
+    extend Forwardable
+    def_delegators :@payload, :[], :each, :to_json, :to_h, :key?, :merge
+
+    def self.success(payload)
+      new(payload.merge(ok: true))
+    end
+
+    def self.failure(payload)
+      new(payload.merge(ok: false))
+    end
+
+    def initialize(payload)
+      @payload = payload
+    end
+
+    def ok? = !!@payload[:ok]
+    def error? = !!@payload[:error]
+    def error = @payload[:error]
+  end
+end

data/lib/elelem/slash_command.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Elelem
+  class SlashCommand
+    attr_reader :name, :description, :completions
+
+    def initialize(name, description = "", completions = nil, &handler)
+      @name = name
+      @description = description
+      @completions = completions
+      @handler = handler
+    end
+
+    def call(args)
+      @handler.call(args)
+    end
+  end
+end

data/lib/elelem/stub_provider.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Elelem
+  class StubProvider
+    def fetch(messages, tools = [], &block)
+      block.call(type: "thinking", text: "considering the request")
+      return block.call(type: "saying", text: "done.") if messages.last[:role] == "tool"
+
+      block.call(type: "saying", text: "let me check.")
+      return unless (tool = tools.first)
+
+      block.call(type: "doing", id: "stub-1", name: tool[:function][:name], arguments: {})
+    end
+  end
+end

data/lib/elelem/system_prompt.rb

@@ -2,12 +2,12 @@
 
 module Elelem
   class SystemPrompt
-    TEMPLATE_PATH = File.expand_path("templates/system_prompt.erb", __dir__)
+    DEFAULT = File.read(File.expand_path("prompts/default.erb", __dir__)).freeze
 
-    attr_reader :memory
+    attr_accessor :template
 
-    def initialize(memory: nil)
-      @memory = memory
+    def initialize(template = nil)
+      @template = template || DEFAULT
     end
 
     def render
@@ -16,44 +16,6 @@ module Elelem
 
     private
 
-    def template
-      File.read(TEMPLATE_PATH)
-    end
-
-    def pwd
-      Dir.pwd
-    end
-
-    def elelem_source
-      File.expand_path("../..", __dir__)
-    end
-
-    def platform
-      RUBY_PLATFORM.split("-").last
-    end
-
-    def date
-      Date.today
-    end
-
-    def git_branch
-      return unless File.exist?(".git")
-
-      "branch: #{`git branch --show-current`.strip}"
-    rescue
-      nil
-    end
-
-    def repo_map
-      `ctags -x --sort=no --languages=Ruby,Python,JavaScript,TypeScript,Go,Rust -R . 2>/dev/null`
-        .lines
-        .reject { |l| l.include?("vendor/") || l.include?("node_modules/") || l.include?("spec/") }
-        .first(100)
-        .join
-    rescue
-      ""
-    end
-
     def agents_md
       Pathname.pwd.ascend.each do |dir|
         file = dir / "AGENTS.md"

data/lib/elelem/tool.rb

@@ -7,11 +7,12 @@ module Elelem
     def initialize(name, description:, params: {}, required: [], aliases: [], &fn)
       @name = name
       @description = description
-      @params = params
-      @required = required
-      @aliases = aliases
+      @params = params.freeze
+      @required = required.freeze
+      @aliases = aliases.freeze
       @fn = fn
-      @schema = JSONSchemer.schema(schema_hash)
+      @schema_hash = { type: "object", properties: @params, required: @required }.freeze
+      @schema = JSONSchemer.schema(@schema_hash)
     end
 
     def call(args)
@@ -30,19 +31,10 @@ module Elelem
         function: {
           name: name,
           description: description,
-          parameters: schema_hash
+          parameters: @schema_hash
         }
       }
     end
 
-    private
-
-    def schema_hash
-      {
-        type: "object",
-        properties: params,
-        required: required
-      }
-    end
   end
 end

data/lib/elelem/toolbox.rb

@@ -10,38 +10,41 @@ module Elelem
       @hooks = { before: Hash.new { |h, k| h[k] = [] }, after: Hash.new { |h, k| h[k] = [] } }
     end
 
+    def clear!
+      @tools.clear
+      @aliases.clear
+      @hooks[:before].clear
+      @hooks[:after].clear
+    end
+
     def add(name, description:, params: {}, required: [], aliases: [], &fn)
       tool = Tool.new(name, description: description, params: params, required: required, aliases: aliases, &fn)
       @tools[name] = tool
       tool.aliases.each { |a| @aliases[a] = name }
     end
 
-    def before(tool_name, &block)
+    def before(tool_name = :*, &block)
       @hooks[:before][tool_name] << block
     end
 
-    def after(tool_name, &block)
+    def after(tool_name = :*, &block)
       @hooks[:after][tool_name] << block
     end
 
-    def header(name, args, state: "+")
-      name = tool_for(name)&.name || "#{name}?"
-      "\n#{state} #{name}(#{args})"
+    def tool_for(name)
+      tools.fetch(@aliases.fetch(name, name)) { NullTool.new(name, available: tools.keys) }
     end
 
     def run(name, args)
       tool = tool_for(name)
-      return failure(error: "unknown tool: #{name}. Use 'execute' to run shell commands like rg, fd, git.", tools: to_a) unless tool
-
       errors = tool.validate(args)
-      return failure(error: errors.join(", ")) if errors.any?
+      return Result.failure(error: errors.join(", ")) if errors.any?
 
-      @hooks[:before][tool.name].each { |h| h.call(args) }
-      result = tool.call(args)
-      @hooks[:after][tool.name].each { |h| h.call(args, result) }
-      result[:error] ? failure(result) : success(result)
+      result = dispatch(tool, args)
+      result[:error] ? Result.failure(result) : Result.success(result)
     rescue => e
-      failure(error: e.message, name: name, args: args)
+      Elelem.logger.warn("toolbox: #{e.message}\n#{e.backtrace.join("\n")}")
+      Result.failure(error: e.message, name: name, args: args)
     end
 
     def to_a
@@ -50,16 +53,13 @@ module Elelem
 
     private
 
-    def tool_for(name)
-      tools[@aliases.fetch(name, name)]
-    end
-
-    def success(payload)
-      payload.merge(ok: true)
-    end
-
-    def failure(payload)
-      payload.merge(ok: false)
+    def dispatch(tool, args)
+      @hooks[:before][:*].each { |h| h.call(args, tool_name: tool.name) }
+      @hooks[:before][tool.name].each { |h| h.call(args) }
+      result = tool.call(args)
+      @hooks[:after][:*].each { |h| h.call(args, result, tool_name: tool.name) }
+      @hooks[:after][tool.name].each { |h| h.call(args, result) }
+      result
     end
   end
 end

data/lib/elelem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Elelem
-  VERSION = "0.9.2"
-end
+  VERSION = "0.11.0"
+end

data/lib/elelem.rb

@@ -1,50 +1,52 @@
 # frozen_string_literal: true
 
-require "date"
 require "erb"
-require "fileutils"
+require "forwardable"
 require "json"
 require "json_schemer"
+require "logger"
 require "open3"
 require "pathname"
-require "reline"
-require "stringio"
-require "tempfile"
+require "shellwords"
 
 require_relative "elelem/agent"
-require_relative "elelem/mcp"
-require_relative "elelem/net"
+require_relative "elelem/slash_command"
+require_relative "elelem/commands"
+require_relative "elelem/conversation"
+require_relative "elelem/input"
+require_relative "elelem/null_input"
+require_relative "elelem/output"
+require_relative "elelem/null_output"
 require_relative "elelem/plugins"
+require_relative "elelem/registration"
+require_relative "elelem/registry"
+require_relative "elelem/config"
+require_relative "elelem/result"
+require_relative "elelem/stub_provider"
 require_relative "elelem/system_prompt"
-require_relative "elelem/terminal"
 require_relative "elelem/tool"
+require_relative "elelem/null_tool"
 require_relative "elelem/toolbox"
 require_relative "elelem/version"
 
 module Elelem
-  def self.sh(cmd, args: [], cwd: Dir.pwd, env: {})
-    output = StringIO.new
-
-    Open3.popen2e(env, cmd, *args, chdir: cwd) do |stdin, out, wait_thr|
-      stdin.close
-      out.each_line do |line|
-        yield line if block_given?
-        output.write(line)
-      end
+  def self.start(provider: "stub", toolbox: Toolbox.new)
+    self.build(provider: provider, toolbox: toolbox).repl
+  end
 
-      { exit_status: wait_thr.value.exitstatus, content: output.string }
-    end
+  def self.ask(prompt, provider: "stub", toolbox: Toolbox.new, output: NullOutput.new)
+    self.build(provider: provider, toolbox: toolbox, input: NullInput.new, output: output).turn(prompt)
   end
 
-  def self.start(client, toolbox: Toolbox.new)
-    Plugins.setup!(toolbox)
-    Agent.new(client, toolbox).repl
+  def self.build(provider: "stub", toolbox: Toolbox.new, input: nil, output: nil)
+    Config.build_agent(provider, toolbox: toolbox, input: input, output: output)
   end
 
-  def self.ask(client, prompt, toolbox: Toolbox.new)
-    Plugins.setup!(toolbox)
-    agent = Agent.new(client, toolbox, terminal: Terminal.new(quiet: true))
-    agent.turn(prompt)
-    agent.history.last[:content]
+  def self.logger
+    @logger ||= Logger.new($stderr).tap do |log|
+      log.level = Logger.const_get(ENV.fetch("ELELEM_LOG_LEVEL", "warn").upcase)
+    end
   end
 end
+
+Elelem.configure { |config| config.provider(:stub) { Elelem::StubProvider.new } }