prompt_objects 0.6.0 → 0.7.0

data/templates/music/primitives/query_sonic_pi.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "socket"
+require_relative "support/osc_bridge"
+
+module PromptObjects
+  module Primitives
+    class QuerySonicPi < Primitive
+      RESPONSE_PORT = 4561
+      TIMEOUT = 2  # seconds to wait for response
+
+      def name
+        "query_sonic_pi"
+      end
+
+      def description
+        "Query Sonic Pi for its current live state — which voices are active, their synths, patterns, and BPM. " \
+        "Returns the actual state from Sonic Pi, not what we think we sent. " \
+        "Returns an error if Sonic Pi is not running or the boot script isn't loaded."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      end
+
+      def receive(message, context:)
+        # Open a UDP socket to receive the response
+        socket = UDPSocket.new
+        socket.bind("127.0.0.1", RESPONSE_PORT)
+
+        # Send the query to Sonic Pi, telling it which port to respond on
+        OscBridge.send_message("/prompt_objects/query", RESPONSE_PORT)
+
+        # Wait for response with timeout
+        ready = IO.select([socket], nil, nil, TIMEOUT)
+
+        unless ready
+          socket.close
+          return "Sonic Pi is not responding. Make sure:\n" \
+                 "1. Sonic Pi is open and running\n" \
+                 "2. The boot script from extras/sonic_pi_boot.rb is loaded and running\n" \
+                 "3. The script includes the /prompt_objects/query handler"
+        end
+
+        data, = socket.recvfrom(4096)
+        socket.close
+
+        # Parse OSC response — extract the string argument
+        state_str = parse_osc_string(data)
+        return "Received empty response from Sonic Pi" unless state_str && !state_str.empty?
+
+        # Parse the state string into structured data
+        parse_state(state_str)
+
+      rescue Errno::EADDRINUSE
+        "Port #{RESPONSE_PORT} is already in use — another query may be in progress. Try again in a moment."
+      rescue => e
+        socket&.close
+        "Error querying Sonic Pi: #{e.message}"
+      end
+
+      private
+
+      # Parse the raw OSC packet to extract the string argument.
+      # OSC format: address (null-padded to 4-byte boundary), type tag string, arguments
+      def parse_osc_string(data)
+        return nil if data.nil? || data.empty?
+
+        # Find the address string (starts at byte 0, null-terminated)
+        addr_end = data.index("\x00")
+        return nil unless addr_end
+
+        # Skip address + padding to 4-byte boundary
+        pos = addr_end + 1
+        pos += 1 while pos % 4 != 0
+
+        # Type tag string starts with ','
+        return nil unless data[pos] == ","
+        type_tag_end = data.index("\x00", pos)
+        return nil unless type_tag_end
+
+        type_tags = data[(pos + 1)...type_tag_end]
+
+        # Skip type tag + padding
+        pos = type_tag_end + 1
+        pos += 1 while pos % 4 != 0
+
+        # First argument should be a string (type 's')
+        if type_tags[0] == "s"
+          str_end = data.index("\x00", pos)
+          return nil unless str_end
+          data[pos...str_end]
+        else
+          nil
+        end
+      end
+
+      def parse_state(state_str)
+        # Format: "bpm|slots_used|slots_free||voice|active|synth|notes|durs||..."
+        parts = state_str.split("||")
+        return "Unexpected state format: #{state_str}" if parts.empty?
+
+        # Header: bpm|slots_used|slots_free
+        header = parts[0].split("|")
+        bpm = header[0].to_i
+        slots_used = header[1].to_i
+        slots_free = header[2].to_i
+
+        voices = {}
+        parts[1..].each do |part|
+          fields = part.split("|")
+          next if fields.length < 3
+
+          voice_name = fields[0]
+          voices[voice_name] = {
+            "active" => fields[1] == "true",
+            "synth" => fields[2],
+            "notes" => fields[3] && !fields[3].empty? ? fields[3] : nil,
+            "durations" => fields[4] && !fields[4].empty? ? fields[4] : nil
+          }
+        end
+
+        state = {
+          "connected" => true,
+          "bpm" => bpm,
+          "slots_used" => slots_used,
+          "slots_free" => slots_free,
+          "voices" => voices
+        }
+
+        JSON.pretty_generate(state)
+      end
+    end
+  end
+end

