rubyn-code 0.1.0 → 0.2.0

data/lib/rubyn_code/tasks/manager.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "securerandom"
-require_relative "models"
-require_relative "dag"
+require 'securerandom'
+require_relative 'models'
+require_relative 'dag'
 
 module RubynCode
   module Tasks
@@ -27,8 +27,8 @@ module RubynCode
       # @return [Task]
       def create(title:, description: nil, session_id: nil, blocked_by: [], priority: 0)
         id = SecureRandom.uuid
-        now = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
-        status = blocked_by.empty? ? "pending" : "blocked"
+        now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
+        status = blocked_by.empty? ? 'pending' : 'blocked'
 
         @db.transaction do
           @db.execute(<<~SQL, [id, session_id, title, description, status, priority, now, now])
@@ -51,7 +51,7 @@ module RubynCode
       # @return [Task]
       def update(id, **attrs)
         allowed = %i[status priority owner result description title metadata]
-        filtered = attrs.select { |k, _| allowed.include?(k) }
+        filtered = attrs.slice(*allowed)
         return get(id) if filtered.empty?
 
         sets = filtered.map { |k, _| "#{k} = ?" }
@@ -77,7 +77,7 @@ module RubynCode
         values = []
 
         if result
-          sets << "result = ?"
+          sets << 'result = ?'
           values << result
         end
 
@@ -112,7 +112,7 @@ module RubynCode
       # @param id [String]
       # @return [Task, nil]
       def get(id)
-        rows = @db.query("SELECT * FROM tasks WHERE id = ?", [id]).to_a
+        rows = @db.query('SELECT * FROM tasks WHERE id = ?', [id]).to_a
         row_to_task(rows.first)
       end
 
@@ -126,18 +126,18 @@ module RubynCode
         params = []
 
         if status
-          conditions << "status = ?"
+          conditions << 'status = ?'
           params << status
         end
 
         if session_id
-          conditions << "session_id = ?"
+          conditions << 'session_id = ?'
           params << session_id
         end
 
-        sql = "SELECT * FROM tasks"
+        sql = 'SELECT * FROM tasks'
         sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
-        sql += " ORDER BY priority DESC, created_at ASC"
+        sql += ' ORDER BY priority DESC, created_at ASC'
 
         @db.query(sql, params).to_a.filter_map { |row| row_to_task(row) }
       end
@@ -159,7 +159,7 @@ module RubynCode
       # @param id [String]
       # @return [void]
       def delete(id)
-        @db.execute("DELETE FROM tasks WHERE id = ?", [id])
+        @db.execute('DELETE FROM tasks WHERE id = ?', [id])
       end
 
       private
@@ -194,17 +194,17 @@ module RubynCode
         return nil if row.nil?
 
         Task.new(
-          id:          row["id"],
-          session_id:  row["session_id"],
-          title:       row["title"],
-          description: row["description"],
-          status:      row["status"],
-          priority:    row["priority"],
-          owner:       row["owner"],
-          result:      row["result"],
-          metadata:    row["metadata"],
-          created_at:  row["created_at"],
-          updated_at:  row["updated_at"]
+          id: row['id'],
+          session_id: row['session_id'],
+          title: row['title'],
+          description: row['description'],
+          status: row['status'],
+          priority: row['priority'],
+          owner: row['owner'],
+          result: row['result'],
+          metadata: row['metadata'],
+          created_at: row['created_at'],
+          updated_at: row['updated_at']
         )
       end
     end

data/lib/rubyn_code/tasks/models.rb

@@ -6,10 +6,10 @@ module RubynCode
       :id, :session_id, :title, :description, :status,
       :priority, :owner, :result, :metadata, :created_at, :updated_at
     ) do
