elelem 0.2.0 → 0.3.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - mo khan
@@ -9,20 +9,6 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: cli-ui
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: erb
   requirement: !ruby/object:Gem::Requirement
@@ -164,30 +150,9 @@ files:
 - exe/elelem
 - lib/elelem.rb
 - lib/elelem/agent.rb
-- lib/elelem/api.rb
 - lib/elelem/application.rb
-- lib/elelem/configuration.rb
 - lib/elelem/conversation.rb
-- lib/elelem/mcp_client.rb
-- lib/elelem/states/idle.rb
-- lib/elelem/states/working.rb
-- lib/elelem/states/working/error.rb
-- lib/elelem/states/working/executing.rb
-- lib/elelem/states/working/state.rb
-- lib/elelem/states/working/talking.rb
-- lib/elelem/states/working/thinking.rb
-- lib/elelem/states/working/waiting.rb
 - lib/elelem/system_prompt.erb
-- lib/elelem/tool.rb
-- lib/elelem/toolbox.rb
-- lib/elelem/toolbox/exec.rb
-- lib/elelem/toolbox/file.rb
-- lib/elelem/toolbox/mcp.rb
-- lib/elelem/toolbox/memory.rb
-- lib/elelem/toolbox/prompt.rb
-- lib/elelem/toolbox/web.rb
-- lib/elelem/tools.rb
-- lib/elelem/tui.rb
 - lib/elelem/version.rb
 homepage: https://www.mokhan.ca
 licenses:

data/lib/elelem/api.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "net/llm"
-
-module Elelem
-  class Api
-    attr_reader :configuration, :client
-
-    def initialize(configuration)
-      @configuration = configuration
-      @client = Net::Llm::Ollama.new(
-        host: configuration.host,
-        model: configuration.model
-      )
-    end
-
-    def chat(messages, &block)
-      tools = configuration.tools.to_h
-      client.chat(messages, tools) do |chunk|
-        normalized = normalize_ollama_response(chunk)
-        block.call(normalized) if normalized
-      end
-    end
-
-    private
-
-    def normalize_ollama_response(chunk)
-      return done_response(chunk) if chunk["done"]
-
-      normalize_message(chunk["message"])
-    end
-
-    def done_response(chunk)
-      { "done" => true, "finish_reason" => chunk["done_reason"] || "stop" }
-    end
-
-    def normalize_message(message)
-      return nil unless message
-
-      {}.tap do |result|
-        result["role"] = message["role"] if message["role"]
-        result["content"] = message["content"] if message["content"]
-        result["reasoning"] = message["thinking"] if message["thinking"]
-        result["tool_calls"] = message["tool_calls"] if message["tool_calls"]
-      end.then { |r| r.empty? ? nil : r }
-    end
-  end
-end

data/lib/elelem/configuration.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  class Configuration
-    attr_reader :host, :model, :token, :debug
-
-    def initialize(host:, model:, token:, debug: false)
-      @host = host
-      @model = model
-      @token = token
-      @debug = debug
-    end
-
-    def tui
-      @tui ||= TUI.new($stdin, $stdout)
-    end
-
-    def api
-      @api ||= Api.new(self)
-    end
-
-    def logger
-      @logger ||= Logger.new("#{Time.now.strftime("%Y-%m-%d")}-elelem.log").tap do |logger|
-        if debug
-          logger.level = :debug
-        else
-          logger.level = ENV.fetch("LOG_LEVEL", "warn")
-        end
-        logger.formatter = ->(severity, datetime, progname, message) {
-          timestamp = datetime.strftime("%H:%M:%S.%3N")
-          "[#{timestamp}] #{severity.ljust(5)} #{message.to_s.strip}\n"
-        }
-      end
-    end
-
-    def conversation
-      @conversation ||= Conversation.new.tap do |conversation|
-        resources = mcp_clients.map do |client|
-          client.resources.map do |resource|
-            resource["uri"]
-          end
-        end.flatten
-        conversation.add(role: :tool, content: resources)
-      end
-    end
-
-    def tools
-      @tools ||= Tools.new(self,
-        [
-          Toolbox::Exec.new(self),
-          Toolbox::File.new(self),
-          Toolbox::Web.new(self),
-          Toolbox::Prompt.new(self),
-          Toolbox::Memory.new(self),
-        ] + mcp_tools
-      )
-    end
-
-    def cleanup
-      @mcp_clients&.each(&:shutdown)
-    end
-
-    private
-
-    def mcp_tools
-      @mcp_tools ||= mcp_clients.map do |client|
-        client.tools.map do |tool|
-          Toolbox::MCP.new(client, tui, tool)
-        end
-      end.flatten
-    end
-
-    def mcp_clients
-      @mcp_clients ||= begin
-        config = Pathname.pwd.join(".mcp.json")
-        return [] unless config.exist?
-
-        JSON.parse(config.read).map do |_key, value|
-          MCPClient.new(self, [value["command"]] + value["args"])
-        end
-      end
-    end
-  end
-end