data/templates/music/primitives/set_synth.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "support/osc_bridge"
+
+
+module PromptObjects
+  module Primitives
+    class SetSynth < Primitive
+      # Pre-tuned sound-pack presets installed by the boot script. Each picks a
+      # warm synth and shapes the envelope, filter, and level so notes never
+      # click or sound harsh. Prefer these over raw synth names.
+      PRESETS = %w[warm_lead soft_pad round_bass warm_bell soft_kick soft_hat].freeze
+
+      def name
+        "set_synth"
+      end
+
+      def description
+        "Set a voice's sound to one of the warm sound-pack presets: #{PRESETS.join(', ')}. " \
+        "Use warm_lead for melodies, soft_pad for sustained chords, round_bass for bass, " \
+        "warm_bell for bells/plucks, soft_kick for kicks, soft_hat for hi-hats. " \
+        "The engine handles envelopes, filtering, and reverb — you just pick the preset."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            voice: {
+              type: "string",
+              description: "Which voice to change (e.g. lead, bass, perc, pad, or any voice name)"
+            },
+            synth: {
+              type: "string",
+              description: "Sound-pack preset: #{PRESETS.join(', ')}. (An advanced raw Sonic Pi synth name also works but won't be as warm.)"
+            }
+          },
+          required: %w[voice synth]
+        }
+      end
+
+      def receive(message, context:)
+        voice = message[:voice] || message["voice"]
+        synth = (message[:synth] || message["synth"]).to_s.strip
+
+        OscBridge.send_message("/chiptune/synth", voice, synth)
+        "Set #{voice} sound to #{synth}"
+      rescue => e
+        "Error setting synth: #{e.message}. Is Sonic Pi running with the boot script loaded?"
+      end
+    end
+  end
+end

data/templates/music/primitives/set_tempo.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "support/osc_bridge"
+
+
+module PromptObjects
+  module Primitives
+    class SetTempo < Primitive
+      def name
+        "set_tempo"
+      end
+
+      def description
+        "Set the global tempo (BPM) for the whole ensemble. There is ONE shared tempo — " \
+        "every voice locks to it via the master clock, so all voices stay in time. " \
+        "Conductor-only: voices should not change the tempo. For background music, 70-90 BPM."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            bpm: {
+              type: "integer",
+              description: "Tempo in beats per minute (e.g. 84). Typical range 60-160."
+            }
+          },
+          required: %w[bpm]
+        }
+      end
+
+      def receive(message, context:)
+        bpm = (message[:bpm] || message["bpm"]).to_i
+        return "Error: bpm must be a positive integer" unless bpm > 0
+
+        OscBridge.send_message("/chiptune/tempo", bpm)
+        "Set the shared tempo to #{bpm} BPM. All voices will lock to it on the next bar."
+      rescue => e
+        "Error setting tempo: #{e.message}. Is Sonic Pi running with the boot script loaded?"
+      end
+    end
+  end
+end

data/templates/music/primitives/stop_voice.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "support/osc_bridge"
+
+
+module PromptObjects
+  module Primitives
+    class StopVoice < Primitive
+      def name
+        "stop_voice"
+      end
+
+      def description
+        "Stop a voice's live loop in Sonic Pi"
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            voice: {
+              type: "string",
+              description: "Which voice to stop (e.g. lead, bass, perc, pad, or any voice name), or 'all' to stop everything"
+            }
+          },
+          required: %w[voice]
+        }
+      end
+
+      def receive(message, context:)
+        voice = message[:voice] || message["voice"]
+
+        OscBridge.send_message("/chiptune/stop", voice)
+        if voice == "all"
+          "Stopped all voices"
+        else
+          "Stopped #{voice} voice"
+        end
+      rescue => e
+        "Error stopping voice: #{e.message}. Is Sonic Pi running with the boot script loaded?"
+      end
+    end
+  end
+end

