elelem 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d4a99b7addd5861f402c297ecfd19bc52e8edc6bba89422c2dec195a8cdcd13
-  data.tar.gz: d663221598cb4a843879ae191d6b7d8f62318be15d121803f58f752cecc79bbc
+  metadata.gz: 7d165866e64423e182a5497407deba0249b4c73ca4fc5c3af36a979925aade9f
+  data.tar.gz: 4b8f6b384a901781514bd085c106672489676b065eab7c2c6057ffff49842b71
 SHA512:
-  metadata.gz: cdc7ccfb94de895a32f5be4cc310f23ca781119628fcbec4bd95a50df2c5b0eb3caa474c3a9058b6120c744e56f53001eb8c67b09cad7934f9b03292202e3c88
-  data.tar.gz: 9732e722f6d1c040d4c497b6826bd53ac425ad129befdd37da0e7ecd60b9bf4e6c96464a44f89a4cd118ca79b5b675ac6190ebf157c21bf4d06aa8ced13507f9
+  metadata.gz: 356ff6e3bbadda54bc3ae9663d67879ea3fc1cd52418eaaa228f8aa1b7a6bf2a9db847dfa482e840fb0f772130753d5d417814d649e75f5c530bca467ef6f2df
+  data.tar.gz: 67313588f14536711acf61e566394466a34513cf52259c286e522648ccc1f47fcc898f4f2856a0072bf79cb63462948931c202bf972b7c29e94494aa3efb4a0f

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 ## [Unreleased]
 
+## [0.2.1] - 2025-10-15
+
+### Fixed
+- Added missing `exe/llm-ollama` and `exe/llm-openai` files to gemspec
+- These executables were added in 0.2.0 but not included in the packaged gem
+
+## [0.2.0] - 2025-10-15
+
+### Added
+- New `llm-ollama` executable - minimal coding agent with streaming support for Ollama
+- New `llm-openai` executable - minimal coding agent for OpenAI/compatible APIs
+- Memory feature for persistent context storage and retrieval
+- Web fetch tool for retrieving and analyzing web content
+- Streaming responses with real-time token display
+- Visual "thinking" progress indicators with dots during reasoning phase
+
+### Changed
+- **BREAKING**: Migrated from custom Net::HTTP implementation to `net-llm` gem
+- API client now uses `Net::Llm::Ollama` for better reliability and maintainability
+- Removed direct dependencies on `net-http` and `uri` (now transitive through net-llm)
+- Maps Ollama's `thinking` field to internal `reasoning` field
+- Maps Ollama's `done_reason` to internal `finish_reason`
+- Improved system prompt for better agent behavior
+- Enhanced error handling and logging
+
+### Fixed
+- Response processing for Ollama's native message format
+- Tool argument parsing to handle both string and object formats
+- Safe navigation operator usage to prevent nil errors
+
 ## [0.1.2] - 2025-08-14
 
 ### Fixed

data/README.md

@@ -58,100 +58,6 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 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).
 
