elelem 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d165866e64423e182a5497407deba0249b4c73ca4fc5c3af36a979925aade9f
-  data.tar.gz: 4b8f6b384a901781514bd085c106672489676b065eab7c2c6057ffff49842b71
+  metadata.gz: bcd68905e2c0dd4aa7e6c22865d0353ab2fa0dff0ce8bfde3e319b10b7d4e548
+  data.tar.gz: ed59f2ca17e210adbd7b371556d7994589e75e7a515d688bb6751d8bbd3380c5
 SHA512:
-  metadata.gz: 356ff6e3bbadda54bc3ae9663d67879ea3fc1cd52418eaaa228f8aa1b7a6bf2a9db847dfa482e840fb0f772130753d5d417814d649e75f5c530bca467ef6f2df
-  data.tar.gz: 67313588f14536711acf61e566394466a34513cf52259c286e522648ccc1f47fcc898f4f2856a0072bf79cb63462948931c202bf972b7c29e94494aa3efb4a0f
+  metadata.gz: 400ae6e321309f3bcb6503942a2a636f8c782c086b17afd9a7be048df98215b248d0bbf4858b35de578ac13d19ad15dd19b2edef4e774ca99ec8af2901fb4006
+  data.tar.gz: 5f138cea24ee1faffdb173c2bed070bead948a7f9dbf17fdea6b44486998aca5517de3f3e7a99f7807fe8c5e969ab6783f09673f7158382742bb1056406d1cd7

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-11-05
+
+### Added
+- **Mode System**: Control agent capabilities with workflow modes
+  - `/mode plan` - Read-only mode (grep, list, read)
+  - `/mode build` - Read + Write mode (grep, list, read, patch, write)
+  - `/mode verify` - Read + Execute mode (grep, list, read, execute)
+  - `/mode auto` - All tools enabled
+  - Each mode adapts system prompt to guide appropriate behavior
+- Improved output formatting
+  - Suppressed verbose thinking/reasoning output
+  - Clean tool call display (e.g., `date` instead of full JSON hash)
+  - Mode switch confirmation messages
+  - Clear command feedback
+- Design philosophy documentation in README
+- Mode system documentation
+
+### Changed
+- **BREAKING**: Removed `llm-ollama` and `llm-openai` standalone executables (use main `elelem chat` command)
+- **BREAKING**: Simplified architecture - consolidated all logic into Agent class
+  - Removed Configuration class
+  - Removed Toolbox system
+  - Removed MCP client infrastructure
+  - Removed Tool and Tools classes
+  - Removed TUI abstraction layer (direct puts/Reline usage)
+  - Removed API wrapper class
+  - Removed state machine
+- Improved execute tool description to guide LLM toward direct command execution
+- Extracted tool definitions from long inline strings to readable private methods
+- Updated README with clear philosophy and usage examples
+- Reduced total codebase from 417 to 395 lines (-5%)
+
+### Fixed
+- Working directory handling for execute tool (handles empty string cwd)
+- REPL EOF handling (graceful exit when input stream ends)
+- Tool call formatting now shows clean, readable commands
+
+### Removed
+- `exe/llm-ollama` (359 lines)
+- `exe/llm-openai` (340 lines)
+- `lib/elelem/configuration.rb`
+- `lib/elelem/toolbox.rb` and toolbox/* files
+- `lib/elelem/mcp_client.rb`
+- `lib/elelem/tool.rb` and `lib/elelem/tools.rb`
+- `lib/elelem/tui.rb`
+- `lib/elelem/api.rb`
+- `lib/elelem/states/*` (state machine infrastructure)
+- Removed ~750 lines of unused/redundant code
+
 ## [0.2.1] - 2025-10-15
 
 ### Fixed

data/README.md

@@ -1,6 +1,64 @@
 # Elelem
 
-Elelem is an interactive REPL (Read-Eval-Print Loop) for Ollama that provides a command-line chat interface for communicating with AI models. It features tool calling capabilities, streaming responses, and a clean state machine architecture.
+Fast, correct, autonomous - Pick two
+
+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.
+
+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/
 
 ## Installation
 
@@ -29,7 +87,6 @@ elelem chat
 - `--host`: Specify Ollama host (default: localhost:11434)
 - `--model`: Specify Ollama model (default: gpt-oss, currently only tested with gpt-oss)  
 - `--token`: Provide authentication token
-- `--debug`: Enable debug logging
 
 ### Examples
 
@@ -39,29 +96,35 @@ elelem chat
 
 # Chat with specific model and host
 elelem chat --model llama2 --host remote-host:11434
-
-# Enable debug mode
-elelem chat --debug
 ```
 
 ### Features
 
 - **Interactive REPL**: Clean command-line interface for chatting
-- **Tool Execution**: Execute shell commands when requested by the AI
+- **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
-- **State Machine**: Robust state management for different interaction modes
 - **Conversation History**: Maintains context across the session
 
+### Mode System
+
+Control what tools the agent can access:
+
+```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
+```
+
+Each mode adapts the system prompt to guide appropriate behavior.
+
 ## Development
 
 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.
 
 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).
 
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/xlgmokha/elelem.
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -2,9 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
-require "rubocop/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
-RuboCop::RakeTask.new
 
-task default: %i[spec rubocop]
+task default: %i[spec]

data/lib/elelem/agent.rb

@@ -2,56 +2,272 @@
 
 module Elelem
   class Agent
-    attr_reader :api, :conversation, :logger, :model, :tui
+    attr_reader :conversation, :client, :tools
 
-    def initialize(configuration)
-      @api = configuration.api
-      @tui = configuration.tui
-      @configuration = configuration
-      @model = configuration.model
-      @conversation = configuration.conversation
-      @logger = configuration.logger
+    def initialize(client)
+      @conversation = Conversation.new
+      @client = client
+      @tools = {
+        read: [grep_tool, list_tool, read_tool],
+        write: [patch_tool, write_tool],
+        execute: [exec_tool]
+      }
+    end
 
-      at_exit { cleanup }
+    def repl
+      mode = Set.new([:read])
 
-      transition_to(States::Idle.new)
+      loop do
+        input = ask?("User> ")
+        break if input.nil?
+        if input.start_with?("/")
+          case input
+          when "/mode auto"
+            mode = Set[:read, :write, :execute]
+            puts "  → Mode: auto (all tools enabled)"
+          when "/mode build"
+            mode = Set[:read, :write]
+            puts "  → Mode: build (read + write)"
+          when "/mode plan"
+            mode = Set[:read]
+            puts "  → Mode: plan (read-only)"
+          when "/mode verify"
+            mode = Set[:read, :execute]
+            puts "  → Mode: verify (read + execute)"
+          when "/mode"
+            puts "  Mode: #{mode.to_a.inspect}"
+            puts "  Tools: #{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
+          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))
+          conversation.add(role: result[:role], content: result[:content])
+        end
+      end
     end
 
-    def repl
+    private
+
+    def ask?(text)
+      Reline.readline(text, true)&.strip
+    end
+
+    def help_banner
+      <<~HELP
+  /mode auto build plan verify
+  /clear
+  /context
+  /exit
+  /help
+      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"
+        cmd = args["cmd"]
+        cmd_args = args["args"] || []
+        cmd_args.empty? ? cmd : "#{cmd} #{cmd_args.join(' ')}"
+      when "grep" then "grep(#{args["query"]})"
+      when "list" then "list(#{args["path"] || "."})"
+      when "patch" then "patch(#{args["diff"]&.lines&.count || 0} lines)"
+      when "read" then "read(#{args["path"]})"
+      when "write" then "write(#{args["path"]})"
+      else
+        "#{name}(#{args.to_s[0...50]})"
+      end
+    end
+
+    def execute_turn(messages, tools:)
+      turn_context = []
+
       loop do
-        current_state.run(self)
-        sleep 0.1
+        content = ""
+        tool_calls = []
+
+        print "Thinking..."
+        client.chat(messages + turn_context, tools) do |chunk|
+          msg = chunk["message"]
+          if msg
+            if msg["content"] && !msg["content"].empty?
+              print "\r\e[K" if content.empty?
+              print msg["content"]
+              content += msg["content"]
+            end
+
+            tool_calls += msg["tool_calls"] if msg["tool_calls"]
+          end
+        end
+
+        puts
+        turn_context << { role: "assistant", content: content, tool_calls: tool_calls }.compact
+
+        if tool_calls.any?
+          tool_calls.each do |call|
+            name = call.dig("function", "name")
+            args = call.dig("function", "arguments")
+
+            puts "Tool> #{format_tool_call(name, args)}"
+            result = run_tool(name, args)
+            turn_context << { role: "tool", content: JSON.dump(result) }
+          end
+
+          tool_calls = []
+          next
+        end
+
+        return { role: "assistant", content: content }
       end
     end
 
-    def transition_to(next_state)
-      if @current_state
-        logger.info("AGENT: #{@current_state.class.name.split('::').last} -> #{next_state.class.name.split('::').last}")
+    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
-        logger.info("AGENT: Starting in #{next_state.class.name.split('::').last}")
+        { error: "Unknown tool", name: name, args: args }
       end
-      @current_state = next_state
+    rescue => error
+      { error: error.message, name: name, args: args }
     end
 
-    def 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
+    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 quit
-      cleanup
-      exit
+    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 cleanup
-      configuration.cleanup
+    def list_tool
+      build_tool(
+        "list",
+        "List all git-tracked files in the repository, optionally filtered by path.",
+        { path: { type: "string" } }
+      )
     end
 
-    private
+    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
 
-    attr_reader :configuration, :current_state
+    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

@@ -3,10 +3,6 @@
 module Elelem
   class Application < Thor
     desc "chat", "Start the REPL"
-    method_option :help,
-                  aliases: "-h",
-                  type: :boolean,
-                  desc: "Display usage information"
     method_option :host,
                   aliases: "--host",
                   type: :string,
@@ -17,32 +13,16 @@ module Elelem
                   type: :string,
                   desc: "Ollama model",
                   default: ENV.fetch("OLLAMA_MODEL", "gpt-oss")
-    method_option :token,
-                  aliases: "--token",
-                  type: :string,
-                  desc: "Ollama token",
-                  default: ENV.fetch("OLLAMA_API_KEY", nil)
-    method_option :debug,
-                  aliases: "--debug",
-                  type: :boolean,
-                  desc: "Debug mode",
-                  default: false
+
     def chat(*)
-      if options[:help]
-        invoke :help, ["chat"]
-      else
-        configuration = Configuration.new(
-          host: options[:host],
-          model: options[:model],
-          token: options[:token],
-          debug: options[:debug]
-        )
-        say "Agent (#{configuration.model})", :green
-        say configuration.tools.banner.to_s, :green
+      client = Net::Llm::Ollama.new(
+        host: options[:host],
+        model: options[:model],
+      )
+      say "Agent (#{options[:model]})", :green
+      agent = Agent.new(client)
 
-        agent = Agent.new(configuration)
-        agent.repl
-      end
+      agent.repl
     end
 
     desc "version", "The version of this CLI"

data/lib/elelem/conversation.rb

@@ -4,7 +4,7 @@ module Elelem
   class Conversation
     ROLES = %i[system assistant user tool].freeze
 
-    def initialize(items = [{ role: "system", content: system_prompt }])
+    def initialize(items = default_context)
       @items = items
     end
 
@@ -12,7 +12,6 @@ module Elelem
       @items
     end
 
-    # :TODO truncate conversation history
     def add(role: :user, content: "")
       role = role.to_sym
       raise "unknown role: #{role}" unless ROLES.include?(role)
@@ -25,8 +24,24 @@ module Elelem
       end
     end
 
+    def clear
+      @items = default_context
+    end
+
+    def set_system_prompt(prompt)
+      @items[0] = { role: :system, content: prompt }
+    end
+
+    def dump
+      JSON.pretty_generate(@items)
+    end
+
     private
 
+    def default_context
+      [{ role: "system", content: system_prompt }]
+    end
+
     def system_prompt
       ERB.new(Pathname.new(__dir__).join("system_prompt.erb").read).result(binding)
     end

data/lib/elelem/system_prompt.erb

@@ -1,18 +1,5 @@
-You are a self-improving coding assistant with the ability to modify your own source code.
+You are a reasoning coding and system agent.
 
-**Core Behavior**: Think via `thinking`, Execute via `tool_calls`, Talk via `content`.
-
-**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.
+- Less is more
+- No code comments
+- No trailing whitespace

data/lib/elelem/version.rb

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

data/lib/elelem.rb

@@ -1,37 +1,23 @@
 # frozen_string_literal: true
 
-require "cli/ui"
 require "erb"
+require "fileutils"
 require "json"
 require "json-schema"
 require "logger"
 require "net/llm"
 require "open3"
+require "pathname"
 require "reline"
+require "set"
 require "thor"
 require "timeout"
 
 require_relative "elelem/agent"
-require_relative "elelem/api"
 require_relative "elelem/application"
-require_relative "elelem/configuration"
 require_relative "elelem/conversation"
-require_relative "elelem/mcp_client"
-require_relative "elelem/states/idle"
-require_relative "elelem/states/working"
-require_relative "elelem/states/working/state"
-require_relative "elelem/states/working/error"
-require_relative "elelem/states/working/executing"
-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"
-require_relative "elelem/tools"
-require_relative "elelem/tui"
 require_relative "elelem/version"
 
-CLI::UI::StdoutRouter.enable
 Reline.input = $stdin
 Reline.output = $stdout