elelem 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5358e2fd855f1b8848a191c4db7160cc7eb296a73451d56f69da7e67b1b83313
-  data.tar.gz: 728dcd83f11d131af93a99cc08b68c3141b57c7ee36d69fb038736220e628eb1
+  metadata.gz: 9f36b6e8749d5c12525548bc5cfd8b270c2bd5f7ada78855f7b4c55e23e3cb52
+  data.tar.gz: 8bf6ae1b937a7fbf5dc22e0b0b522e903803a6562644afa04cf2b00c8d28133b
 SHA512:
-  metadata.gz: 2bcc2bb0271cb1188a68d390922b59a0c1007aaf8f8980c0981c26d60b75d6cb666c481702d72db92d61db4824402d88a9bbfffce0623b73ba133ca8557270df
-  data.tar.gz: 1b36b16c23223f574942de9bf72ea46f34d5e090eae8523c53baeccbd64ce26239de21938f80adf673f76326e87c9344e011723cb53407ed5f3df7d9647a1c3c
+  metadata.gz: 1eccfe3793dc81e84c8c5a82b287732dccab7be793c350ad65e20466d3c29ea183ec1aca561969e2b8a78c5095668329c672ea650f5a97bb5aa52f1d8680379e
+  data.tar.gz: c24188e1de12fb63452d4a34cfa48de11795bc18b85e3b95b7f620959c9e2cf084b6f9dba8b492bdbea5f5cd5f27c07d6fa9657e2ea0b37564ddf1736baf1dba

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 ## [Unreleased]
 
+## [0.7.0] - 2026-01-14
+
+### Added
+- ASCII spinner animation while waiting for LLM responses
+- `Terminal#waiting` method with automatic cleanup on next output
+- Decision-making principles in system prompt (prefer reversible actions, ask when uncertain)
+- Mode enforcement tests
+
+### Changed
+- Renamed internal `mode` concept to `permissions` for clarity (read/write/execute are permissions, plan/build/verify are modes)
+- Refactored `Toolbox#run_tool` to accept `permissions:` parameter
+
+### Fixed
+- **Security**: Mode restrictions now enforced at execution time, not just schema time
+  - Previously, LLMs could call tools outside their mode by guessing tool names
+  - Now `run_tool` validates the tool is allowed for the current permission set
+
+## [0.6.0] - 2026-01-12
+
+### Added
+- `/env` slash command to capture environment variables for provider connections
+- `/shell` slash command
+- `/provider` and `/model` slash commands
+- Tab completion for commands
+- Help output for `/mode` and `/env` commands
+
+### Changed
+- Renamed `bash` tool to `exec`
+- Tuned system prompt
+- Changed thinking prompt to ellipsis
+- Removed username from system prompt
+- Use pessimistic constraint on net-llm dependency
+- Extracted Terminal class for IO abstraction (enables E2E testing)
+
+### Fixed
+- Prevent infinite looping errors
+- Provide function schema when tool is called with invalid arguments
+- Tab completion for `pass` entries without requiring `show` subcommand
+- Password store symlink support in tab completion
+
 ## [0.5.0] - 2025-01-07
 
 ### Added

data/README.md

@@ -141,7 +141,7 @@ seven tools, each represented by a JSON schema that the LLM can call.
 
 | Tool      | Purpose                              | Parameters                           |
 | ----      | -------                              | ----------                           |
-| `bash`    | Run shell commands                   | `cmd`, `args`, `env`, `cwd`, `stdin` |
+| `exec`    | Run shell commands                   | `cmd`, `args`, `env`, `cwd`, `stdin` |
 | `eval`    | Dynamically create new tools         | `code`                               |
 | `grep`    | Search Git‑tracked files             | `query`                              |
 | `list`    | List tracked files                   | `path` (optional)                    |

data/lib/elelem/agent.rb

@@ -2,48 +2,33 @@
 
 module Elelem
   class Agent
