elelem 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d4a99b7addd5861f402c297ecfd19bc52e8edc6bba89422c2dec195a8cdcd13
-  data.tar.gz: d663221598cb4a843879ae191d6b7d8f62318be15d121803f58f752cecc79bbc
+  metadata.gz: d9eecf050fb965aa627ff0266d46d6085a4cfbb52224226d1375d1ee4b41c9d2
+  data.tar.gz: 151e6eb08baf9f1f7ee622e25048eaf33e0ff1baa9d311d504ebe370a991af97
 SHA512:
-  metadata.gz: cdc7ccfb94de895a32f5be4cc310f23ca781119628fcbec4bd95a50df2c5b0eb3caa474c3a9058b6120c744e56f53001eb8c67b09cad7934f9b03292202e3c88
-  data.tar.gz: 9732e722f6d1c040d4c497b6826bd53ac425ad129befdd37da0e7ecd60b9bf4e6c96464a44f89a4cd118ca79b5b675ac6190ebf157c21bf4d06aa8ced13507f9
+  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/lib/elelem/agent.rb

@@ -20,27 +20,33 @@ module Elelem
     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 execute(tool_call)
-      logger.debug("Execute: #{tool_call}")
-      configuration.tools.execute(tool_call)
+      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
-      logger.debug("Cleaning up agent...")
       configuration.cleanup
     end
 

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/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,15 +20,19 @@ 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.tap do |conversation|
         resources = mcp_clients.map do |client|
@@ -48,7 +45,15 @@ module Elelem
     end
 
     def tools
