prompt_objects 0.5.0 → 0.7.0

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

@@ -0,0 +1,140 @@
+require File.join(File.dirname( __FILE__ ), 'network_packet')
+require 'ostruct'
+
+module OSC
+  class UnknownType < StandardError; end
+
+  class OSCPacket
+    def self.messages_from_network(string, ip_info=nil)
+      messages = []
+      osc = new(string)
+
+      if osc.bundle?
+        osc.get_string
+        time = osc.get_timestamp
+
+        osc.get_bundle_messages.each do |message|
+          msg = decode_simple_message(time, OSCPacket.new(message))
+          if ip_info
+            # Append info for the ip address
+            msg.ip_port = ip_info.shift
+            msg.ip_address = ip_info.join(".")
+          end
+          messages << msg
+        end
+
+      else
+        msg = decode_simple_message(time, osc)
+        if ip_info
+          # Append info for the ip address
+          msg.ip_port = ip_info.shift
+          msg.ip_address = ip_info.join(".")
+        end
+        messages << msg
+      end
+
+      return messages
+    end
+
+    def self.decode_simple_message(time, osc_packet)
+      address = osc_packet.get_string
+      args = osc_packet.get_arguments
+
+      Message.new_with_time(address, time, nil, *args)
+    end
+
+    def initialize(string)
+      @packet = NetworkPacket.new(string)
+
+      @types = {
+       "i" => lambda{OSCInt32.new(get_int32)},
+       "f" => lambda{  OSCFloat32.new(get_float32)},
+       "d" => lambda{  OSCDouble64.new(get_double64)},
+       "s" => lambda{  OSCString.new(get_string)},
+       "b" => lambda{  OSCBlob.new(get_blob)}
+     }
+    end
+
+    def get_bundle_messages
+      bundle_messages = []
+
+      until @packet.eof?
+        l = @packet.getn(4).unpack('N')[0]
+        bundle_messages << @packet.getn(l)
+      end
+      bundle_messages
+    end
+
+    def get_string
+      result = ''
+      until ((c = @packet.getc) == string_delemeter)
+        result << c
+      end
+      @packet.skip_padding
+      result
+    end
+
+    def get_timestamp
+      #TODO: refactor this so a mortal can figure it out
+      t1 = @packet.getn(4).unpack('N')[0]
+      t2 = @packet.getn(4).unpack('N')[0]
+      @packet.skip_padding
+
+      if t1 == 0 && t2 == 1
+        time = nil
+      else
+        time = t1 + t2.to_f / (2**32)
+      end
+
+      time
+    end
+
+    def get_arguments
+      if (@packet.getc == ?,)
+        tags = get_string
+        args = []
+
+        tags.scan(/./) do |tag|
+          type_handler = @types[tag]
+          raise(UnknownType, "Unknown OSC type: #{tag}") unless type_handler
+          args << type_handler.call
+        end
+        args
+      end
+    end
+
+    def get_int32
+      i = @packet.getn(4).unpack('N')[0]
+      i -= 2**32 if i > (2**31-1)
+      @packet.skip_padding
+      i
+    end
+
+    def get_float32
+      f = @packet.getn(4).unpack('g')[0]
+      @packet.skip_padding
+      f
+    end
+
+    def get_double64
+      f = @packet.getn(8).unpack('G')[0]
+      @packet.skip_padding
+      f
+    end
+
+    def get_blob
+      l = @packet.getn(4).unpack('N')[0]
+      b = @packet.getn(l)
+      @packet.skip_padding
+      b
+    end
+
+    def bundle?
+      !(@packet.to_s =~ /\A\#bundle/).nil?
+    end
+
+    def string_delemeter
+      "\x00"
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), "osc_argument")
+
+module OSC
+  class OSCInt32 < OSCArgument
+    def tag
+      'i'
+    end
+
+    def encode
+      [@val].pack('N').force_encoding("BINARY")
+    end
+  end
+
+  class OSCFloat32 < OSCArgument
+    def tag
+      'f'
+    end
+
+    def encode
+      [@val].pack('g').force_encoding("BINARY")
+    end
+  end
+
+  class OSCDouble64 < OSCArgument
+    def tag
+      'd'
+    end
+
+    def encode
+      [@val].pack('G').force_encoding("BINARY")
+    end
+  end
+
+  class OSCString < OSCArgument
+    def tag
+      's'
+    end
+
+    def encode
+      padding(@val.sub(/\000.*\z/, '') + "\000").force_encoding("BINARY")
+    end
+  end
+
+  class OSCBlob < OSCArgument
+    def tag
+      'b'
+    end
+
+    def encode
+      padding([@val.size].pack('N') + @val).force_encoding("BINARY")
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module OSC
+  class Server
+    def initialize(port)
+      @socket = UDPSocket.new
+      @socket.bind('', port)
+      @matchers = []
+      @queue = Queue.new
+    end
+
+    def run
+      start_dispatcher
+
+      start_detector
+    end
+
+    def stop
+      @socket.close
+    end
+
+    def add_method(address_pattern, &proc)
+      matcher = AddressPattern.new(address_pattern)
+
+      @matchers << [matcher, proc]
+    end
+
+    private
+
+    def start_detector
+      begin
+        detector
+      rescue
+        Thread.main.raise($!)
+      end
+    end
+
+    def start_dispatcher
+      Thread.fork do
+        begin
+          dispatcher
+        rescue
+          Thread.main.raise($!)
+        end
+      end
+    end
+
+    def dispatcher
+      loop do
+        mesg = @queue.pop
+        dispatch_message(mesg)
+      end
+    end
+
+    def dispatch_message(message)
+      diff = (message.time || 0) - Time.now.to_ntp
+
+      if diff <= 0
+        sendmesg(message)
+      else # spawn a thread to wait until it's time
+        Thread.fork do
+          sleep(diff)
+          sendmesg(message)
+          Thread.exit
+        end
+      end
+    end
+
+    def sendmesg(mesg)
+      @matchers.each do |matcher, proc|
+        if matcher.match?(mesg.address)
+          proc.call(mesg)
+        end
+      end
+    end
+
+    def detector
+      loop do
+        osc_data, network = @socket.recvfrom(16384)
+        begin
+          ip_info = Array.new
+          ip_info << network[1]
+          ip_info.concat(network[2].split('.'))
+          OSCPacket.messages_from_network( osc_data, ip_info ).each do |message|
+            @queue.push(message)
+          end
+
+        rescue(EOFError)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'socket'
+require 'thread'
+
+# core extensions
+require 'osc-ruby/core_ext/time'
+
+# jus the basics
+require 'osc-ruby/osc_types'
+require 'osc-ruby/osc_packet'
+
+require 'osc-ruby/message'
+require 'osc-ruby/bundle'
+require 'osc-ruby/address_pattern'
+
+# now we gettin fancy
+require 'osc-ruby/server'
+require 'osc-ruby/client'
+require 'osc-ruby/broadcast_client'

