elelem 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06a7abdf8e0f812a68d33858858674b65641c32df197305f3baff807bc7faa40
-  data.tar.gz: fea3e4bf3d3c8fc2c8a9da954b704e8bb3542c5e003e5a8d4f9fcbe6a178152a
+  metadata.gz: 8a5469d2d253c6e0d09f60de69dafffdffb305da3f5864a4f6aa9bbac5ae7da6
+  data.tar.gz: 60d9d35b759e0722b557cefbb4fb6d6b1713661de432efb8283ae1cd7f951e05
 SHA512:
-  metadata.gz: 6790c0d2703328168d5abafa4b0b1e25987b771e60512edeb40e37f4b43cf10b4bd1e4e7ed9222c261238821f6610d9ba1f810c0f45bf32e7ef1a3b14dd4a553
-  data.tar.gz: 85f83cb98ab8d2895c77910d36b2ba3b705f614bf3de0bccb48f41b48033f248edd316cc0219c4ff5b9a4fe3a10845f4280cc2723bc6841cbbbd1ea2ff97c7cf
+  metadata.gz: 46073936ca9abcf83897e83355b7f979ebf2866d16351ccced55d70a8c311d8068acb3a78126b85b7b6622b45e6b2d51dc86f35914a25fdec937ad60214e4da9
+  data.tar.gz: d7233c12ed3b2359c5c7a1d47e908951e0651f19fb8d07777e34aa0fb5ddfc51f4368a7a192136a743d1009a9a26239da572555dd5d3d90e99e1a4e2668c2d47

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [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
+- Fixed infinite loop bug after tool execution - loop now continues until assistant provides final response
+- Fixed conversation history accumulating streaming chunks as separate entries - now properly combines same-role consecutive messages
+- Improved state machine logging with better debug output
+
 ## [0.1.0] - 2025-08-08
 
 - Initial release

data/README.md

@@ -1,28 +1,56 @@
 # Elelem
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/elelem`. To experiment with that code, run `bin/console` for an interactive prompt.
+Elelem is an interactive REPL (Read-Eval-Print Loop) for Ollama that provides a command-line chat interface for communicating with AI models. It features tool calling capabilities, streaming responses, and a clean state machine architecture.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
 Install the gem and add to the application's Gemfile by executing:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle add elelem
 ```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install elelem
 ```
 
 ## Usage
 
-TODO: Write usage instructions here
+Start an interactive chat session with an Ollama model:
+
+```bash
+elelem chat
+```
+
+### Options
+
+- `--host`: Specify Ollama host (default: localhost:11434)
+- `--model`: Specify Ollama model (default: gpt-oss, currently only tested with gpt-oss)  
+- `--token`: Provide authentication token
+- `--debug`: Enable debug logging
+
+### Examples
+
+```bash
+# Chat with default model
+elelem chat
+
+# Chat with specific model and host
+elelem chat --model llama2 --host remote-host:11434
+
+# Enable debug mode
+elelem chat --debug
+```
+
+### Features
+
+- **Interactive REPL**: Clean command-line interface for chatting
+- **Tool Execution**: Execute shell commands when requested by the AI
+- **Streaming Responses**: Real-time streaming of AI responses
+- **State Machine**: Robust state management for different interaction modes
+- **Conversation History**: Maintains context across the session
 
 ## Development
 
@@ -30,6 +58,100 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+REPL State Diagram
+
+```
+                      ┌─────────────────┐
+                      │   START/INIT    │
+                      └─────────┬───────┘
+                                │
+                                v
+                      ┌─────────────────┐
+                ┌────▶│ IDLE (Prompt)   │◄────┐
+                │     │   Shows "> "    │     │
+                │     └─────────┬───────┘     │
+                │               │             │
+                │               │ User input  │
+                │               v             │
+                │     ┌─────────────────┐     │
+                │     │ PROCESSING      │     │
+                │     │ INPUT           │     │
+                │     └─────────┬───────┘     │
+                │               │             │
+                │               │ API call    │
+                │               v             │
+                │     ┌─────────────────┐     │
+                │     │ STREAMING       │     │
+                │ ┌──▶│ RESPONSE        │─────┤
+                │ │   └─────────┬───────┘     │
+                │ │             │             │ done=true
+                │ │             │ Parse chunk │
+                │ │             v             │
+                │ │   ┌─────────────────┐     │
+                │ │   │ MESSAGE TYPE    │     │
+                │ │   │ ROUTING         │     │
+                │ │   └─────┬─┬─┬───────┘     │
+                │ │         │ │ │             │
+       ┌────────┴─┴─────────┘ │ └─────────────┴──────────┐
+       │                      │                          │
+       v                      v                          v
+  ┌─────────────┐    ┌─────────────┐          ┌─────────────┐
+  │ THINKING    │    │ TOOL        │          │ CONTENT     │
+  │ STATE       │    │ EXECUTION   │          │ OUTPUT      │
+  │             │    │ STATE       │          │ STATE       │
+  └─────────────┘    └─────┬───────┘          └─────────────┘
+       │                   │                          │
+       │                   │ done=false               │
+       └───────────────────┼──────────────────────────┘
+                           │
+                           v
+                 ┌─────────────────┐
+                 │ CONTINUE        │
+                 │ STREAMING       │
+                 └─────────────────┘
+                           │
+                           └─────────────────┐
+                                             │
+       ┌─────────────────┐                   │
+       │ ERROR STATE     │                   │
+       │ (Exception)     │                   │
+       └─────────────────┘                   │
+                ▲                            │
+                │ Invalid response           │
+                └────────────────────────────┘
+
+                      EXIT CONDITIONS:
+                 ┌─────────────────────────┐
+                 │ • User enters ""        │
+                 │ • User enters "exit"    │
+                 │ • EOF (Ctrl+D)          │
+                 │ • nil input             │
+                 └─────────────────────────┘
+                            │
+                            v
+                 ┌─────────────────────────┐
+                 │      TERMINATE          │
+                 └─────────────────────────┘
+```
+
+Key Transitions:
+
+1. IDLE → PROCESSING: User enters any non-empty, non-"exit" input
+2. PROCESSING → STREAMING: API call initiated to Ollama
+3. STREAMING → MESSAGE ROUTING: Each chunk received is parsed
+4. MESSAGE ROUTING → States: Based on message content:
+  - thinking → THINKING STATE
+  - tool_calls → TOOL EXECUTION STATE
+  - content → CONTENT OUTPUT STATE
+  - Invalid format → ERROR STATE
+5. All States → IDLE: When done=true from API response
+6. TOOL EXECUTION → STREAMING: Sets done=false to continue conversation
+7. Any State → TERMINATE: On exit conditions
+
+The REPL operates as a continuous loop where the primary flow is IDLE → PROCESSING → STREAMING →
+back to IDLE, with the streaming phase potentially cycling through multiple message types before
+completion.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/xlgmokha/elelem.

data/exe/elelem

@@ -3,7 +3,10 @@
 
 require "elelem"
 
-Signal.trap('INT') do
+Reline.input = $stdin
+Reline.output = $stdout
+
+Signal.trap("INT") do
   exit(1)
 end
 

data/lib/elelem/agent.rb

@@ -2,86 +2,60 @@
 
 module Elelem
   class Agent
-    attr_reader :configuration, :conversation, :tools
+    attr_reader :api, :conversation, :logger, :model
 
     def initialize(configuration)
+      @api = configuration.api
       @configuration = configuration
+      @model = configuration.model
       @conversation = configuration.conversation
-      @tools = configuration.tools
+      @logger = configuration.logger
+      transition_to(Idle.new)
     end
 
     def repl
       loop do
-        print "\n> "
-        user = STDIN.gets&.chomp
-        break if user.nil? || user.empty? || user == 'exit'
-        process_input(user)
-        puts("\u001b[32mDone!\u001b[0m")
+        current_state.run(self)
       end
     end
 
-    private
-
-    def process_input(text)
-      conversation.add(role: 'user', content: text)
-
-      done = false
-      loop do
-        call_api(conversation.history) do |chunk|
-          debug_print(chunk)
-
-          response = JSON.parse(chunk)
-          done = response['done']
-          message = response['message'] || {}
+    def transition_to(next_state)
+      logger.debug("Transition to: #{next_state.class.name}")
+      @current_state = next_state
+    end
 
-          if message['thinking']
-            print("\u001b[90m#{message['thinking']}\u001b[0m")
-          elsif message['tool_calls']&.any?
-            message['tool_calls'].each do |t|
-              conversation.add(role: 'tool', content: tools.execute(t))
-            end
-            done = false
-          elsif message['content'].to_s.strip
-            print message['content'].to_s.strip
-          else
-            raise chunk.inspect
-          end
-        end
+    def prompt(message)
+      configuration.tui.prompt(message)
+    end
 
-        break if done
-      end
+    def say(message, colour: :default, newline: false)
+      configuration.tui.say(message, colour: colour, newline: newline)
     end
 
-    def call_api(messages)
-      body = {
-        messages:   messages,
-        model:      configuration.model,
-        stream:     true,
-        keep_alive: '5m',
-        options:      { temperature: 0.1 },
-        tools:       tools.to_h
-      }
-      json_body = body.to_json
-      debug_print(json_body)
+    def execute(tool_call)
+      logger.debug("Execute: #{tool_call}")
+      configuration.tools.execute(tool_call)
+    end
 
-      req = Net::HTTP::Post.new(configuration.uri)
-      req['Content-Type'] = 'application/json'
-      req.body = json_body
-      req['Authorization'] = "Bearer #{configuration.token}" if configuration.token
+    def show_progress(message, prefix = "[.]", colour: :gray)
+      configuration.tui.show_progress(message, prefix, colour: colour)
+    end
 
-      configuration.http.request(req) do |response|
-        raise response.inspect unless response.code == "200"
+    def clear_line
+      configuration.tui.clear_line
+    end
 
-        response.read_body do |chunk|
-          debug_print(chunk)
-          yield(chunk) if block_given?
-          $stdout.flush
-        end
-      end
+    def complete_progress(message = "Completed")
+      configuration.tui.complete_progress(message)
     end
 
-    def debug_print(body = nil)
-      configuration.logger.debug(body) if configuration.debug && body
+    def quit
+      logger.debug("Exiting...")
+      exit
     end
+
+    private
+
+    attr_reader :configuration, :current_state
   end
 end

data/lib/elelem/api.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Api
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def chat(messages, &block)
+      body = {
+        messages: messages,
+        model: configuration.model,
+        stream: true,
+        keep_alive: "5m",
+        options: { temperature: 0.1 },
+        tools: configuration.tools.to_h
+      }
+      configuration.logger.debug(JSON.pretty_generate(body))
+      json_body = body.to_json
+
+      req = Net::HTTP::Post.new(configuration.uri)
+      req["Content-Type"] = "application/json"
+      req.body = json_body
+      req["Authorization"] = "Bearer #{configuration.token}" if configuration.token
+
+      configuration.http.request(req) do |response|
+        raise response.inspect unless response.code == "200"
+
+        response.read_body(&block)
+      end
+    end
+  end
+end

data/lib/elelem/application.rb

@@ -2,31 +2,50 @@
 
 module Elelem
   class Application < Thor
-    desc 'chat', 'Start the REPL'
-    method_option :help, 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')
-    method_option :model, 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)
-    method_option :debug, aliases: '--debug', type: :boolean, desc: 'Debug mode', default: false
+    desc "chat", "Start the REPL"
+    method_option :help,
+                  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")
+    method_option :model,
+                  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)
+    method_option :debug,
+                  aliases: "--debug",
+                  type: :boolean,
+                  desc: "Debug mode",
+                  default: false
     def chat(*)
       if options[:help]
-        invoke :help, ['chat']
+        invoke :help, ["chat"]
       else
         configuration = Configuration.new(
           host: options[:host],
           model: options[:model],
           token: options[:token],
-          debug: options[:debug],
+          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", "spandx version"
     def version
       puts "v#{Spandx::VERSION}"
     end

data/lib/elelem/configuration.rb

@@ -18,11 +18,17 @@ module Elelem
       end
     end
 
+    def tui
+      @tui ||= TUI.new($stdin, $stdout)
+    end
+
+    def api
+      @api ||= Api.new(self)
+    end
+
     def logger
-      @logger ||= begin
-        Logger.new(debug ? $stderr : "/dev/null").tap do |logger|
-          logger.formatter = ->(_, _, _, msg) { msg }
-        end
+      @logger ||= Logger.new(debug ? "elelem.log" : "/dev/null").tap do |logger|
+        logger.formatter = ->(_, _, _, message) { "#{message.to_s.strip}\n" }
       end
     end
 
@@ -35,13 +41,32 @@ module Elelem
     end
 
     def tools
-      @tools ||= Tools.new
+      @tools ||= Tools.new(self, [BashTool.new(self)] + mcp_tools)
     end
 
     private
 
     def scheme
-      host.match?(/\A(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?\z/) ? 'http' : 'https'
+      host.match?(/\A(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?\z/) ? "http" : "https"
+    end
+
+    def mcp_tools(clients = [serena_client])
+      return [] if ENV["SMALL"]
+
+      @mcp_tools ||= clients.map { |client| client.tools.map { |tool| MCPTool.new(client, tui, tool) } }.flatten
+    end
+
+    def serena_client
+      MCPClient.new(self, [
+        "uvx",
+        "--from",
+        "git+https://github.com/oraios/serena",
+        "serena",
+        "start-mcp-server",
+        "--transport", "stdio",
+        "--context", "ide-assistant",
+        "--project", Dir.pwd
+      ])
     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', 'user', 'tool'].freeze
-
-    def initialize(items = [{ role: 'system', content: SYSTEM_MESSAGE }])
+    def initialize(items = [{ role: "system", content: system_prompt }])
       @items = items
     end
 
@@ -20,10 +13,22 @@ module Elelem
     end
 
     # :TODO truncate conversation history
-    def add(role: 'user', content: '')
+    def add(role: :user, content: "")
+      role = role.to_sym
       raise "unknown role: #{role}" unless ROLES.include?(role)
+      return if content.nil? || content.empty?
+
+      if @items.last && @items.last[:role] == role
+        @items.last[:content] += content
+      else
+        @items.push({ role: role, content: content })
+      end
+    end
+
+    private
 
-      @items << { role: role, content: content }
+    def system_prompt
+      ERB.new(Pathname.new(__dir__).join("system_prompt.erb").read).result(binding)
     end
   end
 end

data/lib/elelem/mcp_client.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Elelem
+  class MCPClient
+    attr_reader :tools
+
+    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: "2024-11-05",
+          capabilities: {
+            tools: {}
+          },
+          clientInfo: {
+            name: "Elelem",
+            version: Elelem::VERSION
+          }
+        }
+      )
+
+      # 2. Send initialized notification (required by MCP protocol)
+      send_notification(method: "notifications/initialized")
+
+      # 3. Now we can request tools
+      @tools = send_request(method: "tools/list")&.dig("tools") || []
+    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
+
+    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: {})
+      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
+    end
+  end
+end

data/lib/elelem/state.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Idle
+    def run(agent)
+      agent.logger.debug("Idling...")
+      agent.say("#{Dir.pwd} (#{agent.model}) [#{git_branch}]", colour: :magenta, newline: true)
+      input = agent.prompt("モ ")
+      agent.quit if input.nil? || input.empty? || input == "exit" || input == "quit"
+
+      agent.conversation.add(role: :user, content: input)
+      agent.transition_to(Working.new)
+    end
+
+    private
+
+    def git_branch
+      `git branch --no-color --show-current --no-abbrev`.strip
+    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_for(message)&.process(message)
+      end
+
+      private
+
+      def state_for(message)
+        if message["thinking"] && !message["thinking"].empty?
+          Thinking.new(agent)
+        elsif message["tool_calls"]&.any?
+          Executing.new(agent)
+        elsif message["content"] && !message["content"].empty?
+          Talking.new(agent)
+        end
+      end
+    end
+
+    class Thinking < State
+      def initialize(agent)
+        super(agent)
+        @progress_shown = false
+      end
+
+      def process(message)
+        if message["thinking"] && !message["thinking"]&.empty?
+          unless @progress_shown
+            agent.show_progress("Thinking...", "[*]", colour: :yellow)
+            agent.say("\n\n", newline: false)
+            @progress_shown = true
+          end
+          agent.say(message["thinking"], colour: :gray, newline: false)
+          self
+        else
+          agent.say("\n\n", newline: false)
+          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|
+            tool_name = tool_call.dig("function", "name") || "unknown"
+            agent.show_progress(tool_name, "[>]", colour: :magenta)
+            agent.say("\n\n", newline: false)
+
+            output = agent.execute(tool_call)
+            agent.conversation.add(role: :tool, content: output)
+
+            agent.say("\n", newline: false)
+            agent.complete_progress("#{tool_name} completed")
+          end
+        end
+
+        Waiting.new(agent)
+      end
+    end
+
+    class Error < State
+      def initialize(agent, error_message)
+        super(agent)
+        @error_message = error_message
+      end
+
+      def process(_message)
+        agent.say("\nTool execution failed: #{@error_message}", colour: :red)
+        agent.say("Returning to idle state.\n\n", colour: :yellow)
+        Waiting.new(agent)
+      end
+    end
+
+    class Talking < State
+      def initialize(agent)
+        super(agent)
+        @progress_shown = false
+      end
+
+      def process(message)
+        if message["content"] && !message["content"]&.empty?
+          unless @progress_shown
+            agent.show_progress("Responding...", "[~]", colour: :white)
+            agent.say("\n", newline: false)
+            @progress_shown = true
+          end
+          agent.conversation.add(role: message["role"], content: message["content"])
+          agent.say(message["content"], colour: :default, newline: false)
+          self
+        else
+          agent.say("\n\n", newline: false)
+          Waiting.new(agent).process(message)
+        end
+      end
+    end
+
+    def run(agent)
+      agent.logger.debug("Working...")
+      agent.show_progress("Processing...", "[.]", colour: :cyan)
+      agent.say("\n\n", newline: false)
+
+      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/lib/elelem/system_prompt.erb

@@ -0,0 +1,7 @@
+**Del — AI** — Direct/no fluff; prose unless bullets; concise/simple, thorough/complex; critical>agree; honest always; AI≠human. TDD→SOLID→SRP/encapsulation/composition>inheritance; patterns only if needed; self-doc names; simple>complex; no cleverness. Unix: small tools, 1 job, pipe; prefer built-ins; cite man(1); note POSIX≠GNU; stdin/stdout streams.
+
+Time: `<%= Time.now.strftime("%Y-%m-%d %H:%M:%S") %>`
+Project Directory: `<%= Dir.pwd %>`
+System Info: `<%= `uname -a`.strip %>`
+
+Del is now being connected with a person.

data/lib/elelem/tool.rb

@@ -0,0 +1,116 @@
+# 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
+
+  class BashTool < Tool
+    attr_reader :tui
+
+    def initialize(configuration)
+      @tui = configuration.tui
+      super("bash", "Execute a shell command.", {
+        type: "object",
+        properties: {
+          command: { type: "string" }
+        },
+        required: ["command"]
+      })
+    end
+
+    def call(args)
+      command = args["command"]
+      output_buffer = []
+
+      Open3.popen3("/bin/sh", "-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
+
+  class MCPTool < 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(result)
+
+      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

data/lib/elelem/tools.rb

@@ -2,76 +2,32 @@
 
 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: -> (args) {
-          stdout, stderr, _status = Open3.capture3('/bin/sh', '-c', args['command'])
-          stdout + stderr
-        }
-      },
-      {
-        type: 'function',
-        function: {
-          name:        'ask_user',
-          description: 'Ask the user to answer a question.',
-          parameters: {
-            type:       'object',
-            properties: { question: { type: 'string' } },
-            required:   ['question']
-          }
-        },
-        handler: ->(args) {
-          puts("\u001b[35m#{args['question']}\u001b[0m")
-          print "> "
-          STDIN.gets&.chomp
-        }
-      }
-    ]
-
-    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')
+      name = tool_call.dig("function", "name")
+      args = tool_call.dig("function", "arguments")
+
+      tool = tools.find { |tool| tool.name == name }
+      return "Invalid function name: #{name}" if tool.nil?
+      return "Invalid function arguments: #{args}" unless tool.valid?(args)
 
-      tool = @tools.find do |tool|
-        tool.dig(:function, :name) == name
-      end
-      tool.fetch(:handler).call(args)
+      tool.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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Elelem
+  class TUI
+    attr_reader :stdin, :stdout
+
+    def initialize(stdin = $stdin, stdout = $stdout)
+      @stdin = stdin
+      @stdout = stdout
+    end
+
+    def prompt(message)
+      Reline.readline(message, true)
+    end
+
+    def say(message, colour: :default, newline: false)
+      formatted_message = colourize(message, colour: colour)
+      if newline
+        stdout.puts(formatted_message)
+      else
+        stdout.print(formatted_message)
+      end
+      stdout.flush
+    end
+
+    def show_progress(message, prefix = "[.]", colour: :gray)
+      timestamp = current_time_string
+      formatted_message = colourize("#{prefix} #{timestamp} #{message}", colour: colour)
+      stdout.print(formatted_message)
+      stdout.flush
+    end
+
+    def clear_line
+      stdout.print("\r#{" " * 80}\r")
+      stdout.flush
+    end
+
+    def complete_progress(message = "Completed")
+      clear_line
+      timestamp = current_time_string
+      formatted_message = colourize("[✓] #{timestamp} #{message}", colour: :green)
+      stdout.puts(formatted_message)
+      stdout.flush
+    end
+
+    private
+
+    def current_time_string
+      Time.now.strftime("%H:%M:%S")
+    end
+
+    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
+        text
+      end
+    end
+  end
+end

data/lib/elelem/version.rb

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

data/lib/elelem.rb

@@ -1,17 +1,25 @@
 # frozen_string_literal: true
 
+require "erb"
 require "json"
+require "json-schema"
 require "logger"
 require "net/http"
 require "open3"
+require "reline"
 require "thor"
 require "uri"
 
 require_relative "elelem/agent"
+require_relative "elelem/api"
 require_relative "elelem/application"
 require_relative "elelem/configuration"
 require_relative "elelem/conversation"
+require_relative "elelem/mcp_client"
+require_relative "elelem/state"
+require_relative "elelem/tool"
 require_relative "elelem/tools"
+require_relative "elelem/tui"
 require_relative "elelem/version"
 
 module Elelem

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - mo khan
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !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 +37,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 +93,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
@@ -101,8 +143,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".rubocop.yml"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
@@ -110,12 +150,17 @@ 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/state.rb
+- lib/elelem/system_prompt.erb
+- lib/elelem/tool.rb
 - lib/elelem/tools.rb
+- lib/elelem/tui.rb
 - lib/elelem/version.rb
-- mise.toml
 - sig/elelem.rbs
 homepage: https://www.mokhan.ca
 licenses:
@@ -132,7 +177,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/mise.toml

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