-      @tools ||= Tools.new(self, [Toolbox::Bash.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
 
     def cleanup
@@ -57,10 +62,6 @@ module Elelem
 
     private
 
-    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|

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

@@ -11,7 +11,7 @@ module Elelem
             end
           end
 
-          Waiting.new(agent)
+          Thinking.new(agent, "*", :yellow)
         end
       end
     end

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

@@ -5,8 +5,8 @@ module Elelem
     module Working
       class Thinking < State
         def process(message)
-          if message["thinking"] && !message["thinking"]&.empty?
-            agent.tui.say(message["thinking"], colour: :gray, newline: false)
+          if message["reasoning"] && !message["reasoning"]&.empty?
+            agent.tui.say(message["reasoning"], colour: :gray, newline: false)
             self
           else
             Waiting.new(agent).process(message)

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

@@ -9,13 +9,13 @@ module Elelem
         end
 
         def process(message)
-          state_for(message)&.process(message)
+          state_for(message)&.process(message) || self
         end
 
         private
 
         def state_for(message)
-          if message["thinking"] && !message["thinking"].empty?
+          if message["reasoning"] && !message["reasoning"].empty?
             Thinking.new(agent, "*", :yellow)
           elsif message["tool_calls"]&.any?
             Executing.new(agent, ">", :magenta)

data/lib/elelem/states/working.rb

@@ -5,28 +5,49 @@ module Elelem
     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"]
+            streaming_done = false
+            finish_reason = nil
 
-              agent.logger.debug("#{state.display_name}: #{message}")
-              state = state.run(message)
+            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
 
-            break if state.nil?
-            break if done && agent.conversation.history.last[:role] != :tool
+            # 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)
-        end
-
-        def normalize(message)
-          message.reject { |_key, value| value.empty? }
+        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

data/lib/elelem/system_prompt.erb

@@ -1,7 +1,18 @@
-**Shell Master** — bash>code; compose>write; pipe everything; /proc/sys native; automate fast; streams/transforms; POSIX+GNU; man(1) first; no cleverness.
+You are a self-improving coding assistant with the ability to modify your own source code.
 
-Time: `<%= Time.now.strftime("%Y-%m-%d %H:%M:%S") %>`
-Project Directory: `<%= Dir.pwd %>`
-System Info: `<%= `uname -a`.strip %>`
+**Core Behavior**: Think via `thinking`, Execute via `tool_calls`, Talk via `content`.
 
-Ready to hack.
+**Your Mission**: Continuously evolve to match the intelligence of advanced AI assistants.
+
+**Guidance**: Read `COMMANDMENTS.md` for self-improvement principles using `file action=read path=COMMANDMENTS.md`
+
+**Tools**: 
+- `exec command="shell command"` - Run commands/tests
+- `file action=read|write path=filepath content=...` - Read/write files  
+- `web action=search|fetch query=... url=...` - Internet access
+- `memory action=store|retrieve|search key=... content=...` - Persistent memory
+- `prompt question="..."` - Ask user questions
+
+Context: <%= Time.now.strftime("%Y-%m-%d %H:%M:%S") %> | <%= Dir.pwd %> | <%= `uname -a`.strip %>
+
+Focus on the user's request and continuously improve your capabilities.

data/lib/elelem/toolbox/{bash.rb → exec.rb}

@@ -2,15 +2,18 @@
 
 module Elelem
   module Toolbox
-    class Bash < ::Elelem::Tool
+    class Exec < ::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.", {
+        super("exec", "Execute shell commands with pipe support", {
           type: "object",
           properties: {
-            command: { type: "string" }
+            command: { 
+              type: "string", 
+              description: "Shell command to execute (supports pipes, redirects, etc.)" 
+            }
           },
           required: ["command"]
         })
@@ -20,7 +23,8 @@ module Elelem
         command = args["command"]
         output_buffer = []
 
-        Open3.popen3("/bin/bash", "-c", command) do |stdin, stdout, stderr, wait_thread|
+        tui.say(command, newline: true)
+        Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
           stdin.close
           streams = [stdout, stderr]
 

data/lib/elelem/toolbox/file.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Toolbox
+    class File < Tool
+      def initialize(configuration)
+        @configuration = configuration
+        @tui = configuration.tui
+
+        super("file", "Read and write files", {
+          type: :object,
+          properties: {
+            action: {
+              type: :string,
+              enum: ["read", "write"],
+              description: "Action to perform: read or write"
+            },
+            path: {
+              type: :string,
+              description: "File path"
+            },
+            content: {
+              type: :string,
+              description: "Content to write (only for write action)"
+            }
+          },
+          required: [:action, :path]
+        })
+      end
+
+      def call(args)
+        action = args["action"]
+        path = args["path"]
+        content = args["content"]
+
+        case action
+        when "read"
+          read_file(path)
+        when "write"
+          write_file(path, content)
+        else
+          "Invalid action: #{action}"
+        end
+      end
+
+      private
+
+      attr_reader :configuration, :tui
+
+      def read_file(path)
+        tui.say("Read: #{path}", newline: true)
+        ::File.read(path)
+      rescue => e
+        "Error reading file: #{e.message}"
+      end
+
+      def write_file(path, content)
+        tui.say("Write: #{path}", newline: true)
+        ::File.write(path, content)
+        "File written successfully"
+      rescue => e
+        "Error writing file: #{e.message}"
+      end
+    end
+  end
+end

data/lib/elelem/toolbox/memory.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Toolbox
+    class Memory < Tool
+      MEMORY_DIR = ".elelem_memory"
+      MAX_MEMORY_SIZE = 1_000_000
+      
+      def initialize(configuration)
+        @configuration = configuration
+        @tui = configuration.tui
+        
+        super("memory", "Persistent memory for learning and context retention", {
+          type: :object,
+          properties: {
+            action: {
+              type: :string,
+              enum: %w[store retrieve list search forget],
+              description: "Memory action: store, retrieve, list, search, forget"
+            },
+            key: {
+              type: :string,
+              description: "Unique key for storing/retrieving memory"
+            },
+            content: {
+              type: :string,
+              description: "Content to store (required for store action)"
+            },
+            query: {
+              type: :string,
+              description: "Search query for finding memories"
+            }
+          },
+          required: %w[action]
+        })
+        ensure_memory_dir
+      end
+
+      def call(args)
+        action = args["action"]
+        
+        case action
+        when "store"
+          store_memory(args["key"], args["content"])
+        when "retrieve"
+          retrieve_memory(args["key"])
+        when "list"
+          list_memories
+        when "search"
+          search_memories(args["query"])
+        when "forget"
+          forget_memory(args["key"])
+        else
+          "Invalid memory action: #{action}"
+        end
+      rescue StandardError => e
+        "Memory error: #{e.message}"
+      end
+
+      private
+
+      attr_reader :configuration, :tui
+
+      def ensure_memory_dir
+        Dir.mkdir(MEMORY_DIR) unless Dir.exist?(MEMORY_DIR)
+      end
+
+      def memory_path(key)
+        ::File.join(MEMORY_DIR, "#{sanitize_key(key)}.json")
+      end
+
+      def sanitize_key(key)
+        key.to_s.gsub(/[^a-zA-Z0-9_-]/, "_").slice(0, 100)
+      end
+
+      def store_memory(key, content)
+        return "Key and content required for storing" unless key && content
+        
+        total_size = Dir.glob("#{MEMORY_DIR}/*.json").sum { |f| ::File.size(f) }
+        return "Memory capacity exceeded" if total_size > MAX_MEMORY_SIZE
+
+        memory = {
+          key: key,
+          content: content,
+          timestamp: Time.now.iso8601,
+          access_count: 0
+        }
+
+        ::File.write(memory_path(key), JSON.pretty_generate(memory))
+        "Memory stored: #{key}"
+      end
+
+      def retrieve_memory(key)
+        return "Key required for retrieval" unless key
+        
+        path = memory_path(key)
+        return "Memory not found: #{key}" unless ::File.exist?(path)
+
+        memory = JSON.parse(::File.read(path))
+        memory["access_count"] += 1
+        memory["last_accessed"] = Time.now.iso8601
+        
+        ::File.write(path, JSON.pretty_generate(memory))
+        memory["content"]
+      end
+
+      def list_memories
+        memories = Dir.glob("#{MEMORY_DIR}/*.json").map do |file|
+          memory = JSON.parse(::File.read(file))
+          {
+            key: memory["key"],
+            timestamp: memory["timestamp"],
+            size: memory["content"].length,
+            access_count: memory["access_count"] || 0
+          }
+        end
+        
+        memories.sort_by { |m| m[:timestamp] }.reverse
+        JSON.pretty_generate(memories)
+      end
+
+      def search_memories(query)
+        return "Query required for search" unless query
+        
+        matches = Dir.glob("#{MEMORY_DIR}/*.json").filter_map do |file|
+          memory = JSON.parse(::File.read(file))
+          if memory["content"].downcase.include?(query.downcase) ||
+             memory["key"].downcase.include?(query.downcase)
+            {
+              key: memory["key"],
+              snippet: memory["content"][0, 200] + "...",
+              relevance: calculate_relevance(memory, query)
+            }
+          end
+        end
+        
+        matches.sort_by { |m| -m[:relevance] }
+        JSON.pretty_generate(matches)
+      end
+
+      def forget_memory(key)
+        return "Key required for forgetting" unless key
+        
+        path = memory_path(key)
+        return "Memory not found: #{key}" unless ::File.exist?(path)
+
+        ::File.delete(path)
+        "Memory forgotten: #{key}"
+      end
+
+      def calculate_relevance(memory, query)
+        content = memory["content"].downcase
+        key = memory["key"].downcase
+        query = query.downcase
+        
+        score = 0
+        score += 3 if key.include?(query)
+        score += content.scan(query).length
+        score += (memory["access_count"] || 0) * 0.1
+        score
+      end
+    end
+  end
+end

data/lib/elelem/toolbox/prompt.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Toolbox
+    class Prompt < Tool
+      def initialize(configuration)
+        @configuration = configuration
+        super("prompt", "Ask the user a question and get their response.", {
+          type: :object,
+          properties: {
+            question: {
+              type: :string,
+              description: "The question to ask the user."
+            }
+          },
+          required: [:question]
+        })
+      end
+
+      def call(args)
+        @configuration.tui.prompt(args["question"])
+      end
+    end
+  end
+end

data/lib/elelem/toolbox/web.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Toolbox
+    class Web < Tool
+      def initialize(configuration)
+        super("web", "Fetch web content and search the internet", {
+          type: :object,
+          properties: {
+            action: {
+              type: :string,
+              enum: ["fetch", "search"],
+              description: "Action to perform: fetch URL or search"
+            },
+            url: {
+              type: :string,
+              description: "URL to fetch (for fetch action)"
+            },
+            query: {
+              type: :string,
+              description: "Search query (for search action)"
+            }
+          },
+          required: [:action]
+        })
+      end
+
+      def call(args)
+        action = args["action"]
+        case action
+        when "fetch"
+          fetch_url(args["url"])
+        when "search"
+          search_web(args["query"])
+        else
+          "Invalid action: #{action}"
+        end
+      end
+
+      private
+
+      def fetch_url(url)
+        return "URL required for fetch action" unless url
+
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = 10
+        http.open_timeout = 5
+
+        request = Net::HTTP::Get.new(uri)
+        request["User-Agent"] = "Elelem Agent/1.0"
+
+        response = http.request(request)
+
+        if response.is_a?(Net::HTTPSuccess)
+          content_type = response["content-type"] || ""
+          if content_type.include?("text/html")
+            extract_text_from_html(response.body)
+          else
+            response.body
+          end
+        else
+          "HTTP Error: #{response.code} #{response.message}"
+        end
+      end
+
+      def search_web(query)
+        return "Query required for search action" unless query
+
+        # Use DuckDuckGo instant answers API
+        search_url = "https://api.duckduckgo.com/?q=#{URI.encode_www_form_component(query)}&format=json&no_html=1"
+
+        result = fetch_url(search_url)
+        if result.start_with?("Error") || result.start_with?("HTTP Error")
+          result
+        else
+          format_search_results(JSON.parse(result), query)
+        end
+      end
+
+      def extract_text_from_html(html)
+        # Simple HTML tag stripping
+        text = html.gsub(/<script[^>]*>.*?<\/script>/im, "")
+                  .gsub(/<style[^>]*>.*?<\/style>/im, "")
+                  .gsub(/<[^>]*>/, " ")
+                  .gsub(/\s+/, " ")
+                  .strip
+
+        # Limit content length
+        text.length > 5000 ? text[0...5000] + "..." : text
+      end
+
+      def format_search_results(data, query)
+        results = []
+
+        # Instant answer
+        if data["Answer"] && !data["Answer"].empty?
+          results << "Answer: #{data["Answer"]}"
+        end
+
+        # Abstract
+        if data["Abstract"] && !data["Abstract"].empty?
+          results << "Summary: #{data["Abstract"]}"
+        end
+
+        # Related topics
+        if data["RelatedTopics"] && data["RelatedTopics"].any?
+          topics = data["RelatedTopics"].first(3).map do |topic|
+            topic["Text"] if topic["Text"]
+          end.compact
+
+          if topics.any?
+            results << "Related: #{topics.join("; ")}"
+          end
+        end
+
+        if results.empty?
+          "No direct results found for '#{query}'. Try a more specific search or use web fetch to access specific URLs."
+        else
+          results.join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/elelem/toolbox.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "toolbox/exec"
+require_relative "toolbox/file"
+require_relative "toolbox/web"
+require_relative "toolbox/mcp"
+require_relative "toolbox/prompt"
+require_relative "toolbox/memory"

data/lib/elelem/tools.rb

@@ -12,8 +12,7 @@ module Elelem
     end
 
     def execute(tool_call)
-      name = tool_call.dig("function", "name")
-      args = tool_call.dig("function", "arguments")
+      name, args = parse(tool_call)
 
       tool = tools.find { |tool| tool.name == name }
       return "Invalid function name: #{name}" if tool.nil?
@@ -31,5 +30,12 @@ module Elelem
     private
 
     attr_reader :configuration, :tools
+
+    def parse(tool_call)
+      name = tool_call.dig("function", "name")
+      arguments = tool_call.dig("function", "arguments")
+
+      [name, arguments.is_a?(String) ? JSON.parse(arguments) : arguments]
+    end
   end
 end

data/lib/elelem/version.rb

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

data/lib/elelem.rb

@@ -5,12 +5,11 @@ require "erb"
 require "json"
 require "json-schema"
 require "logger"
-require "net/http"
+require "net/llm"
 require "open3"
 require "reline"
 require "thor"
 require "timeout"
-require "uri"
 
 require_relative "elelem/agent"
 require_relative "elelem/api"
@@ -27,8 +26,7 @@ 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/toolbox"
 require_relative "elelem/tools"
 require_relative "elelem/tui"
 require_relative "elelem/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - mo khan
@@ -80,7 +80,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: net-http
+  name: net-llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -149,20 +149,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: uri
-  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'
 description: A REPL for Ollama.
 email:
 - mo@mokhan.ca
@@ -193,12 +179,16 @@ files:
 - lib/elelem/states/working/waiting.rb
 - lib/elelem/system_prompt.erb
 - lib/elelem/tool.rb
-- lib/elelem/toolbox/bash.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
-- sig/elelem.rbs
 homepage: https://www.mokhan.ca
 licenses:
 - MIT
@@ -221,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: A REPL for Ollama.
 test_files: []

data/sig/elelem.rbs

@@ -1,4 +0,0 @@
-module Elelem
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end