elelem 0.2.1 → 0.3.0

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

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

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

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class Waiting < State
-        def initialize(agent)
-          super(agent, ".", :cyan)
-        end
-
-        def process(message)
-          state_for(message)&.process(message) || self
-        end
-
-        private
-
-        def state_for(message)
-          if message["reasoning"] && !message["reasoning"].empty?
-            Thinking.new(agent, "*", :yellow)
-          elsif message["tool_calls"]&.any?
-            Executing.new(agent, ">", :magenta)
-          elsif message["content"] && !message["content"].empty?
-            Talking.new(agent, "~", :white)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/elelem/states/working.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module States
-    module Working
-      class << self
-        def run(agent)
-          state = Waiting.new(agent)
-
-          loop do
-            streaming_done = false
-            finish_reason = nil
-
-            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
-
-            # 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)
-        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
-  end
-end

data/lib/elelem/tool.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  class Tool
-    attr_reader :name, :description, :parameters
-
-    def initialize(name, description, parameters)
-      @name = name
-      @description = description
-      @parameters = parameters
-    end
-
-    def banner
-      [name, parameters].join(": ")
-    end
-
-    def valid?(args)
-      JSON::Validator.validate(parameters, args, insert_defaults: true)
-    end
-
-    def to_h
-      {
-        type: "function",
-        function: {
-          name: name,
-          description: description,
-          parameters: parameters
-        }
-      }
-    end
-  end
-end

data/lib/elelem/toolbox/exec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  module Toolbox
-    class Exec < ::Elelem::Tool
-      attr_reader :tui
-
-      def initialize(configuration)
-        @tui = configuration.tui
-        super("exec", "Execute shell commands with pipe support", {
-          type: "object",
-          properties: {
-            command: { 
-              type: "string", 
-              description: "Shell command to execute (supports pipes, redirects, etc.)" 
-            }
-          },
-          required: ["command"]
-        })
-      end
-
-      def call(args)
-        command = args["command"]
-        output_buffer = []
-
-        tui.say(command, newline: true)
-        Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
-          stdin.close
-          streams = [stdout, stderr]
-
-          until streams.empty?
-            ready = IO.select(streams, nil, nil, 0.1)
-
-            if ready
-              ready[0].each do |io|
-                data = io.read_nonblock(4096)
-                output_buffer << data
-
-                if io == stderr
-                  tui.say(data, colour: :red, newline: false)
-                else
-                  tui.say(data, newline: false)
-                end
-              rescue IO::WaitReadable
-                next
-              rescue EOFError
-                streams.delete(io)
-              end
-            elsif !wait_thread.alive?
-              break
-            end
-          end
-
-          wait_thread.value
-        end
-
-        output_buffer.join
-      end
-    end
-  end
-end

data/lib/elelem/toolbox/file.rb

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

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

data/lib/elelem/toolbox/memory.rb

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

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

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

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Elelem
-  class Tools
-    def initialize(configuration, tools)
-      @configuration = configuration
-      @tools = tools
-    end
-
-    def banner
-      tools.map(&:banner).sort.join("\n  ")
-    end
-
-    def execute(tool_call)
-      name, args = parse(tool_call)
-
-      tool = tools.find { |tool| tool.name == name }
-      return "Invalid function name: #{name}" if tool.nil?
-      return "Invalid function arguments: #{args}" unless tool.valid?(args)
-
-      CLI::UI::Frame.open(name) do
-        tool.call(args)
-      end
-    end
-
-    def to_h
-      tools.map(&:to_h)
-    end
-
-    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