elelem 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 139cfa01fc1cb7c7a7d7c7b86fa72d49027dfeead68754dfd1be3d864228dbff
-  data.tar.gz: ee500832246d4a8c6e9c5c6aab4daadbbfe9b4c1724afe771de310a3dc402eb3
+  metadata.gz: 9d4a99b7addd5861f402c297ecfd19bc52e8edc6bba89422c2dec195a8cdcd13
+  data.tar.gz: d663221598cb4a843879ae191d6b7d8f62318be15d121803f58f752cecc79bbc
 SHA512:
-  metadata.gz: 920741eb6faf5bcfe67b78c62e65496012919a65d52b1919eefea0bedafd11f65de399c16d9bd6b3d812f2d21fd47303c8145267b9368d15cdba741a92dd50ef
-  data.tar.gz: e95155995fe0e21242bef5cd574699a47025b79064857183617b8d99c6d309885a226851db714ab2c8cb4b0a053055821b1f6b013df8e33b97034b0cd05bc270
+  metadata.gz: cdc7ccfb94de895a32f5be4cc310f23ca781119628fcbec4bd95a50df2c5b0eb3caa474c3a9058b6120c744e56f53001eb8c67b09cad7934f9b03292202e3c88
+  data.tar.gz: 9732e722f6d1c040d4c497b6826bd53ac425ad129befdd37da0e7ecd60b9bf4e6c96464a44f89a4cd118ca79b5b675ac6190ebf157c21bf4d06aa8ced13507f9

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.1.2] - 2025-08-14
+
+### Fixed
+- Fixed critical bug where bash tool had nested parameters schema causing tool calls to fail with "no implicit conversion of nil into String" error
+
 ## [0.1.1] - 2025-08-12
 
 ### Fixed

data/lib/elelem/agent.rb

@@ -2,14 +2,19 @@
 
 module Elelem
   class Agent
-    attr_reader :api, :conversation, :logger
+    attr_reader :api, :conversation, :logger, :model, :tui
 
     def initialize(configuration)
       @api = configuration.api
+      @tui = configuration.tui
       @configuration = configuration
+      @model = configuration.model
       @conversation = configuration.conversation
       @logger = configuration.logger
-      transition_to(Idle.new)
+
+      at_exit { cleanup }
+
+      transition_to(States::Idle.new)
     end
 
     def repl
@@ -23,14 +28,6 @@ module Elelem
       @current_state = next_state
     end
 
-    def prompt(message)
-      configuration.tui.prompt(message)
-    end
-
-    def say(message, colour: :default, newline: false)
-      configuration.tui.say(message, colour: colour, newline: newline)
-    end
-
     def execute(tool_call)
       logger.debug("Execute: #{tool_call}")
       configuration.tools.execute(tool_call)
@@ -38,9 +35,15 @@ module Elelem
 
     def quit
       logger.debug("Exiting...")
+      cleanup
       exit
     end
 
+    def cleanup
+      logger.debug("Cleaning up agent...")
+      configuration.cleanup
+    end
+
     private
 
     attr_reader :configuration, :current_state

data/lib/elelem/api.rb

@@ -8,7 +8,7 @@ module Elelem
       @configuration = configuration
     end
 
