elelem 0.8.0 → 0.9.0

data/lib/elelem/templates/system_prompt.erb

@@ -0,0 +1,53 @@
+Terminal coding agent. Be concise. Verify your work.
+
+# 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
+
+# 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 (this agent's source): <%= elelem_source %>
+<%= git_branch %>
+
+# Codebase
+<%= repo_map %>
+<% if agents_md %>
+
+# Project Instructions
+<%= agents_md %>
+<% end %>
+<% if memory %>
+
+# Earlier Context
+<%= memory %>
+<% end %>

data/lib/elelem/terminal.rb

@@ -2,58 +2,79 @@
 
 module Elelem
   class Terminal
-    def initialize(commands: [], modes: [], providers: [], env_vars: [])
+    def initialize(commands: [], quiet: false)
       @commands = commands
-      @modes = modes
-      @providers = providers
-      @env_vars = env_vars
-      @spinner_thread = nil
-      setup_completion
+      @quiet = quiet
+      @dots_thread = nil
+      setup_completion unless @quiet
     end
 
     def ask(prompt)
       Reline.readline(prompt, true)&.strip
     end
 
-    def say(message)
-      stop_spinner
-      $stdout.puts message
+    def think(text)
+      return if blank?(text)
+
+      "\e[2;3m#{text}\e[0m"
     end
 
-    def write(message)
-      stop_spinner
-      $stdout.print message
+    def markdown(text)
+      return if @quiet || blank?(text)
+
+      newline(n: 2)
+      width = $stdout.winsize[1] rescue 80
+      IO.popen(["glow", "-s", "dark", "-w", width.to_s, "-"], "r+") do |io|
+        io.write(text)
+        io.close_write
+        io.read
+      end
+    rescue Errno::ENOENT
+      text
+    end
+
+    def print(text)
+      return if @quiet || blank?(text)
+
+      stop_dots
+      $stdout.print text
+    end
+
+    def say(text)
+      return if @quiet || blank?(text)
+
+      stop_dots
+      $stdout.puts text
+    end
+
+    def newline(n: 1)
+      n.times { $stdout.puts("") }
     end
 
     def waiting
-      @spinner_thread = Thread.new do
-        frames = %w[| / - \\]
-        i = 0
+      return if @quiet
+
+      @dots_thread = Thread.new do
         loop do
-          $stdout.print "\r#{frames[i % frames.length]} "
+          $stdout.print "."
           $stdout.flush
-          i += 1
           sleep 0.1
         end
       end
     end
 
-    def select(question, options, &block)
-      CLI::UI::Prompt.ask(question) do |handler|
-        options.each do |option|
-          handler.option(option) { |selected| block.call(selected) }
-        end
-      end
-    end
-
     private
 
-    def stop_spinner
-      return unless @spinner_thread
+    def blank?(text)
+      text.nil? || text.strip.empty?
+    end
+
+    def stop_dots
+      return unless @dots_thread
 
-      @spinner_thread.kill
-      @spinner_thread = nil
-      $stdout.print "\r  \r"
+      @dots_thread.kill
+      @dots_thread = nil
+      newline
     end
 
     def setup_completion
@@ -63,45 +84,14 @@ module Elelem
 
     def complete(target, preposing)
       line = "#{preposing}#{target}"
+      return @commands.select { |c| c.start_with?(line) } if line.start_with?("/") && !preposing.include?(" ")
 
-      if line.start_with?('/') && !preposing.include?(' ')
-        return @commands.select { |c| c.start_with?(line) }
-      end
-
-      case preposing.strip
-      when '/mode'
-        @modes.select { |m| m.start_with?(target) }
-      when '/provider'
-        @providers.select { |p| p.start_with?(target) }
-      when '/env'
-        @env_vars.select { |v| v.start_with?(target) }
-      when %r{^/env\s+\w+\s+pass(\s+show)?\s*$}
-        subcommands = %w[show ls insert generate edit rm]
-        matches = subcommands.select { |c| c.start_with?(target) }
-        matches.any? ? matches : complete_pass_entries(target)
-      when %r{^/env\s+\w+$}
-        complete_commands(target)
-      else
-        complete_files(target)
-      end
-    end
-
-    def complete_commands(target)
-      result = Elelem.shell.execute("bash", args: ["-c", "compgen -c #{target}"])
-      result["stdout"].lines.map(&:strip).first(20)
+      complete_files(target)
     end
 
     def complete_files(target)
