rubyn-code 0.1.0

data/db/migrations/003_create_tasks.sql

@@ -0,0 +1,17 @@
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,
+  session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+  title TEXT NOT NULL,
+  description TEXT,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','in_progress','blocked','completed','cancelled')),
+  priority INTEGER NOT NULL DEFAULT 0,
+  owner TEXT,
+  result TEXT,
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+  updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_owner ON tasks(owner);

data/db/migrations/004_create_task_dependencies.sql

@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS task_dependencies (
+  task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  depends_on_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  PRIMARY KEY (task_id, depends_on_id),
+  CHECK(task_id != depends_on_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_deps_depends_on ON task_dependencies(depends_on_id);

data/db/migrations/005_create_memories.sql

@@ -0,0 +1,44 @@
+CREATE TABLE IF NOT EXISTS memories (
+  id TEXT PRIMARY KEY,
+  project_path TEXT NOT NULL,
+  tier TEXT NOT NULL CHECK(tier IN ('short','medium','long')),
+  category TEXT,
+  content TEXT NOT NULL,
+  relevance_score REAL NOT NULL DEFAULT 1.0,
+  access_count INTEGER NOT NULL DEFAULT 0,
+  last_accessed_at TEXT,
+  expires_at TEXT,
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_path);
+CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier);
+CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(project_path, category);
+CREATE INDEX IF NOT EXISTS idx_memories_expires ON memories(expires_at);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  content,
+  category,
+  content=memories,
+  content_rowid=rowid,
+  tokenize='porter unicode61'
+);
+
+-- Triggers to keep FTS index in sync with the memories table
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, content, category)
+  VALUES (NEW.rowid, NEW.content, NEW.category);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, category)
+  VALUES ('delete', OLD.rowid, OLD.content, OLD.category);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, category)
+  VALUES ('delete', OLD.rowid, OLD.content, OLD.category);
+  INSERT INTO memories_fts(rowid, content, category)
+  VALUES (NEW.rowid, NEW.content, NEW.category);
+END;

data/db/migrations/006_create_cost_records.sql

