rubyn-code 0.1.0

data/lib/rubyn_code/tools/spawn_teammate.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class SpawnTeammate < Base
+      TOOL_NAME = "spawn_teammate"
+      DESCRIPTION = "Spawn a persistent named teammate agent with a role and an initial task. " \
+                    "The teammate gets its own conversation, processes the initial prompt, and " \
+                    "remains available via the mailbox for further messages."
+      PARAMETERS = {
+        name: {
+          type: :string,
+          description: "Unique name for the teammate",
+          required: true
+        },
+        role: {
+          type: :string,
+          description: "The teammate's role (e.g. 'coder', 'reviewer', 'tester')",
+          required: true
+        },
+        prompt: {
+          type: :string,
+          description: "Initial task or instruction for the teammate",
+          required: true
+        }
+      }.freeze
+      RISK_LEVEL = :execute
+
+      attr_writer :llm_client, :on_status, :db
+
+      def execute(name:, role:, prompt:)
+        callback = @on_status || method(:default_status)
+
+        raise Error, "LLM client not available" unless @llm_client
+        raise Error, "Database not available" unless @db
+
+        mailbox = Teams::Mailbox.new(@db)
+        manager = Teams::Manager.new(@db, mailbox: mailbox)
+
+        teammate = manager.spawn(name: name, role: role)
+        callback.call(:started, "Spawning teammate '#{name}' as #{role}...")
+
+        # Spawn a background thread running the teammate agent
+        Thread.new do
+          run_teammate_agent(teammate, prompt, mailbox, callback)
+        end
+
+        "Spawned teammate '#{name}' as #{role}. Initial task: #{prompt[0..100]}"
+      end
+
+      private
+
+      def run_teammate_agent(teammate, initial_prompt, mailbox, callback)
+        conversation = Agent::Conversation.new
+        conversation.add_user_message(initial_prompt)
+
+        system_prompt = "You are #{teammate.name}, a #{teammate.role} teammate agent. " \
+                        "Complete tasks efficiently. Use tools when needed. " \
+                        "When done, provide a clear summary of what you accomplished."
+
+        tools = tools_for_teammate
+        max_iterations = Config::Defaults::MAX_SUB_AGENT_ITERATIONS
+
+        max_iterations.times do
+          response = @llm_client.chat(
+            messages: conversation.to_api_format,
+            tools: tools,
+            system: system_prompt
+          )
+
+          content = response.respond_to?(:content) ? Array(response.content) : []
+          tool_calls = content.select { |b| b.respond_to?(:type) && b.type == "tool_use" }
+
+          if tool_calls.empty?
+            text = content.select { |b| b.respond_to?(:type) && b.type == "text" }
+                          .map(&:text).join("\n")
+            conversation.add_assistant_message(content)
+            callback.call(:done, "Teammate '#{teammate.name}' finished initial task.")
+
+            # Send result back to main agent inbox
+            mailbox.send(from: teammate.name, to: "rubyn", content: text)
+
+            # Now loop waiting for new messages
+            poll_inbox(teammate, conversation, tools, system_prompt, mailbox, callback)
+            return
+          end
+
+          conversation.add_assistant_message(content)
+          execute_tool_calls(tool_calls, conversation, callback)
+        end
+
+        callback.call(:done, "Teammate '#{teammate.name}' reached iteration limit.")
+      rescue StandardError => e
+        callback.call(:done, "Teammate '#{teammate.name}' error: #{e.message}")
+        $stderr.puts "[Teammate #{teammate.name}] Error: #{e.class}: #{e.message}" if ENV["RUBYN_DEBUG"]
+      end
+
+      def poll_inbox(teammate, conversation, tools, system_prompt, mailbox, callback)
+        loop do
+          sleep Config::Defaults::POLL_INTERVAL
+
+          messages = mailbox.read_inbox(teammate.name)
+          next if messages.empty?
+
+          messages.each do |msg|
+            conversation.add_user_message(msg[:content])
+
+            response = @llm_client.chat(
+              messages: conversation.to_api_format,
+              tools: tools,
+              system: system_prompt
+            )
+
+            content = response.respond_to?(:content) ? Array(response.content) : []
+            conversation.add_assistant_message(content)
+
+            text = content.select { |b| b.respond_to?(:type) && b.type == "text" }
+                          .map(&:text).join("\n")
+            mailbox.send(from: teammate.name, to: msg[:from], content: text) unless text.empty?
+          end
+        end
+      rescue StandardError => e
+        $stderr.puts "[Teammate #{teammate.name}] Poll error: #{e.message}" if ENV["RUBYN_DEBUG"]
+      end
+
+      def execute_tool_calls(tool_calls, conversation, callback)
+        tool_calls.each do |tc|
+          name = tc.respond_to?(:name) ? tc.name : tc[:name]
+          input = tc.respond_to?(:input) ? tc.input : tc[:input]
+          id = tc.respond_to?(:id) ? tc.id : tc[:id]
+
+          callback.call(:tool, "  [teammate] > #{name}")
+
+          begin
+            # Block recursive spawning
+            if %w[spawn_agent spawn_teammate].include?(name)
+              conversation.add_tool_result(id, name, "Error: Teammates cannot spawn other agents.", is_error: true)
+              next
+            end
+
+            tool_class = Registry.get(name)
+            tool = tool_class.new(project_root: project_root)
+            result = tool.execute(**input.transform_keys(&:to_sym))
+            truncated = tool.truncate(result.to_s)
+            conversation.add_tool_result(id, name, truncated)
+          rescue StandardError => e
+            conversation.add_tool_result(id, name, "Error: #{e.message}", is_error: true)
+          end
+        end
+      end
+
+      def tools_for_teammate
+        all_tools = Registry.tool_definitions
+        blocked = %w[spawn_agent spawn_teammate send_message read_inbox compact]
+        all_tools.reject { |t| blocked.include?(t[:name]) }
+      end
+
+      def default_status(_type, message)
+        $stderr.puts "[spawn_teammate] #{message}" if ENV["RUBYN_DEBUG"]
+      end
+    end
+
+    Registry.register(SpawnTeammate)
+  end
+end

