elelem 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcd68905e2c0dd4aa7e6c22865d0353ab2fa0dff0ce8bfde3e319b10b7d4e548
-  data.tar.gz: ed59f2ca17e210adbd7b371556d7994589e75e7a515d688bb6751d8bbd3380c5
+  metadata.gz: 2885faeaffa4f0ee7eff742f50bbf1ee78f257f7989c6401c787c4d4feb5d6a2
+  data.tar.gz: '0965d3a94ce8633cd01e7471e5688912216794e9b6af49450d0c1a5326e24645'
 SHA512:
-  metadata.gz: 400ae6e321309f3bcb6503942a2a636f8c782c086b17afd9a7be048df98215b248d0bbf4858b35de578ac13d19ad15dd19b2edef4e774ca99ec8af2901fb4006
-  data.tar.gz: 5f138cea24ee1faffdb173c2bed070bead948a7f9dbf17fdea6b44486998aca5517de3f3e7a99f7807fe8c5e969ab6783f09673f7158382742bb1056406d1cd7
+  metadata.gz: e00079252cb138588937776e7d37fc28de2e451c1ac72a190f842d29d27df537123a524b3358c6f36a685704b18e5c3a424cd819b3c8eb3ed1259f1937bdf02d
+  data.tar.gz: c77a7a8b34cf326e812db4ac23a38de0f7841fc1763f18f569a60d783be6719e251ff1eae59234b4da68cb8276c71fb617491ea46d97905ec39e05f5359b405f

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [0.4.0] - 2025-11-10
+
+### Added
+- **Eval Tool**: Meta-programming tool that allows the LLM to dynamically create and register new tools at runtime
+  - Eval tool has access to the toolbox for enhanced capabilities
+- Comprehensive test coverage with RSpec
+  - Agent specs
+  - Conversation specs
+  - Toolbox specs
+
+### Changed
+- **Architecture Improvements**: Significant refactoring for better separation of concerns
+  - Extracted Tool class to separate file (`lib/elelem/tool.rb`)
+  - Extracted Toolbox class to separate file (`lib/elelem/toolbox.rb`)
+  - Extracted Shell class for command execution
+  - Improved tool registration through `#add_tool` method
+  - Tool constants moved to Toolbox for better organization
+  - Agent class simplified by delegating to Tool instances
+
+### Fixed
+- `/context` command now correctly accounts for the current mode
+
 ## [0.3.0] - 2025-11-05
 
 ### Added

data/README.md

@@ -1,74 +1,61 @@
 # Elelem
 
-Fast, correct, autonomous - Pick two
+Fast, correct, autonomous – pick two.
 
-PURPOSE:
+## Purpose
 
-Elelem 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.
+Elelem is a minimal coding agent written in Ruby. It is designed to help
+you write, edit, and manage code and plain-text files from the command line
+by delegating work to an LLM. The agent exposes a simple text-based UI and a
+set of built-in tools that give the LLM access to the local file system
+and Git.
 
-DESIGN PRINCIPLES:
+## 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
+* Unix philosophy – simple, composable, minimal.
+* Convention over configuration.
+* No defensive checks or complexity beyond what is necessary.
+* Assumes a mature, responsible LLM that behaves like a capable engineer.
+* Optimised for my personal workflow and preferences.
+* Efficient and minimal like *aider* – https://aider.chat/.
+* UX similar to Claude Code – https://docs.claude.com/en/docs/claude-code/overview.
 
-SYSTEM ASSUMPTIONS:
+## 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.
+* Linux host with Alacritty, tmux, Bash, Vim.
+* Runs inside a Git repository.
+* Git is available and functional.
 
-SCOPE:
+## 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.
+Only plain-text and source-code files are supported. No binary handling,
+sandboxing, or permission checks are performed - the LLM has full access.
 
-CONFIGURATION:
+## 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.
+Prefer convention over configuration. Add environment variables only after
+repeated use proves their usefulness.
 
-UI EXPECTATIONS:
+## UI Expectations
 
-- The TUI must remain simple, fast, and predictable.
-- No mouse support or complex UI components are required.
-- Interaction is strictly keyboard-driven.
+Keyboard-driven, minimal TUI. No mouse support or complex widgets.
 
-CODING STANDARDS FOR LLM:
+## Coding Standards for the 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.
+* No extra error handling unless essential.
+* Keep methods short, single-purpose.
+* Descriptive, conventional names.
+* Use Ruby standard library where possible.
 