@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS cost_records (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  model TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL NOT NULL DEFAULT 0.0,
+  request_type TEXT,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_cost_records_session ON cost_records(session_id);
+CREATE INDEX IF NOT EXISTS idx_cost_records_model ON cost_records(model);
+CREATE INDEX IF NOT EXISTS idx_cost_records_created ON cost_records(created_at);

data/db/migrations/007_create_hooks.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS hook_configs (
+  id TEXT PRIMARY KEY,
+  event_type TEXT NOT NULL,
+  handler_type TEXT NOT NULL,
+  handler_config TEXT NOT NULL DEFAULT '{}',
+  enabled INTEGER NOT NULL DEFAULT 1,
+  priority 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_hooks_event ON hook_configs(event_type);
+CREATE INDEX IF NOT EXISTS idx_hooks_enabled ON hook_configs(enabled, event_type);

data/db/migrations/008_create_skills_cache.sql

@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS skills_cache (
+  id TEXT PRIMARY KEY,
+  skill_name TEXT NOT NULL UNIQUE,
+  content_hash TEXT NOT NULL,
+  loaded_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_skills_cache_name ON skills_cache(skill_name);

data/db/migrations/009_create_teams.sql

@@ -0,0 +1,27 @@
+CREATE TABLE IF NOT EXISTS teammates (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  role TEXT NOT NULL,
+  persona TEXT,
+  model TEXT NOT NULL DEFAULT 'claude-sonnet-4-20250514',
+  status TEXT NOT NULL DEFAULT 'idle' CHECK(status IN ('idle','busy','offline')),
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_teammates_name ON teammates(name);
+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')),
+  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_created ON mailbox_messages(created_at);

data/db/migrations/010_create_instincts.sql

@@ -0,0 +1,15 @@
+CREATE TABLE IF NOT EXISTS instincts (
+  id TEXT PRIMARY KEY,
+  project_path TEXT NOT NULL,
+  pattern TEXT NOT NULL,
+  context_tags TEXT DEFAULT '[]',
+  confidence REAL NOT NULL DEFAULT 0.5,
+  decay_rate REAL NOT NULL DEFAULT 0.01,
+  times_applied INTEGER NOT NULL DEFAULT 0,
+  times_helpful INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+  updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_instincts_project ON instincts(project_path);
+CREATE INDEX IF NOT EXISTS idx_instincts_confidence ON instincts(confidence DESC);

data/exe/rubyn-code

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

data/lib/rubyn_code/agent/conversation.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Agent
+    class Conversation
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+      end
+
+      # Append a user turn to the conversation.
+      #
+      # @param content [String]
+      # @return [Hash] the appended message
+      def add_user_message(content)
+        message = { role: "user", content: content }
+        @messages << message
+        message
+      end
+
+      # Append an assistant turn to the conversation.
+      #
+      # @param content [Array<Hash>, String, nil] text blocks from the response
+      # @param tool_calls [Array<Hash>] tool_use blocks from the response
+      # @return [Hash] the appended message
+      def add_assistant_message(content, tool_calls: [])
+        blocks = normalize_content(content, tool_calls)
+        message = { role: "assistant", content: blocks }
+        @messages << message
+        message
+      end
+
+      # Append a tool result turn to the conversation.
+      #
+      # @param tool_use_id [String]
+      # @param tool_name [String]
+      # @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)
+        result_block = {
+          type: "tool_result",
+          tool_use_id: tool_use_id,
+          content: output.to_s
+        }
+        result_block[:is_error] = true if is_error
+
+        # The Claude API expects tool results as a user message whose content
+        # 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)
+          @messages.last[:content] << result_block
+        else
+          @messages << { role: "user", content: [result_block] }
+        end
+
+        result_block
+      end
+
+      # Extract the text from the most recent assistant message.
+      #
+      # @return [String, nil]
+      def last_assistant_text
+        assistant_msg = @messages.reverse_each.find { |m| m[:role] == "assistant" }
+        return nil unless assistant_msg
+
+        extract_text(assistant_msg[:content])
+      end
+
+      # @return [Integer]
+      def length
+        @messages.length
+      end
+
+      # Reset the conversation to an empty state.
+      #
+      # @return [void]
+      def clear!
+        @messages.clear
+      end
+
+      # Return the messages array formatted for the Claude API.
+      # Ensures proper role alternation and content structure.
+      #
+      # @return [Array<Hash>]
+      def to_api_format
+        @messages.map do |msg|
+          {
+            role: msg[:role],
+            content: format_content(msg[:content])
+          }
+        end
+      end
+
+      # Remove the last user + assistant exchange. Useful for undo.
+      # If the last two messages are assistant then user (most recent first),
+      # removes both. Otherwise removes only the last message.
+      #
+      # @return [void]
+      def undo_last!
+        return if @messages.empty?
+
+        # Walk backwards and remove the most recent user+assistant pair.
+        # The typical pattern is: [..., user, assistant] or
+        # [..., assistant, user(tool_results)].
+        removed = 0
+        while @messages.any? && removed < 2
+          last = @messages.last
+          break if removed == 1 && last[:role] != "assistant" && last[:role] != "user"
+
+          @messages.pop
+          removed += 1
+        end
+      end
+
+      private
+
+      # Normalize content and tool_calls into a single array of content blocks.
+      def normalize_content(content, tool_calls)
+        blocks = []
+
+        case content
+        when Array
+          content.each { |b| blocks << block_to_hash(b) }
+        when String
+          blocks << { type: "text", text: content } unless content.empty?
+        when Hash
+          blocks << content
+        else
+          blocks << block_to_hash(content) if content.respond_to?(:type)
+        end
+
+        tool_calls.each do |tc|
+          blocks << block_to_hash(tc)
+        end
+
+        blocks
+      end
+
+      # Format message content for the API. Converts Data objects to hashes.
+      def format_content(content)
+        case content
+        when String then content
+        when Array
+          content.map { |block| block_to_hash(block) }
+        else ""
+        end
+      end
+
+      def block_to_hash(block)
+        return block if block.is_a?(Hash)
+
+        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 }
+            h[:is_error] = true if block.respond_to?(:is_error) && block.is_error
+            h
+          else
+            block.respond_to?(:to_h) ? block.to_h : block
+          end
+        else
+          block
+        end
+      end
+
+      # Extract text from content blocks.
+      def extract_text(content)
+        case content
+        when String
+          content
+        when Array
+          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
+      end
+
+      # Check whether a message is a tool-result-bearing user message.
+      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" }
+      end
+    end
+  end
+end