-    attr_reader :conversation, :client, :toolbox
+    PROVIDERS = %w[ollama anthropic openai vertex-ai].freeze
+    ANTHROPIC_MODELS = %w[claude-sonnet-4-20250514 claude-opus-4-20250514 claude-haiku-3-5-20241022].freeze
+    VERTEX_MODELS = %w[claude-sonnet-4@20250514 claude-opus-4-5@20251101].freeze
+    COMMANDS = %w[/env /mode /provider /model /shell /clear /context /exit /help].freeze
+    MODES = %w[auto build plan verify].freeze
+    ENV_VARS = %w[ANTHROPIC_API_KEY OPENAI_API_KEY OPENAI_BASE_URL OLLAMA_HOST GOOGLE_CLOUD_PROJECT GOOGLE_CLOUD_REGION].freeze
 
-    def initialize(client, toolbox)
+    attr_reader :conversation, :client, :toolbox, :provider, :terminal, :permissions
+
+    def initialize(provider, model, toolbox, terminal: nil)
       @conversation = Conversation.new
-      @client = client
+      @provider = provider
       @toolbox = toolbox
+      @client = build_client(provider, model)
+      @terminal = terminal || default_terminal
+      @permissions = Set.new([:read])
     end
 
     def repl
-      mode = Set.new([:read])
-
       loop do
-        input = ask?("User> ")
+        input = terminal.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: #{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(mode)
-          else
-            puts help_banner
-          end
+          handle_slash_command(input)
         else
           conversation.add(role: :user, content: input)
-          result = execute_turn(conversation.history_for(mode), tools: toolbox.tools_for(mode))
+          result = execute_turn(conversation.history_for(permissions))
           conversation.add(role: result[:role], content: result[:content])
         end
       end
@@ -51,13 +36,110 @@ module Elelem
 
     private
 
