rubyn-code 0.1.0 → 0.2.0

data/db/migrations/009_create_teams.sql

@@ -14,14 +14,14 @@ CREATE INDEX IF NOT EXISTS idx_teammates_status ON teammates(status);
 
 CREATE TABLE IF NOT EXISTS mailbox_messages (
   id TEXT PRIMARY KEY,
-  from_agent TEXT NOT NULL,
-  to_agent TEXT NOT NULL,
-  content TEXT NOT NULL,
-  message_type TEXT NOT NULL DEFAULT 'text' CHECK(message_type IN ('text','task','result','error')),
+  sender TEXT NOT NULL,
+  recipient TEXT NOT NULL,
+  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 DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
 );
 
-CREATE INDEX IF NOT EXISTS idx_mailbox_to ON mailbox_messages(to_agent, read);
-CREATE INDEX IF NOT EXISTS idx_mailbox_from ON mailbox_messages(from_agent);
+CREATE INDEX IF NOT EXISTS idx_mailbox_recipient_read ON mailbox_messages(recipient, read);
+CREATE INDEX IF NOT EXISTS idx_mailbox_sender ON mailbox_messages(sender);
 CREATE INDEX IF NOT EXISTS idx_mailbox_created ON mailbox_messages(created_at);

data/db/migrations/011_fix_mailbox_messages_columns.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Fix mailbox_messages column mismatch between 009_create_teams.sql and
+# Teams::Mailbox. The original migration used from_agent/to_agent/content
+# but the Mailbox class expects sender/recipient/payload.
+#
+# This is a Ruby migration (not SQL) because we need to detect which schema
+# the user has before running the appropriate ALTER statements. Pure SQL
+# can't branch on column existence without parse errors.
+module Migration011FixMailboxMessagesColumns
+  module_function
+
+  # @param db [RubynCode::DB::Connection] the database connection
+  def up(db)
+    columns = db.query("SELECT name FROM pragma_table_info('mailbox_messages')").to_a
+    column_names = columns.map { |c| c['name'] }
+
+    if column_names.include?('from_agent')
+      # Old schema from 009 migration — rename columns
+      db.execute('ALTER TABLE mailbox_messages RENAME COLUMN from_agent TO sender')
+      db.execute('ALTER TABLE mailbox_messages RENAME COLUMN to_agent TO recipient')
+      db.execute('ALTER TABLE mailbox_messages RENAME COLUMN content TO payload')
+
+      # Remap 'text' message_type to 'message' to match Mailbox default
+      db.execute("UPDATE mailbox_messages SET message_type = 'message' WHERE message_type = 'text'")
+    end
+
+    # Ensure indexes match regardless of which schema path we took
+    db.execute('DROP INDEX IF EXISTS idx_mailbox_to')
+    db.execute('DROP INDEX IF EXISTS idx_mailbox_from')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_recipient_read ON mailbox_messages(recipient, read)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_sender ON mailbox_messages(sender)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_created ON mailbox_messages(created_at)')
+  end
+end

data/db/migrations/012_expand_mailbox_message_types.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Expands the mailbox_messages CHECK constraint to include protocol message types:
+#   shutdown_request, shutdown_response, status_change
+#
+# SQLite does not support ALTER CONSTRAINT, so we rebuild the table.
+# The Migrator already wraps .up in a transaction — no manual BEGIN/COMMIT here.
+module Migration012ExpandMailboxMessageTypes
+  module_function
+
+  def up(db)
+    db.execute(<<~SQL)
+      CREATE TABLE mailbox_messages_new (
+        id TEXT PRIMARY KEY,
+        sender TEXT NOT NULL,
+        recipient TEXT NOT NULL,
+        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 DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+      )
+    SQL
+
+    db.execute(<<~SQL)
+      INSERT INTO mailbox_messages_new (id, sender, recipient, message_type, payload, read, created_at)
+      SELECT id, sender, recipient, message_type, payload, read, created_at
+      FROM mailbox_messages
+    SQL
+
+    db.execute('DROP TABLE mailbox_messages')
+    db.execute('ALTER TABLE mailbox_messages_new RENAME TO mailbox_messages')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_recipient_read ON mailbox_messages(recipient, read)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_sender ON mailbox_messages(sender)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_created ON mailbox_messages(created_at)')
+  end
+end