data/templates/music/primitives/support/osc_bridge.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "osc-ruby"
+
+module PromptObjects
+  module Primitives
+    # Shared OSC client for communicating with Sonic Pi.
+    # Thread-safe via Mutex. Used by music primitives and the heartbeat service.
+    module OscBridge
+      SONIC_PI_HOST = ENV.fetch("SONIC_PI_HOST", "127.0.0.1")
+      SONIC_PI_PORT = ENV.fetch("SONIC_PI_PORT", "4560").to_i
+
+      @client = nil
+      @mutex = Mutex.new
+
+      def self.client
+        @mutex.synchronize do
+          @client ||= OSC::Client.new(SONIC_PI_HOST, SONIC_PI_PORT)
+        end
+      end
+
+      def self.send_message(path, *args)
+        client.send(OSC::Message.new(path, *args))
+      end
+
+      def self.connected?
+        !@client.nil?
+      rescue
+        false
+      end
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Colin Harris
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/address_pattern.rb

@@ -0,0 +1,58 @@
+module OSC
+  class AddressPattern
+    def initialize(pattern)
+      @pattern = pattern
+
+      generate_regex_from_pattern
+    end
+
+    def match?(address)
+      !!(@re.nil? || @re.match(address))
+    end
+
+    private
+
+    def generate_regex_from_pattern
+      case @pattern
+      when nil
+        @re = @pattern
+      when Regexp
+        @re = @pattern
+      when String
+        # i'm unsure what this does
+        # @pattern.gsub!(/[.^(|)]/, '\\1')
+
+        # handles osc single char wildcard matching
+        @pattern.gsub!(/\?/, '[^/]')
+
+        # handles ** - used in creating osc routers
+        # TODO: turns out the OSC 1.1 spec says that we shoudl use "//"
+        # this will be implemented in the next major release of this gem
+        #@pattern.gsub!(/\*\*/, '.*' )
+
+        # handles osc * - 0 or more matching
+        @pattern.gsub!(/\*[^\*]/, '[^/]*')
+
+        # handles [!] matching
+        @pattern.gsub!(/\[!/, '[^')
+
+        # handles {} matching
+        @pattern.gsub!(/\{/, '(')
+        @pattern.gsub!(/,/, '|')
+        @pattern.gsub!(/\}/, ')')
+
+
+        # keeps from matching before the begining of the pattern
+        @pattern.gsub!(/\A/, '\A')
+
+        # keeps from matching beyond the end,
+        # eg. pattern /hi does not match /hidden
+        @pattern.gsub!(/\z/, '\z')
+
+        @re = Regexp.new(@pattern)
+      else
+        raise(ArgumentError, 'invalid pattern')
+      end
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/broadcast_client.rb

@@ -0,0 +1,24 @@
+require 'ipaddr'
+
+module OSC
+  class BroadcastClient
+
+    BROADCAST_ADDRESS = '<broadcast>'
+
+    attr_reader :port
+
+    def initialize(port, local_ip = nil)
+      @port = port
+      @so = UDPSocket.new
+      @so.setsockopt Socket::SOL_SOCKET, Socket::SO_BROADCAST, true
+      if local_ip
+        @so.setsockopt Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF, IPAddr.new(local_ip).hton
+        @so.bind(local_ip, 0)
+      end
+    end
+
+    def send(mesg)
+      @so.send(mesg.encode, 0, BROADCAST_ADDRESS, @port)
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/bundle.rb

@@ -0,0 +1,46 @@
+module OSC
+  class Bundle
+    attr_accessor :timetag
+
+    def initialize(timetag=nil, *args)
+      @timetag = timetag
+      @args = args
+    end
+
+    def encode()
+      s = OSCString.new('#bundle').encode
+      s << encode_timetag(@timetag)
+      s << @args.collect do |x|
+        x2 = x.encode; [x2.size].pack('N') + x2
+      end.join
+    end
+
+    def to_a
+      @args.collect{|x| x.to_a}
+    end
+
+    private
+
+    def encode_timetag(t)
+      case t
+      when nil # immediately
+        t1 = 0
+        t2 = 1
+      when Numeric
+        t1, t2 = construct_timetag(t)
+      when Time
+        t1, t2 = construct_timetag(t.to_ntp)
+      else
+        raise(ArgumentError, 'invalid time')
+      end
+      [t1, t2].pack('N2')
+    end
+
+    def construct_timetag(time)
+      t1, fr = time.divmod(1)
+      t2 = (fr * (2**32)).to_i
+
+      [t1, t2]
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/client.rb

@@ -0,0 +1,13 @@
+module OSC
+  class Client
+
+    def initialize(host, port)
+      @so = UDPSocket.new
+      @so.connect(host, port)
+    end
+
+    def send(mesg)
+      @so.send(mesg.encode, 0)
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/core_ext/time.rb

@@ -0,0 +1,6 @@
+class Time
+  
+  def to_ntp
+    self.to_f + 2208988800
+  end 
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/em_server.rb

@@ -0,0 +1,63 @@
+require 'eventmachine'
+
+module OSC
+  Channel = EM::Channel.new
+
+  class Connection < EventMachine::Connection
+    def receive_data(data)
+      ip_info = get_peername[2,6].unpack("nC4")
+      Channel << OSC::OSCPacket.messages_from_network(data, ip_info)
+    end
+  end
+
+  class EMServer
+
+    def initialize(port = 3333)
+      @port = port
+      setup_dispatcher
+      @tuples = []
+    end
+
+    def run
+      EM.error_handler{ |e|
+        Thread.main.raise e
+      }
+
+      EM.run do
+        EM::open_datagram_socket "0.0.0.0",  @port, Connection
+      end
+    end
+
+    def add_method(address_pattern, &proc)
+      matcher = AddressPattern.new(address_pattern)
+
+      @tuples << [matcher, proc]
+    end
+
+    private
+    def setup_dispatcher
+      Channel.subscribe do |messages|
+        messages.each do |message|
+          diff =  (message.time || 0) - Time.now.to_ntp
+
+          if diff <= 0
+            sendmesg(message)
+          else
+            EM.defer do
+              sleep(diff)
+              sendmesg(message)
+            end
+          end
+        end
+      end
+    end
+
+    def sendmesg(mesg)
+      @tuples.each do |matcher, obj|
+        if matcher.match?(mesg.address)
+          obj.call(mesg)
+        end
+      end
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/message.rb

@@ -0,0 +1,46 @@
+module OSC
+  class Message
+    attr_accessor :address
+    attr_accessor :time
+    attr_accessor :ip_address
+    attr_accessor :ip_port
+
+    def self.new_with_time(address, time, tags=nil, *args)
+      message = new(address, tags, *args)
+      message.time = time
+      message
+    end
+
+    def initialize(address, *args)
+      @address = address
+      @args = []
+
+      args.each do |arg|
+        case arg
+        when Integer;     @args << OSCInt32.new(arg)
+        when Float;       @args << OSCFloat32.new(arg)
+        when String;      @args << OSCString.new(arg)
+        when OSCArgument; @args << arg
+        end
+      end
+    end
+
+    def tags
+      @args.collect{|x| x.tag}.join
+    end
+
+    def encode
+      s = OSCString.new(@address).encode
+      s << OSCString.new(',' + tags).encode
+      s << @args.collect{|x| x.encode}.join
+    end
+
+    def to_a
+      @args.collect{|x| x.val}
+    end
+
+    def ==(other)
+      @address == other.address && to_a == other.to_a
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/network_packet.rb

@@ -0,0 +1,42 @@
+module OSC
+  class NetworkPacket
+    def initialize(str)
+      @str = str.force_encoding("BINARY")
+      @index = 0
+    end
+
+    def to_s
+      @str
+    end
+
+    def rem
+      @str.length - @index
+    end
+
+    def eof?
+      rem <= 0
+    end
+
+    def skip(n)
+      @index += n
+    end
+
+    def skip_padding
+      skip((4 - (@index % 4)) % 4)
+    end
+
+    def getn(n)
+      raise(EOFError) if rem < n
+      s = @str[@index, n]
+      skip(n)
+      s
+    end
+
+    def getc
+      raise(EOFError) if rem < 1
+      c = @str[@index]
+      skip(1)
+      c
+    end
+  end
+end

data/templates/music/vendor/osc-ruby-1.1.5/lib/osc-ruby/osc_argument.rb

@@ -0,0 +1,26 @@
+module OSC
+  class OSCArgument
+    def initialize(val)
+      @val = val
+    end
+
+    attr_accessor :val
+
+    def to_i()
+      @val.to_i
+    end
+
+    def to_f()
+      @val.to_f
+    end
+
+    def to_s()
+      @val.to_s
+    end
+
+    private
+    def padding(s)
+      s + ("\000" * ((4 - (s.size % 4)) % 4))
+    end
+  end
+end