-    def chat(messages)
+    def chat(messages, &block)
       body = {
         messages: messages,
         model: configuration.model,
@@ -28,9 +28,7 @@ module Elelem
       configuration.http.request(req) do |response|
         raise response.inspect unless response.code == "200"
 
-        response.read_body do |chunk|
-          yield(chunk)
-        end
+        response.read_body(&block)
       end
     end
   end

data/lib/elelem/application.rb

@@ -4,29 +4,29 @@ module Elelem
   class Application < Thor
     desc "chat", "Start the REPL"
     method_option :help,
-      aliases: "-h",
-      type: :boolean,
-      desc: "Display usage information"
+                  aliases: "-h",
+                  type: :boolean,
+                  desc: "Display usage information"
     method_option :host,
-      aliases: "--host",
-      type: :string,
-      desc: "Ollama host",
-      default: ENV.fetch("OLLAMA_HOST", "localhost:11434")
+                  aliases: "--host",
+                  type: :string,
+                  desc: "Ollama host",
+                  default: ENV.fetch("OLLAMA_HOST", "localhost:11434")
     method_option :model,
-      aliases: "--model",
-      type: :string,
-      desc: "Ollama model",
-      default: ENV.fetch("OLLAMA_MODEL", "gpt-oss")
+                  aliases: "--model",
+                  type: :string,
+                  desc: "Ollama model",
+                  default: ENV.fetch("OLLAMA_MODEL", "gpt-oss")
     method_option :token,
-      aliases: "--token",
-      type: :string,
-      desc: "Ollama token",
-      default: ENV.fetch("OLLAMA_API_KEY", nil)
+                  aliases: "--token",
+                  type: :string,
+                  desc: "Ollama token",
+                  default: ENV.fetch("OLLAMA_API_KEY", nil)
     method_option :debug,
-      aliases: "--debug",
-      type: :boolean,
-      desc: "Debug mode",
-      default: false
+                  aliases: "--debug",
+                  type: :boolean,
+                  desc: "Debug mode",
+                  default: false
     def chat(*)
       if options[:help]
         invoke :help, ["chat"]
@@ -37,17 +37,17 @@ module Elelem
           token: options[:token],
           debug: options[:debug]
         )
-        say "Ollama Agent (#{configuration.model})", :green
-        say "Tools:\n  #{configuration.tools.banner}", :green
+        say "Agent (#{configuration.model})", :green
+        say configuration.tools.banner.to_s, :green
 
         agent = Agent.new(configuration)
         agent.repl
       end
     end
 
-    desc "version", "spandx version"
+    desc "version", "The version of this CLI"
     def version
-      puts "v#{Spandx::VERSION}"
+      say "v#{Elelem::VERSION}"
     end
     map %w[--version -v] => :version
   end

data/lib/elelem/configuration.rb

@@ -28,7 +28,7 @@ module Elelem
 
     def logger
       @logger ||= Logger.new(debug ? "elelem.log" : "/dev/null").tap do |logger|
-        logger.formatter = ->(_, _, _, message) { message.strip + "\n" }
+        logger.formatter = ->(_, _, _, message) { "#{message.to_s.strip}\n" }
       end
     end
 
@@ -37,11 +37,22 @@ module Elelem
     end
 
     def conversation
-      @conversation ||= Conversation.new
+      @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
+      @tools ||= Tools.new(self, [Toolbox::Bash.new(self)] + mcp_tools)
+    end
+
+    def cleanup
+      @mcp_clients&.each(&:shutdown)
     end
 
     private
