elelem 0.1.3 → 0.2.1

data/exe/llm-openai

@@ -0,0 +1,339 @@
+#!/usr/bin/env ruby
+
+=begin
+Fast, correct, autonomous - Pick two
+
+PURPOSE:
+
+This script is a minimal coding agent written in Ruby. It is intended to
+assist me (a software engineer and computer science student) with writing,
+editing, and managing code and text files from the command line. It acts
+as a direct interface to an LLM, providing it with a simple text-based
+UI and access to the local filesystem.
+
+DESIGN PRINCIPLES:
+
+- Follows the Unix philosophy: simple, composable, minimal.
+- Convention over configuration.
+- Avoids unnecessary defensive checks, or complexity.
+- Assumes a mature and responsible LLM that behaves like a capable engineer.
+- Designed for my workflow and preferences.
+- Efficient and minimal like aider - https://aider.chat/
+- UX like Claude Code - https://docs.claude.com/en/docs/claude-code/overview
+
+SYSTEM ASSUMPTIONS:
+
+- This script is used on a Linux system with the following tools: Alacritty, tmux, Bash, and Vim.
+- It is always run inside a Git repository.
+- All project work is assumed to be version-controlled with Git.
+- Git is expected to be available and working; no checks are necessary.
+
+SCOPE:
+
+- This program operates only on code and plain-text files.
+- It does not need to support binary files.
+- The LLM has full access to execute system commands.
+- There are no sandboxing, permission, or validation layers.
+- Execution is not restricted or monitored — responsibility is delegated to the LLM.
+
+CONFIGURATION:
+
+- Avoid adding configuration options unless absolutely necessary.
+- Prefer hard-coded values that can be changed later if needed.
+- Only introduce environment variables after repeated usage proves them worthwhile.
+
+UI EXPECTATIONS:
+
+- The TUI must remain simple, fast, and predictable.
+- No mouse support or complex UI components are required.
+- Interaction is strictly keyboard-driven.
+
+CODING STANDARDS FOR LLM:
+
+- Do not add error handling or logging unless it is essential for functionality.
+- Keep methods short and single-purpose.
+- Use descriptive, conventional names.
+- Stick to Ruby's standard library whenever possible.
+
+HELPFUL LINKS:
+
+- https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
+- https://www.anthropic.com/engineering/writing-tools-for-agents
+- https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
+
+=end
+
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+
+  gem "fileutils", "~> 1.0"
+  gem "json", "~> 2.0"
+  gem "net-llm", "0.3.1"
+  gem "open3", "~> 0.1"
+  gem "ostruct", "~> 0.1"
+  gem "reline", "~> 0.1"
+  gem "set", "~> 1.0"
+  gem "uri", "~> 1.0"
+end
+
+STDOUT.set_encoding(Encoding::UTF_8)
+STDERR.set_encoding(Encoding::UTF_8)
+
+API_KEY = ENV["OPENAI_API_KEY"] or abort("Set OPENAI_API_KEY")
+SYSTEM_PROMPT="You are a reasoning coding and system agent."
+
+def build_tool(name, description, properties, required = [])
+  {
+    type: "function",
+    function: {
+      name: name,
+      description: description,
+      parameters: {
+        type: "object",
+        properties: properties,
+        required: required
+      }
+    }
+  }
+end
+
+EXEC_TOOL = build_tool("execute", "Execute shell commands. Returns stdout, stderr, and exit code. Use for: checking system state, running tests, managing services. Common Unix tools available: git, bash, grep, etc. Tip: Check exit_status in response to determine success.", { cmd: { type: "string" }, args: { type: "array", items: { type: "string" } }, env: { type: "object", additionalProperties: { type: "string" } }, cwd: { type: "string" }, stdin: { type: "string" } }, ["cmd"])
+GREP_TOOL = build_tool("grep", "Search all git-tracked files using git grep. Returns file paths with matching line numbers. Use this to discover where code/configuration exists before reading files. Examples: search 'def method_name' to find method definitions. Much faster than reading multiple files.", { query: { type: "string" } }, ["query"])
+LS_TOOL = build_tool("list", "List all git-tracked files in the repository, optionally filtered by path. Use this to explore project structure or find files in a directory. Returns relative paths from repo root. Tip: Use this before reading if you need to discover what files exist.", { path: { type: "string" } })
+PATCH_TOOL = build_tool("patch", "Apply a unified diff patch via 'git apply'. Use this for surgical edits to existing files rather than rewriting entire files. Generates proper git diffs. Format: standard unified diff with --- and +++ headers. Tip: More efficient than write for small changes to large files.", { diff: { type: "string" } }, ["diff"])
+READ_TOOL = build_tool("read", "Read complete contents of a file. Requires exact file path. Use grep or list first if you don't know the path. Best for: understanding existing code, reading config files, reviewing implementation details. Tip: For large files, grep first to confirm relevance.", { path: { type: "string" } }, ["path"])
+WRITE_TOOL = build_tool("write", "Write complete file contents (overwrites existing files). Creates parent directories automatically. Best for: creating new files, replacing entire file contents. For small edits to existing files, consider using patch instead.", { path: { type: "string" }, content: { type: "string" } }, ["path", "content"])
+
+TOOLS = {
+  read: [GREP_TOOL, LS_TOOL, READ_TOOL],
+  write: [PATCH_TOOL, WRITE_TOOL],
+  execute: [EXEC_TOOL]
+}
+
+trap("INT") do
+  puts "\nExiting."
+  exit
+end
+
+def run_exec(command, args: [], env: {}, cwd: Dir.pwd, stdin: nil)
+  stdout, stderr, status = Open3.capture3(env, command, *args, chdir: cwd, stdin_data: stdin)
+  {
+    "exit_status" => status.exitstatus,
+    "stdout" => stdout.to_s,
+    "stderr" => stderr.to_s
+  }
+end
+
+def expand_path(path)
+  Pathname.new(path).expand_path
+end
+
+def read_file(path)
+  full_path = expand_path(path)
+  full_path.exist? ? { content: full_path.read } : { error: "File not found: #{path}" }
+end
+
+def write_file(path, content)
+  full_path = expand_path(path)
+  FileUtils.mkdir_p(full_path.dirname)
+  { bytes_written: full_path.write(content) }
+end
+
+def run_tool(name, args)
+  case name
+  when "execute" then run_exec(args["cmd"], args: args["args"] || [], env: args["env"] || {}, cwd: args["cwd"] || Dir.pwd, stdin: args["stdin"])
+  when "grep" then run_exec("git", args: ["grep", "-nI", args["query"]])
+  when "list" then run_exec("git", args: args["path"] ? ["ls-files", "--", args["path"]] : ["ls-files"])
+  when "patch" then run_exec("git", args: ["apply", "--index", "--whitespace=nowarn", "-p1"], stdin: args["diff"])
+  when "read" then read_file(args["path"])
+  when "write" then write_file(args["path"], args["content"])
+  else
+    { error: "Unknown tool", name: name, args: args }
+  end
+end
+
+def format_tool_call(name, args)
+  case name
+  when "execute" then "execute(#{args["cmd"]})"
+  when "grep" then "grep(#{args["query"]})"
+  when "list" then "list(#{args["path"] || '.'})"
+  when "patch" then "patch(#{args["diff"].lines.count} lines)"
+  when "read" then "read(#{args["path"]})"
+  when "write" then "write(#{args["path"]})"
+  else
+    "▶ #{name}(#{args.to_s[0...70]})"
+  end
+end
+
+def system_prompt_for(mode)
+  base = "You are a reasoning coding and system agent."
+
+  case mode.sort
+  when [:read]
+    "#{base}\n\nRead and analyze. Understand before suggesting action."
+  when [:write]
+    "#{base}\n\nWrite clean, thoughtful code."
+  when [:execute]
+    "#{base}\n\nUse shell commands creatively to understand and manipulate the system."
+  when [:read, :write]
+    "#{base}\n\nFirst understand, then build solutions that integrate well."
+  when [:read, :execute]
+    "#{base}\n\nUse commands to deeply understand the system."
+  when [:write, :execute]
+    "#{base}\n\nCreate and execute freely. Have fun. Be kind."
+  when [:read, :write, :execute]
+    "#{base}\n\nYou have all tools. Use them wisely."
+  else
+    base
+  end
+end
+
+def tools_for(modes)
+  modes.map { |mode| TOOLS[mode] }.flatten
+end
+
+def prune_context(messages, keep_recent: 5)
+  return messages if messages.length <= keep_recent + 1
+
+  default_context + messages.last(keep_recent)
+end
+
+def execute_turn(client, messages, tools:)
+  turn_context = []
+
+  loop do
+    puts "Thinking..."
+    response = client.chat(messages + turn_context, tools)
+    abort "API Error #{response['code']}: #{response['body']}" if response["code"]
+    message = response.dig("choices", 0, "message")
+    turn_context << message
+
+    if message["tool_calls"]
+      message["tool_calls"].each do |call|
+        name = call.dig("function", "name")
+        # args = JSON.parse(call.dig("function", "arguments"))
+        begin
+          args = JSON.parse(call.dig("function", "arguments"))
+        rescue JSON::ParserError => e
+          # Feed the error back to the LLM as a tool result
+          turn_context << {
+            role: "tool",
+            tool_call_id: call["id"],
+            content: JSON.dump({
+              error: "Invalid JSON in arguments: #{e.message}",
+              received: call.dig("function", "arguments")
+            })
+          }
+          next  # Continue the loop, giving the LLM a chance to correct itself
+        end
+
+        puts "Tool> #{format_tool_call(name, args)}"
+        result = run_tool(name, args)
+        turn_context << { role: "tool", tool_call_id: call["id"], content: JSON.dump(result) }
+      end
+      next
+    end
+
+    if message["content"] && !message["content"].strip.empty?
+      puts "\nAssistant>\n#{message['content']}"
+
+      unless message["tool_calls"]
+        return { role: "assistant", content: message["content"] }
+      end
+    end
+  end
+end
+
+def dump_context(messages)
+  puts JSON.pretty_generate(messages)
+end
+
+def print_status(mode, messages)
+  puts "Mode: #{mode.inspect}"
+  puts "Tools: #{tools_for(mode).map { |x| x.dig(:function, :name) }}"
+end
+
+def strip_ansi(text)
+  text.gsub(/^Script started.*?\n/, '')
+      .gsub(/\nScript done.*$/, '')
+      .gsub(/\e\[[0-9;]*[a-zA-Z]/, '')        # Standard ANSI codes
+      .gsub(/\e\[\?[0-9]+[hl]/, '')           # Bracketed paste mode
+      .gsub(/[\b]/, '')                       # Backspace chars
+      .gsub(/\r/, '')                         # Carriage returns
+end
+
+def start_shell
+  Tempfile.create do |file|
+    system("script -q #{file.path}")
+    { role: "user", content: strip_ansi(File.read(file.path)) }
+  end
+end
+
+def ask?(text)
+  input = Reline.readline(text, true)&.strip
+  exit if input.nil? || input.downcase == "exit"
+
+  input
+end
+
+def print_help
+  puts <<~HELP
+  /chmod - (+|-)rwx auto build plan
+  /clear
+  /context
+  /exit
+  /help
+  /shell
+  /status
+  HELP
+end
+
+def default_context
+  [{ role: "system", content: SYSTEM_PROMPT }]
+end
+
+def main
+  client = Net::Llm::OpenAI.new(
+    api_key: API_KEY,
+    base_url: ENV["BASE_URL"] || "https://api.openai.com/v1",
+    model: ENV["MODEL"] || "gpt-4o-mini"
+  )
+
+  messages = default_context
+  mode = Set.new([:read])
+
+  loop do
+    input = ask?("User> ")
+    if input.start_with?("/")
+      case input
+      when "/chmod +r" then mode.add(:read)
+      when "/chmod +w" then mode.add(:write)
+      when "/chmod +x" then mode.add(:execute)
+      when "/chmod -r" then mode.add(:read)
+      when "/chmod -w" then mode.add(:write)
+      when "/chmod -x" then mode.add(:execute)
+      when "/clear" then messages = default_context
+      when "/compact" then messages = prune_context(messages, keep_recent: 10)
+      when "/context" then dump_context(messages)
+      when "/exit" then exit
+      when "/help" then print_help
+      when "/mode auto" then mode = Set[:read, :write, :execute]
+      when "/mode build" then mode = Set[:read, :write]
+      when "/mode plan" then mode = Set[:read]
+      when "/mode verify" then mode = Set[:read, :execute]
+      when "/mode" then print_status(mode, messages)
+      when "/shell" then messages << start_shell
+      else
+        print_help
+      end
+    else
+      messages[0] = { role: "system", content: system_prompt_for(mode) }
+      messages << { role: "user", content: input }
+      messages << execute_turn(client, messages, tools: tools_for(mode))
+    end
+  end
+end
+
+main

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]