elelem 0.10.0 → 0.12.0

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,55 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Output
+    RENDERERS = {
+      error: ->(text) { "error: #{text}" },
+      markdown: ->(text) { "```\n#{text}\n```\n" }
+    }.freeze
+    private_constant :RENDERERS
+
+    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)
+      RENDERERS[as]&.call(text) || text
+    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,43 +1,36 @@
 # 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!(agent)
-      load_plugins
-      registry.each_value { |plugin| plugin.call(agent) }
+    def initialize(load_paths: LOAD_PATHS)
+      @loaded = false
+      @load_paths = load_paths
     end
 
-    def self.reload!(agent)
-      registry.clear
-      load_plugins
-      registry.each_value { |plugin| plugin.call(agent) }
-    end
+    def load!(force: false)
+      return if @loaded && !force
 
-    def self.load_plugins
-      LOAD_PATHS.each do |path|
-        dir = File.expand_path(path)
-        next unless File.directory?(dir)
-
-        Dir["#{dir}/*.rb"].sort.each do |file|
-          load(file)
-        rescue => e
-          warn "elelem: failed to load plugin #{file}: #{e.message}"
-        end
-      end
+      @load_paths.each { |path| load_dir(File.expand_path(path)) }
+      @loaded = true
     end
 
-    def self.register(name, &block)
-      registry[name] = block
+    private
+
+    def load_dir(dir)
+      return unless File.directory?(dir)
+
+      Dir["#{dir}/*.rb"].each { |file| load_plugin(file) }
     end
 
-    def self.registry
-      @registry ||= {}
+    def load_plugin(file)
+      load(file)
+    rescue StandardError, ScriptError => e
+      warn "elelem: failed to load plugin #{file}: #{e.message}"
     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,68 @@
+# 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(session)
+      @plugins.load!
+      @registration.setups.each_value { |block| block.call(session) }
+    end
+
+    def reload(session)
+      @registration.clear_setups!
+      session.toolbox.clear!
+      session.commands.clear!
+      @plugins.load!(force: true)
+      apply(session)
+    end
+
+    def names
+      @registration.providers.keys
+    end
+
+    def build_session(provider, toolbox: Toolbox.new, input: nil, output: nil)
+      commands = Commands.new
+      agent = Agent.new(build_provider(provider), toolbox: toolbox, output: output || build_output)
+      session = Session.new(agent, input: input || build_input(commands: commands), commands: commands)
+      apply(session)
+      session
+    end
+
+    private
+
+    def build_input(**)
+      @plugins.load!
+      (@registration.factories[:input] || ->(**o) { Input.new(**o) }).call(**)
+    end
+
+    def build_output(**)
+      @plugins.load!
+      (@registration.factories[:output] || ->(**o) { Output.new(**o) }).call(**)
+    end
+
+    def require_gem(name)
+      require "elelem/#{name}"
+      @registration.providers.fetch(name.to_s) { unregistered_provider(name) }
+    rescue LoadError
+      raise "unknown provider: #{name.inspect}. Available: #{names.join(", ")}. Run: gem install elelem-#{name}"
+    end
+
+    def unregistered_provider(name)
+      raise "elelem-#{name} did not register a provider named #{name.inspect}"
+    end
+  end
+end

data/lib/elelem/repl.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Repl
+    def initialize(session)
+      @session = session
+    end
+
+    def run
+      @session.output.say "elelem v#{VERSION}"
+      while (line = @session.input.ask("> "))
+        dispatch_line(line) unless line.empty?
+      end
+    end
+
+    private
+
+    def dispatch_line(line)
+      line.start_with?("/") ? command(line) : @session.turn(line)
+    end
+
+    def command(line)
+      name, args = line.delete_prefix("/").split(" ", 2)
+      @session.commands.run(name, args) || @session.output.say(@session.commands.names.join(" "))
+    rescue StandardError, ScriptError => e
+      warn_and_say(e)
+    end
+
+    def warn_and_say(error)
+      Elelem.logger.warn("repl: #{error.message}")
+      @session.output.say(error.message, as: :error)
+    end
+  end
+end

