anon987654321 · December 19, 2025 22:42
diff --git a/cli.rb b/cli.rb
 #!/usr/bin/env ruby
 # frozen_string_literal: true

 # CONVERGENCE CLI v3.0
 # Self-bootstrapping AI assistant
 #
 # First run: auto-installs gems, checks for browser
 # Just: chmod +x cli.rb && ./cli.rb

 require "json"
 require "net/http"
 require "uri"
 require "fileutils"
 require "open3"
 require "timeout"
 require "digest"

 # OpenBSD security hardening
 PLEDGE_AVAILABLE = if RUBY_PLATFORM =~ /openbsd/
  begin
    require "pledge"
    Pledge.pledge("stdio rpath wpath cpath inet dns proc exec prot_exec", nil) rescue nil
    Pledge.unveil(ENV["HOME"], "rwc") rescue nil
    Pledge.unveil("/tmp", "rwc") rescue nil
    Pledge.unveil("/usr/local", "rx") rescue nil
    Pledge.unveil("/etc/ssl", "r") rescue nil
    Pledge.unveil(nil, nil) rescue nil
    true
  rescue LoadError
    false
  end
 else
  false
 end

 # First run detection
 FIRST_RUN = !File.exist?(File.expand_path("~/.convergence_installed"))

 # Suppress gem warnings during startup by redirecting stderr early
 original_stderr = $stderr.dup
 $stderr.reopen(File.open(File::NULL, "w")) unless ENV["DEBUG"]

 # Auto-fix broken gem extensions (runs silently every startup)
 broken_output = `gem list 2>&1`
 broken_gems = broken_output.scan(/Ignoring (\S+) because its extensions are not built/).flatten.uniq
 gems_fixed = false
 broken_gems.each do |gem_name|
  system("gem pristine #{gem_name} --quiet 2>/dev/null")
  gems_fixed = true
 end

 # Restore stderr
 $stderr.reopen(original_stderr) unless ENV["DEBUG"]

 # If we fixed gems, recommend restart to clear warnings
 if gems_fixed && !ARGV.include?("--no-restart")
  warn "fixed broken gems, restarting..."
  exec("ruby", $0, "--no-restart", *ARGV)
 end

 warn "convergence v3.0 - first run setup\n" if FIRST_RUN

 # Self-bootstrap missing gems with auto-retry
 def ensure_gem(name, require_as = nil)
  require(require_as || name)
  true
 rescue LoadError
  return false if ENV["NO_AUTO_INSTALL"]
  2.times do |attempt|
    $stderr.puts "  installing #{name}..." if FIRST_RUN && attempt == 0
    result = system("gem install #{name} --no-document --quiet 2>/dev/null")
    if result
      Gem.clear_paths
      begin
        require(require_as || name)
        return true
      rescue LoadError
        next
      end
    end
    sleep 1
  end
  false
 end

 # Check for browser
 def find_browser
  paths = %w[
    /usr/bin/chromium
    /usr/bin/chromium-browser
    /usr/bin/google-chrome
    /usr/bin/google-chrome-stable
    /usr/local/bin/chrome
    /usr/local/bin/chromium
    /usr/local/chrome/chrome
  ]
  # Platform-specific paths
  case RUBY_PLATFORM
  when /darwin/
    paths += [
      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
      "/Applications/Chromium.app/Contents/MacOS/Chromium"
    ]
  when /openbsd/
    paths += ["/usr/local/bin/chrome", "/usr/local/bin/iridium"]
  end
  paths.find { |p| File.executable?(p) }
 end

 def check_browser
  return true if find_browser
  warn "\nno browser found for webchat mode"
  warn "install chromium:"
  case RUBY_PLATFORM
  when /darwin/ then warn "  brew install chromium"
  when /linux/
    if File.exist?("/etc/debian_version")
      warn "  sudo apt install chromium-browser"
    elsif File.exist?("/etc/redhat-release")
      warn "  sudo dnf install chromium"
    elsif File.exist?("/etc/arch-release")
      warn "  sudo pacman -S chromium"
    else
      warn "  install chromium via your package manager"
    end
  when /openbsd/ then warn "  doas pkg_add chromium"
  when /freebsd/ then warn "  sudo pkg install chromium"
  end
  warn "\nor set ANTHROPIC_API_KEY to use API mode instead\n"
  false
 end

 # Bootstrap gems
 TTY = ensure_gem("tty-prompt") && ensure_gem("tty-spinner") && ensure_gem("pastel")
 FERRUM = ensure_gem("ferrum")
 ANTHROPIC = ensure_gem("anthropic")

 # Mark first run complete
 if FIRST_RUN
  FileUtils.touch(File.expand_path("~/.convergence_installed"))
  warn "setup complete\n"
 end

 # Validate we have a working backend
 unless ANTHROPIC && ENV["ANTHROPIC_API_KEY"]&.start_with?("sk-ant-")
  unless FERRUM && check_browser
    warn "error: no backend available"
    warn "either:"
    warn "  1. install chromium for free webchat mode"
    warn "  2. set ANTHROPIC_API_KEY for API mode"
    exit 1
  end
 end

 # Logging
 module Log
  def self.out(level, msg, **ctx)
    return if level == :debug && !ENV["DEBUG"]
    entry = { t: Time.now.strftime("%H:%M:%S"), l: level, m: msg }.merge(ctx)
    $stderr.puts JSON.generate(entry) if ENV["LOG_JSON"]
  end
  def self.info(msg, **ctx) = out(:info, msg, **ctx)
  def self.warn(msg, **ctx) = out(:warn, msg, **ctx)
  def self.error(msg, **ctx) = out(:error, msg, **ctx)
  def self.debug(msg, **ctx) = out(:debug, msg, **ctx)
 end

 # UI - minimal, no decorations, follows NN heuristics
 module UI
  extend self

  def init
    @pastel = TTY ? Pastel.new : nil
    @prompt = TTY ? TTY::Prompt.new : nil
  end

  def puts(text = "") = Kernel.puts(text)
  def c(style, text) = @pastel ? @pastel.send(style, text) : text

  def banner(mode)
    puts "convergence v3.0"
    puts "mode: #{mode}"
    puts "security: #{PLEDGE_AVAILABLE ? "pledge+unveil" : "standard"}" if RUBY_PLATFORM =~ /openbsd/
    puts "type /help for commands\n\n"
  end

  def prompt
    TTY ? @prompt.ask(">", required: false)&.strip : (print "> "; $stdin.gets&.chomp)
  end

  def thinking(msg = "thinking")
    if TTY
      s = TTY::Spinner.new("#{msg}...", format: :dots)
      s.auto_spin
      yield.tap { s.success("") }
    else
      print "#{msg}... "
      yield.tap { puts "done" }
    end
  rescue => e
    s&.error("") if TTY
    raise
  end

  def response(text) = puts("\n#{text}\n")
  def error(msg) = puts(c(:red, "error: #{msg}"))
  def status(msg) = puts(c(:dim, msg))
  def confirm(msg) = TTY ? @prompt.yes?(msg) : (print "#{msg} [y/N] "; $stdin.gets&.strip&.downcase == "y")
 end

 # Webchat - browser automation for free AI access
 class WebChat
  PROVIDERS = {
    "lmsys" => { url: "https://chat.lmsys.org", input: 'textarea[placeholder*="Type"], textarea[data-testid="textbox"]', response: '.message.bot, .chatbot .bot' },
    "chatgpt" => { url: "https://chatgpt.com", input: 'textarea#prompt-textarea', response: '.markdown, [data-message-author-role="assistant"]' },
    "claude" => { url: "https://claude.ai", input: 'div[contenteditable="true"]', response: '.font-claude-message' },
    "deepseek" => { url: "https://chat.deepseek.com", input: 'textarea#chat-input', response: '.markdown-body, .ds-markdown' },
    "gemini" => { url: "https://gemini.google.com", input: 'rich-textarea, textarea', response: '.model-response' },
    "grok" => { url: "https://grok.x.ai", input: 'textarea[placeholder*="Ask"]', response: '[data-testid="message-content"]' },
    "glm" => { url: "https://chatglm.cn", input: 'textarea.chat-input', response: '.message-content' },
    "huggingchat" => { url: "https://huggingface.co/chat", input: 'textarea[placeholder*="Ask"]', response: '.prose' },
    "perplexity" => { url: "https://perplexity.ai", input: 'textarea', response: '.prose' },
    "copilot" => { url: "https://copilot.microsoft.com", input: 'textarea', response: '.response-message' },
    "poe" => { url: "https://poe.com", input: 'textarea', response: '.Message_botMessageBubble' }
  }

  FALLBACK_ORDER = %w[lmsys huggingchat deepseek chatgpt perplexity]

  attr_reader :provider

  def self.connect_with_fallback(preferred = "lmsys")
    providers_to_try = [preferred] + (FALLBACK_ORDER - [preferred])
    last_error = nil

    providers_to_try.each do |p|
      next unless PROVIDERS[p]
      begin
        return new(p)
      rescue => e
        last_error = e
        $stderr.puts "#{p} failed, trying next..." if ENV["DEBUG"]
      end
    end

    raise last_error || "all providers failed"
  end

  def initialize(provider = "lmsys", retries: 2)
    @provider = provider
    @cfg = PROVIDERS[provider] || PROVIDERS["lmsys"]
    @retries = retries
    connect_browser
  end

  def send(text)
    with_retry do
      el = find(@cfg[:input]) or raise "input not found"
      el.focus
      el.type(text)
      sleep 0.2
      el.type(:Enter)
      wait_response
    end
  end

  def quit = @browser&.quit

  private

  def connect_browser
    with_retry do
      browser_path = find_browser
      @browser = Ferrum::Browser.new(
        headless: true,
        timeout: 120,
        process_timeout: 120,
        browser_path: browser_path,
        browser_options: { "no-sandbox": nil, "disable-gpu": nil, "disable-dev-shm-usage": nil }
      )
      @page = @browser.create_page
      @page.go_to(@cfg[:url])
      wait_ready
    end
  end

  def with_retry(attempts = @retries)
    tries = 0
    begin
      tries += 1
      yield
    rescue => e
      if tries <= attempts
        sleep(tries * 2)
        retry
      end
      raise
    end
  end

  def find(selectors)
    selectors.split(", ").each { |s| (el = @page.at_css(s) rescue nil) and return el }
    nil
  end

  def wait_ready(timeout = 30)
    deadline = Time.now + timeout
    until find(@cfg[:input]) or Time.now > deadline
      sleep 0.5
    end
  end

  def wait_response(timeout = 90)
    deadline, last, stable = Time.now + timeout, "", 0
    loop do
      raise "timeout waiting for response" if Time.now > deadline
      elements = @page.css(@cfg[:response]) rescue []
      if elements.any?
        current = elements.last.text.strip
        if current == last && !current.empty?
          return current.sub(/^(Model [AB]?:?\s*|Response:?\s*)/i, "").strip if (stable += 1) >= 3
        else
          stable, last = 0, current
        end
      end
      sleep 1
    end
  end
 end

 # API Client - Anthropic Claude
 class APIClient
  def initialize(tools = [])
    @client = Anthropic::Client.new(api_key: ENV["ANTHROPIC_API_KEY"])
    @messages = []
    @tools = tools
    @model = ENV["CLAUDE_MODEL"] || "claude-sonnet-4-20250514"
    @pending_tool_calls = []
  end

  def send(text, auto_tools: false)
    @messages << { role: "user", content: text }
    call_api(auto_tools)
  end

  def process_tool_results(results)
    @messages << { role: "user", content: results }
    call_api(false)
  end

  def pending_tools? = @pending_tool_calls.any?
  def pending_tools = @pending_tool_calls

  private

  def call_api(auto_tools)
    params = { model: @model, max_tokens: 8192, messages: @messages }
    params[:tools] = @tools.flat_map { |t| t.class.schema } if @tools.any?

    response = @client.messages(**params)
    content = response["content"]
    @messages << { role: "assistant", content: content }

    tool_blocks = content.select { |c| c["type"] == "tool_use" }
    if tool_blocks.any?
      @pending_tool_calls = tool_blocks
      return "[tool calls pending - approve with /yes or /no]" unless auto_tools
      execute_tools
    else
      @pending_tool_calls = []
      content.map { |c| c["text"] }.compact.join("\n")
    end
  end

  def execute_tools
    results = @pending_tool_calls.map do |tc|
      tool = @tools.find { |t| t.class.schema.any? { |s| s[:name] == tc["name"] } }
      result = tool ? tool.send(tc["name"], **tc["input"].transform_keys(&:to_sym)) : { error: "unknown tool" }
      { type: "tool_result", tool_use_id: tc["id"], content: JSON.generate(result) }
    end
    @pending_tool_calls = []
    process_tool_results(results)
  end
 end

 # Tools
 module ToolDSL
  def self.extended(base)
    base.instance_variable_set(:@schema, [])
  end

  def tool(name, desc, props = {}, required = [])
    @schema << { name: name.to_s, description: desc,
      input_schema: { type: "object", properties: props, required: required.map(&:to_s) } }
  end

  def schema = @schema
 end

 class ShellTool
  extend ToolDSL
  tool :shell, "Execute shell command", { command: { type: "string", description: "command" } }, [:command]

  BLOCKED = %w[sudo rm -rf passwd shadow python bash sed awk tr wc head tail find]

  def shell(command:)
    BLOCKED.each { |b| return { error: "blocked: #{b} (master.yml)" } if command =~ /\b#{Regexp.escape(b)}\b/ }
    shell_path = ["/usr/local/bin/zsh", "/bin/zsh", "/bin/ksh", ENV["SHELL"]].find { |s| s && File.executable?(s) } || "/bin/sh"
    stdout, stderr, status = Open3.capture3(shell_path, "-c", command)
    { stdout: stdout[0..4000], stderr: stderr[0..1000], exit: status.exitstatus }
  rescue => e
    { error: e.message }
  end
 end

 class FileTool
  extend ToolDSL
  tool :read_file, "Read file", { path: { type: "string" } }, [:path]
  tool :write_file, "Write file", { path: { type: "string" }, content: { type: "string" } }, [:path, :content]
  tool :list_dir, "List directory", { path: { type: "string" } }, [:path]

  ALLOWED = [ENV["HOME"], Dir.pwd, "/tmp"].compact

  def read_file(path:)
    return { error: "outside allowed paths" } unless allowed?(path)
    return { error: "not found" } unless File.exist?(path)
    { content: File.read(path)[0..50000], size: File.size(path) }
  rescue => e
    { error: e.message }
  end

  def write_file(path:, content:)
    return { error: "outside allowed paths" } unless allowed?(path)
    File.write(path, content)
    { ok: true, size: content.bytesize }
  rescue => e
    { error: e.message }
  end

  def list_dir(path:)
    return { error: "outside allowed paths" } unless allowed?(path)
    entries = Dir.entries(path).reject { |e| e.start_with?(".") }.map do |e|
      full = File.join(path, e)
      { name: e, type: File.directory?(full) ? "dir" : "file", size: File.size?(full) }
    end
    { entries: entries.sort_by { |e| [e[:type] == "dir" ? 0 : 1, e[:name]] } }
  rescue => e
    { error: e.message }
  end

  private

  def allowed?(path)
    expanded = File.expand_path(path)
    ALLOWED.any? { |a| expanded.start_with?(File.expand_path(a)) }
  end
 end

 # RAG - Retrieval Augmented Generation
 class RAG
  def initialize
    @chunks = []
    @embeddings = {}
    @provider = detect_provider
  end

  def ingest(path)
    return ingest_dir(path) if File.directory?(path)
    return 0 unless File.file?(path)

    text = File.read(path) rescue nil
    return 0 unless text

    chunks = chunk_text(text, source: path)
    chunks.each do |chunk|
      vec = embed(chunk[:text])
      next unless vec
      @chunks << chunk
      @embeddings[chunk[:id]] = vec
    end
    chunks.size
  end

  def search(query, k: 5)
    return [] if @chunks.empty?
    qvec = embed(query)
    return [] unless qvec

    scored = @chunks.map do |c|
      vec = @embeddings[c[:id]]
      next unless vec
      { chunk: c, score: cosine(qvec, vec) }
    end.compact

    scored.sort_by { |s| -s[:score] }.first(k)
  end

  def augment(query, k: 3)
    results = search(query, k: k)
    return query if results.empty?

    context = results.map { |r| r[:chunk][:text] }.join("\n\n")
    "Context:\n#{context}\n\nQuestion: #{query}"
  end

  def stats = { chunks: @chunks.size, provider: @provider }
  def clear = (@chunks = []; @embeddings = {})
  def enabled? = @provider != :none

  private

  def detect_provider
    return :openai if ENV["OPENAI_API_KEY"]
    return :local if system("curl -s http://localhost:11434/api/tags > /dev/null 2>&1")
    :none
  end

  def embed(text)
    case @provider
    when :openai then embed_openai(text)
    when :local then embed_ollama(text)
    else nil
    end
  end

  def embed_openai(text)
    uri = URI("https://api.openai.com/v1/embeddings")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    req = Net::HTTP::Post.new(uri)
    req["Authorization"] = "Bearer #{ENV["OPENAI_API_KEY"]}"
    req["Content-Type"] = "application/json"
    req.body = JSON.generate(model: "text-embedding-3-small", input: text)
    res = http.request(req)
    return nil unless res.code == "200"
    JSON.parse(res.body).dig("data", 0, "embedding")
  rescue
    nil
  end

  def embed_ollama(text)
    uri = URI("http://localhost:11434/api/embeddings")
    http = Net::HTTP.new(uri.host, uri.port)
    req = Net::HTTP::Post.new(uri)
    req["Content-Type"] = "application/json"
    req.body = JSON.generate(model: "nomic-embed-text", prompt: text)
    res = http.request(req)
    return nil unless res.code == "200"
    JSON.parse(res.body)["embedding"]
  rescue
    nil
  end

  def chunk_text(text, source: nil, size: 500)
    paragraphs = text.split(/\n{2,}/)
    chunks, current, idx = [], "", 0

    paragraphs.each do |p|
      p = p.strip
      next if p.empty?
      if current.length + p.length < size
        current += (current.empty? ? "" : "\n\n") + p
      else
        chunks << make_chunk(current, source, idx) unless current.empty?
        idx += 1
        current = p
      end
    end
    chunks << make_chunk(current, source, idx) unless current.empty?
    chunks
  end

  def make_chunk(text, source, idx)
    { id: "#{idx}_#{Digest::MD5.hexdigest(text)[0..7]}", text: text, source: source, idx: idx }
  end

  def cosine(a, b)
    return 0 unless a&.size == b&.size
    dot = a.zip(b).sum { |x, y| x * y }
    mag_a = Math.sqrt(a.sum { |x| x * x })
    mag_b = Math.sqrt(b.sum { |x| x * x })
    mag_a.zero? || mag_b.zero? ? 0 : dot / (mag_a * mag_b)
  end

  def ingest_dir(path)
    count = 0
    Dir.glob(File.join(path, "**", "*")).each do |f|
      next unless File.file?(f)
      next unless %w[.txt .md .rb .yml .json .html].include?(File.extname(f).downcase)
      count += ingest(f)
    end
    count
  end
 end

 # Agent - enables file ops in webchat mode via response parsing
 class Agent
  SYSTEM_PROMPT = <<~PROMPT
    You have access to these tools. Use XML tags to invoke them:

    <read_file path="/path/to/file"/>
    <write_file path="/path/to/file">content here</write_file>
    <shell>command here</shell>
    <list_dir path="/path/to/dir"/>
    <task_complete>summary of what was done</task_complete>

    Always use absolute paths. Wait for tool results before continuing.
    When task is done, use <task_complete> to signal completion.
  PROMPT

  def initialize(tools)
    @tools = tools
    @shell = tools.find { |t| t.is_a?(ShellTool) }
    @file = tools.find { |t| t.is_a?(FileTool) }
    @max_iterations = 10
  end

  def wrap_prompt(user_input)
    "#{SYSTEM_PROMPT}\n\nUser request: #{user_input}"
  end

  def parse_and_execute(response)
    results = []
    
    # Parse read_file
    response.scan(/<read_file\s+path="([^"]+)"\s*\/>/).each do |match|
      path = match[0]
      result = @file.read_file(path: path)
      results << { tool: "read_file", path: path, result: result }
    end

    # Parse write_file
    response.scan(/<write_file\s+path="([^"]+)">(.*?)<\/write_file>/m).each do |match|
      path, content = match
      result = @file.write_file(path: path, content: content)
      results << { tool: "write_file", path: path, result: result }
    end

    # Parse shell
    response.scan(/<shell>(.*?)<\/shell>/m).each do |match|
      command = match[0].strip
      result = @shell.shell(command: command)
      results << { tool: "shell", command: command, result: result }
    end

    # Parse list_dir
    response.scan(/<list_dir\s+path="([^"]+)"\s*\/>/).each do |match|
      path = match[0]
      result = @file.list_dir(path: path)
      results << { tool: "list_dir", path: path, result: result }
    end

    # Check for task complete
    complete = response.match(/<task_complete>(.*?)<\/task_complete>/m)
    
    { results: results, complete: !!complete, summary: complete&.[](1) }
  end

  def format_results(parsed)
    return nil if parsed[:results].empty?
    
    parsed[:results].map do |r|
      output = r[:result].is_a?(Hash) ? JSON.generate(r[:result]) : r[:result].to_s
      "[#{r[:tool]}] #{output[0..500]}"
    end.join("\n\n")
  end
 end

 # Main CLI
 class CLI
  HELP = <<~H
    /help          show commands
    /mode          show current mode
    /provider X    switch webchat provider (lmsys, chatgpt, deepseek, claude, gemini, grok, glm, huggingchat, perplexity, copilot, poe)
    /tools         list available tools (API mode only)
    /yes           approve pending tool calls
    /no            reject pending tool calls
    /agent         toggle agent mode (file/shell ops in webchat with auto-iteration)
    /ingest PATH   add files to knowledge base
    /search QUERY  search knowledge base
    /rag           toggle RAG augmentation
    /rag-stats     show RAG statistics
    /fix           repair broken gem extensions
    /clear         clear conversation
    exit           quit

    cli args: --fix-gems, --version, --help
  H

  def initialize
    UI.init
    @mode = detect_mode
    @provider = "lmsys"
    @client = nil
    @tools = [ShellTool.new, FileTool.new]
    @rag = RAG.new
    @rag_enabled = false
    @agent = Agent.new(@tools)
    @agent_enabled = false
  end

  def run
    UI.banner(mode_label)
    connect

    loop do
      input = UI.prompt
      break if input.nil? || input =~ /^(exit|quit|bye)$/i
      next if input.strip.empty?

      input.start_with?("/") ? command(input) : message(input)
    end

    UI.status("session ended")
  ensure
    @client.quit if @client.is_a?(WebChat)
  end

  private

  def detect_mode
    return :api if ANTHROPIC && ENV["ANTHROPIC_API_KEY"]&.start_with?("sk-ant-")
    return :webchat if FERRUM
    :none
  end

  def mode_label
    case @mode
    when :api then "api (#{ENV["CLAUDE_MODEL"] || "claude-sonnet-4-20250514"})"
    when :webchat then "webchat/#{@provider}"
    else "unavailable"
    end
  end

  def connect
    case @mode
    when :api
      @client = APIClient.new(@tools)
      UI.status("connected to API")
    when :webchat
      @client = UI.thinking("connecting") { WebChat.connect_with_fallback(@provider) }
      @provider = @client.provider
      UI.status("connected to #{@provider}")
    else
      UI.error("no backend - install ferrum gem or set ANTHROPIC_API_KEY")
      exit 1
    end
  rescue => e
    UI.error("connection failed: #{e.message}")
    exit 1
  end

  def command(input)
    parts = input.split(/\s+/, 2)
    cmd, arg = parts[0], parts[1]

    case cmd
    when "/help" then UI.puts(HELP)
    when "/mode" then UI.status(mode_label)
    when "/clear" then system("clear") || system("cls")
    when "/tools"
      if @mode == :api
        @tools.each { |t| t.class.schema.each { |s| UI.puts("#{s[:name]}: #{s[:description]}") } }
      else
        UI.status("tools only available in API mode")
      end
    when "/yes" then approve_tools(true)
    when "/no" then approve_tools(false)
    when "/provider" then switch_provider(arg)
    when "/ingest" then rag_ingest(arg)
    when "/search" then rag_search(arg)
    when "/rag" then toggle_rag
    when "/rag-stats" then UI.puts(@rag.stats.map { |k, v| "#{k}: #{v}" }.join(", "))
    when "/fix" then fix_gems
    when "/agent" then toggle_agent
    else UI.error("unknown command, try /help")
    end
  end

  def message(text)
    text = @rag.augment(text) if @rag_enabled && @rag.stats[:chunks] > 0

    if @agent_enabled && @mode == :webchat
      agent_loop(text)
    else
      response = UI.thinking { @client.send(text) }
      UI.response(response)
      show_pending_tools if @mode == :api && @client.pending_tools?
    end
  rescue => e
    if @mode == :webchat && e.message =~ /timeout|not found|failed/i
      UI.status("reconnecting...")
      @client&.quit rescue nil
      @client = WebChat.connect_with_fallback(@provider)
      @provider = @client.provider
      UI.status("reconnected to #{@provider}, please retry")
    else
      UI.error(e.message)
    end
  end

  def agent_loop(task)
    prompt = @agent.wrap_prompt(task)
    iteration = 0
    
    loop do
      iteration += 1
      UI.status("iteration #{iteration}")
      
      if iteration > 10
        UI.status("max iterations reached")
        break
      end

      response = UI.thinking("thinking") { @client.send(prompt) }
      UI.response(response)

      parsed = @agent.parse_and_execute(response)
      
      if parsed[:complete]
        UI.status("task complete: #{parsed[:summary]}")
        break
      end

      if parsed[:results].empty?
        UI.status("no tools invoked, waiting for next instruction")
        break
      end

      # Show what was executed
      parsed[:results].each do |r|
        UI.status("executed: #{r[:tool]}")
      end

      # Feed results back for next iteration
      results_text = @agent.format_results(parsed)
      prompt = "Tool results:\n#{results_text}\n\nContinue with the task. Use <task_complete> when done."
    end
  end

  def show_pending_tools
    @client.pending_tools.each do |tc|
      UI.puts("tool: #{tc["name"]}")
      UI.puts("input: #{tc["input"].to_json}")
    end
    UI.status("approve with /yes or reject with /no")
  end

  def approve_tools(approved)
    return UI.status("no pending tools") unless @mode == :api && @client.pending_tools?

    if approved
      response = UI.thinking("executing") { @client.process_tool_results(execute_pending) }
      UI.response(response)
    else
      UI.status("tools rejected")
    end
  end

  def execute_pending
    @client.pending_tools.map do |tc|
      tool = @tools.find { |t| t.class.schema.any? { |s| s[:name] == tc["name"] } }
      result = tool ? tool.send(tc["name"], **tc["input"].transform_keys(&:to_sym)) : { error: "unknown" }
      { type: "tool_result", tool_use_id: tc["id"], content: JSON.generate(result) }
    end
  end

  def switch_provider(name)
    unless name
      UI.puts("providers: #{WebChat::PROVIDERS.keys.join(", ")}")
      return
    end
    unless WebChat::PROVIDERS[name]
      UI.error("unknown provider: #{name}")
      return
    end
    return UI.status("provider switching only in webchat mode") unless @mode == :webchat

    @client&.quit
    @provider = name
    UI.thinking("connecting to #{name}") { @client = WebChat.new(name) }
    UI.status("switched to #{name}")
  end

  def rag_ingest(path)
    return UI.error("usage: /ingest PATH") unless path
    return UI.error("embeddings not available - set OPENAI_API_KEY or run ollama") unless @rag.enabled?

    expanded = File.expand_path(path)
    count = UI.thinking("ingesting") { @rag.ingest(expanded) }
    UI.status("added #{count} chunks")
  end

  def rag_search(query)
    return UI.error("usage: /search QUERY") unless query

    results = @rag.search(query, k: 5)
    if results.empty?
      UI.status("no results")
    else
      results.each_with_index do |r, i|
        UI.puts("#{i + 1}. [#{r[:score].round(3)}] #{r[:chunk][:source]}")
        UI.puts("   #{r[:chunk][:text][0..150]}...")
      end
    end
  end

  def toggle_rag
    @rag_enabled = !@rag_enabled
    UI.status("RAG augmentation #{@rag_enabled ? "enabled" : "disabled"}")
    UI.status("knowledge base empty, use /ingest first") if @rag_enabled && @rag.stats[:chunks] == 0
  end

  def toggle_agent
    @agent_enabled = !@agent_enabled
    UI.status("agent mode #{@agent_enabled ? "enabled" : "disabled"}")
    UI.status("agent enables file/shell ops in webchat mode with auto-iteration") if @agent_enabled
  end

  def fix_gems
    broken = `gem list 2>&1`.scan(/Ignoring (\S+) because its extensions are not built/).flatten.uniq
    if broken.empty?
      UI.status("no broken gems")
    else
      broken.each do |g|
        UI.status("fixing #{g}...")
        system("gem pristine #{g} --quiet")
      end
      UI.status("done, restart cli for changes to take effect")
    end
  end
 end

 # Entry point with CLI args
 if __FILE__ == $0
  case ARGV[0]
  when "--version", "-v"
    puts "convergence v3.0"
  when "--fix-gems"
    warn "fixing broken gems..."
    broken = `gem list 2>&1`.scan(/Ignoring (\S+) because its extensions are not built/).flatten.uniq
    if broken.empty?
      puts "no broken gems found"
    else
      broken.each { |g| puts "  fixing #{g}..."; system("gem pristine #{g}") }
      puts "done"
    end
  when "--help", "-h"
    puts <<~USAGE
      convergence v3.0 - self-bootstrapping AI CLI

      usage:
        ./cli.rb              start interactive session
        ./cli.rb --fix-gems   repair broken gem extensions
        ./cli.rb --version    show version
        ./cli.rb --help       show this help

      environment:
        ANTHROPIC_API_KEY     use API mode (faster, tools)
        OPENAI_API_KEY        enable RAG embeddings
        NO_AUTO_INSTALL       skip automatic gem installation
        DEBUG                 enable debug logging
    USAGE
  else
    CLI.new.run
  end
 end
diff --git a/final.md b/final.md
No results found