data/lib/rubyn_code/tools/task.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class Task < Base
+      TOOL_NAME = "task"
+      DESCRIPTION = "Manage tasks: create, update, complete, list, or get tasks for tracking work items and dependencies."
+      PARAMETERS = {
+        action: {
+          type: :string, required: true,
+          description: "Action to perform: create, update, complete, list, get"
+        },
+        title: {
+          type: :string, required: false,
+          description: "Task title (required for create)"
+        },
+        description: {
+          type: :string, required: false,
+          description: "Task description"
+        },
+        task_id: {
+          type: :string, required: false,
+          description: "Task ID (required for update, complete, get)"
+        },
+        status: {
+          type: :string, required: false,
+          description: "Filter by status (for list) or set status (for update)"
+        },
+        session_id: {
+          type: :string, required: false,
+          description: "Session ID for scoping tasks"
+        },
+        priority: {
+          type: :integer, required: false,
+          description: "Task priority (higher = more important)"
+        },
+        blocked_by: {
+          type: :array, required: false,
+          description: "Array of task IDs this task depends on (for create)"
+        },
+        result: {
+          type: :string, required: false,
+          description: "Result text (for complete)"
+        },
+        owner: {
+          type: :string, required: false,
+          description: "Owner identifier (for update)"
+        }
+      }.freeze
+      RISK_LEVEL = :write
+      REQUIRES_CONFIRMATION = false
+
+      def execute(action:, **params)
+        manager = Tasks::Manager.new(DB::Connection.instance)
+
+        case action
+        when "create"  then execute_create(manager, **params)
+        when "update"  then execute_update(manager, **params)
+        when "complete" then execute_complete(manager, **params)
+        when "list"    then execute_list(manager, **params)
+        when "get"     then execute_get(manager, **params)
+        else
+          raise Error, "Unknown task action: #{action}. Valid actions: create, update, complete, list, get"
+        end
+      end
+
+      private
+
+      def execute_create(manager, title: nil, description: nil, session_id: nil, blocked_by: [], priority: 0, **)
+        raise Error, "title is required for create" if title.nil? || title.empty?
+
+        task = manager.create(
+          title: title,
+          description: description,
+          session_id: session_id,
+          blocked_by: Array(blocked_by),
+          priority: priority.to_i
+        )
+
+        format_task(task, prefix: "Created task")
+      end
+
+      def execute_update(manager, task_id: nil, **params)
+        raise Error, "task_id is required for update" if task_id.nil? || task_id.empty?
+
+        attrs = params.slice(:status, :priority, :owner, :result, :description, :title, :metadata)
+        attrs[:priority] = attrs[:priority].to_i if attrs.key?(:priority)
+
+        task = manager.update(task_id, **attrs)
+        raise Error, "Task not found: #{task_id}" if task.nil?
+
+        format_task(task, prefix: "Updated task")
+      end
+
+      def execute_complete(manager, task_id: nil, result: nil, **)
+        raise Error, "task_id is required for complete" if task_id.nil? || task_id.empty?
+
+        task = manager.complete(task_id, result: result)
+        raise Error, "Task not found: #{task_id}" if task.nil?
+
+        format_task(task, prefix: "Completed task")
+      end
+
+      def execute_list(manager, status: nil, session_id: nil, **)
+        tasks = manager.list(status: status, session_id: session_id)
+
+        return "No tasks found." if tasks.empty?
+
+        lines = tasks.map { |t| format_task_line(t) }
+        "Found #{tasks.size} task(s):\n\n#{lines.join("\n")}"
+      end
+
+      def execute_get(manager, task_id: nil, **)
+        raise Error, "task_id is required for get" if task_id.nil? || task_id.empty?
+
+        task = manager.get(task_id)
+        raise Error, "Task not found: #{task_id}" if task.nil?
+
+        format_task(task)
+      end
+
+      def format_task(task, prefix: nil)
+        header = prefix ? "#{prefix}: #{task.title}" : task.title
+        parts = [
+          header,
+          "  ID:       #{task.id}",
+          "  Status:   #{task.status}",
+          "  Priority: #{task.priority}"
+        ]
+        parts << "  Owner:    #{task.owner}" if task.owner
+        parts << "  Result:   #{task.result}" if task.result
+        parts << "  Session:  #{task.session_id}" if task.session_id
+        parts << "  Description: #{task.description}" if task.description
+        parts.join("\n")
+      end
+
+      def format_task_line(task)
+        owner_part = task.owner ? " (#{task.owner})" : ""
+        "[#{task.status}] #{task.title} (#{task.id[0, 8]}...)#{owner_part} priority=#{task.priority}"
+      end
+    end
+
+    Registry.register(Task)
+  end
+end

