elelem 0.1.3 → 0.2.1

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.1"
 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.1
 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,25 +149,13 @@ 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
 executables:
 - elelem
+- llm-ollama
+- llm-openai
 extensions: []
 extra_rdoc_files: []
 files:
@@ -176,6 +164,8 @@ files:
 - README.md
 - Rakefile
 - exe/elelem
+- exe/llm-ollama
+- exe/llm-openai
 - lib/elelem.rb
 - lib/elelem/agent.rb
 - lib/elelem/api.rb
@@ -193,12 +183,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 +215,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