elelem 0.1.2 → 0.2.0

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

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

@@ -0,0 +1,55 @@
+# 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/system_prompt.erb

@@ -1,7 +1,18 @@
-**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.
+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`.
 
-Del is now being connected with a person.
+**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/tool.rb

@@ -29,88 +29,4 @@ module Elelem
       }
     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/toolbox/exec.rb

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

@@ -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/mcp.rb

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

@@ -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"