data/templates/music-beginner/README.md

@@ -0,0 +1,100 @@
+# Music Beginner
+
+`music-beginner` is a constrained-but-generative Sonic Pi ensemble. Five Prompt
+Objects own distinct musical roles, communicate through a shared composition
+contract, and keep rewriting their own looping patterns. The constraints are a
+musical guardrail, not a prerecorded arrangement: agents still choose the
+notes, chords, rests, rhythms, instrumentation, and evolution.
+
+New environments default to Gemini 3.5 Flash for a responsive balance of tool
+use and musical direction. The selected provider and model are stored in the
+environment manifest, so the choice survives a server restart. Set
+`GEMINI_API_KEY` before serving the environment.
+
+## Start it
+
+1. Create a new environment from this template and start Prompt Objects.
+2. Open Sonic Pi.
+3. In an empty Sonic Pi buffer, run one line, replacing the path with the new
+   environment's absolute path:
+
+   ```ruby
+   run_file "/Users/you/.prompt_objects/environments/my-music/extras/sonic_pi_boot.rb"
+   ```
+
+4. Send the conductor: `Hit it.` The conductor treats that as a complete cue to
+   check Sonic Pi and launch the template's talk-safe backing-track contract.
+5. Start with your computer volume low and bring it up gradually.
+
+Once it is playing, the conductor also understands `change it up`, `bring it
+down`, and `stop`/`cut`. These are performance cues rather than fixed songs:
+the voices still compose and perform their own material within the template's
+musical guardrails.
+
+The autonomous timer stays dormant until the conductor receives a new human
+message after the server starts. It then waits 45 seconds before its first
+evolution turn, so your initialization prompt always establishes the piece.
+Later timer turns use the short evolution instruction configured in the
+conductor's frontmatter; they do not reuse your original prompt.
+
+The conductor verifies every activation against live engine state. “Connected”
+only means the boot engine is reachable; a connected engine with zero active
+voices is silent. Musicians are instructed to perform their playback tool calls
+in the same turn instead of stopping at a prose proposal.
+
+The engine listens for OSC on Sonic Pi's standard port `4560`. The Prompt
+Objects query state on port `4561`. Set `SONIC_PI_HOST` or `SONIC_PI_PORT` before
+starting Prompt Objects if you need different OSC settings.
+
+The supplied patch set requires Sonic Pi 4.0 or newer (`:bass_foundation` was
+introduced in 4.0). It is developed against Sonic Pi 4.6.0. The Ruby tests can
+verify the protocol and template wiring without audio, but the final balance is
+speaker-, room-, and voice-dependent, so audition it in Sonic Pi before a live
+performance.
+
+## Pattern notation
+
+A voice sends semicolon-separated events:
+
+```text
+C3+E3+G3@4@0.7@4.5;R@1;F3+A3+C4@3@0.6@3.2
+```
+
+Each event is `sound@step_beats@amplitude@gate_beats`. Amplitude and gate are
+optional. `step_beats` controls when the next event begins; `gate_beats`
+controls how long sustained presets such as pads, bass, and tonal textures ring,
+so pads may overlap slightly while a keys phrase stays articulated. Amplitude
+is clamped to `0.0..1.0`. Sounds are:
+
+- a note: `C4`, `Fs3`, `Eb5`, or MIDI `60`
+- a chord joined with `+`: `C3+E3+G3`
+- a rest: `R`
+- with `gentle_kit`, a real sample token: `kick`, `hat`, `snare`, or `tick`
+
+Patterns may contain up to 32 events and 64 beats. The engine pads their length
+to the next whole bar and applies replacements at a synchronized pattern/bar
+boundary, so an agent changing a loop does not knock the ensemble out of time.
+
+## The safe palette
+
+- `soft_keys` — rounded electric piano
+- `air_pad` — slow, filtered pad
+- `warm_bass` — centered low foundation
+- `felt_pluck` — quiet kalimba-like accents
+- `glass_bell` — very sparse bell color
+- `sine_glow` — nearly pure tonal texture
+- `gentle_kit` — real kick, closed-hat, snare, and tick samples
+
+Preset gains, envelopes, filtering, and effects are deliberately conservative.
+Agents can change voice level and per-event amplitude, but the engine applies a
+second hard level clamp. `stop_voice(voice: "all")` is the emergency silence.
+
+## A useful first audition
+
+Tell the conductor `Hit it.` Its default is `96 BPM, C major pentatonic, Cmaj7 /
+Am7 / Fmaj7 / G6, one chord per bar, flowing-light density`. Bring voices in one
+at a time: connected pad, phrase-based keys, bass, quiet percussion, then
+optional texture. For background use, lower levels rather than asking every
+voice to add more rests. Let it evolve for several minutes; autonomous changes
+develop recognizable new movements by coordinating a few voices around one
+intention while keeping an unchanged voice as a continuity anchor.

data/templates/music-beginner/extras/README.md

@@ -0,0 +1,27 @@
+# Start the Music Beginner engine
+
+Open Sonic Pi and run this one line from an empty buffer, replacing the path
+with this environment's absolute path:
+
+```ruby
+run_file "/Users/you/.prompt_objects/environments/my-music/extras/sonic_pi_boot.rb"
+```
+
+Then tell the conductor `Hit it.` It will check the connection and begin a
+quiet talk-safe composition using the template's default musical contract.
+Start with your computer volume low. For immediate silence, tell the conductor
+to stop all voices or press Sonic Pi's Stop button.
+
+The default contract uses connected one-bar chord changes and a quiet rhythmic
+spine. If the result sounds like isolated notes separated by long gaps, query
+the live engine: the pad should report `air_pad`, and keys or percussion should
+remain rhythmically active.
+
+`connected: true` confirms only that the engine is reachable. The conductor
+must make each musician perform its playback tools and verify that the engine
+reports an active voice; an engine with zero active voices is silent.
+
+Pattern notation and audition suggestions are documented in the source
+template's `README.md`. You can also ask the `engine_setup` Prompt Object for
+connection, setup, and notation help. It is intentionally read-only and cannot
+change the music.