-      def pending? = status == "pending"
-      def in_progress? = status == "in_progress"
-      def completed? = status == "completed"
-      def blocked? = status == "blocked"
+      def pending? = status == 'pending'
+      def in_progress? = status == 'in_progress'
+      def completed? = status == 'completed'
+      def blocked? = status == 'blocked'
 
       def to_h
         {

data/lib/rubyn_code/teams/RUBYN.md

@@ -0,0 +1,14 @@
+# Layer 9: Teams
+
+Persistent named teammate agents with asynchronous mailbox messaging.
+
+## Classes
+
+- **`Manager`** — Spawns and manages persistent teammate agents. Each teammate has a name,
+  role, and its own conversation context. Persisted in the `teams` SQLite table.
+
+- **`Teammate`** — Represents a single teammate: name, role, conversation state, status.
+  Processes messages from its mailbox and can send messages back.
+
+- **`Mailbox`** — Asynchronous message queue between agents. `send_message` enqueues,
+  `read_inbox` dequeues. Messages are typed (`:message`, `:task`, `:result`).

data/lib/rubyn_code/teams/mailbox.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "json"
-require "securerandom"
+require 'json'
+require 'securerandom'
 
 module RubynCode
   module Teams
@@ -23,18 +23,18 @@ module RubynCode
       # @param content [String] message body
       # @param message_type [String] type of message (default: "message")
       # @return [String] the message id
-      def send(from:, to:, content:, message_type: "message")
+      def send(from:, to:, content:, message_type: 'message')
         id = SecureRandom.uuid
         now = Time.now.utc.iso8601
 
         payload = JSON.generate({
-          id: id,
-          from: from,
-          to: to,
-          content: content,
-          message_type: message_type,
-          timestamp: now
-        })
+                                  id: id,
+                                  from: from,
+                                  to: to,
+                                  content: content,
+                                  message_type: message_type,
+                                  timestamp: now
+                                })
 
         @db.execute(
           <<~SQL,
@@ -63,11 +63,11 @@ module RubynCode
 
         return [] if rows.empty?
 
-        ids = rows.map { |r| r["id"] }
-        messages = rows.map { |r| JSON.parse(r["payload"], symbolize_names: true) }
+        ids = rows.map { |r| r['id'] }
+        messages = rows.map { |r| JSON.parse(r['payload'], symbolize_names: true) }
 
         # Mark all fetched messages as read in a single statement
-        placeholders = ids.map { "?" }.join(", ")
+        placeholders = ids.map { '?' }.join(', ')
         @db.execute(
           "UPDATE mailbox_messages SET read = 1 WHERE id IN (#{placeholders})",
           ids
@@ -86,35 +86,55 @@ module RubynCode
         recipients = all_names.reject { |n| n == from }
 
         recipients.map do |recipient|
-          send(from: from, to: recipient, content: content, message_type: "broadcast")
+          send(from: from, to: recipient, content: content, message_type: 'broadcast')
         end
       end
 
+      # Returns unread messages for the given agent WITHOUT marking them as read.
+      # Used by IdlePoller to check for pending work without consuming messages.
+      #
+      # @param name [String] the recipient agent name
+      # @return [Array<Hash>] parsed message hashes
+      def pending_for(name)
+        rows = @db.query(
+          <<~SQL,
+            SELECT payload FROM mailbox_messages
+            WHERE recipient = ? AND read = 0
+            ORDER BY created_at ASC
+          SQL
+          [name]
+        ).to_a
+
+        rows.map { |r| JSON.parse(r['payload'], symbolize_names: true) }
+      end
+
       # Returns the count of unread messages for the given agent.
       #
       # @param name [String] the recipient agent name
       # @return [Integer]
       def unread_count(name)
         rows = @db.query(
-          "SELECT COUNT(*) AS cnt FROM mailbox_messages WHERE recipient = ? AND read = 0",
+          'SELECT COUNT(*) AS cnt FROM mailbox_messages WHERE recipient = ? AND read = 0',
           [name]
         ).to_a
-        rows.first&.fetch("cnt", 0) || 0
+        rows.first&.fetch('cnt', 0) || 0
       end
 
       private
 
       # Creates the mailbox_messages table if it does not already exist.
+      # Schema must stay in sync with db/migrations/009_create_teams.sql.
       def ensure_table!
         @db.execute(<<~SQL)
           CREATE TABLE IF NOT EXISTS mailbox_messages (
             id TEXT PRIMARY KEY,
             sender TEXT NOT NULL,
             recipient TEXT NOT NULL,
-            message_type TEXT NOT NULL DEFAULT 'message',
+            message_type TEXT NOT NULL DEFAULT 'message'
+              CHECK(message_type IN ('message','task','result','error','broadcast','shutdown_request','shutdown_response','status_change')),
             payload TEXT NOT NULL,
             read INTEGER NOT NULL DEFAULT 0,
-            created_at TEXT NOT NULL
+            created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
           )
         SQL
 

data/lib/rubyn_code/teams/manager.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
-require "securerandom"
-require_relative "teammate"
+require 'json'
+require 'securerandom'
+require_relative 'teammate'
 
 module RubynCode
   module Teams
@@ -40,7 +40,7 @@ module RubynCode
             INSERT INTO teammates (id, name, role, persona, model, status, metadata, created_at)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?)
           SQL
-          [id, name, role, persona, model, "idle", metadata_json, now]
+          [id, name, role, persona, model, 'idle', metadata_json, now]
         )
 
         Teammate.new(
@@ -49,7 +49,7 @@ module RubynCode
           role: role,
           persona: persona,
           model: model,
-          status: "idle",
+          status: 'idle',
           metadata: {},
           created_at: now
         )