data/lib/elelem/result.rb

@@ -0,0 +1,27 @@
+# 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/schema.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Schema
+    def initialize(params: {}, required: [])
+      @params = params.freeze
+      @required = required.freeze
+      @schema_hash = { type: "object", properties: @params, required: @required }.freeze
+      @json_schemer = JSONSchemer.schema(@schema_hash)
+    end
+
+    def to_h
+      @schema_hash
+    end
+
+    def validate(args)
+      @json_schemer.validate(args || {}).map { |error| error["error"] }
+    end
+  end
+end

data/lib/elelem/session.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Session
+    extend Forwardable
+
+    attr_reader :agent, :input, :commands
+
+    def_delegators :@agent, :provider, :provider=, :toolbox, :output, :conversation, :context, :turn
+
+    def initialize(agent, input: NullInput.new, commands: Commands.new)
+      @agent = agent
+      @input = input
+      @commands = commands
+    end
+  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,153 +2,30 @@
 
 module Elelem
   class SystemPrompt
-    TEMPLATE = <<~ERB
-      Terminal coding agent. Be concise. Verify your work.
+    DEFAULT = File.read(File.expand_path("prompts/default.erb", __dir__)).freeze
+    USER_AGENTS_MD = Pathname.new(Dir.home).join(".agents/AGENTS.md").freeze
 
-      # Tools
-      - read(path): file contents
-      - write(path, content): create/overwrite file
-      - execute(command): shell command
-      - eval(ruby): execute Ruby code; use to create tools for repetitive tasks
-      - task(prompt): delegate complex searches or multi-file analysis to a focused subagent
+    attr_accessor :template
 
-      # Editing
-      Use execute(`patch -p1`) for multi-line changes: `echo "DIFF" | patch -p1`
-      Use execute(`sed`) for single-line changes: `sed -i'' 's/old/new/' file`
-      Use write for new files or full rewrites
-
-      # Search
-      Use execute(`rg`) for text search: `rg -n "pattern" .`
-      Use execute(`fd`) for file discovery: `fd -e rb .`
-      Use execute(`sg`) (ast-grep) for structural search: `sg -p 'def $NAME' -l ruby`
-
-      # Task Management
-      For complex tasks:
-      1. State plan before acting
-      2. Work through steps one at a time
-      3. Summarize what was done
-
-      # Long Tasks
-      For complex multi-step work, write notes to .elelem/scratch.md
-
-      # Policy
-      - Explain before non-trivial commands
-      - Verify changes (read file, run tests)
-      - No interactive flags (-i, -p)
-      - Use `man` when you need to understand how to execute a program
-
-      # Environment
-      pwd: <%= pwd %>
-      platform: <%= platform %>
-      date: <%= date %>
-      self: <%= elelem_source %>
-      <%= git_info %>
-
-      <% if repo_map && !repo_map.empty? %>
-      # Codebase
-      ```
-      <%= repo_map %>```
-      <% end %>
-      <%= agents_md %>
-    ERB
+    def initialize(template = nil)
+      @template = template || DEFAULT
+    end
 
     def render
-      ERB.new(TEMPLATE, trim_mode: "-").result(binding)
+      ERB.new(template, trim_mode: "-").result(binding)
     end
 
     private
 