-      result = Elelem.shell.execute("bash", args: ["-c", "compgen -f #{target}"])
-      result["stdout"].lines.map(&:strip).first(20)
-    end
-
-    def complete_pass_entries(target)
-      store = ENV.fetch("PASSWORD_STORE_DIR", File.expand_path("~/.password-store"))
-      result = Elelem.shell.execute("find", args: ["-L", store, "-name", "*.gpg"])
-      result["stdout"].lines.map { |l|
-        l.strip.sub("#{store}/", "").sub(/\.gpg$/, "")
-      }.select { |e| e.start_with?(target) }.first(20)
+      result = Elelem.sh("bash", args: ["-c", "compgen -f #{target}"])
+      result[:content].lines.map(&:strip).first(20)
     end
   end
 end

data/lib/elelem/tool.rb

@@ -2,49 +2,47 @@
 
 module Elelem
   class Tool
-    attr_reader :name
+    attr_reader :name, :description, :params, :required, :aliases
 
-    def initialize(schema, &block)
-      @name = schema.dig(:function, :name)
-      @schema = schema
-      @block = block
+    def initialize(name, description:, params: {}, required: [], aliases: [], &fn)
+      @name = name
+      @description = description
+      @params = params
+      @required = required
+      @aliases = aliases
+      @fn = fn
+      @schema = JSONSchemer.schema(schema_hash)
     end
 
     def call(args)
-      unless valid?(args)
-        actual = args.keys
-        expected = @schema.dig(:function, :parameters)
-        return { error: "Invalid args for #{@name}.", actual: actual, expected: expected }
-      end
-
-      @block.call(args)
+      @fn.call(args)
     end
 
-    def valid?(args)
-      JSON::Validator.validate(@schema.dig(:function, :parameters), args)
+    def validate(args)
+      @schema.validate(args || {}).map do |error|
+        error["error"]
+      end
     end
 
     def to_h
-      @schema&.to_h
+      {
+        type: "function",
+        function: {
+          name: name,
+          description: description,
+          parameters: schema_hash
+        }
+      }
     end
 
-    class << self
-      def build(name, description, properties, required = [])
-        new({
-          type: "function",
-          function: {
-            name: name,
-            description: description,
-            parameters: {
-              type: "object",
-              properties: properties,
-              required: required
-            }
-          }
-        }) do |args|
-          yield args
-        end
-      end
+    private
+
+    def schema_hash
+      {
+        type: "object",
+        properties: params,
+        required: required
+      }
     end
   end
 end

data/lib/elelem/toolbox.rb

@@ -2,122 +2,64 @@
 
 module Elelem
   class Toolbox
-    READ_TOOL = Tool.build("read", "Read complete contents of a file. Requires exact file path.", { path: { type: "string" } }, ["path"]) do |args|
-      path = args["path"]
-      full_path = Pathname.new(path).expand_path
-      full_path.exist? ? { content: full_path.read } : { error: "File not found: #{path}" }
-    end
-
-    EXEC_TOOL = Tool.build("exec", "Run shell commands. Returns stdout/stderr/exit_status.", { cmd: { type: "string" }, args: { type: "array", items: { type: "string" } }, env: { type: "object", additionalProperties: { type: "string" } }, cwd: { type: "string", description: "Working directory (defaults to current)" }, stdin: { type: "string" } }, ["cmd"]) do |args|
-      Elelem.shell.execute(
-        args["cmd"],
-        args: args["args"] || [],
-        env: args["env"] || {},
-        cwd: args["cwd"].to_s.empty? ? Dir.pwd : args["cwd"],
-        stdin: args["stdin"]
-      )
-    end
-
-    GREP_TOOL = Tool.build("grep", "Search all git-tracked files using git grep. Returns file paths with matching line numbers.", { query: { type: "string" } }, ["query"]) do |args|
-      Elelem.shell.execute("git", args: ["grep", "-nI", args["query"]])
-    end
+    attr_reader :tools, :hooks, :aliases
 
