elelem 0.8.0 → 0.9.0

data/lib/elelem/net/claude.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Net
+    class Claude
+      def self.anthropic(model:, api_key:, http: Elelem::Net.http)
+        new(
+          endpoint: "https://api.anthropic.com/v1/messages",
+          headers: { "x-api-key" => api_key, "anthropic-version" => "2023-06-01" },
+          model:,
+          http:
+        )
+      end
+
+      def self.vertex(model:, project:, region: "us-east5", http: Elelem::Net.http)
+        new(
+          endpoint: "https://#{region}-aiplatform.googleapis.com/v1/projects/#{project}/locations/#{region}/publishers/anthropic/models/#{model}:rawPredict",
+          headers: -> { { "Authorization" => "Bearer #{`gcloud auth application-default print-access-token`.strip}" } },
+          model:,
+          version: "vertex-2023-10-16",
+          http:
+        )
+      end
+
+      def initialize(endpoint:, headers:, model:, version: nil, http: Elelem::Net.http)
+        @endpoint = endpoint
+        @headers_source = headers
+        @model = model
+        @version = version
+        @http = http
+      end
+
+      def fetch(messages, tools = [], &block)
+        system_prompt, normalized_messages = extract_system(messages)
+        tool_calls = []
+
+        stream(normalized_messages, system_prompt, tools) do |event|
+          handle_event(event, tool_calls, &block)
+        end
+
+        finalize_tool_calls(tool_calls)
+      end
+
+      private
+
+      def headers
+        @headers_source.respond_to?(:call) ? @headers_source.call : @headers_source
+      end
+
+      def handle_event(event, tool_calls, &block)
+        case event["type"]
+        when "content_block_start"
+          handle_content_block_start(event, tool_calls)
+        when "content_block_delta"
+          handle_content_block_delta(event, tool_calls, &block)
+        end
+      end
+
+      def handle_content_block_start(event, tool_calls)
+        content_block = event["content_block"]
+        return unless content_block["type"] == "tool_use"
+
+        tool_calls << {
+          id: content_block["id"],
+          name: content_block["name"],
+          args: String.new
+        }
+      end
+
+      def handle_content_block_delta(event, tool_calls, &block)
+        delta = event["delta"]
+
+        case delta["type"]
+        when "text_delta"
+          block.call(content: delta["text"], thinking: nil)
+        when "thinking_delta"
+          block.call(content: nil, thinking: delta["thinking"])
+        when "input_json_delta"
+          tool_calls.last[:args] << delta["partial_json"].to_s if tool_calls.any?
+        end
+      end
+
+      def finalize_tool_calls(tool_calls)
+        tool_calls.each do |tool_call|
+          args = tool_call.delete(:args)
+          tool_call[:arguments] = args.empty? ? {} : JSON.parse(args)
+        end
+      end
+
+      def stream(messages, system_prompt, tools)
+        body = build_request_body(messages, system_prompt, tools)
+
+        @http.post(@endpoint, headers:, body:) do |response|
+          raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(::Net::HTTPSuccess)
+
+          read_sse_stream(response) { |event| yield event }
+        end
+      end
+
+      def build_request_body(messages, system_prompt, tools)
+        body = { max_tokens: 64000, messages:, stream: true }
+        body[:model] = @model unless @version
+        body[:anthropic_version] = @version if @version
+        body[:system] = system_prompt if system_prompt
+        body[:tools] = unwrap_tools(tools) unless tools.empty?
+        body
+      end
+
+      def read_sse_stream(response)
+        buffer = String.new
+
+        response.read_body do |chunk|
+          buffer << chunk
+
+          while (index = buffer.index("\n\n"))
+            raw_event = buffer.slice!(0, index + 2)
+            event = parse_sse(raw_event)
+            yield event if event
+          end
+        end
+      end
+
+      def parse_sse(raw)
+        line = raw.lines.find { |l| l.start_with?("data: ") }
+        return nil unless line
+
+        data = line.delete_prefix("data: ").strip
+        return nil if data == "[DONE]"
+
+        JSON.parse(data)
+      end
+
+      def extract_system(messages)
+        system_messages, other_messages = messages.partition { |message| message[:role] == "system" }
+        system_content = system_messages.first&.dig(:content)
+        [system_content, normalize(other_messages)]
+      end
+
+      def normalize(messages)
+        messages.map { |message| normalize_message(message) }
+      end
+
+      def normalize_message(message)
+        case message[:role]
+        when "tool"
+          tool_result_message(message)
+        when "assistant"
+          message[:tool_calls]&.any? ? assistant_with_tools_message(message) : message
+        else
+          message
+        end
+      end
+
+      def tool_result_message(message)
+        {
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: message[:tool_call_id],
+            content: message[:content]
+          }]
+        }
+      end
+
+      def assistant_with_tools_message(message)
+        text_content = build_text_content(message[:content])
+        tool_content = build_tool_content(message[:tool_calls])
+
+        { role: "assistant", content: text_content + tool_content }
+      end
+
+      def build_text_content(content)
+        return [] if content.to_s.empty?
+
+        [{ type: "text", text: content }]
+      end
+
+      def build_tool_content(tool_calls)
+        tool_calls.map do |tool_call|
+          {
+            type: "tool_use",
+            id: tool_call[:id],
+            name: tool_call[:name],
+            input: tool_call[:arguments]
+          }
+        end
+      end
+
+      def unwrap_tools(tools)
+        tools.map do |tool|
+          {
+            name: tool.dig(:function, :name),
+            description: tool.dig(:function, :description),
+            input_schema: tool.dig(:function, :parameters)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/elelem/net/ollama.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Net
+    class Ollama
+      def initialize(model:, host: "localhost:11434", http: Elelem::Net.http)
+        @url = normalize_url(host)
+        @model = model
+        @http = http
+      end
+
+      def fetch(messages, tools = [], &block)
+        tool_calls = []
+        body = build_request_body(messages, tools)
+
+        stream(body) do |event|
+          handle_event(event, tool_calls, &block)
+        end
+
+        tool_calls
+      end
+
+      private
+
+      def normalize_url(host)
+        base = host.start_with?("http") ? host : "http://#{host}"
+        "#{base}/api/chat"
+      end
+
+      def build_request_body(messages, tools)
+        { model: @model, messages:, tools:, stream: true }
+      end
+
+      def handle_event(event, tool_calls, &block)
+        message = event["message"] || {}
+
+        unless event["done"]
+          block.call(content: message["content"], thinking: message["thinking"])
+        end
+
+        if message["tool_calls"]
+          tool_calls.concat(parse_tool_calls(message["tool_calls"]))
+        end
+      end
+
+      def stream(body)
+        @http.post(@url, body:) do |response|
+          raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(::Net::HTTPSuccess)
+
+          read_ndjson_stream(response) { |event| yield event }
+        end
+      end
+
+      def read_ndjson_stream(response)
+        buffer = String.new
+
+        response.read_body do |chunk|
+          buffer << chunk
+
+          while (index = buffer.index("\n"))
+            line = buffer.slice!(0, index + 1)
+            yield JSON.parse(line)
+          end
+        end
+      end
+
+      def parse_tool_calls(tool_calls)
+        tool_calls.map do |tool_call|
+          {
+            id: tool_call["id"],
+            name: tool_call.dig("function", "name"),
+            arguments: tool_call.dig("function", "arguments") || {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/elelem/net/openai.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Net
+    class OpenAI
+      def initialize(model:, api_key:, base_url: "https://api.openai.com/v1", http: Elelem::Net.http)
+        @url = "#{base_url}/chat/completions"
+        @model = model
+        @api_key = api_key
+        @http = http
+      end
+
+      def fetch(messages, tools = [], &block)
+        tool_calls = {}
+        body = build_request_body(messages, tools)
+
+        stream(body) do |event|
+          handle_event(event, tool_calls, &block)
+        end
+
+        finalize_tool_calls(tool_calls)
+      end
+
+      private
+
+      def build_request_body(messages, tools)
+        { model: @model, messages:, stream: true, tools:, tool_choice: "auto" }
+      end
+
+      def handle_event(event, tool_calls, &block)
+        delta = event.dig("choices", 0, "delta") || {}
+
+        block.call(content: delta["content"], thinking: nil) if delta["content"]
+
+        accumulate_tool_calls(delta["tool_calls"], tool_calls) if delta["tool_calls"]
+      end
+
+      def accumulate_tool_calls(incoming_tool_calls, tool_calls)
+        incoming_tool_calls.each do |tool_call|
+          index = tool_call["index"]
+          tool_calls[index] ||= { id: nil, name: nil, args: String.new }
+          tool_calls[index][:id] ||= tool_call["id"]
+          tool_calls[index][:name] ||= tool_call.dig("function", "name")
+          tool_calls[index][:args] << tool_call.dig("function", "arguments").to_s
+        end
+      end
+
+      def stream(body)
+        @http.post(@url, headers: headers, body:) do |response|
+          raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(::Net::HTTPSuccess)
+
+          read_sse_stream(response) { |event| yield event }
+        end
+      end
+
+      def headers
+        { "Authorization" => "Bearer #{@api_key}" }
+      end
+
+      def read_sse_stream(response)
+        buffer = String.new
+
+        response.read_body do |chunk|
+          buffer << chunk
+
+          while (index = buffer.index("\n"))
+            line = buffer.slice!(0, index + 1).strip
+            next unless line.start_with?("data: ") && line != "data: [DONE]"
+
+            yield JSON.parse(line.delete_prefix("data: "))
+          end
+        end
+      end
+
+      def finalize_tool_calls(tool_calls)
+        tool_calls.values.map do |tool_call|
+          {
+            id: tool_call[:id],
+            name: tool_call[:name],
+            arguments: JSON.parse(tool_call[:args])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/elelem/net.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "net/hippie"
+require "json"
+
+require_relative "net/ollama"
+require_relative "net/openai"
+require_relative "net/claude"
+
+module Elelem
+  module Net
+    def self.http
+      @http ||= ::Net::Hippie::Client.new(read_timeout: 3600, open_timeout: 10)
+    end
+  end
+end

data/lib/elelem/plugins/confirm.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+Elelem::Plugins.register(:confirm) do |toolbox|
+  toolbox.before("execute") do |args|
+    next unless $stdin.tty?
+
+    cmd = args["command"]
+    $stdout.print "  Allow? [Y/n] > "
+    answer = $stdin.gets&.strip&.downcase
+    raise "User denied permission to execute: #{cmd}" if answer == "n"
+  end
+end

data/lib/elelem/plugins/edit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Elelem::Plugins.register(:edit) do |toolbox|
+  toolbox.add("edit",
+    description: "Replace first occurrence of text in file",
+    params: { path: { type: "string" }, old: { type: "string" }, new: { type: "string" } },
+    required: ["path", "old", "new"]
+  ) do |a|
+    path = Pathname.new(a["path"]).expand_path
+    content = path.read
+    toolbox
+      .run("write", { "path" => a["path"], "content" => content.sub(a["old"], a["new"]) })
+      .merge(replaced: a["old"], with: a["new"])
+  end
+end

data/lib/elelem/plugins/eval.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Elelem::Plugins.register(:eval) do |toolbox|
+  description = <<~'DESC'
+    Evaluate Ruby code. Available API:
+
+    name = "search"
+    toolbox.add(name, description: "Search using rg", params: { query: { type: "string" } }, required: ["query"], aliases: []) do |args|
+      toolbox.run("execute", { "command" => "rg --json -nI -F #{args["query"]}" })
+    end
+  DESC
+
+  toolbox.add("eval",
+    description: description,
+    params: { ruby: { type: "string" } },
+    required: ["ruby"]
+  ) do |args|
+    { result: binding.eval(args["ruby"]) }
+  end
+end

data/lib/elelem/plugins/execute.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+Elelem::Plugins.register(:execute) do |toolbox|
+  toolbox.add("execute",
+    description: "Run shell command (supports pipes and redirections)",
+    params: { command: { type: "string" } },
+    required: ["command"],
+    aliases: ["bash", "sh", "exec", "execute<|channel|>"]
+  ) do |a|
+    Elelem.sh("bash", args: ["-c", a["command"]]) { |x| $stdout.print(x) }
+  end
+
+  toolbox.after("execute") do |args, result|
+    return if result[:exit_status] == 0
+
+    $stdout.puts toolbox.header("execute", args, state: "x")
+  end
+end

data/lib/elelem/plugins/mcp.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+Elelem::Plugins.register(:mcp) do |toolbox|
+  mcp = Elelem::MCP.new
+  at_exit { mcp.close }
+  mcp.tools.each do |name, tool|
+    toolbox.add(name,
+      description: tool[:description],
+      params: tool[:params],
+      required: tool[:required],
+      &tool[:fn]
+    )
+  end
+end

data/lib/elelem/plugins/read.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+Elelem::Plugins.register(:read) do |toolbox|
+  toolbox.add("read",
+    description: "Read file",
+    params: { path: { type: "string" } },
+    required: ["path"],
+    aliases: ["open"]
+  ) do |a|
+    path = Pathname.new(a["path"]).expand_path
+    path.exist? ? { content: path.read, path: a["path"] } : { error: "not found" }
+  end
+
+  toolbox.after("read") do |_, result|
+    if result[:error]
+      $stdout.puts "  ! #{result[:error]}"
+    elsif !system("bat", "--paging=never", result[:path])
+      $stdout.puts result[:content]
+    end
+  end
+end

data/lib/elelem/plugins/verify.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Verifiers
+    SYNTAX = {
+      ".rb" => "ruby -c %{path}",
+      ".erb" => "erb -x %{path} | ruby -c",
+      ".py" => "python -m py_compile %{path}",
+      ".go" => "go vet %{path}",
+      ".rs" => "cargo check --quiet",
+      ".ts" => "npx tsc --noEmit %{path}",
+      ".js" => "node --check %{path}",
+    }.freeze
+
+    def self.for(path)
+      return [] unless path
+
+      cmds = []
+      ext = File.extname(path)
+      cmds << (SYNTAX[ext] % { path: path }) if SYNTAX[ext]
+      cmds << test_runner
+      cmds.compact
+    end
+
+    def self.test_runner
+      %w[bin/test script/test].find { |s| File.executable?(s) }
+    end
+  end
+
+  Plugins.register(:verify) do |toolbox|
+    toolbox.add("verify",
+      description: "Verify file syntax and run tests",
+      params: { path: { type: "string" } },
+      required: ["path"]
+    ) do |a|
+      path = a["path"]
+      Verifiers.for(path).inject({verified: []}) do |memo, cmd|
+        $stdout.puts toolbox.header("execute", { "command" => cmd })
+        v = toolbox.run("execute", { "command" => cmd })
+        return v.merge(path: path, command: cmd) if v[:exit_status] != 0
+
+        memo[:verified] << cmd
+        memo
+      end
+    end
+  end
+end

data/lib/elelem/plugins/write.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Elelem::Plugins.register(:write) do |toolbox|
+  toolbox.add("write",
+    description: "Write file",
+    params: { path: { type: "string" }, content: { type: "string" } },
+    required: ["path", "content"],
+    aliases: ["write<|channel|>"]
+  ) do |a|
+    path = Pathname.new(a["path"]).expand_path
+    FileUtils.mkdir_p(path.dirname)
+    { bytes: path.write(a["content"]), path: a["path"] }
+  end
+
+  toolbox.after("write") do |_, result|
+    if result[:error]
+      $stdout.puts "  ! #{result[:error]}"
+    else
+      system("bat", "--paging=never", result[:path]) || $stdout.puts("  -> #{result[:path]}")
+      toolbox.run("verify", { "path" => result[:path] })
+    end
+  end
+end

data/lib/elelem/plugins.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Plugins
+    LOAD_PATHS = [
+      File.expand_path("plugins", __dir__),
+      "~/.elelem/plugins",
+      ".elelem/plugins"
+    ].freeze
+
+    def self.setup!(toolbox)
+      load_plugins
+      registry.each_value { |plugin| plugin.call(toolbox) }
+    end
+
+    def self.reload!(toolbox)
+      @registry = {}
+      load_plugins
+      registry.each_value { |plugin| plugin.call(toolbox) }
+    end
+
+    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
+    end
+
+    def self.register(name, &block)
+      (@registry ||= {})[name] = block
+    end
+
+    def self.registry
+      @registry ||= {}
+    end
+  end
+end

data/lib/elelem/system_prompt.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Elelem
+  class SystemPrompt
+    TEMPLATE_PATH = File.expand_path("templates/system_prompt.erb", __dir__)
+
+    attr_reader :memory
+
+    def initialize(memory: nil)
+      @memory = memory
+    end
+
+    def render
+      ERB.new(template, trim_mode: "-").result(binding)
+    end
+
+    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"
+        return file.read if file.exist?
+      end
+      nil
+    end
+  end
+end