data/exe/rubyn-code

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "rubyn_code"
+require 'rubyn_code'
 
 RubynCode::CLI::App.start(ARGV)

data/lib/rubyn_code/agent/RUBYN.md

@@ -0,0 +1,17 @@
+# Layer 1: Agent
+
+The core agentic loop. This is the heartbeat of the whole system.
+
+## Classes
+
+- **`Loop`** — The main agent loop. Sends conversation to Claude, receives a response.
+  If the response contains `tool_use` blocks, dispatches them via `Tools::Executor`,
+  appends results, and loops. Stops when Claude returns plain text, budget is exhausted,
+  or `MAX_ITERATIONS` is reached. Collaborates with `LoopDetector` to break stalls.
+
+- **`Conversation`** — In-memory conversation state. Holds the messages array (user turns,
+  assistant turns, tool results). Supports undo, clear, and context compaction.
+
+- **`LoopDetector`** — Detects when the agent is stuck calling the same tool with the same
+  arguments. Uses a sliding window (default: 5) with a threshold (default: 3 identical calls).
+  Raises `StallDetectedError` when triggered.

data/lib/rubyn_code/agent/conversation.rb

@@ -14,7 +14,7 @@ module RubynCode
       # @param content [String]
       # @return [Hash] the appended message
       def add_user_message(content)
-        message = { role: "user", content: content }
+        message = { role: 'user', content: content }
         @messages << message
         message
       end
@@ -26,7 +26,7 @@ module RubynCode
       # @return [Hash] the appended message
       def add_assistant_message(content, tool_calls: [])
         blocks = normalize_content(content, tool_calls)
-        message = { role: "assistant", content: blocks }
+        message = { role: 'assistant', content: blocks }
         @messages << message
         message
       end
@@ -38,9 +38,9 @@ module RubynCode
       # @param output [String]
       # @param is_error [Boolean]
       # @return [Hash] the appended message
-      def add_tool_result(tool_use_id, tool_name, output, is_error: false)
+      def add_tool_result(tool_use_id, _tool_name, output, is_error: false)
         result_block = {
-          type: "tool_result",
+          type: 'tool_result',
           tool_use_id: tool_use_id,
           content: output.to_s
         }
@@ -50,10 +50,10 @@ module RubynCode
         # is an array of tool_result blocks.  When the previous message is
         # already a user/tool_result message we append to it so that multiple
         # tool results for the same assistant turn are batched together.
-        if @messages.last && @messages.last[:role] == "user" && tool_result_message?(@messages.last)
+        if @messages.last && @messages.last[:role] == 'user' && tool_result_message?(@messages.last)
           @messages.last[:content] << result_block
         else
-          @messages << { role: "user", content: [result_block] }
+          @messages << { role: 'user', content: [result_block] }
         end
 
         result_block
@@ -63,7 +63,7 @@ module RubynCode
       #
       # @return [String, nil]
       def last_assistant_text
-        assistant_msg = @messages.reverse_each.find { |m| m[:role] == "assistant" }
+        assistant_msg = @messages.reverse_each.find { |m| m[:role] == 'assistant' }
         return nil unless assistant_msg
 
         extract_text(assistant_msg[:content])
@@ -86,12 +86,14 @@ module RubynCode
       #
       # @return [Array<Hash>]
       def to_api_format
-        @messages.map do |msg|
+        formatted = @messages.map do |msg|
           {
             role: msg[:role],
             content: format_content(msg[:content])
           }
         end
+
+        repair_orphaned_tool_uses(formatted)
       end
 
       # Remove the last user + assistant exchange. Useful for undo.
@@ -108,15 +110,62 @@ module RubynCode
         removed = 0
         while @messages.any? && removed < 2
           last = @messages.last
-          break if removed == 1 && last[:role] != "assistant" && last[:role] != "user"
+          break if removed == 1 && last[:role] != 'assistant' && last[:role] != 'user'
 
           @messages.pop
           removed += 1
         end
       end
 
