elelem 0.8.0 → 0.9.0

data/lib/elelem/agent.rb

@@ -2,277 +2,184 @@
 
 module Elelem
   class Agent
-    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
-
-    attr_reader :conversation, :client, :toolbox, :provider, :terminal, :permissions
-
-    def initialize(provider, model, toolbox, terminal: nil)
-      @conversation = Conversation.new
-      @provider = provider
+    COMMANDS = %w[/clear /context /init /reload /shell /exit /help].freeze
+    MAX_CONTEXT_MESSAGES = 50
+    INIT_PROMPT = <<~PROMPT
+      AGENTS.md generator. Analyze codebase and write AGENTS.md to project root.
+
+      # AGENTS.md Spec (https://agents.md/)
+      A file providing context and instructions for AI coding agents.
+
+      ## Recommended Sections
+      - Commands: build, test, lint commands
+      - Code Style: conventions, patterns
+      - Architecture: key components and flow
+      - Testing: how to run tests
+
+      ## Process
+      1. Read README.md if present
+      2. Identify language (Gemfile, package.json, go.mod)
+      3. Find test scripts (bin/test, npm test)
+      4. Check linter configs
+      5. Write concise AGENTS.md
+
+      Keep it minimal. No fluff.
+    PROMPT
+
+    attr_reader :history, :client, :toolbox, :terminal
+
+    def initialize(client, toolbox, terminal: nil, history: nil, system_prompt: nil)
+      @client = client
       @toolbox = toolbox
-      @client = build_client(provider, model)
-      @terminal = terminal || default_terminal
-      @permissions = Set.new([:read])
+      @terminal = terminal || Terminal.new(commands: COMMANDS)
+      @history = history || []
+      @system_prompt = system_prompt
+      @memory = nil
+      register_task_tool
     end
 
     def repl
+      terminal.say "elelem v#{VERSION}"
       loop do
-        input = terminal.ask("User> ")
+        input = terminal.ask("> ")
         break if input.nil?
-        if input.start_with?("/")
-          handle_slash_command(input)
-        else
-          conversation.add(role: :user, content: input)
-          result = execute_turn(conversation.history_for(permissions))
-          conversation.add(role: result[:role], content: result[:content])
-        end
+        next if input.empty?
+        input.start_with?("/") ? command(input) : turn(input)
       end
     end
 
-    private
-
-    def default_terminal
-      Terminal.new(
-        commands: COMMANDS,
-        env_vars: ENV_VARS,
-        modes: MODES,
-        providers: PROVIDERS
-      )
-    end
-
-    def handle_slash_command(input)
+    def 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 "/exit" then exit(0)
+      when "/init" then init_agents_md
+      when "/reload" then reload_source!
       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
+        history << { role: "user", content: transcript } unless transcript.strip.empty?
+      when "/clear"
+        @history = []
+        @memory = nil
+        terminal.say "  → context cleared"
+      when "/context"
+        terminal.say JSON.pretty_generate(combined_history)
       else
-        terminal.say help_banner
+        terminal.say COMMANDS.join(" ")
       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 turn(input)
+      compact_if_needed
+      history << { role: "user", content: input }
+      ctx = []
+      content = nil
 
-    def start_shell
-      Tempfile.create do |file|
-        system("script -q #{file.path}", chdir: Dir.pwd)
-        strip_ansi(File.read(file.path))
+      loop do
+        terminal.waiting
+        content, tool_calls = fetch_response(ctx)
+        terminal.say(terminal.markdown(content))
+        break if tool_calls.empty?
+
+        ctx << { role: "assistant", content: content, tool_calls: tool_calls }.compact
+        tool_calls.each do |tool_call|
+          ctx << { role: "tool", tool_call_id: tool_call[:id], content: process(tool_call).to_json }
+        end
       end
-    end
 
-    def help_banner
-      <<~HELP
-  /env VAR cmd...
-  /mode auto build plan verify
-  /provider
-  /model
-  /shell
-  /clear
-  /context
-  /exit
-  /help
-      HELP
+      history << { role: "assistant", content: content }
+      content
     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
+    private
 
-    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
-        []
+    def process(tool_call)
+      name, args = tool_call[:name], tool_call[:arguments]
+      terminal.say toolbox.header(name, args)
+      toolbox.run(name.to_s, args)
+    end
+
+    def register_task_tool
+      @toolbox.add("task",
+        description: "Delegate subtask to focused agent (complex searches, multi-file analysis)",
+        params: { prompt: { type: "string" } },
+        required: ["prompt"]
+      ) do |a|
+        sub = Agent.new(client, toolbox, terminal: terminal,
+          system_prompt: "Research agent. Search, analyze, report. Be concise.")
+        sub.turn(a["prompt"])
+        { result: sub.history.last[:content] }
       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}"
+    def init_agents_md
+      sub = Agent.new(client, toolbox, terminal: terminal, system_prompt: INIT_PROMPT)
+      sub.turn("Generate AGENTS.md for this project")
     end
 
-    def switch_model(model)
-      @client = build_client(provider, model)
-      terminal.say "  → Switched to #{provider}/#{client.model}"
+    def reload_source!
+      lib_dir = File.expand_path("..", __dir__)
+      original_verbose, $VERBOSE = $VERBOSE, nil
+      Dir["#{lib_dir}/**/*.rb"].sort.each { |f| load(f) }
+      $VERBOSE = original_verbose
+      @toolbox = Toolbox.new
+      Plugins.reload!(@toolbox)
+      register_task_tool
     end
 