-HELPFUL LINKS:
+## 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/
+* 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/
 
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
-
-```bash
-bundle add elelem
-```
-
-If bundler is not being used to manage dependencies, install the gem by executing:
+Install the gem directly:
 
 ```bash
 gem install elelem
@@ -84,47 +71,86 @@ elelem chat
 
 ### Options
 
-- `--host`: Specify Ollama host (default: localhost:11434)
-- `--model`: Specify Ollama model (default: gpt-oss, currently only tested with gpt-oss)  
-- `--token`: Provide authentication token
+* `--host` – Ollama host (default: `localhost:11434`).
+* `--model` – Ollama model (default: `gpt-oss`).
+* `--token` – Authentication token.
 
 ### Examples
 
 ```bash
-# Chat with default model
+# Default model
 elelem chat
 
-# Chat with specific model and host
+# Specific model and host
 elelem chat --model llama2 --host remote-host:11434
 ```
 
-### Features
+## Mode System
 
-- **Interactive REPL**: Clean command-line interface for chatting
-- **Mode System**: Control agent capabilities with workflow modes (plan, build, verify, auto)
-- **Tool Execution**: Execute shell commands, read/write files, search code
-- **Streaming Responses**: Real-time streaming of AI responses
-- **Conversation History**: Maintains context across the session
+The agent exposes seven built‑in tools. You can switch which ones are
+available by changing the *mode*:
 
-### Mode System
+| Mode    | Enabled Tools                            |
+|---------|------------------------------------------|
+| plan    | `grep`, `list`, `read`                   |
+| build   | `grep`, `list`, `read`, `patch`, `write` |
+| verify  | `grep`, `list`, `read`, `execute`        |
+| auto    | All tools                                |
 
-Control what tools the agent can access:
+Use the following commands inside the REPL:
 
-```bash
-/mode plan    # Read-only (grep, list, read)
-/mode build   # Read + Write (grep, list, read, patch, write)
-/mode verify  # Read + Execute (grep, list, read, execute)
-/mode auto    # All tools enabled
+```text
+/mode plan    # Read‑only
+/mode build   # Read + Write
+/mode verify  # Read + Execute
+/mode auto    # All tools
+/mode         # Show current mode
 ```
 
-Each mode adapts the system prompt to guide appropriate behavior.
+The system prompt is adjusted per mode so the LLM knows which actions
+are permissible.
+
+## Features
+
+* **Interactive REPL** – clean, streaming chat.
+* **Toolbox** – file I/O, Git, shell execution.
+* **Streaming Responses** – output appears in real time.
+* **Conversation History** – persists across turns; can be cleared.
+* **Context Dump** – `/context` shows the current conversation state.
+
+## Toolbox Overview
+
+The `Toolbox` class is defined in `lib/elelem/toolbox.rb`. It supplies
+seven tools, each represented by a JSON schema that the LLM can call.
+
+| Tool      | Purpose                              | Parameters                           |
+| ----      | -------                              | ----------                           |
+| `eval`    | Dynamically create new tools         | `code`                               |
+| `grep`    | Search Git‑tracked files             | `query`                              |
+| `list`    | List tracked files                   | `path` (optional)                    |
+| `read`    | Read file contents                   | `path`                               |
+| `write`   | Overwrite a file                     | `path`, `content`                    |
+| `patch`   | Apply a unified diff via `git apply` | `diff`                               |
+| `execute` | Run shell commands                   | `cmd`, `args`, `env`, `cwd`, `stdin` |
+
+## Tool Definition
+
+The core `Tool` wrapper is defined in `lib/elelem/tool.rb`. Each tool is
+created with a name, description, JSON schema for arguments, and a block
+that performs the operation. The LLM calls a tool by name and passes the
+arguments as a hash.
+
+## Known Limitations
 
-## Development
+* Assumes the current directory is a Git repository.
+* No sandboxing – the LLM can run arbitrary commands.
+* Error handling is minimal; exceptions are returned as an `error` field.
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Contributing
 
-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).
+Feel free to open issues or pull requests. The repository follows the
+GitHub Flow.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+MIT – see the bundled `LICENSE.txt`.

data/lib/elelem/agent.rb

@@ -2,16 +2,12 @@
 
 module Elelem
   class Agent