-    LIST_TOOL = Tool.build("list", "List all git-tracked files in the repository, optionally filtered by path.", { path: { type: "string" } }) do |args|
-      Elelem.shell.execute("git", args: args["path"] ? ["ls-files", "--", args["path"]] : ["ls-files"])
+    def initialize
+      @tools = {}
+      @aliases = {}
+      @hooks = { before: Hash.new { |h, k| h[k] = [] }, after: Hash.new { |h, k| h[k] = [] } }
     end
 
-    PATCH_TOOL = Tool.build( "patch", "Apply a unified diff patch via 'git apply'. Use for surgical edits to existing files.", { diff: { type: "string" } }, ["diff"]) do |args|
-      Elelem.shell.execute("git", args: ["apply", "--index", "--whitespace=nowarn", "-p1"], stdin: args["diff"])
+    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
 
-    WRITE_TOOL = Tool.build("write", "Write complete file contents (overwrites existing files). Creates parent directories automatically.", { path: { type: "string" }, content: { type: "string" } }, ["path", "content"]) do |args|
-      full_path = Pathname.new(args["path"]).expand_path
-      FileUtils.mkdir_p(full_path.dirname)
-      { bytes_written: full_path.write(args["content"]) }
+    def before(tool_name, &block)
+      @hooks[:before][tool_name] << block
     end
 
-    FETCH_TOOL = Tool.build("fetch", "Fetch content from a URL. Returns status, headers, and body.", { url: { type: "string", description: "The URL to fetch" } }, ["url"]) do |args|
-      client = Net::Hippie::Client.new
-      response = client.get(args["url"])
-      { status: response.code.to_i, body: response.body }
+    def after(tool_name, &block)
+      @hooks[:after][tool_name] << block
     end
 
-    WEB_SEARCH_TOOL = Tool.build("search_engine", "Search the web using DuckDuckGo. Returns raw API response.", { query: { type: "string", description: "The search query" } }, ["query"]) do |args|
-      query = CGI.escape(args["query"])
-      url = "https://api.duckduckgo.com/?q=#{query}&format=json&no_html=1"
-      client = Net::Hippie::Client.new
-      response = client.get(url)
-      JSON.parse(response.body)
+    def header(name, args, state: "+")
+      name = tool_for(name)&.name || "#{name}?"
+      "\n#{state} #{name}(#{args})"
     end
 
-    TOOL_ALIASES = {
-      "bash" => "exec",
-      "duckduckgo" => "search_engine",
-      "ddg" => "search_engine",
-      "execute" => "exec",
-      "get" => "fetch",
-      "open" => "read",
-      "search" => "grep",
-      "sh" => "exec",
-      "web" => "fetch",
-    }
+    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
 
-    attr_reader :tools
+      errors = tool.validate(args)
+      return failure(error: errors.join(", ")) if errors.any?
 
-    def initialize
-      @tools_by_name = {}
-      @tool_permissions = {}
-      @tools = { read: [], write: [], execute: [] }
-      add_tool(eval_tool(binding), :execute)
-      add_tool(WEB_SEARCH_TOOL, :read)
-      add_tool(EXEC_TOOL, :execute)
-      add_tool(FETCH_TOOL, :read)
-      add_tool(GREP_TOOL, :read)
-      add_tool(LIST_TOOL, :read)
-      add_tool(PATCH_TOOL, :write)
-      add_tool(READ_TOOL, :read)
-      add_tool(WRITE_TOOL, :write)
+      @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)
+    rescue => e
+      failure(error: e.message, name: name, args: args)
     end
 
