elelem 0.10.0 → 0.12.0

data/lib/elelem/mcp.rb

@@ -1,243 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "mcp/token_storage"
-require_relative "mcp/oauth"
-
-module Elelem
-  # https://modelcontextprotocol.io/specification/2025-11-25/server/tools.md
-  class MCP
-    CONFIG_PATHS = [
-      "~/.elelem/mcp.json",
-      ".elelem/mcp.json"
-    ].freeze
-
-    def initialize(configurations = CONFIG_PATHS)
-      @config = load_config(configurations)
-      @servers = {}
-    end
-
-    def tools
-      @config.fetch("mcpServers", {}).flat_map do |name, _|
-        server(name).tools.map do |tool|
-          [
-            "#{name}_#{tool["name"]}",
-            {
-              description: tool["description"],
-              params: tool.dig("inputSchema", "properties") || {},
-              required: tool.dig("inputSchema", "required") || [],
-              fn: ->(a) { server(name).call(tool["name"], a) }
-            }
-          ]
-        end
-      end.to_h
-    end
-
-    def close
-      @servers.each_value(&:close)
-    end
-
-    private
-
-    def load_config(configurations)
-      configurations.each_with_object({}) do |path, merged|
-        file = File.expand_path(path)
-        next unless File.exist?(file)
-
-        config = JSON.parse(IO.read(file))
-        servers = config.fetch("mcpServers", {})
-        merged["mcpServers"] = (merged["mcpServers"] || {}).merge(servers)
-      end
-    end
-
-    def server(name)
-      @servers[name] ||= build_server(@config.dig("mcpServers", name))
-    end
-
-    def build_server(config)
-      if config["type"] == "http"
-        HttpServer.new(url: config["url"], headers: config["headers"] || {})
-      else
-        Server.new(**config.transform_keys(&:to_sym))
-      end
-    end
-
-    module ServerInterface
-      def tools
-        request("tools/list")["tools"]
-      end
-
-      def call(name, args)
-        result = request("tools/call", { name: name, arguments: args })
-        logger.info({ tool: name, args: args, result: result }.to_json)
-        content = extract_content(result)
-        result["isError"] ? { error: content } : { content: content }
-      end
-
-      def extract_content(result)
-        if (structured = result["structuredContent"])
-          structured
-        else
-          result["content"]&.map { |c| c["text"] }&.join("\n")
-        end
-      end
-
-      def logger
-        @logger ||= Logger.new(File.expand_path("~/.elelem/mcp.log"))
-      end
-
-      private
-
-      def handshake!
-        request("initialize", {
-          protocolVersion: "2025-06-18",
-          capabilities: {},
-          clientInfo: { name: "elelem", version: VERSION }
-        })
-        notify("notifications/initialized")
-      end
-    end
-
-    class Server
-      include ServerInterface
-
-      def initialize(command:, args: [], env: {})
-        resolved_env = env.transform_values do |v|
-          v.gsub(/\$\{(\w+)\}/) { ENV[$1] || raise("Missing environment variable: #{$1}") }
-        end
-        @stdin, @stdout, @stderr, @wait = Open3.popen3(resolved_env, command, *args)
-        @id = 0
-        handshake!
-      end
-
-      def close
-        [@stdin, @stdout, @stderr].each { |io| io.close rescue nil }
-        @wait.kill rescue nil
-      end
-
-      private
-
-      def request(method, params = {})
-        send_msg(id: @id += 1, method: method, params: params)
-        read_response(@id)
-      end
-
-      def notify(method, params = {})
-        send_msg(method: method, params: params)
-      end
-
-      def send_msg(msg)
-        @stdin.puts({ jsonrpc: "2.0", **msg }.to_json)
-        @stdin.flush
-      end
-
-      def read_response(id)
-        loop do
-          line = @stdout.gets
-          raise "Server closed" unless line
-          msg = JSON.parse(line)
-          return msg["result"] if msg["id"] == id
-          raise msg["error"]["message"] if msg["error"]
-        end
-      end
-    end
-
-    class HttpServer
-      include ServerInterface
-
-      def initialize(url:, headers: {}, http: Elelem::Net.http)
-        @url = url
-        @headers = resolve_headers(headers)
-        @http = http
-        @id = 0
-        @session_id = nil
-        @access_token = nil
-        handshake!
-      end
-
-      def close
-      end
-
-      private
-
-      def resolve_headers(headers)
-        headers.transform_values do |v|
-          v.gsub(/\$\{(\w+)\}/) do
-            ENV[$1] || raise("Missing environment variable: #{$1}")
-          end
-        end
-      end
-
-      def request(method, params = {})
-        msg = { jsonrpc: "2.0", id: @id += 1, method: method, params: params }
-        response = post(msg)
-        raise response["error"]["message"] if response["error"]
-        response["result"]
-      end
-
-      def notify(method, params = {})
-        msg = { jsonrpc: "2.0", method: method, params: params }
-        post(msg)
-      end
-
-      def post(msg, retry_auth: true)
-        result = nil
-        needs_auth = false
-        error = nil
-
-        @http.post(@url, headers: request_headers, body: msg) do |response|
-          case response
-          when ::Net::HTTPSuccess
-            @session_id ||= response["Mcp-Session-Id"]
-            result = parse_response(response)
-          when ::Net::HTTPUnauthorized
-            needs_auth = true
-          else
-            error = "HTTP #{response.code}: #{response.body}"
-          end
-        end
-
-        raise error if error
-        if needs_auth
-          raise "Authorization failed" unless retry_auth
-
-          @access_token = OAuth.new(@url, http: @http).token
-          return post(msg, retry_auth: false)
-        end
-        result
-      end
-
-      def request_headers
-        base = { "Accept" => "application/json, text/event-stream" }
-        base["Mcp-Session-Id"] = @session_id if @session_id
-        base["Authorization"] = "Bearer #{@access_token}" if @access_token
-        @headers.merge(base)
-      end
-
-      def parse_response(response)
-        if response.content_type&.include?("text/event-stream")
-          parse_sse(response)
-        elsif response.body && !response.body.empty?
-          JSON.parse(response.body)
-        end
-      end
-
-      def parse_sse(response)
-        buffer = String.new
-        result = nil
-
-        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: ")
-
-            result = JSON.parse(line.delete_prefix("data: "))
-          end
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/elelem/net/claude.rb