-REPL State Diagram
-
-```
-                      ┌─────────────────┐
-                      │   START/INIT    │
-                      └─────────┬───────┘
-                                │
-                                v
-                      ┌─────────────────┐
-                ┌────▶│ IDLE (Prompt)   │◄────┐
-                │     │   Shows "> "    │     │
-                │     └─────────┬───────┘     │
-                │               │             │
-                │               │ User input  │
-                │               v             │
-                │     ┌─────────────────┐     │
-                │     │ PROCESSING      │     │
-                │     │ INPUT           │     │
-                │     └─────────┬───────┘     │
-                │               │             │
-                │               │ API call    │
-                │               v             │
-                │     ┌─────────────────┐     │
-                │     │ STREAMING       │     │
-                │ ┌──▶│ RESPONSE        │─────┤
-                │ │   └─────────┬───────┘     │
-                │ │             │             │ done=true
-                │ │             │ Parse chunk │
-                │ │             v             │
-                │ │   ┌─────────────────┐     │
-                │ │   │ MESSAGE TYPE    │     │
-                │ │   │ ROUTING         │     │
-                │ │   └─────┬─┬─┬───────┘     │
-                │ │         │ │ │             │
-       ┌────────┴─┴─────────┘ │ └─────────────┴──────────┐
-       │                      │                          │
-       v                      v                          v
-  ┌─────────────┐    ┌─────────────┐          ┌─────────────┐
-  │ THINKING    │    │ TOOL        │          │ CONTENT     │
-  │ STATE       │    │ EXECUTION   │          │ OUTPUT      │
-  │             │    │ STATE       │          │ STATE       │
-  └─────────────┘    └─────┬───────┘          └─────────────┘
-       │                   │                          │
-       │                   │ done=false               │
-       └───────────────────┼──────────────────────────┘
-                           │
-                           v
-                 ┌─────────────────┐
-                 │ CONTINUE        │
-                 │ STREAMING       │
-                 └─────────────────┘
-                           │
-                           └─────────────────┐
-                                             │
-       ┌─────────────────┐                   │
-       │ ERROR STATE     │                   │
-       │ (Exception)     │                   │
-       └─────────────────┘                   │
-                ▲                            │
-                │ Invalid response           │
-                └────────────────────────────┘
-
-                      EXIT CONDITIONS:
-                 ┌─────────────────────────┐
-                 │ • User enters ""        │
-                 │ • User enters "exit"    │
-                 │ • EOF (Ctrl+D)          │
-                 │ • nil input             │
-                 └─────────────────────────┘
-                            │
-                            v
-                 ┌─────────────────────────┐
-                 │      TERMINATE          │
-                 └─────────────────────────┘
-```
-
-Key Transitions:
-
-1. IDLE → PROCESSING: User enters any non-empty, non-"exit" input
-2. PROCESSING → STREAMING: API call initiated to Ollama
-3. STREAMING → MESSAGE ROUTING: Each chunk received is parsed
-4. MESSAGE ROUTING → States: Based on message content:
-  - thinking → THINKING STATE
-  - tool_calls → TOOL EXECUTION STATE
-  - content → CONTENT OUTPUT STATE
-  - Invalid format → ERROR STATE
-5. All States → IDLE: When done=true from API response
-6. TOOL EXECUTION → STREAMING: Sets done=false to continue conversation
-7. Any State → TERMINATE: On exit conditions
-
-The REPL operates as a continuous loop where the primary flow is IDLE → PROCESSING → STREAMING →
-back to IDLE, with the streaming phase potentially cycling through multiple message types before
-completion.
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/xlgmokha/elelem.

data/exe/llm-ollama

@@ -0,0 +1,358 @@
+#!/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.4"
+  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)
+
+OLLAMA_HOST = ENV["OLLAMA_HOST"] || "localhost:11434"
+OLLAMA_MODEL = ENV["OLLAMA_MODEL"] || "gpt-oss:latest"
+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
+    content = ""
+    tool_calls = nil
+    role = "assistant"
+    first_content = true
+
+    print "Thinking..."
+    client.chat(messages + turn_context, tools) do |chunk|
+      if chunk["message"]
+        msg = chunk["message"]
+        role = msg["role"] if msg["role"]
+
+        if msg["thinking"] && !msg["thinking"].empty?
+          print "."
+        end
+
+        if msg["content"] && !msg["content"].empty?
+          if first_content
+            print "\r\e[KAssistant> "
+            first_content = false
+          end
+          print msg["content"]
+          $stdout.flush
+          content += msg["content"]
+        end
+
+        tool_calls = msg["tool_calls"] if msg["tool_calls"]
+      end
+    end
+    puts
+
+    turn_context << { role: role, content: content, tool_calls: tool_calls }.compact
+
+    if tool_calls
+      tool_calls.each do |call|
+        name = call.dig("function", "name")
+        args_raw = call.dig("function", "arguments")
+
+        begin
+          args = args_raw.is_a?(String) ? JSON.parse(args_raw) : args_raw
+        rescue JSON::ParserError => e
+          turn_context << {
+            role: "tool",
+            content: JSON.dump({
+              error: "Invalid JSON in arguments: #{e.message}",
+              received: args_raw
+            })
+          }
+          next
+        end
+
+        puts "Tool> #{format_tool_call(name, args)}"
+        result = run_tool(name, args)
+        turn_context << { role: "tool", content: JSON.dump(result) }
+      end
+      next
+    end
+
+    return { role: "assistant", content: content } unless content.strip.empty?
+  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::Ollama.new(
+    host: OLLAMA_HOST,
+    model: OLLAMA_MODEL
+  )
+
+  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