elelem 0.9.2 → 0.11.0

data/lib/elelem/net/claude.rb

@@ -1,200 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-# 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

@@ -1,86 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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|
-    next if result[:exit_status] == 0
-
-    $stdout.puts toolbox.header("execute", args, state: "x")
-  end
-end

data/lib/elelem/plugins/mcp.rb

@@ -1,14 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# 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 })
-        break 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

@@ -1,23 +0,0 @@
-# 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/templates/system_prompt.erb

@@ -1,53 +0,0 @@
-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 %>