@@ -1,202 +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, &block)
-      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(type: "saying", text: delta["text"])
-        when "thinking_delta"
-          block.call(type: "thinking", text: 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, &block)
-        tool_calls.each do |tool_call|
-          args = tool_call.delete(:args)
-          tool_call[:arguments] = args.empty? ? {} : JSON.parse(args)
-          block.call(type: "tool_call", id: tool_call[:id], name: tool_call[:name], arguments: tool_call[:arguments])
-        end
-        tool_calls
-      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,81 +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(type: "saying", text: message["content"]) if message["content"]
-          block.call(type: "thinking", text: message["thinking"]) if message["thinking"]
-        end
-
-        if message["tool_calls"]
-          parsed = parse_tool_calls(message["tool_calls"])
-          parsed.each { |tc| block.call(type: "tool_call", **tc) }
-          tool_calls.concat(parsed)
-        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,88 +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, &block)
-      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(type: "saying", text: delta["content"]) 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, &block)
-        tool_calls.values.map do |tool_call|
-          result = {
-            id: tool_call[:id],
-            name: tool_call[:name],
-            arguments: JSON.parse(tool_call[:args])
-          }
-          block.call(type: "tool_call", **result)
-          result
-        end
-      end
-    end
-  end
-end

data/lib/elelem/net.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-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/permissions.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  class Permissions
-    LOAD_PATHS = [
-      File.expand_path("plugins/permissions.json", __dir__),
-      "~/.elelem/permissions.json",
-      ".elelem/permissions.json"
-    ].freeze
-
-    def initialize
-      @rules = LOAD_PATHS.reduce({}) do |rules, path|
-        rules.merge(load_config(File.expand_path(path)))
-      end
-    end
-
-    def check(tool_name, args, terminal:)
-      policy = @rules[tool_name.to_sym] || :ask
-      case policy
-      when :allow then true
-      when :deny then raise "Permission denied: #{tool_name}"
-      when :ask then prompt(tool_name, args, terminal)
-      end
-    end
-
-    private
-
-    def load_config(path)
-      return {} unless File.exist?(path)
-
-      JSON.parse(File.read(path)).transform_keys(&:to_sym).transform_values(&:to_sym)
-    rescue JSON::ParserError
-      {}
-    end
-
-    def prompt(tool_name, args, terminal)
-      return true unless $stdin.tty?
-
-      answer = terminal.ask("  Allow? [Y/n] > ")&.downcase
-      raise "User denied permission: #{tool_name}" if answer == "n"
-
-      true
-    end
-  end
-end