data/lib/elelem/mcp_client.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  class MCPClient
-    attr_reader :tools, :resources
-
-    def initialize(configuration, command = [])
-      @configuration = configuration
-      @stdin, @stdout, @stderr, @worker = Open3.popen3(*command, pgroup: true)
-
-      # 1. Send initialize request
-      send_request(
-        method: "initialize",
-        params: {
-          protocolVersion: "2025-06-08",
-          capabilities: {
-            tools: {}
-          },
-          clientInfo: {
-            name: "Elelem",
-            version: Elelem::VERSION
-          }
-        }
-      )
-
-      # 2. Send initialized notification (optional for some MCP servers)
-      send_notification(method: "notifications/initialized")
-
-      # 3. Now we can request tools
-      @tools = send_request(method: "tools/list")&.dig("tools") || []
-      @resources = send_request(method: "resources/list")&.dig("resources") || []
-    end
-
-    def connected?
-      return false unless @worker&.alive?
-      return false unless @stdin && !@stdin.closed?
-      return false unless @stdout && !@stdout.closed?
-
-      begin
-        Process.getpgid(@worker.pid)
-        true
-      rescue Errno::ESRCH
-        false
-      end
-    end
-
-    def call(name, arguments = {})
-      send_request(
-        method: "tools/call",
-        params: {
-          name: name,
-          arguments: arguments
-        }
-      )
-    end
-
-    def shutdown
-      return unless connected?
-
-      configuration.logger.debug("Shutting down MCP client")
-
-      [@stdin, @stdout, @stderr].each do |stream|
-        stream&.close unless stream&.closed?
-      end
-
-      return unless @worker&.alive?
-
-      begin
-        Process.kill("TERM", @worker.pid)
-        # Give it 2 seconds to terminate gracefully
-        Timeout.timeout(2) { @worker.value }
-      rescue Timeout::Error
-        # Force kill if it doesn't respond
-        begin
-          Process.kill("KILL", @worker.pid)
-        rescue StandardError
-          nil
-        end
-      rescue Errno::ESRCH
-        # Process already dead
-      end
-    end
-
-    private
-
-    attr_reader :stdin, :stdout, :stderr, :worker, :configuration
-
-    def send_request(method:, params: {})
-      return {} unless connected?
-
-      request = {
-        jsonrpc: "2.0",
-        id: Time.now.to_i,
-        method: method
-      }
-      request[:params] = params unless params.empty?
-      configuration.logger.debug(JSON.pretty_generate(request))
-
-      @stdin.puts(JSON.generate(request))
-      @stdin.flush
-
-      response_line = @stdout.gets&.strip
-      return {} if response_line.nil? || response_line.empty?
-
-      response = JSON.parse(response_line)
-      configuration.logger.debug(JSON.pretty_generate(response))
-
-      if response["error"]
-        configuration.logger.error(response["error"]["message"])
-        { error: response["error"]["message"] }
-      else
-        response["result"]
-      end
-    end
-
-    def send_notification(method:, params: {})
-      return unless connected?
-
-      notification = {
-        jsonrpc: "2.0",
-        method: method
-      }
-      notification[:params] = params unless params.empty?
-      configuration.logger.debug("Sending notification: #{JSON.pretty_generate(notification)}")
-      @stdin.puts(JSON.generate(notification))
-      @stdin.flush
-
-      response_line = @stdout.gets&.strip
-      return {} if response_line.nil? || response_line.empty?
-
-      response = JSON.parse(response_line)
-      configuration.logger.debug(JSON.pretty_generate(response))
-      response
-    end
-  end
-end

data/lib/elelem/states/idle.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    class Idle
-      def run(agent)
-        agent.logger.debug("Idling...")
-        agent.tui.say("#{Dir.pwd} (#{agent.model}) [#{git_branch}]", colour: :magenta, newline: true)
-        input = agent.tui.prompt("モ ")
-        agent.quit if input.nil? || input.empty? || input == "exit" || input == "quit"
-
-        agent.conversation.add(role: :user, content: input)
-        agent.transition_to(Working)
-      end
-
-      private
-
-      def git_branch
-        `git branch --no-color --show-current --no-abbrev`.strip
-      end
-    end
-  end
-end

data/lib/elelem/states/working/error.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class Error < State
-        def initialize(agent, error_message)
-          super(agent, "X", :red)
-          @error_message = error_message
-        end
-
-        def process(_message)
-          agent.tui.say("\nTool execution failed: #{@error_message}", colour: :red)
-          Waiting.new(agent)
-        end
-      end
-    end
-  end
-end

data/lib/elelem/states/working/executing.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class Executing < State
-        def process(message)
-          if message["tool_calls"]&.any?
-            message["tool_calls"].each do |tool_call|
-              agent.conversation.add(role: :tool, content: agent.execute(tool_call))
-            end
-          end
-
-          Thinking.new(agent, "*", :yellow)
-        end
-      end
-    end
-  end
-end