-    attr_reader :conversation, :client, :tools
+    attr_reader :conversation, :client, :toolbox
 
-    def initialize(client)
+    def initialize(client, toolbox)
       @conversation = Conversation.new
       @client = client
-      @tools = {
-        read: [grep_tool, list_tool, read_tool],
-        write: [patch_tool, write_tool],
-        execute: [exec_tool]
-      }
+      @toolbox = toolbox
     end
 
     def repl
@@ -36,19 +32,18 @@ module Elelem
             puts "  → Mode: verify (read + execute)"
           when "/mode"
             puts "  Mode: #{mode.to_a.inspect}"
-            puts "  Tools: #{tools_for(mode).map { |t| t.dig(:function, :name) }}"
+            puts "  Tools: #{toolbox.tools_for(mode).map { |t| t.dig(:function, :name) }}"
           when "/exit" then exit
           when "/clear"
             conversation.clear
             puts "  → Conversation cleared"
-          when "/context" then puts conversation.dump
+          when "/context" then puts conversation.dump(mode)
           else
             puts help_banner
           end
         else
-          conversation.set_system_prompt(system_prompt_for(mode))
           conversation.add(role: :user, content: input)
-          result = execute_turn(conversation.history, tools: tools_for(mode))
+          result = execute_turn(conversation.history_for(mode), tools: toolbox.tools_for(mode))
           conversation.add(role: result[:role], content: result[:content])
         end
       end
@@ -70,33 +65,6 @@ module Elelem
       HELP
     end
 
-    def tools_for(modes)
-      modes.map { |mode| tools[mode] }.flatten
-    end
-
-    def system_prompt_for(mode)
-      base = "You are a reasoning coding and system agent."
-
-      case mode.to_a.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 format_tool_call(name, args)
       case name
       when "execute"
@@ -143,7 +111,7 @@ module Elelem
             args = call.dig("function", "arguments")
 
             puts "Tool> #{format_tool_call(name, args)}"
-            result = run_tool(name, args)
+            result = toolbox.run_tool(name, args)
             turn_context << { role: "tool", content: JSON.dump(result) }
           end
 
@@ -154,120 +122,5 @@ module Elelem
         return { role: "assistant", content: content }
       end
     end
-
-    def run_exec(command, args: [], env: {}, cwd: Dir.pwd, stdin: nil)
-      cmd = command.is_a?(Array) ? command.first : command
-      cmd_args = command.is_a?(Array) ? command[1..] + args : args
-      stdout, stderr, status = Open3.capture3(env, cmd, *cmd_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"].to_s.empty? ? Dir.pwd : args["cwd"], 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
-    rescue => error
-      { error: error.message, name: name, args: args }
-    end
-
-    def exec_tool
-      build_tool(
-        "execute",
-        "Execute shell commands directly. Commands run in a shell context. Examples: 'date', 'git status'.",
-        {
-          cmd: { type: "string" },
-          args: { type: "array", items: { type: "string" } },
-          env: { type: "object", additionalProperties: { type: "string" } },
-          cwd: { type: "string", description: "Working directory (defaults to current)" },
-          stdin: { type: "string" }
-        },
-        ["cmd"]
-      )
-    end
-
-    def grep_tool
-      build_tool(
-        "grep",
-        "Search all git-tracked files using git grep. Returns file paths with matching line numbers.",
-        { query: { type: "string" } },
-        ["query"]
-      )
-    end
-
-    def list_tool
-      build_tool(
-        "list",
-        "List all git-tracked files in the repository, optionally filtered by path.",
-        { path: { type: "string" } }
-      )
-    end
-
-    def patch_tool
-      build_tool(
-        "patch",
-        "Apply a unified diff patch via 'git apply'. Use for surgical edits to existing files.",
-        { diff: { type: "string" } },
-        ["diff"]
-      )
-    end
-
-    def read_tool
-      build_tool(
-        "read",
-        "Read complete contents of a file. Requires exact file path.",
-        { path: { type: "string" } },
-        ["path"]
-      )
-    end
-
-    def write_tool
-      build_tool(
-        "write",
-        "Write complete file contents (overwrites existing files). Creates parent directories automatically.",
-        { path: { type: "string" }, content: { type: "string" } },
-        ["path", "content"]
-      )
-    end
-
-    def build_tool(name, description, properties, required = [])
-      {
-        type: "function",
-        function: {
-          name: name,
-          description: description,
-          parameters: {
-            type: "object",
-            properties: properties,
-            required: required
-          }
-        }
-      }
-    end
   end
 end

data/lib/elelem/application.rb

@@ -20,8 +20,7 @@ module Elelem
         model: options[:model],
       )
       say "Agent (#{options[:model]})", :green
