elelem 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a5469d2d253c6e0d09f60de69dafffdffb305da3f5864a4f6aa9bbac5ae7da6
-  data.tar.gz: 60d9d35b759e0722b557cefbb4fb6d6b1713661de432efb8283ae1cd7f951e05
+  metadata.gz: d9eecf050fb965aa627ff0266d46d6085a4cfbb52224226d1375d1ee4b41c9d2
+  data.tar.gz: 151e6eb08baf9f1f7ee622e25048eaf33e0ff1baa9d311d504ebe370a991af97
 SHA512:
-  metadata.gz: 46073936ca9abcf83897e83355b7f979ebf2866d16351ccced55d70a8c311d8068acb3a78126b85b7b6622b45e6b2d51dc86f35914a25fdec937ad60214e4da9
-  data.tar.gz: d7233c12ed3b2359c5c7a1d47e908951e0651f19fb8d07777e34aa0fb5ddfc51f4368a7a192136a743d1009a9a26239da572555dd5d3d90e99e1a4e2668c2d47
+  metadata.gz: 3d23eec1c298290ddd9480093b8ed908fbcbe1f55bb468618abaf445a6c1545fb4e43c995e8d4fce1655c7e92d255aed8237cc46fa48675e462fcb68718aa85c
+  data.tar.gz: f3dce29e2aa754be66f2c4cb01093f5ebb10788e96299e5925fbae59df7196cc3eed548aa154876184471ed3a4491260f969fe0409581ef8bbd89624cafedf9f

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## [Unreleased]
 
+## [0.2.0] - 2025-10-15
+
+### Added
+- New `llm-ollama` executable - minimal coding agent with streaming support for Ollama
+- New `llm-openai` executable - minimal coding agent for OpenAI/compatible APIs
+- Memory feature for persistent context storage and retrieval
+- Web fetch tool for retrieving and analyzing web content
+- Streaming responses with real-time token display
+- Visual "thinking" progress indicators with dots during reasoning phase
+
+### Changed
+- **BREAKING**: Migrated from custom Net::HTTP implementation to `net-llm` gem
+- API client now uses `Net::Llm::Ollama` for better reliability and maintainability
+- Removed direct dependencies on `net-http` and `uri` (now transitive through net-llm)
+- Maps Ollama's `thinking` field to internal `reasoning` field
+- Maps Ollama's `done_reason` to internal `finish_reason`
+- Improved system prompt for better agent behavior
+- Enhanced error handling and logging
+
+### Fixed
+- Response processing for Ollama's native message format
+- Tool argument parsing to handle both string and object formats
+- Safe navigation operator usage to prevent nil errors
+
 ## [0.1.2] - 2025-08-14
 
 ### Fixed

data/README.md

@@ -58,100 +58,6 @@ 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,9 +3,6 @@
 
 require "elelem"
 
-Reline.input = $stdin
-Reline.output = $stdout
-
 Signal.trap("INT") do
   exit(1)
 end

data/lib/elelem/agent.rb

@@ -2,58 +2,54 @@
 
 module Elelem
   class Agent
-    attr_reader :api, :conversation, :logger, :model
+    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
       loop do
         current_state.run(self)
+        sleep 0.1
       end
     end
 
     def transition_to(next_state)
-      logger.debug("Transition to: #{next_state.class.name}")
+      if @current_state
+        logger.info("AGENT: #{@current_state.class.name.split('::').last} -> #{next_state.class.name.split('::').last}")
+      else
+        logger.info("AGENT: Starting in #{next_state.class.name.split('::').last}")
+      end
       @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)
-    end
-
-    def show_progress(message, prefix = "[.]", colour: :gray)
-      configuration.tui.show_progress(message, prefix, colour: colour)
-    end
-
-    def clear_line
-      configuration.tui.clear_line
-    end
-
-    def complete_progress(message = "Completed")
-      configuration.tui.complete_progress(message)
+      tool_name = tool_call.dig("function", "name")
+      logger.debug("TOOL: Full call - #{tool_call}")
+      result = configuration.tools.execute(tool_call)
+      logger.debug("TOOL: Result (#{result.length} chars)") if result
+      result
     end
 
     def quit
-      logger.debug("Exiting...")
+      cleanup
       exit
     end
 
+    def cleanup
+      configuration.cleanup
+    end
+
     private
 
     attr_reader :configuration, :current_state

data/lib/elelem/api.rb

@@ -1,35 +1,48 @@
 # frozen_string_literal: true
 
+require "net/llm"
+
 module Elelem
   class Api
-    attr_reader :configuration
+    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)
-      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)
+      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/application.rb

@@ -45,9 +45,9 @@ module Elelem
       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

@@ -11,13 +11,6 @@ module Elelem
       @debug = debug
     end
 
-    def http
-      @http ||= Net::HTTP.new(uri.host, uri.port).tap do |h|
-        h.read_timeout = 3_600
-        h.open_timeout = 10
-      end
-    end
-
     def tui
       @tui ||= TUI.new($stdin, $stdout)
     end
@@ -27,46 +20,65 @@ module Elelem
     end
 
     def logger
-      @logger ||= Logger.new(debug ? "elelem.log" : "/dev/null").tap do |logger|
-        logger.formatter = ->(_, _, _, message) { "#{message.to_s.strip}\n" }
+      @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 uri
-      @uri ||= URI("#{scheme}://#{host}/api/chat")
-    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(self, [BashTool.new(self)] + mcp_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
 
-    private
-
-    def scheme
-      host.match?(/\A(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?\z/) ? "http" : "https"
+    def cleanup
+      @mcp_clients&.each(&:shutdown)
     end
 
-    def mcp_tools(clients = [serena_client])
-      return [] if ENV["SMALL"]
+    private
 
-      @mcp_tools ||= clients.map { |client| client.tools.map { |tool| MCPTool.new(client, tui, tool) } }.flatten
+    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 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
-      ])
+    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

@@ -21,7 +21,7 @@ module Elelem
       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
 
@@ -30,5 +30,13 @@ module Elelem
     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
 end

data/lib/elelem/mcp_client.rb

@@ -2,7 +2,7 @@
 
 module Elelem
   class MCPClient
-    attr_reader :tools
+    attr_reader :tools, :resources
 
     def initialize(configuration, command = [])
       @configuration = configuration
@@ -12,7 +12,7 @@ module Elelem
       send_request(
         method: "initialize",
         params: {
-          protocolVersion: "2024-11-05",
+          protocolVersion: "2025-06-08",
           capabilities: {
             tools: {}
           },
@@ -23,11 +23,12 @@ module Elelem
         }
       )
 
-      # 2. Send initialized notification (required by MCP protocol)
+      # 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?
@@ -53,6 +54,33 @@ module Elelem
       )
     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
@@ -86,6 +114,8 @@ module Elelem
     end
 
     def send_notification(method:, params: {})
+      return unless connected?
+
       notification = {
         jsonrpc: "2.0",
         method: method
@@ -94,6 +124,13 @@ module Elelem
       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
+
+          Thinking.new(agent, "*", :yellow)
+        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["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