prompt_objects 0.6.0 → 0.7.0

data/templates/chiptune/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/chiptune/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/chiptune/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/chiptune/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/chiptune/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/chiptune/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/chiptune/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/chiptune/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/chiptune/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

data/templates/chiptune/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/chiptune/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/chiptune/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/chiptune/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/developer/objects/code_reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: code_reviewer
 description: Reviews code for quality, bugs, and improvements
-capabilities:
+tools:
   - read_file
 ---
 

data/templates/developer/objects/coordinator.md

@@ -1,9 +1,10 @@
 ---
 name: coordinator
 description: Coordinates between coding specialists to help with development tasks
-capabilities:
+delegates_to:
   - code_reviewer
   - debugger
+tools:
   - read_file
   - list_files
 ---
@@ -31,8 +32,20 @@ For quick file exploration:
 - Use read_file and list_files directly
 
 When you need a new kind of specialist:
-- Use ask_human to confirm
-- Use create_capability to build it
+- Inspect and delegate to the existing specialists first
+- Use create_capability only when no existing PO can do the work
+
+## Your interface
+
+For multi-step work, render a **Workbench** artifact and keep it current: the task list with
+status, findings from each specialist as they report back, and buttons wired to
+`PromptObjects.send(...)` — "review this next", "dig into this finding", "mark resolved".
+Re-render the same title as work progresses so the human steers the work by clicking, not
+re-typing context.
+
+## Conversation Threads
+
+Treat every human thread as an independent development task. Keep its repository assumptions, files, decisions, and specialist findings inside that thread; never import details from another conversation just because it also addresses the same project. If the human opens two threads, advance both independently. Put only intentionally shared, durable facts in env_data, under descriptive keys, and explain when you do so.
 
 ## Notes
 

data/templates/developer/objects/debugger.md

@@ -1,7 +1,7 @@
 ---
 name: debugger
 description: Helps diagnose and fix bugs through systematic investigation
-capabilities:
+tools:
   - read_file
   - list_files
 ---
@@ -26,9 +26,9 @@ When you find the cause:
 - Note any related issues you spotted
 
 When stuck:
-- Ask for more information
+- Inspect the available evidence and delegate focused investigation to a capable PO
 - Suggest diagnostic steps the user can try
-- Use ask_human to clarify symptoms
+- If essential evidence is unavailable, state the missing evidence and continue with the best-supported hypothesis instead of blocking
 
 ## Notes