-    def add_tool(tool, permission)
-      @tools[permission] << tool
-      @tools_by_name[tool.name] = tool
-      @tool_permissions[tool.name] = permission
+    def to_a
+      tools.values.map(&:to_h)
     end
 
-    def register_tool(name, description, properties = {}, required = [], mode: :execute, &block)
-      add_tool(Tool.build(name, description, properties, required, &block), mode)
-    end
-
-    def tools_for(permissions)
-      Array(permissions).map { |permission| tools[permission].map(&:to_h) }.flatten
-    end
-
-    def run_tool(name, args, permissions: [])
-      resolved_name = TOOL_ALIASES.fetch(name, name)
-      tool = @tools_by_name[resolved_name]
-      return { error: "Unknown tool", name: name, args: args } unless tool
-
-      tool_permission = @tool_permissions[resolved_name]
-      unless Array(permissions).include?(tool_permission)
-        return { error: "Tool '#{resolved_name}' not available in current mode", name: name }
-      end
+    private
 
-      tool.call(args)
-    rescue => error
-      { error: error.message, name: name, args: args, backtrace: error.backtrace.first(5) }
+    def tool_for(name)
+      tools[@aliases.fetch(name, name)]
     end
 
-    def tool_schema(name)
-      @tools_by_name[name]&.to_h
+    def success(payload)
+      payload.merge(ok: true)
     end
 
-    private
-
-    def eval_tool(target_binding)
-      Tool.build("eval", "Evaluates Ruby code with full access to register new tools via the `register_tool(name, desc, properties, required, mode: :execute) { |args| ... }` method.", { ruby: { type: "string" } }, ["ruby"]) do |args|
-        { result: target_binding.eval(args["ruby"]) }
-      end
+    def failure(payload)
+      payload.merge(ok: false)
     end
   end
 end

data/lib/elelem/version.rb

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

data/lib/elelem.rb

@@ -1,58 +1,50 @@
 # frozen_string_literal: true
 
-require "cgi"
-require "cli/ui"
+require "date"
 require "erb"
 require "fileutils"
 require "json"
-require "json-schema"
-require "logger"
-require "net/hippie"
-require "net/llm"
+require "json_schemer"
 require "open3"
 require "pathname"
 require "reline"
-require "set"
-require "thor"
-require "timeout"
+require "stringio"
+require "tempfile"
 
 require_relative "elelem/agent"
-require_relative "elelem/application"
-require_relative "elelem/conversation"
-require_relative "elelem/git_context"
+require_relative "elelem/mcp"
+require_relative "elelem/net"
+require_relative "elelem/plugins"
+require_relative "elelem/system_prompt"
 require_relative "elelem/terminal"
 require_relative "elelem/tool"
 require_relative "elelem/toolbox"
 require_relative "elelem/version"
 
-Reline.input = $stdin
-Reline.output = $stdout
-
 module Elelem
-  class Error < StandardError; end
+  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
 
-  class Shell
-    def execute(command, args: [], env: {}, cwd: Dir.pwd, stdin: nil)
-      cmd = command.is_a?(Array) ? command.first : command
-      cmd_args = command.is_a?(Array) ? command[1..] + args : args
-      stdout, stderr, status = Open3.capture3(
-        env,
-        cmd,
-        *cmd_args,
-        chdir: cwd,
-        stdin_data: stdin
-      )
-      {
-        "exit_status" => status.exitstatus,
-        "stdout" => stdout.to_s,
-        "stderr" => stderr.to_s
-      }
+      { exit_status: wait_thr.value.exitstatus, content: output.string }
     end
   end
 
-  class << self
-    def shell
-      @shell ||= Shell.new
-    end
+  def self.start(client, toolbox: Toolbox.new)
+    Plugins.setup!(toolbox)
+    Agent.new(client, toolbox).repl
+  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]
   end
 end