@@ -59,7 +59,7 @@ module RubynCode
       #
       # @return [Array<Teammate>]
       def list
-        rows = @db.query("SELECT * FROM teammates ORDER BY created_at ASC").to_a
+        rows = @db.query('SELECT * FROM teammates ORDER BY created_at ASC').to_a
         rows.map { |row| row_to_teammate(row) }
       end
 
@@ -68,7 +68,7 @@ module RubynCode
       # @param name [String]
       # @return [Teammate, nil]
       def get(name)
-        rows = @db.query("SELECT * FROM teammates WHERE name = ? LIMIT 1", [name]).to_a
+        rows = @db.query('SELECT * FROM teammates WHERE name = ? LIMIT 1', [name]).to_a
         return nil if rows.empty?
 
         row_to_teammate(rows.first)
@@ -90,7 +90,7 @@ module RubynCode
         raise Error, "Teammate '#{name}' not found" unless teammate
 
         @db.execute(
-          "UPDATE teammates SET status = ? WHERE name = ?",
+          'UPDATE teammates SET status = ? WHERE name = ?',
           [status, name]
         )
       end
@@ -104,7 +104,7 @@ module RubynCode
         teammate = get(name)
         raise Error, "Teammate '#{name}' not found" unless teammate
 
-        @db.execute("DELETE FROM teammates WHERE name = ?", [name])
+        @db.execute('DELETE FROM teammates WHERE name = ?', [name])
       end
 
       # Returns all teammates with status "active".
@@ -112,8 +112,8 @@ module RubynCode
       # @return [Array<Teammate>]
       def active_teammates
         rows = @db.query(
-          "SELECT * FROM teammates WHERE status = ? ORDER BY created_at ASC",
-          ["active"]
+          'SELECT * FROM teammates WHERE status = ? ORDER BY created_at ASC',
+          ['active']
         ).to_a
         rows.map { |row| row_to_teammate(row) }
       end
@@ -125,17 +125,17 @@ module RubynCode
       # @param row [Hash]
       # @return [Teammate]
       def row_to_teammate(row)
-        metadata = parse_metadata(row["metadata"])
+        metadata = parse_metadata(row['metadata'])
 
         Teammate.new(
-          id: row["id"],
-          name: row["name"],
-          role: row["role"],
-          persona: row["persona"],
-          model: row["model"],
-          status: row["status"],
+          id: row['id'],
+          name: row['name'],
+          role: row['role'],
+          persona: row['persona'],
+          model: row['model'],
+          status: row['status'],
           metadata: metadata,
-          created_at: row["created_at"]
+          created_at: row['created_at']
         )
       end
 

data/lib/rubyn_code/teams/teammate.rb

@@ -10,15 +10,14 @@ module RubynCode
     Teammate = Data.define(
       :id, :name, :role, :persona, :model, :status, :metadata, :created_at
     ) do
-
       # @return [Boolean]
-      def idle? = status == "idle"
+      def idle? = status == 'idle'
 
       # @return [Boolean]
-      def active? = status == "active"
+      def active? = status == 'active'
 
       # @return [Boolean]
-      def offline? = status == "offline"
+      def offline? = status == 'offline'
 
       # @return [Hash]
       def to_h

data/lib/rubyn_code/tools/RUBYN.md