-    def format_tool_call_result(result)
-      return if result.nil?
-      return result["stdout"] if result["stdout"]
-      return result["stderr"] if result["stderr"]
-      return result[:error] if result[:error]
-
-      ""
+    def start_shell
+      Tempfile.create do |file|
+        system("script", "-q", file.path, chdir: Dir.pwd)
+        strip_ansi(File.read(file.path))
+      end
     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
+    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 fetch_response(ctx)
+      content = ""
+      tool_calls = client.fetch(combined_history + ctx, toolbox.to_a) do |delta|
+        content += delta[:content].to_s
+        terminal.print(terminal.think(delta[:thinking])) if delta[:thinking]
       end
+      [content, tool_calls]
+    rescue => e
+      terminal.say "\n  ✗ #{e.message}"
+      ["Error: #{e.message} #{e.backtrace.join("\n")}", []]
     end
 
-    def format_tool_calls_for_api(tool_calls)
-      tool_calls.map do |tc|
-        args = openai_client? ? JSON.dump(tc[:arguments]) : tc[:arguments]
-        {
-          id: tc[:id],
-          type: "function",
-          function: { name: tc[:name], arguments: args }
-        }
-      end
+    def combined_history
+      [{ role: "system", content: system_prompt }] + history
     end
 
-    def openai_client?
-      client.is_a?(Net::Llm::OpenAI)
+    def system_prompt
+      @system_prompt || SystemPrompt.new(memory: @memory).render
     end
 
-    def execute_turn(messages)
-      tools = toolbox.tools_for(permissions)
-      turn_context = []
-      errors = 0
+    def compact_if_needed
+      return if history.length <= MAX_CONTEXT_MESSAGES
 
-      loop do
-        content = ""
-        tool_calls = []
+      terminal.say "  → compacting context"
+      keep = MAX_CONTEXT_MESSAGES / 2
+      old = history.first(history.length - keep)
 
-        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
+      to_summarize = @memory ? [{ role: "memory", content: @memory }, *old] : old
+      @memory = summarize(to_summarize)
+      @history = history.last(keep)
+    end
 
-        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
+    def summarize(messages)
+      text = messages.map { |message| { role: message[:role], content: message[:content] } }.to_json
 
-        if tool_calls.any?
-          tool_calls.each do |call|
-            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
-          return { role: "assistant", content: "[Stopped: too many errors]" } if errors >= 3
-          next
+      String.new.tap do |buffer|
+        client.fetch([{ role: "user", content: "Summarize key facts:\n#{text}" }], []) do |d|
+          buffer << d[:content].to_s
         end
-
-        return { role: "assistant", content: content }
       end
     end
   end

data/lib/elelem/mcp.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Elelem
+  class MCP
+    def initialize(config_path = ".mcp.json")
+      @config = File.exist?(config_path) ? JSON.parse(IO.read(config_path)) : {}
+      @servers = {}
+    end
+
+    def tools
+      @config.fetch("mcpServers", {}).flat_map do |name, _|
+        server(name).tools.map do |tool|
+          [
+            "#{name}_#{tool["name"]}",
+            {
+              description: tool["description"],
+              params: tool.dig("inputSchema", "properties") || {},
+              required: tool.dig("inputSchema", "required") || [],
+              fn: ->(a) { server(name).call(tool["name"], a) }
+            }
+          ]
+        end
+      end.to_h
+    end
+
+    def close
+      @servers.each_value(&:close)
+    end
+
+    private
+
+    def server(name)
+      @servers[name] ||= Server.new(**@config.dig("mcpServers", name).transform_keys(&:to_sym))
+    end
+
+    class Server
+      def initialize(command:, args: [], env: {})
+        resolved_env = env.transform_values { |v| v.gsub(/\$\{(\w+)\}/) { ENV[$1] } }
+        @stdin, @stdout, @stderr, @wait = Open3.popen3(resolved_env, command, *args)
+        @id = 0
+        initialize!
+      end
+
+      def tools
+        request("tools/list")["tools"]
+      end
+
+      def call(name, args)
+        result = request("tools/call", { name: name, arguments: args })
+        { content: result["content"]&.map { |c| c["text"] }&.join("\n") }
+      end
+
+      def close
+        @stdin.close rescue nil
+        @stdout.close rescue nil
+        @stderr.close rescue nil
+        @wait.kill rescue nil
+      end
+
+      private
+
+      def initialize!
+        request("initialize", {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "elelem", version: VERSION }
+        })
+        notify("notifications/initialized")
+      end
+
+      def request(method, params = {})
+        send_msg(id: @id += 1, method: method, params: params)
+        read_response(@id)
+      end
+
+      def notify(method, params = {})
+        send_msg(method: method, params: params)
+      end
+
+      def send_msg(msg)
+        @stdin.puts({ jsonrpc: "2.0", **msg }.to_json)
+        @stdin.flush
+      end
+
+      def read_response(id)
+        loop do
+          line = @stdout.gets
+          raise "Server closed" unless line
+          msg = JSON.parse(line)
+          return msg["result"] if msg["id"] == id
+          raise msg["error"]["message"] if msg["error"]
+        end
+      end
+    end
+  end
+end