-      agent = Agent.new(client)
-
+      agent = Agent.new(client, Toolbox.new)
       agent.repl
     end
 

data/lib/elelem/conversation.rb

@@ -8,8 +8,10 @@ module Elelem
       @items = items
     end
 
-    def history
-      @items
+    def history_for(mode)
+      history = @items.dup
+      history[0] = { role: "system", content: system_prompt_for(mode) }
+      history
     end
 
     def add(role: :user, content: "")
@@ -28,18 +30,37 @@ module Elelem
       @items = default_context
     end
 
-    def set_system_prompt(prompt)
-      @items[0] = { role: :system, content: prompt }
+    def dump(mode)
+      JSON.pretty_generate(history_for(mode))
     end
 
-    def dump
-      JSON.pretty_generate(@items)
+    private
+
+    def default_context(prompt = system_prompt_for([]))
+      [{ role: "system", content: prompt }]
     end
 
-    private
+    def system_prompt_for(mode)
+      base = system_prompt
 
-    def default_context
-      [{ role: "system", content: system_prompt }]
+      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 [:execute, :read]
+        "#{base}\n\nUse commands to deeply understand the system."
+      when [:execute, :write]
+        "#{base}\n\nCreate and execute freely. Have fun. Be kind."
+      when [:execute, :read, :write]
+        "#{base}\n\nYou have all tools. Use them wisely."
+      else
+        base
+      end
     end
 
     def system_prompt

data/lib/elelem/tool.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Tool
+    attr_reader :name
+
+    def initialize(schema, &block)
+      @name = schema.dig(:function, :name)
+      @schema = schema
+      @block = block
+    end
+
+    def call(args)
+      return ArgumentError.new(args) unless valid?(args)
+
+      @block.call(args)
+    end
+
+    def valid?(args)
+      # TODO:: Use JSON Schema Validator
+      true
+    end
+
+    def to_h
+      @schema&.to_h
+    end
+
+    class << self
+      def build(name, description, properties, required = [])
+        new({
+          type: "function",
+          function: {
+            name: name,
+            description: description,
+            parameters: {
+              type: "object",
+              properties: properties,
+              required: required
+            }
+          }
+        }) do |args|
+          yield args
+        end
+      end
+    end
+  end
+end