+      # Replace messages with a new array (used after compaction).
+      def replace!(new_messages)
+        @messages.replace(new_messages)
+      end
+
       private
 
+      # Ensure every tool_use block has a matching tool_result.
+      # If a tool_use is orphaned (e.g. from Ctrl-C interruption),
+      # inject a synthetic tool_result so the API doesn't reject the request.
+      def repair_orphaned_tool_uses(formatted)
+        # Collect all tool_use IDs from assistant messages
+        tool_use_ids = Set.new
+        formatted.each do |msg|
+          next unless msg[:role] == 'assistant' && msg[:content].is_a?(Array)
+
+          msg[:content].each do |block|
+            if block.is_a?(Hash) && (block[:type] == 'tool_use' || block['type'] == 'tool_use')
+              tool_use_ids << (block[:id] || block['id'])
+            end
+          end
+        end
+
+        # Collect all tool_result IDs from user messages
+        tool_result_ids = Set.new
+        formatted.each do |msg|
+          next unless msg[:role] == 'user' && msg[:content].is_a?(Array)
+
+          msg[:content].each do |block|
+            if block.is_a?(Hash) && (block[:type] == 'tool_result' || block['type'] == 'tool_result')
+              tool_result_ids << (block[:tool_use_id] || block['tool_use_id'])
+            end
+          end
+        end
+
+        # Find orphans
+        orphaned = tool_use_ids - tool_result_ids
+        return formatted if orphaned.empty?
+
+        # Inject synthetic tool_results for orphans
+        orphan_results = orphaned.map do |id|
+          { type: 'tool_result', tool_use_id: id, content: '[interrupted]', is_error: true }
+        end
+
+        # Append as a user message after the last assistant message
+        formatted << { role: 'user', content: orphan_results }
+        formatted
+      end
+
       # Normalize content and tool_calls into a single array of content blocks.
       def normalize_content(content, tool_calls)
         blocks = []
@@ -125,7 +174,7 @@ module RubynCode
         when Array
           content.each { |b| blocks << block_to_hash(b) }
         when String
-          blocks << { type: "text", text: content } unless content.empty?
+          blocks << { type: 'text', text: content } unless content.empty?
         when Hash
           blocks << content
         else
@@ -145,7 +194,7 @@ module RubynCode
         when String then content
         when Array
           content.map { |block| block_to_hash(block) }
-        else ""
+        else ''
         end
       end
 
@@ -154,12 +203,12 @@ module RubynCode
 
         if block.respond_to?(:type)
           case block.type.to_s
-          when "text"
-            { type: "text", text: block.text }
-          when "tool_use"
-            { type: "tool_use", id: block.id, name: block.name, input: block.input }
-          when "tool_result"
-            h = { type: "tool_result", tool_use_id: block.tool_use_id, content: block.content.to_s }
+          when 'text'
+            { type: 'text', text: block.text }
+          when 'tool_use'
+            { type: 'tool_use', id: block.id, name: block.name, input: block.input }
+          when 'tool_result'
+            h = { type: 'tool_result', tool_use_id: block.tool_use_id, content: block.content.to_s }
             h[:is_error] = true if block.respond_to?(:is_error) && block.is_error
             h
           else
@@ -176,7 +225,7 @@ module RubynCode
         when String
           content
         when Array
-          text_blocks = content.select { |b| b.is_a?(Hash) && b[:type] == "text" }
+          text_blocks = content.select { |b| b.is_a?(Hash) && b[:type] == 'text' }
           texts = text_blocks.map { |b| b[:text] }
           texts.empty? ? nil : texts.join("\n")
         end
@@ -186,7 +235,7 @@ module RubynCode
       def tool_result_message?(msg)
         return false unless msg[:content].is_a?(Array)
 
-        msg[:content].all? { |b| b.is_a?(Hash) && b[:type] == "tool_result" }
+        msg[:content].all? { |b| b.is_a?(Hash) && b[:type] == 'tool_result' }
       end
     end
   end