@@ -0,0 +1,38 @@
+# Layer 2: Tools
+
+32 built-in tools that Claude can invoke. The extensibility surface of the system.
+
+## Core Classes
+
+- **`Base`** — Abstract base class. Subclasses define `self.tool_name`, `self.description`,
+  `self.schema` (JSON Schema), and `execute(params)`. Returns a string result.
+
+- **`Registry`** — Maps tool names to classes. Tools self-register on load.
+  `Registry.find('read_file')` returns the tool class.
+
+- **`Schema`** — Converts tool classes into Claude's expected tool definition format
+  (name, description, input_schema).
+
+- **`Executor`** — Dispatches tool calls. Checks `Permissions::Policy` before execution,
+  wraps errors, and returns results. The bridge between Claude's tool_use blocks and Ruby.
+
+## Tool Categories
+
+| Category | Tools |
+|----------|-------|
+| File I/O | `read_file`, `write_file`, `edit_file`, `glob`, `grep` |
+| Shell | `bash`, `background_run` |
+| Rails | `rails_generate`, `db_migrate`, `run_specs`, `bundle_install`, `bundle_add` |
+| Git | `git_commit`, `git_diff`, `git_log`, `git_status` |
+| Web | `web_search`, `web_fetch` |
+| Memory | `memory_search`, `memory_write` |
+| Agents | `spawn_agent`, `spawn_teammate`, `send_message`, `read_inbox` |
+| Meta | `compact`, `load_skill`, `task`, `review_pr` |
+
+## Adding a Tool
+
+1. Create `my_tool.rb` in this directory, inherit `Tools::Base`
+2. Define `self.tool_name`, `self.description`, `self.schema`
+3. Implement `execute(params)` — return a string
+4. Add `autoload :MyTool` in `lib/rubyn_code.rb`
+5. Register in `Tools::Registry`

data/lib/rubyn_code/tools/background_run.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require_relative "base"
-require_relative "registry"
+require_relative 'base'
+require_relative 'registry'
 
 module RubynCode
   module Tools
     class BackgroundRun < Base
-      TOOL_NAME = "background_run"
-      DESCRIPTION = "Run a command in the background (test suites, builds, deploys). " \
-                    "Returns immediately with a job ID. Results are delivered automatically " \
-                    "before your next LLM call."
+      TOOL_NAME = 'background_run'
+      DESCRIPTION = 'Run a command in the background (test suites, builds, deploys). ' \
+                    'Returns immediately with a job ID. Results are delivered automatically ' \
+                    'before your next LLM call.'
       PARAMETERS = {
         command: {
           type: :string,
-          description: "The shell command to run in the background",
+          description: 'The shell command to run in the background',
           required: true
         },
         timeout: {
           type: :integer,
-          description: "Timeout in seconds (default: 300)",
+          description: 'Timeout in seconds (default: 300)',
           required: false
         }
       }.freeze
@@ -27,9 +27,7 @@ module RubynCode
       attr_writer :background_worker
 
       def execute(command:, timeout: 300)
-        unless @background_worker
-          return "Error: Background worker not available. Use bash tool instead."
-        end
+        return 'Error: Background worker not available. Use bash tool instead.' unless @background_worker
 
         job_id = @background_worker.run(command, timeout: timeout)
         "Background job started: #{job_id}\nCommand: #{command}\nTimeout: #{timeout}s\nResults will appear automatically when complete."

data/lib/rubyn_code/tools/base.rb

@@ -3,8 +3,8 @@
 module RubynCode
   module Tools
     class Base
-      TOOL_NAME = ""
-      DESCRIPTION = ""
+      TOOL_NAME = ''
+      DESCRIPTION = ''
       PARAMETERS = {}.freeze
       RISK_LEVEL = :read
       REQUIRES_CONFIRMATION = false
@@ -63,7 +63,7 @@ module RubynCode
         expanded
       end
 
-      def truncate(output, max: 50_000)
+      def truncate(output, max: 10_000)
         return output if output.nil? || output.length <= max
 
         half = max / 2
@@ -72,6 +72,57 @@ module RubynCode
 
       private
 