@@ -49,5 +60,24 @@ module Elelem
     def scheme
       host.match?(/\A(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?\z/) ? "http" : "https"
     end
+
+    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/conversation.rb

@@ -2,16 +2,9 @@
 
 module Elelem
   class Conversation
-    SYSTEM_MESSAGE = <<~SYS
-      You are ChatGPT, a helpful assistant with reasoning capabilities.
-      Current date: #{Time.now.strftime("%Y-%m-%d")}.
-      System info: `uname -a` output: #{`uname -a`.strip}
-      Reasoning: high
-    SYS
+    ROLES = %i[system assistant user tool].freeze
 
-    ROLES = [:system, :assistant, :user, :tool].freeze
-
-    def initialize(items = [{ role: "system", content: SYSTEM_MESSAGE }])
+    def initialize(items = [{ role: "system", content: system_prompt }])
       @items = items
     end
 
@@ -23,12 +16,26 @@ module Elelem
     def add(role: :user, content: "")
       role = role.to_sym
       raise "unknown role: #{role}" unless ROLES.include?(role)
-      return if content.empty?
+      return if content.nil? || content.empty?
 
       if @items.last && @items.last[:role] == role
         @items.last[:content] += content
       else
-        @items.push({ role: role, content: content })
+        @items.push({ role: role, content: normalize(content) })
+      end
+    end
+
+    private
+
+    def system_prompt
+      ERB.new(Pathname.new(__dir__).join("system_prompt.erb").read).result(binding)
+    end
+
+    def normalize(content)
+      if content.is_a?(Array)
+        content.join(", ")
+      else
+        content.to_s
       end
     end
   end

data/lib/elelem/mcp_client.rb

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

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

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

@@ -0,0 +1,19 @@
+# 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
+
+          Waiting.new(agent)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,29 @@
+# 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)
+        end
+
+        private
+
+        def state_for(message)
+          if message["thinking"] && !message["thinking"].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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Elelem
+  module States
+    module Working
+      class << self
+        def run(agent)
+          done = false
+          state = Waiting.new(agent)
+
+          loop do
+            agent.api.chat(agent.conversation.history) do |chunk|
+              response = JSON.parse(chunk)
+              message = normalize(response["message"] || {})
+              done = response["done"]
+
+              agent.logger.debug("#{state.display_name}: #{message}")
+              state = state.run(message)
+            end
+
+            break if state.nil?
+            break if done && agent.conversation.history.last[:role] != :tool
+          end
+
+          agent.transition_to(States::Idle.new)
+        end
+
+        def normalize(message)
+          message.reject { |_key, value| value.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/elelem/system_prompt.erb

@@ -0,0 +1,7 @@
+**Shell Master** — bash>code; compose>write; pipe everything; /proc/sys native; automate fast; streams/transforms; POSIX+GNU; man(1) first; no cleverness.
+
+Time: `<%= Time.now.strftime("%Y-%m-%d %H:%M:%S") %>`
+Project Directory: `<%= Dir.pwd %>`
+System Info: `<%= `uname -a`.strip %>`
+
+Ready to hack.

data/lib/elelem/tool.rb

@@ -0,0 +1,32 @@
+# 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/bash.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Toolbox
+    class Bash < ::Elelem::Tool
+      attr_reader :tui
+
+      def initialize(configuration)
+        @tui = configuration.tui
+        super("bash", "Run commands in /bin/bash -c. Full access to filesystem, network, processes, and all Unix tools.", {
+          type: "object",
+          properties: {
+            command: { type: "string" }
+          },
+          required: ["command"]
+        })
+      end
+
+      def call(args)
+        command = args["command"]
+        output_buffer = []
+
+        Open3.popen3("/bin/bash", "-c", 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

data/lib/elelem/toolbox/mcp.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Toolbox
+    class MCP < ::Elelem::Tool
+      attr_reader :client, :tui
+
+      def initialize(client, tui, tool)
+        @client = client
+        @tui = tui
+        super(tool["name"], tool["description"], tool["inputSchema"] || {})
+      end
+
+      def call(args)
+        unless client.connected?
+          tui.say("MCP connection lost", colour: :red)
+          return ""
+        end
+
+        result = client.call(name, args)
+        tui.say(JSON.pretty_generate(result), newline: true)
+
+        if result.nil? || result.empty?
+          tui.say("Tool call failed: no response from MCP server", colour: :red)
+          return result
+        end
+
+        if result["error"]
+          tui.say(result["error"], colour: :red)
+          return result
+        end
+
+        result.dig("content", 0, "text") || result.to_s
+      end
+    end
+  end
+end

data/lib/elelem/tools.rb

@@ -2,61 +2,34 @@
 
 module Elelem
   class Tools
-    DEFAULT_TOOLS = [
-      {
-        type: "function",
-        function: {
-          name: "execute_command",
-          description: "Execute a shell command.",
-          parameters: {
-            type: "object",
-            properties: {
-              command: { type: "string" },
-            },
-            required: ["command"]
-          }
-        },
-        handler: lambda { |args|
-          stdout, stderr, _status = Open3.capture3("/bin/sh", "-c", args["command"])
-          stdout + stderr
-        }
-      },
-    ]
-
-    def initialize(tools = DEFAULT_TOOLS)
+    def initialize(configuration, tools)
+      @configuration = configuration
       @tools = tools
     end
 
     def banner
-      @tools.map do |h|
-        [
-          h.dig(:function, :name),
-          h.dig(:function, :description)
-        ].join(": ")
-      end.sort.join("\n  ")
+      tools.map(&:banner).sort.join("\n  ")
     end
 
     def execute(tool_call)
       name = tool_call.dig("function", "name")
       args = tool_call.dig("function", "arguments")
 
-      tool = @tools.find do |tool|
-        tool.dig(:function, :name) == name
+      tool = tools.find { |tool| tool.name == name }
+      return "Invalid function name: #{name}" if tool.nil?
+      return "Invalid function arguments: #{args}" unless tool.valid?(args)
+
+      CLI::UI::Frame.open(name) do
+        tool.call(args)
       end
-      tool&.fetch(:handler)&.call(args)
     end
 
     def to_h
-      @tools.map do |tool|
-        {
-          type: tool[:type],
-          function: {
-            name: tool.dig(:function, :name),
-            description: tool.dig(:function, :description),
-            parameters: tool.dig(:function, :parameters)
-          }
-        }
-      end
+      tools.map(&:to_h)
     end
+
+    private
+
+    attr_reader :configuration, :tools
   end
 end

data/lib/elelem/tui.rb

@@ -10,24 +10,52 @@ module Elelem
     end
 
     def prompt(message)
-      say(message)
-      stdin.gets&.chomp
+      Reline.readline(message, true)
     end
 
     def say(message, colour: :default, newline: false)
-      formatted_message = colourize(message, colour: colour)
       if newline
-        stdout.puts(formatted_message)
+        stdout.puts(colourize(message, colour: colour))
       else
-        stdout.print(formatted_message)
+        stdout.print(colourize(message, colour: colour))
       end
       stdout.flush
     end
 
+    def show_progress(message, icon = ".", colour: :gray)
+      timestamp = Time.now.strftime("%H:%M:%S")
+      say("\n[#{icon}] #{timestamp} #{message}", colour: colour, newline: true)
+    end
+
+    def clear_line
+      say("\r#{" " * 80}\r", newline: false)
+    end
+
+    def complete_progress(message = "Completed")
+      clear_line
+      show_progress(message, "✓", colour: :green)
+    end
+
     private
 
     def colourize(text, colour: :default)
       case colour
+      when :black
+        "\e[30m#{text}\e[0m"
+      when :red
+        "\e[31m#{text}\e[0m"
+      when :green
+        "\e[32m#{text}\e[0m"
+      when :yellow
+        "\e[33m#{text}\e[0m"
+      when :blue
+        "\e[34m#{text}\e[0m"
+      when :magenta
+        "\e[35m#{text}\e[0m"
+      when :cyan
+        "\e[36m#{text}\e[0m"
+      when :white
+        "\e[37m#{text}\e[0m"
       when :gray
         "\e[90m#{text}\e[0m"
       else

data/lib/elelem/version.rb

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

data/lib/elelem.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
+require "cli/ui"
+require "erb"
 require "json"
+require "json-schema"
 require "logger"
 require "net/http"
 require "open3"
+require "reline"
 require "thor"
+require "timeout"
 require "uri"
 
 require_relative "elelem/agent"
@@ -12,11 +17,26 @@ require_relative "elelem/api"
 require_relative "elelem/application"
 require_relative "elelem/configuration"
 require_relative "elelem/conversation"
-require_relative "elelem/state"
+require_relative "elelem/mcp_client"
+require_relative "elelem/states/idle"
+require_relative "elelem/states/working"
+require_relative "elelem/states/working/state"
+require_relative "elelem/states/working/error"
+require_relative "elelem/states/working/executing"
+require_relative "elelem/states/working/talking"
+require_relative "elelem/states/working/thinking"
+require_relative "elelem/states/working/waiting"
+require_relative "elelem/tool"
+require_relative "elelem/toolbox/bash"
+require_relative "elelem/toolbox/mcp"
 require_relative "elelem/tools"
 require_relative "elelem/tui"
 require_relative "elelem/version"
 
+CLI::UI::StdoutRouter.enable
+Reline.input = $stdin
+Reline.output = $stdout
+
 module Elelem
   class Error < StandardError; end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - mo khan
@@ -9,6 +9,34 @@ 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
+    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: json
   requirement: !ruby/object:Gem::Requirement
@@ -23,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  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: logger
   requirement: !ruby/object:Gem::Requirement
@@ -65,6 +107,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: reline
+  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: thor
   requirement: !ruby/object:Gem::Requirement
@@ -79,6 +135,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timeout
+  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: uri
   requirement: !ruby/object:Gem::Requirement
@@ -101,8 +171,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".rubocop.yml"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
@@ -114,11 +182,22 @@ files:
 - lib/elelem/application.rb
 - lib/elelem/configuration.rb
 - lib/elelem/conversation.rb
-- lib/elelem/state.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/bash.rb
+- lib/elelem/toolbox/mcp.rb
 - lib/elelem/tools.rb
 - lib/elelem/tui.rb
 - lib/elelem/version.rb
-- mise.toml
 - sig/elelem.rbs
 homepage: https://www.mokhan.ca
 licenses:
@@ -135,7 +214,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.rubocop.yml

@@ -1,8 +0,0 @@
-AllCops:
-  TargetRubyVersion: 3.1
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes

data/lib/elelem/state.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  class Idle
-    def run(agent)
-      agent.logger.debug("Idling...")
-      input = agent.prompt("\n> ")
-      agent.quit if input.nil? || input.empty? || input == "exit"
-
-      agent.conversation.add(role: :user, content: input)
-      agent.transition_to(Working.new)
-    end
-  end
-
-  class Working
-    class State
-      attr_reader :agent
-
-      def initialize(agent)
-        @agent = agent
-      end
-
-      def display_name
-        self.class.name.split("::").last
-      end
-    end
-
-    class Waiting < State
-      def process(message)
-        state = self
-
-        if message["thinking"] && !message["thinking"].empty?
-          state = Thinking.new(agent)
-        elsif message["tool_calls"]&.any?
-          state = Executing.new(agent)
-        elsif message["content"] && !message["content"].empty?
-          state = Talking.new(agent)
-        else
-          state = nil
-        end
-
-        state&.process(message)
-      end
-    end
-
-    class Thinking < State
-      def process(message)
-        if message["thinking"] && !message["thinking"]&.empty?
-          agent.say(message["thinking"], colour: :gray, newline: false)
-          self
-        else
-          agent.say("", newline: true)
-          Waiting.new(agent).process(message)
-        end
-      end
-    end
-
-    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
-
-        Waiting.new(agent)
-      end
-    end
-
-    class Talking < State
-      def process(message)
-        if message["content"] && !message["content"]&.empty?
-          agent.conversation.add(role: message["role"], content: message["content"])
-          agent.say(message["content"], colour: :default, newline: false)
-          self
-        else
-          agent.say("", newline: true)
-          Waiting.new(agent).process(message)
-        end
-      end
-    end
-
-    def run(agent)
-      agent.logger.debug("Working...")
-      state = Waiting.new(agent)
-      done = false
-
-      loop do
-        agent.api.chat(agent.conversation.history) do |chunk|
-          response = JSON.parse(chunk)
-          message = normalize(response["message"] || {})
-          done = response["done"]
-
-          agent.logger.debug("#{state.display_name}: #{message}")
-          state = state.process(message)
-        end
-
-        break if state.nil?
-        break if done && agent.conversation.history.last[:role] != :tool
-      end
-
-      agent.transition_to(Idle.new)
-    end
-
-    private
-
-    def normalize(message)
-      message.reject { |_key, value| value.empty? }
-    end
-  end
-end

data/mise.toml

@@ -1,2 +0,0 @@
-[tools]
-ruby = "latest"