data/lib/elelem/states/working/state.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class State
-        attr_reader :agent
-
-        def initialize(agent, icon, colour)
-          @agent = agent
-
-          agent.logger.debug("#{display_name}...")
-          agent.tui.show_progress("#{display_name}...", icon, colour: colour)
-        end
-
-        def run(message)
-          process(message)
-        end
-
-        def display_name
-          self.class.name.split("::").last
-        end
-      end
-    end
-  end
-end

data/lib/elelem/states/working/talking.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class Talking < State
-        def process(message)
-          if message["content"] && !message["content"]&.empty?
-            agent.conversation.add(role: message["role"], content: message["content"])
-            agent.tui.say(message["content"], colour: :default, newline: false)
-            self
-          else
-            Waiting.new(agent).process(message)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/elelem/states/working/thinking.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class Thinking < State
-        def process(message)
-          if message["reasoning"] && !message["reasoning"]&.empty?
-            agent.tui.say(message["reasoning"], colour: :gray, newline: false)
-            self
-          else
-            Waiting.new(agent).process(message)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/elelem/states/working/waiting.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class Waiting < State
-        def initialize(agent)
-          super(agent, ".", :cyan)
-        end
-
-        def process(message)
-          state_for(message)&.process(message) || self
-        end
-
-        private
-
-        def state_for(message)
-          if message["reasoning"] && !message["reasoning"].empty?
-            Thinking.new(agent, "*", :yellow)
-          elsif message["tool_calls"]&.any?
-            Executing.new(agent, ">", :magenta)
-          elsif message["content"] && !message["content"].empty?
-            Talking.new(agent, "~", :white)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/elelem/states/working.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class << self
-        def run(agent)
-          state = Waiting.new(agent)
-
-          loop do
-            streaming_done = false
-            finish_reason = nil
-
-            agent.api.chat(agent.conversation.history) do |message|
-              if message["done"]
-                streaming_done = true
-                next
-              end
-
-              if message["finish_reason"]
-                finish_reason = message["finish_reason"]
-                agent.logger.debug("Working: finish_reason = #{finish_reason}")
-              end
-
-              new_state = state.run(message)
-              if new_state.class != state.class
-                agent.logger.info("STATE: #{state.display_name} -> #{new_state.display_name}")
-              end
-              state = new_state
-            end
-
-            # Only exit when task is actually complete, not just streaming done
-            if finish_reason == "stop"
-              agent.logger.debug("Working: Task complete, exiting to Idle")
-              break
-            elsif finish_reason == "tool_calls"
-              agent.logger.debug("Working: Tool calls finished, continuing conversation")
-              # Continue loop to process tool results
-            elsif streaming_done && finish_reason.nil?
-              agent.logger.debug("Working: Streaming done but no finish_reason, continuing")
-              # Continue for cases where finish_reason comes in separate chunk
-            end
-          end
-
-          agent.transition_to(States::Idle.new)
-        rescue StandardError => e
-          agent.logger.error(e)
-          agent.conversation.add(role: :tool, content: e.message)
-          agent.tui.say(e.message, colour: :red, newline: true)
-          agent.transition_to(States::Idle.new)
-        end
-      end
-    end
-  end
-end

data/lib/elelem/tool.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  class Tool
-    attr_reader :name, :description, :parameters
-
-    def initialize(name, description, parameters)
-      @name = name
-      @description = description
-      @parameters = parameters
-    end
-
-    def banner
-      [name, parameters].join(": ")
-    end
-
-    def valid?(args)
-      JSON::Validator.validate(parameters, args, insert_defaults: true)
-    end
-
-    def to_h
-      {
-        type: "function",
-        function: {
-          name: name,
-          description: description,
-          parameters: parameters
-        }
-      }
-    end
-  end
-end

data/lib/elelem/toolbox/exec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module Toolbox
-    class Exec < ::Elelem::Tool
-      attr_reader :tui
-
-      def initialize(configuration)
-        @tui = configuration.tui
-        super("exec", "Execute shell commands with pipe support", {
-          type: "object",
-          properties: {
-            command: { 
-              type: "string", 
-              description: "Shell command to execute (supports pipes, redirects, etc.)" 
-            }
-          },
-          required: ["command"]
-        })
-      end
-
-      def call(args)
-        command = args["command"]
-        output_buffer = []
-
-        tui.say(command, newline: true)
-        Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
-          stdin.close
-          streams = [stdout, stderr]
-
-          until streams.empty?
-            ready = IO.select(streams, nil, nil, 0.1)
-
-            if ready
-              ready[0].each do |io|
-                data = io.read_nonblock(4096)
-                output_buffer << data
-
-                if io == stderr
-                  tui.say(data, colour: :red, newline: false)
-                else
-                  tui.say(data, newline: false)
-                end
-              rescue IO::WaitReadable
-                next
-              rescue EOFError
-                streams.delete(io)
-              end
-            elsif !wait_thread.alive?
-              break
-            end
-          end
-
-          wait_thread.value
-        end
-
-        output_buffer.join
-      end
-    end
-  end
-end