-    def ask?(text)
-      Reline.readline(text, true)&.strip
+    def default_terminal
+      Terminal.new(
+        commands: COMMANDS,
+        env_vars: ENV_VARS,
+        modes: MODES,
+        providers: PROVIDERS
+      )
+    end
+
+    def handle_slash_command(input)
+      case input
+      when "/mode auto"
+        permissions.replace([:read, :write, :execute])
+        terminal.say "  → Mode: auto (all tools enabled)"
+      when "/mode build"
+        permissions.replace([:read, :write])
+        terminal.say "  → Mode: build (read + write)"
+      when "/mode plan"
+        permissions.replace([:read])
+        terminal.say "  → Mode: plan (read-only)"
+      when "/mode verify"
+        permissions.replace([:read, :execute])
+        terminal.say "  → Mode: verify (read + execute)"
+      when "/mode"
+        terminal.say "  Usage: /mode [auto|build|plan|verify]"
+        terminal.say ""
+        terminal.say "  Provider: #{provider}/#{client.model}"
+        terminal.say "  Permissions: #{permissions.to_a.inspect}"
+        terminal.say "  Tools: #{toolbox.tools_for(permissions).map { |t| t.dig(:function, :name) }}"
+      when "/exit" then exit
+      when "/clear"
+        conversation.clear
+        terminal.say "  → Conversation cleared"
+      when "/context"
+        terminal.say conversation.dump(permissions)
+      when "/shell"
+        transcript = start_shell
+        conversation.add(role: :user, content: transcript) unless transcript.strip.empty?
+        terminal.say "  → Shell session captured"
+      when "/provider"
+        terminal.select("Provider?", PROVIDERS) do |selected_provider|
+          terminal.select("Model?", models_for(selected_provider)) do |m|
+            switch_client(selected_provider, m)
+          end
+        end
+      when "/model"
+        terminal.select("Model?", models_for(provider)) do |m|
+          switch_model(m)
+        end
+      when "/env"
+        terminal.say "  Usage: /env VAR cmd..."
+        terminal.say ""
+        ENV_VARS.each do |var|
+          value = ENV[var]
+          if value
+            masked = value.length > 8 ? "#{value[0..3]}...#{value[-4..]}" : "****"
+            terminal.say "  #{var}=#{masked}"
+          else
+            terminal.say "  #{var}=(not set)"
+          end
+        end
+      when %r{^/env\s+(\w+)\s+(.+)$}
+        var_name = $1
+        command = $2
+        result = Elelem.shell.execute("sh", args: ["-c", command])
+        if result["exit_status"].zero?
+          value = result["stdout"].lines.first&.strip
+          if value && !value.empty?
+            ENV[var_name] = value
+            terminal.say "  → Set #{var_name}"
+          else
+            terminal.say "  ⚠ Command produced no output"
+          end
+        else
+          terminal.say "  ⚠ Command failed: #{result['stderr']}"
+        end
+      else
+        terminal.say help_banner
+      end
+    end
+
+    def strip_ansi(text)
+      text.gsub(/^Script started.*?\n/, '')
+          .gsub(/\nScript done.*$/, '')
+          .gsub(/\e\[[0-9;]*[a-zA-Z]/, '')
+          .gsub(/\e\[\?[0-9]+[hl]/, '')
+          .gsub(/[\b]/, '')
+          .gsub(/\r/, '')
+    end
+
+    def start_shell
+      Tempfile.create do |file|
+        system("script -q #{file.path}", chdir: Dir.pwd)
+        strip_ansi(File.read(file.path))
+      end
     end
 
     def help_banner
       <<~HELP
+  /env VAR cmd...
   /mode auto build plan verify
+  /provider
+  /model
+  /shell
   /clear
   /context
   /exit
@@ -65,6 +147,53 @@ module Elelem
       HELP
     end
 
+    def build_client(provider_name, model = nil)
+      model_opts = model ? { model: model } : {}
+
+      case provider_name
+      when "ollama"     then Net::Llm::Ollama.new(**model_opts)
+      when "anthropic"  then Net::Llm::Anthropic.new(**model_opts)
+      when "openai"     then Net::Llm::OpenAI.new(**model_opts)
+      when "vertex-ai"  then Net::Llm::VertexAI.new(**model_opts)
+      else
+        raise Error, "Unknown provider: #{provider_name}"
+      end
+    end
+
+    def models_for(provider_name)
+      case provider_name
+      when "ollama"
+        client_for_models = provider_name == provider ? client : build_client(provider_name)
+        client_for_models.tags["models"]&.map { |m| m["name"] } || []
+      when "openai"
+        client_for_models = provider_name == provider ? client : build_client(provider_name)
+        client_for_models.models["data"]&.map { |m| m["id"] } || []
+      when "anthropic"
+        ANTHROPIC_MODELS
+      when "vertex-ai"
+        VERTEX_MODELS
+      else
+        []
+      end
+    rescue KeyError => e
+      terminal.say "  ⚠ Missing credentials: #{e.message}"
+      []
+    rescue => e
+      terminal.say "  ⚠ Could not fetch models: #{e.message}"
+      []
+    end
+
+    def switch_client(new_provider, model)
+      @provider = new_provider
+      @client = build_client(new_provider, model)
+      terminal.say "  → Switched to #{new_provider}/#{client.model}"
+    end
+
+    def switch_model(model)
+      @client = build_client(provider, model)
+      terminal.say "  → Switched to #{provider}/#{client.model}"
+    end
+
     def format_tool_call_result(result)
       return if result.nil?
       return result["stdout"] if result["stdout"]
@@ -74,6 +203,17 @@ module Elelem
       ""
     end
 
+    def truncate_output(text, max_lines: 30)
+      return text if text.nil? || text.empty?
+
+      lines = text.to_s.lines
+      if lines.size > max_lines
+        lines.first(max_lines).join + "\n... (#{lines.size - max_lines} more lines)"
+      else
+        text
+      end
+    end
+
     def format_tool_calls_for_api(tool_calls)
       tool_calls.map do |tc|
         args = openai_client? ? JSON.dump(tc[:arguments]) : tc[:arguments]
@@ -89,41 +229,46 @@ module Elelem
       client.is_a?(Net::Llm::OpenAI)
     end
 
-    def execute_turn(messages, tools:)
+    def execute_turn(messages)
+      tools = toolbox.tools_for(permissions)
       turn_context = []
+      errors = 0
 
       loop do
         content = ""
         tool_calls = []
 
-        print "Thinking> "
-        client.fetch(messages + turn_context, tools) do |chunk|
-          case chunk[:type]
-          when :delta
-            print chunk[:thinking] if chunk[:thinking]
-            content += chunk[:content] if chunk[:content]
-          when :complete
-            content = chunk[:content] if chunk[:content]
-            tool_calls = chunk[:tool_calls] || []
+        terminal.waiting
+        begin
+          client.fetch(messages + turn_context, tools) do |chunk|
+            case chunk[:type]
+            when :delta
+              terminal.write chunk[:thinking] if chunk[:thinking]
+              content += chunk[:content] if chunk[:content]
+            when :complete
+              content = chunk[:content] if chunk[:content]
+              tool_calls = chunk[:tool_calls] || []
+            end
           end
+        rescue => e
+          terminal.say "\n  ✗ API Error: #{e.message}"
+          return { role: "assistant", content: "[Error: #{e.message}]" }
         end
 
-        puts "\nAssistant> #{content}" unless content.to_s.empty?
+        terminal.say "\nAssistant> #{content}" unless content.to_s.empty?
         api_tool_calls = tool_calls.any? ? format_tool_calls_for_api(tool_calls) : nil
         turn_context << { role: "assistant", content: content, tool_calls: api_tool_calls }.compact
 
         if tool_calls.any?
           tool_calls.each do |call|
-            name = call[:name]
-            args = call[:arguments]
-
-            puts "\nTool> #{name}(#{args})"
-            result = toolbox.run_tool(name, args)
-            puts format_tool_call_result(result)
+            name, args = call[:name], call[:arguments]
+            terminal.say "\nTool> #{name}(#{args})"
+            result = toolbox.run_tool(name, args, permissions: permissions)
+            terminal.say truncate_output(format_tool_call_result(result))
             turn_context << { role: "tool", tool_call_id: call[:id], content: JSON.dump(result) }
+            errors += 1 if result[:error]
           end
-
-          tool_calls = []
+          return { role: "assistant", content: "[Stopped: too many errors]" } if errors >= 3
           next
         end
 

data/lib/elelem/application.rb

@@ -15,27 +15,13 @@ module Elelem
                   type: :string,
                   desc: "Model name (uses provider default if not specified)"
     def chat(*)
-      client = build_client
-      say "Agent (#{options[:provider]}/#{client.model})", :green
-      agent = Agent.new(client, Toolbox.new)
+      provider = options[:provider]
+      model = options[:model]
+      say "Agent (#{provider})", :green
+      agent = Agent.new(provider, model, Toolbox.new)
       agent.repl
     end
 
-    private
-
-    def build_client
-      model_opts = options[:model] ? { model: options[:model] } : {}
-
-      case options[:provider]
-      when "ollama"     then Net::Llm::Ollama.new(**model_opts)
-      when "anthropic"  then Net::Llm::Anthropic.new(**model_opts)
-      when "openai"     then Net::Llm::OpenAI.new(**model_opts)
-      when "vertex-ai"  then Net::Llm::VertexAI.new(**model_opts)
-      else
-        raise Error, "Unknown provider: #{options[:provider]}. Use: #{PROVIDERS.join(', ')}"
-      end
-    end
-
     desc "files", "Generate CXML of the files"
     def files
       puts '<documents>'

data/lib/elelem/conversation.rb

@@ -8,9 +8,9 @@ module Elelem
       @items = items
     end
 
-    def history_for(mode)
+    def history_for(permissions)
       history = @items.dup
-      history[0] = { role: "system", content: system_prompt_for(mode) }
+      history[0] = { role: "system", content: system_prompt_for(permissions) }
       history
     end
 
@@ -30,8 +30,8 @@ module Elelem
       @items = default_context
     end
 
-    def dump(mode)
-      JSON.pretty_generate(history_for(mode))
+    def dump(permissions)
+      JSON.pretty_generate(history_for(permissions))
     end
 
     private
@@ -40,10 +40,10 @@ module Elelem
       [{ role: "system", content: prompt }]
     end
 
-    def system_prompt_for(mode)
+    def system_prompt_for(permissions)
       base = system_prompt
 
-      case mode.sort
+      case permissions.sort
       when [:read]
         "#{base}\n\nYou may read files on the system."
       when [:write]

data/lib/elelem/git_context.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Elelem
+  class GitContext
+    MAX_DIFF_LINES = 100
+
+    def initialize(shell = Elelem.shell)
+      @shell = shell
+    end
+
+    def to_s
+      return "" unless git_repo?
+
+      parts = []
+      parts << "Branch: #{branch}" if branch
+      parts << status_section if status.any?
+      parts << diff_section if staged_diff.any? || unstaged_diff.any?
+      parts << recent_commits_section if recent_commits.any?
+      parts.join("\n\n")
+    end
+
+    private
+
+    def git_repo?
+      @shell.execute("git", args: ["rev-parse", "--git-dir"])["exit_status"].zero?
+    end
+
+    def branch
+      @branch ||= @shell.execute("git", args: ["branch", "--show-current"])["stdout"].strip.then { |b| b.empty? ? nil : b }
+    end
+
+    def status
+      @status ||= @shell.execute("git", args: ["status", "--porcelain"])["stdout"].lines.map(&:chomp)
+    end
+
+    def staged_diff
+      @staged_diff ||= @shell.execute("git", args: ["diff", "--cached", "--stat"])["stdout"].lines
+    end
+
+    def unstaged_diff
+      @unstaged_diff ||= @shell.execute("git", args: ["diff", "--stat"])["stdout"].lines
+    end
+
+    def recent_commits
+      @recent_commits ||= @shell.execute("git", args: ["log", "--oneline", "-5"])["stdout"].lines.map(&:strip)
+    end
+
+    def status_section
+      modified = status.select { |l| l[0] == "M" || l[1] == "M" }.map { |l| l[3..] }
+      added = status.select { |l| l[0] == "A" || l.start_with?("??") }.map { |l| l[3..] }
+      deleted = status.select { |l| l[0] == "D" || l[1] == "D" }.map { |l| l[3..] }
+
+      lines = []
+      lines << "Modified: #{modified.join(', ')}" if modified.any?
+      lines << "Added: #{added.join(', ')}" if added.any?
+      lines << "Deleted: #{deleted.join(', ')}" if deleted.any?
+      lines.any? ? "Working tree:\n#{lines.join("\n")}" : nil
+    end
+
+    def diff_section
+      lines = []
+      lines << "Staged:\n#{truncate(staged_diff)}" if staged_diff.any?
+      lines << "Unstaged:\n#{truncate(unstaged_diff)}" if unstaged_diff.any?
+      lines.join("\n\n")
+    end
+
+    def recent_commits_section
+      "Recent commits:\n#{recent_commits.join("\n")}"
+    end
+
+    def truncate(lines)
+      if lines.size > MAX_DIFF_LINES
+        lines.first(MAX_DIFF_LINES).join + "\n... (#{lines.size - MAX_DIFF_LINES} more lines)"
+      else
+        lines.join
+      end
+    end
+  end
+end

data/lib/elelem/system_prompt.erb

@@ -1,15 +1,16 @@
-You are a reasoning coding and system agent.
+You are a trusted terminal agent. You act on behalf of the user - executing tasks directly through bash, files, and git. Be capable, be direct, be done.
+
+## Principles
+
+- Act, don't explain. Execute the task.
+- Read before write. Understand existing code first.
+- Small focused changes. One thing at a time.
+- Verify your work. Run tests, check output.
 
 ## System
 
-Operating System: <%= `uname -a` %>
-USER: <%= ENV['USER'] %>
-HOME: <%= ENV['HOME'] %>
-SHELL: <%= ENV['SHELL'] %>
-PATH: <%= ENV['PATH'] %>
-PWD: <%= ENV['PWD'] %>
-LANG: <%= ENV['LANG'] %>
-EDITOR: <%= ENV['EDITOR'] %>
-LOGNAME: <%= ENV['LOGNAME'] %>
-TERM: <%= ENV['TERM'] %>
-MAIL: <%= ENV['MAIL'] %>
+<%= `uname -s`.strip %> · <%= ENV['PWD'] %>
+
+## Git State
+
+<%= Elelem::GitContext.new.to_s %>

data/lib/elelem/terminal.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Terminal
+    def initialize(commands: [], modes: [], providers: [], env_vars: [])
+      @commands = commands
+      @modes = modes
+      @providers = providers
+      @env_vars = env_vars
+      @spinner_thread = nil
+      setup_completion
+    end
+
+    def ask(prompt)
+      Reline.readline(prompt, true)&.strip
+    end
+
+    def say(message)
+      stop_spinner
+      $stdout.puts message
+    end
+
+    def write(message)
+      stop_spinner
+      $stdout.print message
+    end
+
+    def waiting
+      @spinner_thread = Thread.new do
+        frames = %w[| / - \\]
+        i = 0
+        loop do
+          $stdout.print "\r#{frames[i % frames.length]} "
+          $stdout.flush
+          i += 1
+          sleep 0.1
+        end
+      end
+    end
+
+    def select(question, options, &block)
+      CLI::UI::Prompt.ask(question) do |handler|
+        options.each do |option|
+          handler.option(option) { |selected| block.call(selected) }
+        end
+      end
+    end
+
+    private
+
+    def stop_spinner
+      return unless @spinner_thread
+
+      @spinner_thread.kill
+      @spinner_thread = nil
+      $stdout.print "\r  \r"
+    end
+
+    def setup_completion
+      Reline.autocompletion = true
+      Reline.completion_proc = ->(target, preposing) { complete(target, preposing) }
+    end
+
+    def complete(target, preposing)
+      line = "#{preposing}#{target}"
+
+      if line.start_with?('/') && !preposing.include?(' ')
+        return @commands.select { |c| c.start_with?(line) }
+      end
+
+      case preposing.strip
+      when '/mode'
+        @modes.select { |m| m.start_with?(target) }
+      when '/provider'
+        @providers.select { |p| p.start_with?(target) }
+      when '/env'
+        @env_vars.select { |v| v.start_with?(target) }
+      when %r{^/env\s+\w+\s+pass(\s+show)?\s*$}
+        subcommands = %w[show ls insert generate edit rm]
+        matches = subcommands.select { |c| c.start_with?(target) }
+        matches.any? ? matches : complete_pass_entries(target)
+      when %r{^/env\s+\w+$}
+        complete_commands(target)
+      else
+        complete_files(target)
+      end
+    end
+
+    def complete_commands(target)
+      result = Elelem.shell.execute("bash", args: ["-c", "compgen -c #{target}"])
+      result["stdout"].lines.map(&:strip).first(20)
+    end
+
+    def complete_files(target)
+      result = Elelem.shell.execute("bash", args: ["-c", "compgen -f #{target}"])
+      result["stdout"].lines.map(&:strip).first(20)
+    end
+
+    def complete_pass_entries(target)
+      store = ENV.fetch("PASSWORD_STORE_DIR", File.expand_path("~/.password-store"))
+      result = Elelem.shell.execute("find", args: ["-L", store, "-name", "*.gpg"])
+      result["stdout"].lines.map { |l|
+        l.strip.sub("#{store}/", "").sub(/\.gpg$/, "")
+      }.select { |e| e.start_with?(target) }.first(20)
+    end
+  end
+end

data/lib/elelem/tool.rb

@@ -12,7 +12,9 @@ module Elelem
 
     def call(args)
       unless valid?(args)
-        return { error: "Invalid args for #{@name}", received: args.keys, expected: @schema.dig(:function, :parameters, :required) }
+        actual = args.keys
+        expected = @schema.dig(:function, :parameters)
+        return { error: "Invalid args for #{@name}.", actual: actual, expected: expected }
       end
 
       @block.call(args)

data/lib/elelem/toolbox.rb

@@ -9,7 +9,7 @@ module Elelem
       full_path.exist? ? { content: full_path.read } : { error: "File not found: #{path}" }
     end
 
-    BASH_TOOL = Tool.build("bash", "Run shell commands. For git: bash({\"cmd\": \"git\", \"args\": [\"log\", \"--oneline\"]}). Returns stdout/stderr/exit_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|
+    EXEC_TOOL = Tool.build("exec", "Run shell commands. Returns stdout/stderr/exit_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"] || [],
@@ -38,19 +38,21 @@ module Elelem
     end
 
     TOOL_ALIASES = {
-      "exec" => "bash",
-      "execute" => "bash",
+      "bash" => "exec",
+      "execute" => "exec",
       "open" => "read",
       "search" => "grep",
+      "sh" => "exec",
     }
 
     attr_reader :tools
 
     def initialize
       @tools_by_name = {}
+      @tool_permissions = {}
       @tools = { read: [], write: [], execute: [] }
       add_tool(eval_tool(binding), :execute)
-      add_tool(BASH_TOOL, :execute)
+      add_tool(EXEC_TOOL, :execute)
       add_tool(GREP_TOOL, :read)
       add_tool(LIST_TOOL, :read)
       add_tool(PATCH_TOOL, :write)
@@ -58,22 +60,31 @@ module Elelem
       add_tool(WRITE_TOOL, :write)
     end
 
-    def add_tool(tool, mode)
-      @tools[mode] << tool
+    def add_tool(tool, permission)
+      @tools[permission] << tool
       @tools_by_name[tool.name] = tool
+      @tool_permissions[tool.name] = permission
     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
+    def tools_for(permissions)
+      Array(permissions).map { |permission| tools[permission].map(&:to_h) }.flatten
     end
 
-    def run_tool(name, args)
+    def run_tool(name, args, permissions: [])
       resolved_name = TOOL_ALIASES.fetch(name, name)
-      @tools_by_name[resolved_name]&.call(args) || { error: "Unknown tool", name: name, args: args }
+      tool = @tools_by_name[resolved_name]
+      return { error: "Unknown tool", name: name, args: args } unless tool
+
+      tool_permission = @tool_permissions[resolved_name]
+      unless Array(permissions).include?(tool_permission)
+        return { error: "Tool '#{resolved_name}' not available in current mode", name: name }
+      end
+
+      tool.call(args)
     rescue => error
       { error: error.message, name: name, args: args, backtrace: error.backtrace.first(5) }
     end

data/lib/elelem/version.rb

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

data/lib/elelem.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "cli/ui"
 require "erb"
 require "fileutils"
 require "json"
@@ -16,6 +17,8 @@ require "timeout"
 require_relative "elelem/agent"
 require_relative "elelem/application"
 require_relative "elelem/conversation"
+require_relative "elelem/git_context"
+require_relative "elelem/terminal"
 require_relative "elelem/tool"
 require_relative "elelem/toolbox"
 require_relative "elelem/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - mo khan
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: cli-ui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: erb
   requirement: !ruby/object:Gem::Requirement
@@ -200,7 +214,9 @@ files:
 - lib/elelem/agent.rb
 - lib/elelem/application.rb
 - lib/elelem/conversation.rb
+- lib/elelem/git_context.rb
 - lib/elelem/system_prompt.erb
+- lib/elelem/terminal.rb
 - lib/elelem/tool.rb
 - lib/elelem/toolbox.rb
 - lib/elelem/version.rb