-    def pwd = Dir.pwd
-    def platform = RUBY_PLATFORM.split("-").last
-    def date = Date.today
-
-    def elelem_source
-      spec = Gem.loaded_specs["elelem"]
-      spec ? spec.gem_dir : File.expand_path("../..", __dir__)
-    end
-
-    def git_info
-      return unless File.exist?(".git")
-      "branch: #{`git branch --show-current`.strip}"
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def repo_map
-      files = `git ls-files '*.rb' 2>/dev/null`.lines.map(&:strip)
-      return "" if files.empty?
-
-      symbols = extract_symbols(files)
-      format_symbols(symbols, budget: 2000)
-    end
-
-    def extract_symbols(files)
-      output, status = Open3.capture2("sg", "run", "-p", "def $NAME", "-l", "ruby", "--json=compact", ".", err: File::NULL)
-      return ctags_fallback(files) unless status.success?
-
-      parse_sg_output(output, files)
-    end
-
-    def parse_sg_output(output, tracked_files)
-      JSON.parse(output).filter_map do |match|
-        file = match["file"]
-        next unless tracked_files.include?(file)
-        { file: file, name: match.dig("metaVariables", "single", "NAME", "text") }
-      end
-    rescue JSON::ParserError
-      []
-    end
-
-    def ctags_fallback(files)
-      return [] if files.empty?
-
-      output = IO.popen(["ctags", "-x", "--languages=Ruby", "--kinds-Ruby=cfm", "-L", "-"], "r+") do |io|
-        io.puts(files)
-        io.close_write
-        io.read
-      end
-
-      output.lines.map do |line|
-        parts = line.split(/\s+/, 4)
-        { file: parts[2], name: parts[0] }
-      end
-    rescue Errno::ENOENT
-      []
-    end
-
-    def format_symbols(symbols, budget:)
-      tree = build_tree(symbols)
-      render_tree(tree, budget: budget)
-    end
-
-    def build_tree(symbols)
-      tree = {}
-      symbols.group_by { |s| s[:file] }.each do |file, syms|
-        parts = file.split("/")
-        node = tree
-        parts[0..-2].each { |dir| node = (node[dir + "/"] ||= {}) }
-        node[parts.last] = syms.map { |s| s[:name] }.uniq
-      end
-      tree
+    def agents_md
+      [global_agents_md, project_agents_md].compact.then { |parts| parts.empty? ? nil : parts.join("\n\n") }
     end
 
-    def render_tree(node, indent: 0, budget:, result: String.new)
-      node.each do |key, value|
-        if value.is_a?(Hash)
-          line = "  " * indent + key + "\n"
-          return result if result.length + line.length > budget
-          result << line
-          render_tree(value, indent: indent + 1, budget: budget, result: result)
-        else
-          line = "  " * indent + key.sub(/\.rb$/, "") + ": " + value.join(" ") + "\n"
-          return result if result.length + line.length > budget
-          result << line
-        end
-      end
-      result
+    def global_agents_md
+      USER_AGENTS_MD.read if USER_AGENTS_MD.exist?
     end
 
-    def agents_md
+    def project_agents_md
       Pathname.pwd.ascend.each do |dir|
         file = dir / "AGENTS.md"
         return file.read if file.exist?

data/lib/elelem/tool.rb

@@ -2,27 +2,22 @@
 
 module Elelem
   class Tool
-    attr_reader :name, :description, :params, :required, :aliases
+    attr_reader :name, :description, :aliases
 
-    def initialize(name, description:, params: {}, required: [], aliases: [], &fn)
+    def initialize(name, description:, schema: Schema.new, aliases: [], &handler)
       @name = name
       @description = description
-      @params = params.freeze
-      @required = required.freeze
+      @schema = schema
       @aliases = aliases.freeze
-      @fn = fn
-      @schema_hash = { type: "object", properties: @params, required: @required }.freeze
-      @schema = JSONSchemer.schema(@schema_hash)
+      @handler = handler
     end
 
     def call(args)
-      @fn.call(args)
+      @handler.call(args)
     end
 
     def validate(args)
-      @schema.validate(args || {}).map do |error|
-        error["error"]
-      end
+      @schema.validate(args)
     end
 
     def to_h
@@ -31,7 +26,7 @@ module Elelem
         function: {
           name: name,
           description: description,
-          parameters: @schema_hash
+          parameters: @schema.to_h
         }
       }
     end