data/lib/elelem/toolbox.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Toolbox
+    READ_TOOL = Tool.build("read", "Read complete contents of a file. Requires exact file path.", { path: { type: "string" } }, ["path"]) do |args|
+      path = args["path"]
+      full_path = Pathname.new(path).expand_path
+      full_path.exist? ? { content: full_path.read } : { error: "File not found: #{path}" }
+    end
+
+    EXEC_TOOL = Tool.build("execute", "Execute shell commands directly. Commands run in a shell context. Examples: 'date', 'git status'.", { cmd: { type: "string" }, args: { type: "array", items: { type: "string" } }, env: { type: "object", additionalProperties: { type: "string" } }, cwd: { type: "string", description: "Working directory (defaults to current)" }, stdin: { type: "string" } }, ["cmd"]) do |args|
+      Elelem.shell.execute(
+        args["cmd"],
+        args: args["args"] || [],
+        env: args["env"] || {},
+        cwd: args["cwd"].to_s.empty? ? Dir.pwd : args["cwd"],
+        stdin: args["stdin"]
+      )
+    end
+
+    GREP_TOOL = Tool.build("grep", "Search all git-tracked files using git grep. Returns file paths with matching line numbers.", { query: { type: "string" } }, ["query"]) do |args|
+      Elelem.shell.execute("git", args: ["grep", "-nI", args["query"]])
+    end
+
+    LIST_TOOL = Tool.build("list", "List all git-tracked files in the repository, optionally filtered by path.", { path: { type: "string" } }) do |args|
+      Elelem.shell.execute("git", args: args["path"] ? ["ls-files", "--", args["path"]] : ["ls-files"])
+    end
+
+    PATCH_TOOL = Tool.build( "patch", "Apply a unified diff patch via 'git apply'. Use for surgical edits to existing files.", { diff: { type: "string" } }, ["diff"]) do |args|
+      Elelem.shell.execute("git", args: ["apply", "--index", "--whitespace=nowarn", "-p1"], stdin: args["diff"])
+    end
+
+    WRITE_TOOL = Tool.build("write", "Write complete file contents (overwrites existing files). Creates parent directories automatically.", { path: { type: "string" }, content: { type: "string" } }, ["path", "content"]) do |args|
+      full_path = Pathname.new(args["path"]).expand_path
+      FileUtils.mkdir_p(full_path.dirname)
+      { bytes_written: full_path.write(args["content"]) }
+    end
+
+    attr_reader :tools
+
+    def initialize
+      @tools_by_name = {}
+      @tools = { read: [], write: [], execute: [] }
+      add_tool(eval_tool(binding), :execute)
+      add_tool(EXEC_TOOL, :execute)
+      add_tool(GREP_TOOL, :read)
+      add_tool(LIST_TOOL, :read)
+      add_tool(PATCH_TOOL, :write)
+      add_tool(READ_TOOL, :read)
+      add_tool(WRITE_TOOL, :write)
+    end
+
+    def add_tool(tool, mode)
+      @tools[mode] << tool
+      @tools_by_name[tool.name] = tool
+    end
+
+    def register_tool(name, description, properties = {}, required = [], mode: :execute, &block)
+      add_tool(Tool.build(name, description, properties, required, &block), mode)
+    end
+
+    def tools_for(modes)
+      Array(modes).map { |mode| tools[mode].map(&:to_h) }.flatten
+    end
+
+    def run_tool(name, args)
+      @tools_by_name[name]&.call(args) || { error: "Unknown tool", name: name, args: args }
+    rescue => error
+      { error: error.message, name: name, args: args, backtrace: error.backtrace.first(5) }
+    end
+
+    def tool_schema(name)
+      @tools_by_name[name]&.to_h
+    end
+
+    private
+
+    def eval_tool(target_binding)
+      Tool.build("eval", "Evaluates Ruby code with full access to register new tools via the `register_tool(name, desc, properties, required, mode: :execute) { |args| ... }` method.", { ruby: { type: "string" } }, ["ruby"]) do |args|
+        { result: target_binding.eval(args["ruby"]) }
+      end
+    end
+  end
+end

data/lib/elelem/version.rb

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

data/lib/elelem.rb

@@ -16,6 +16,8 @@ require "timeout"
 require_relative "elelem/agent"
 require_relative "elelem/application"
 require_relative "elelem/conversation"
+require_relative "elelem/tool"
+require_relative "elelem/toolbox"
 require_relative "elelem/version"
 
 Reline.input = $stdin
@@ -23,4 +25,29 @@ Reline.output = $stdout
 
 module Elelem
   class Error < StandardError; end
+
+  class Shell
+    def execute(command, args: [], env: {}, cwd: Dir.pwd, stdin: nil)
+      cmd = command.is_a?(Array) ? command.first : command
+      cmd_args = command.is_a?(Array) ? command[1..] + args : args
+      stdout, stderr, status = Open3.capture3(
+        env,
+        cmd,
+        *cmd_args,
+        chdir: cwd,
+        stdin_data: stdin
+      )
+      {
+        "exit_status" => status.exitstatus,
+        "stdout" => stdout.to_s,
+        "stderr" => stderr.to_s
+      }
+    end
+  end
+
+  class << self
+    def shell
+      @shell ||= Shell.new
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - mo khan
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fileutils
+  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'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +107,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pathname
+  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'
 - !ruby/object:Gem::Dependency
   name: reline
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +135,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: set
+  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'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -153,13 +195,15 @@ files:
 - lib/elelem/application.rb
 - lib/elelem/conversation.rb
 - lib/elelem/system_prompt.erb
+- lib/elelem/tool.rb
+- lib/elelem/toolbox.rb
 - lib/elelem/version.rb
-homepage: https://www.mokhan.ca
+homepage: https://gitlab.com/mokhax/elelem
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://www.mokhan.ca
+  homepage_uri: https://gitlab.com/mokhax/elelem
   source_code_uri: https://gitlab.com/mokhax/elelem
   changelog_uri: https://gitlab.com/mokhax/elelem/-/blob/main/CHANGELOG.md
 rdoc_options: []