data/lib/rubyn_code/tools/web_fetch.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "faraday"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class WebFetch < Base
+      TOOL_NAME = "web_fetch"
+      DESCRIPTION = "Fetch the content of a web page and return it as text. Useful for reading documentation, READMEs, or API docs."
+      PARAMETERS = {
+        url: { type: :string, required: true, description: "The URL to fetch (must start with http:// or https://)" },
+        max_length: { type: :integer, required: false, default: 10_000, description: "Maximum number of characters to return (default: 10000)" }
+      }.freeze
+      RISK_LEVEL = :external
+      REQUIRES_CONFIRMATION = true
+
+      def execute(url:, max_length: 10_000)
+        validate_url!(url)
+        max_length = [[max_length.to_i, 500].max, 100_000].min
+
+        response = fetch_page(url)
+        text = html_to_text(response.body)
+        text = collapse_whitespace(text)
+
+        if text.strip.empty?
+          "Fetched #{url} but no readable text content was found."
+        else
+          header = "Content from: #{url}\n#{"=" * 60}\n\n"
+          available = max_length - header.length
+          content = text.length > available ? "#{text[0, available]}\n\n... [truncated at #{max_length} characters]" : text
+          "#{header}#{content}"
+        end
+      end
+
+      private
+
+      def validate_url!(url)
+        unless url.match?(%r{\Ahttps?://}i)
+          raise Error, "Invalid URL: must start with http:// or https:// — got: #{url}"
+        end
+      end
+
+      def fetch_page(url)
+        conn = Faraday.new do |f|
+          f.options.timeout = 30
+          f.options.open_timeout = 10
+          f.headers["User-Agent"] = "Mozilla/5.0 (compatible; RubynCode/1.0)"
+          f.headers["Accept"] = "text/html,application/xhtml+xml,text/plain,*/*"
+          f.response :follow_redirects, limit: 5
+        end
+
+        response = conn.get(url)
+
+        unless response.success?
+          raise Error, "HTTP #{response.status} fetching #{url}"
+        end
+
+        response
+      rescue Faraday::TimeoutError
+        raise Error, "Request timed out after 30 seconds fetching #{url}"
+      rescue Faraday::ConnectionFailed => e
+        raise Error, "Connection failed for #{url}: #{e.message}"
+      rescue Faraday::Error => e
+        raise Error, "Request failed for #{url}: #{e.message}"
+      end
+
+      def html_to_text(html)
+        return "" if html.nil? || html.empty?
+
+        text = html.dup
+
+        # Remove script and style blocks entirely
+        text.gsub!(%r{<script[^>]*>.*?</script>}mi, "")
+        text.gsub!(%r{<style[^>]*>.*?</style>}mi, "")
+
+        # Convert common block elements to newlines
+        text.gsub!(%r{<br\s*/?>}i, "\n")
+        text.gsub!(%r{</(p|div|h[1-6]|li|tr|blockquote|pre)>}i, "\n")
+        text.gsub!(%r{<(p|div|h[1-6]|li|tr|blockquote|pre)[^>]*>}i, "\n")
+
+        # Strip all remaining HTML tags
+        text.gsub!(/<[^>]*>/, "")
+
+        # Decode common HTML entities
+        text.gsub!("&amp;", "&")
+        text.gsub!("&lt;", "<")
+        text.gsub!("&gt;", ">")
+        text.gsub!("&quot;", '"')
+        text.gsub!("&#39;", "'")
+        text.gsub!("&nbsp;", " ")
+        text.gsub!(/&#(\d+);/) { [$1.to_i].pack("U") }
+
+        text
+      end
+
+      def collapse_whitespace(text)
+        # Collapse runs of spaces/tabs on each line, then collapse 3+ newlines into 2
+        text.gsub(/[^\S\n]+/, " ")
+            .gsub(/\n{3,}/, "\n\n")
+            .strip
+      end
+    end
+
+    Registry.register(WebFetch)
+  end
+end

data/lib/rubyn_code/tools/web_search.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "open3"
+require "cgi"
+require "json"
+require "faraday"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class WebSearch < Base
+      TOOL_NAME = "web_search"
+      DESCRIPTION = "Search the web for information. Returns search results with titles, URLs, and snippets."
+      PARAMETERS = {
+        query: { type: :string, required: true, description: "The search query string" },
+        num_results: { type: :integer, required: false, default: 5, description: "Number of results (default: 5)" }
+      }.freeze
+      RISK_LEVEL = :external
+      REQUIRES_CONFIRMATION = true
+
+      # Adapter registry — add new providers here
+      ADAPTERS = {
+        "duckduckgo" => :search_duckduckgo,
+        "brave"      => :search_brave,
+        "serpapi"     => :search_serpapi,
+        "tavily"     => :search_tavily,
+        "google"     => :search_google
+      }.freeze
+
+      def execute(query:, num_results: 5)
+        num_results = [[num_results.to_i, 1].max, 20].min
+        provider = detect_provider
+
+        results = send(ADAPTERS[provider], query, num_results)
+
+        if results.empty?
+          "No results found for: #{query}"
+        else
+          format_results(query, results, provider)
+        end
+      rescue StandardError => e
+        "Search failed (#{detect_provider}): #{e.message}"
+      end
+
+      private
+
+      # Pick the best available provider based on env vars
+      def detect_provider
+        return "tavily"     if ENV["TAVILY_API_KEY"]
+        return "brave"      if ENV["BRAVE_API_KEY"]
+        return "serpapi"     if ENV["SERPAPI_API_KEY"]
+        return "google"     if ENV["GOOGLE_SEARCH_API_KEY"] && ENV["GOOGLE_SEARCH_CX"]
+
+        "duckduckgo"
+      end
+
+      # ─── DuckDuckGo (no API key, free) ───
+
+      def search_duckduckgo(query, num_results)
+        encoded = CGI.escape(query)
+        stdout, _, status = Open3.capture3(
+          "curl", "-sL", "--max-time", "15",
+          "-H", "User-Agent: Mozilla/5.0 (compatible; RubynCode/1.0)",
+          "https://lite.duckduckgo.com/lite/?q=#{encoded}"
+        )
+        return [] unless status.success?
+
+        parse_duckduckgo(stdout, num_results)
+      end
+
+      def parse_duckduckgo(html, max)
+        results = []
+        links = html.scan(/<a[^>]+rel="nofollow"[^>]+href="([^"]+)"[^>]*>(.*?)<\/a>/i)
+        links = html.scan(/<a[^>]+href="(https?:\/\/(?!lite\.duckduckgo)[^"]+)"[^>]*>(.*?)<\/a>/i) if links.empty?
+        snippets = html.scan(/<td[^>]*class="result-snippet"[^>]*>(.*?)<\/td>/im)
+
+        links.each_with_index do |match, idx|
+          break if results.length >= max
+
+          url = match[0].strip
+          title = strip_html(match[1]).strip
+          next if url.empty? || title.empty? || url.include?("duckduckgo.com")
+
+          snippet = snippets[idx] ? strip_html(snippets[idx][0]).strip : ""
+          results << { title: title, url: url, snippet: snippet }
+        end
+
+        results
+      end
+
+      # ─── Brave Search (free tier: 2000 queries/mo) ───
+
+      def search_brave(query, num_results)
+        resp = Faraday.get("https://api.search.brave.com/res/v1/web/search") do |req|
+          req.params["q"] = query
+          req.params["count"] = num_results
+          req.headers["Accept"] = "application/json"
+          req.headers["Accept-Encoding"] = "gzip"
+          req.headers["X-Subscription-Token"] = ENV["BRAVE_API_KEY"]
+          req.options.timeout = 15
+        end
+
+        data = JSON.parse(resp.body)
+        (data.dig("web", "results") || []).map do |r|
+          { title: r["title"], url: r["url"], snippet: r["description"] || "" }
+        end
+      end
+
+      # ─── Tavily (built for AI agents, free tier: 1000 queries/mo) ───
+
+      def search_tavily(query, num_results)
+        resp = Faraday.post("https://api.tavily.com/search") do |req|
+          req.headers["Content-Type"] = "application/json"
+          req.body = JSON.generate({
+            api_key: ENV["TAVILY_API_KEY"],
+            query: query,
+            max_results: num_results,
+            include_answer: true
+          })
+          req.options.timeout = 15
+        end
+
+        data = JSON.parse(resp.body)
+        results = (data["results"] || []).map do |r|
+          { title: r["title"], url: r["url"], snippet: r["content"] || "" }
+        end
+
+        # Tavily provides a direct answer — prepend it
+        if data["answer"]
+          results.unshift({ title: "AI Answer", url: "", snippet: data["answer"] })
+        end
+
+        results
+      end
+
+      # ─── SerpAPI (free tier: 100 queries/mo) ───
+
+      def search_serpapi(query, num_results)
+        resp = Faraday.get("https://serpapi.com/search.json") do |req|
+          req.params["q"] = query
+          req.params["num"] = num_results
+          req.params["api_key"] = ENV["SERPAPI_API_KEY"]
+          req.options.timeout = 15
+        end
+
+        data = JSON.parse(resp.body)
+        (data["organic_results"] || []).map do |r|
+          { title: r["title"], url: r["link"], snippet: r["snippet"] || "" }
+        end
+      end
+
+      # ─── Google Custom Search (free tier: 100 queries/day) ───
+
+      def search_google(query, num_results)
+        resp = Faraday.get("https://www.googleapis.com/customsearch/v1") do |req|
+          req.params["q"] = query
+          req.params["num"] = [num_results, 10].min
+          req.params["key"] = ENV["GOOGLE_SEARCH_API_KEY"]
+          req.params["cx"] = ENV["GOOGLE_SEARCH_CX"]
+          req.options.timeout = 15
+        end
+
+        data = JSON.parse(resp.body)
+        (data["items"] || []).map do |r|
+          { title: r["title"], url: r["link"], snippet: r["snippet"] || "" }
+        end
+      end
+
+      # ─── Shared ───
+
+      def strip_html(text)
+        return "" if text.nil?
+
+        text.gsub(/<[^>]*>/, "").gsub(/&amp;/, "&").gsub(/&lt;/, "<")
+            .gsub(/&gt;/, ">").gsub(/&quot;/, '"').gsub(/&#39;/, "'")
+            .gsub(/&nbsp;/, " ").gsub(/\s+/, " ").strip
+      end
+
+      def format_results(query, results, provider)
+        lines = ["Search results for: #{query} (via #{provider})\n"]
+
+        results.each_with_index do |result, idx|
+          lines << "#{idx + 1}. #{result[:title]}"
+          lines << "   URL: #{result[:url]}" unless result[:url].empty?
+          lines << "   #{result[:snippet]}" unless result[:snippet].empty?
+          lines << ""
+        end
+
+        truncate(lines.join("\n"), max: 30_000)
+      end
+    end
+
+    Registry.register(WebSearch)
+  end
+end

data/lib/rubyn_code/tools/write_file.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class WriteFile < Base
+      TOOL_NAME = "write_file"
+      DESCRIPTION = "Writes content to a file. Creates parent directories if needed."
+      PARAMETERS = {
+        path: { type: :string, required: true, description: "Path to the file to write (relative to project root or absolute)" },
+        content: { type: :string, required: true, description: "Content to write to the file" }
+      }.freeze
+      RISK_LEVEL = :write
+      REQUIRES_CONFIRMATION = false
+
+      def execute(path:, content:)
+        resolved = safe_path(path)
+
+        FileUtils.mkdir_p(File.dirname(resolved))
+        bytes = File.write(resolved, content)
+
+        "Successfully wrote #{bytes} bytes to #{path}"
+      end
+    end
+
+    Registry.register(WriteFile)
+  end
+end

data/lib/rubyn_code/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubynCode
+  VERSION = "0.1.0"
+end