+      # Safe replacement for Open3.capture3 that avoids Ruby 4.0's IOError
+      # when threads race on stream closure. All tools should use this instead
+      # of Open3.capture3 directly.
+      def safe_capture3(*cmd, chdir: project_root, timeout: 120, **)
+        stdin, stdout_io, stderr_io, wait_thr = Open3.popen3(*cmd, chdir: chdir, **)
+        stdin.close
+
+        stdout = +''
+        stderr = +''
+
+        out_reader = Thread.new do
+          stdout << stdout_io.read
+        rescue StandardError
+          nil
+        end
+        err_reader = Thread.new do
+          stderr << stderr_io.read
+        rescue StandardError
+          nil
+        end
+
+        timed_out = false
+        unless wait_thr.join(timeout)
+          timed_out = true
+          begin
+            Process.kill('TERM', wait_thr.pid)
+          rescue StandardError
+            nil
+          end
+          sleep 0.1
+          begin
+            Process.kill('KILL', wait_thr.pid)
+          rescue StandardError
+            nil
+          end
+          wait_thr.join(5)
+        end
+
+        out_reader.join(5)
+        err_reader.join(5)
+        [stdout_io, stderr_io].each do |io|
+          io.close
+        rescue StandardError
+          nil
+        end
+
+        raise Error, "Command timed out after #{timeout}s" if timed_out
+
+        [stdout, stderr, wait_thr.value]
+      end
+
       def read_file_safely(path)
         resolved = safe_path(path)
         raise Error, "File not found: #{path}" unless File.exist?(resolved)

data/lib/rubyn_code/tools/bash.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require "open3"
-require "timeout"
-require_relative "base"
-require_relative "registry"
+require 'open3'
+require 'timeout'
+require_relative 'base'
+require_relative 'registry'
 
 module RubynCode
   module Tools
     class Bash < Base
-      TOOL_NAME = "bash"
-      DESCRIPTION = "Runs a shell command in the project directory. Blocks dangerous patterns and scrubs sensitive environment variables."
+      TOOL_NAME = 'bash'
+      DESCRIPTION = 'Runs a shell command in the project directory. Blocks dangerous patterns and scrubs sensitive environment variables.'
       PARAMETERS = {
-        command: { type: :string, required: true, description: "The shell command to execute" },
-        timeout: { type: :integer, required: false, default: 120, description: "Timeout in seconds (default: 120)" }
+        command: { type: :string, required: true, description: 'The shell command to execute' },
+        timeout: { type: :integer, required: false, default: 120, description: 'Timeout in seconds (default: 120)' }
       }.freeze
       RISK_LEVEL = :execute
       REQUIRES_CONFIRMATION = true
@@ -20,28 +20,16 @@ module RubynCode
       def execute(command:, timeout: 120)
         validate_command!(command)
 
-        env = scrubbed_env
+        stdout, stderr, status = safe_capture3(scrubbed_env, command, chdir: project_root, timeout: timeout)
 
-        stdout, stderr, status = nil
-        begin
-          Timeout.timeout(timeout) do
-            stdout, stderr, status = Open3.capture3(env, command, chdir: project_root)
-          end
-        rescue Timeout::Error
-          raise Error, "Command timed out after #{timeout} seconds: #{command}"
-        end
-
-        output = build_output(stdout, stderr, status)
-        output
+        build_output(stdout, stderr, status)
       end
 
       private
 
       def validate_command!(command)
         Config::Defaults::DANGEROUS_PATTERNS.each do |pattern|
-          if command.include?(pattern)
-            raise PermissionDeniedError, "Blocked dangerous command pattern: '#{pattern}'"
-          end
+          raise PermissionDeniedError, "Blocked dangerous command pattern: '#{pattern}'" if command.include?(pattern)
         end
       end
 
@@ -50,7 +38,7 @@ module RubynCode
 
         env.each_key do |key|
           if Config::Defaults::SCRUB_ENV_VARS.any? { |sensitive| key.upcase.include?(sensitive) }
-            env[key] = "[SCRUBBED]"
+            env[key] = '[SCRUBBED]'
           end
         end
 
@@ -60,19 +48,13 @@ module RubynCode
       def build_output(stdout, stderr, status)
         parts = []
 
-        unless stdout.empty?
-          parts << stdout
-        end
+        parts << stdout unless stdout.empty?
 
-        unless stderr.empty?
-          parts << "STDERR:\n#{stderr}"
-        end
+        parts << "STDERR:\n#{stderr}" unless stderr.empty?
 
-        unless status.success?
-          parts << "Exit code: #{status.exitstatus}"
-        end
+        parts << "Exit code: #{status.exitstatus}" unless status.success?
 
-        parts.empty? ? "(no output)" : parts.join("\n")
+        parts.empty? ? '(no output)' : parts.join("\n")
       end
     end