pedicab 0.1.4 → 0.1.6

data/lib/pedicab/calc.rb~

@@ -0,0 +1,8 @@
+module Pedicab
+  class Calc
+    def initialize
+
+    end
+    
+  end
+end

data/lib/pedicab/link.rb

@@ -0,0 +1,38 @@
+module LINK
+  @@L = {}
+  def self.on
+    @@L
+  end
+  def self.each_pair &b
+    @@L.each_pair { |k,v| b.call(k,v) }
+  end
+end
+
+LINK.on["named entites which need to be defined or calculated"] = lambda { |s,e|
+  s.each("each named entity", e) { |ee|
+    if s.gate "The following has a calculatable formula:\n#{ee}"
+      s.prompt("Respond with only the bare mathmatical formula to be calculated by the ruby eqn gem for the following:\n#{ee}")
+    else
+      s.prompt("Define the following in the simplest terms:\n#{ee}")
+    end
+  }
+}
+
+LINK.on["a single fact based answer"] = lambda { |s,e| s.prompt("Respond with the fact needed to correctly respond to the following:\n#{e}") }
+
+LINK.on["a step by step plan"] = lambda { |s,e| s.prompt("Respond with only a plan for the following without repeating yourself:\n#{e}").gsub(/\n\n+/,"\n") }
+
+LINK.on["an answer by logical progression of thought"] = lambda { |s,e| s.prompt("Outline your thinking about the following without repeating yourself:\n#{e}").gsub(/\n\n+/,"\n") }
+
+#LINK.on["goals which need to be achieved"] = lambda { |s,e|
+#  s.each("all goals which need to be achieved", e) { |ee|
+#    s.prompt("Outline the steps necessary to accomplish the following:\n#{ee}")
+#  }
+#}
+
+#LINK.on["decisions which need to be made"] = lambda { |s,e|
+#  s.each("all decisions which need to be made", e) { |ee|
+#    s.prompt("Decide the following:\n#{ee}")
+#  }
+#}
+

data/lib/pedicab/link.rb~

@@ -0,0 +1,14 @@
+module LINK
+  @@L = {}
+  def self.on
+    @@L
+  end
+  def self.each_pair &b
+    @@L.each_pair { |k,v| b.call(k,v) }
+  end
+end
+
+LINK.on["calculating a mathmatical formula"] = lambda { |s,e| s.dispatch("Define the mathmatical formula equal to the following:\n#{e} = ") }
+LINK.on["abstract or complex planning"] = lambda { |s,e| s.dispatch("Create a plan for the following:\n#{e}") }
+LINK.on["an answer by logical progression of thought"] = lambda { |s,e| s.dispath("Outline your thinking about the following:\n#{e}") }
+#LINK.on["fact based knowledge from known and trusted sources"] = lambda { |s,e| s.prompt("Respond with only the answer to the following with no formatting or punctuation in as few words as possible:\n#{e}") }

data/lib/pedicab/mark.rb

@@ -0,0 +1,9 @@
+module Pedicab
+  def self.mark x
+    Nokogiri::HTML(Redcarpet::Markdown.new(Redcarpet::Render::HTML, autolink: true).render(x)).css('p').map { |e|
+      if !/http.*/.match(e.text)
+        e.text
+      end
+    }.flatten.compact
+  end
+end

data/lib/pedicab/mark.rb~

@@ -0,0 +1,5 @@
+module Pedicab
+  def self.mark x
+    Redcarpet::Markdown.new(Redcarpet::Render::HTML, autolink: true, tables: true).render(x)
+  end
+end

data/lib/pedicab/on.rb

@@ -0,0 +1,6 @@
+module Pedicab
+  @@ON = Hash.new { |h,k| h[k] = lambda() { |ride| ride } }
+  def self.on
+    @@ON
+  end
+end

data/lib/pedicab/on.rb~

@@ -0,0 +1,6 @@
+module Pedicab
+	@@ON = Hash.new { |h,k| h[k] = lambda() { |ride| ride } }
+	def self.on
+		@@ON
+	end
+end

data/lib/pedicab/poke.rb

@@ -0,0 +1,14 @@
+module POKE
+  @@POKE = {}
+  def self.on
+    @@POKE
+  end
+  def self.[] q
+    a = [ q ]
+    @@POKE.each_pair { |r,b| if m = Regexp.new(r).match(q); a << b.call(q, m); end; }
+    return a.reverse.join("\n")
+  end
+end
+
+POKE.on[" time "] = lambda { |q, m| t = Time.now; %[The current time is #{t.strftime('%T')}.] }
+POKE.on[" date "] = lambda { |q, m| t = Time.now; %[The current date is #{t.strftime('%D')}.] }

data/lib/pedicab/poke.rb~

@@ -0,0 +1,15 @@
+module POKE
+  @@POKE = {}
+  def self.on
+    @@POKE
+  end
+  def self.[] q
+    a = [ q ]
+    @@POKE.each_pair { |r,b| if m = Regexp.new(r).match(q); a << b.call(q, m); end; }
+    return a.reverse.join("\n")
+  end
+end
+
+POKE.on["time"] = lambda { |q, m| t = Time.now; %[The current time is #{t.strftime('%T')}.] }
+POKE.on["date"] = lambda { |q, m| t = Time.now; %[The current date is #{t.strftime('%D')}.] }
+POKE.on[/ (\d+)d(\d+) /] = lambda { |q, m| a, t = [], 0; m[1].to_i.times { x = rand(m[2].to_i) + 1; t += x; a << x }; %[Rolling #{m[1]}d#{m[2]} gave #{a.join(', ')} for a total of #{t}.] }

data/lib/pedicab/query.rb

@@ -0,0 +1,92 @@
+module Pedicab
+  class RedditQuery
+    include HTTParty
+    base_uri 'https://www.reddit.com'
+    
+    # Set a custom user agent (Reddit requires this)
+    headers 'User-Agent' => 'Ruby Reddit Client/1.0'
+    
+    def initialize(topic)
+      @topic = topic
+    end
+    
+    # Search for posts about the topic
+    def search(limit: 25, sort: 'relevance', time: 'all')
+      options = {
+        query: {
+          q: @topic,
+          limit: limit,
+          sort: sort,
+          t: time,
+          raw_json: 1
+        }
+      }
+      
+      response = self.class.get('/search.json', options)
+      parse_response(response)
+    end
+    
+    # Get posts from a specific subreddit about the topic
+    def search_subreddit(subreddit, limit: 25, sort: 'hot')
+      options = {
+        query: {
+          limit: limit,
+          raw_json: 1
+        }
+      }
+      
+      response = self.class.get("/r/#{subreddit}/search.json?q=#{@topic}&restrict_sr=1", options)
+      parse_response(response)
+    end
+    
+    # Get hot posts from a subreddit
+    def get_subreddit_posts(subreddit, limit: 25, sort: 'hot')
+      options = {
+        query: {
+          limit: limit,
+          raw_json: 1
+        }
+      }
+      
+      response = self.class.get("/r/#{subreddit}/#{sort}.json", options)
+      parse_response(response)
+    end
+    
+    private
+    
+    def parse_response(response)
+      if response.success?
+        data = response.parsed_response
+        posts = data.dig('data', 'children') || []
+        
+        posts.map do |post|
+          post_data = post['data']
+          {
+            title: post_data['title'],
+            author: post_data['author'],
+            subreddit: post_data['subreddit'],
+            score: post_data['score'],
+            url: post_data['url'],
+            permalink: "https://www.reddit.com#{post_data['permalink']}",
+            created_utc: Time.at(post_data['created_utc']),
+            num_comments: post_data['num_comments'],
+            selftext: post_data['selftext']
+          }
+        end
+      else
+        puts "Error: #{response.code} - #{response.message}"
+        []
+      end
+    end
+  end
+  
+  # Example usage:
+  def self.reddit q
+    qq = RedditQuery.new(q).search(limit: 10, sort: 'hot', time: 'week').map { |post|
+      p = post[:selftext];
+      if p.length > 0;
+        p;
+      end;
+    }.flatten.compact
+  end
+end

data/lib/pedicab/query.rb~

@@ -0,0 +1,93 @@
+module Pedicab
+  class RedditQuery
+    include HTTParty
+    base_uri 'https://www.reddit.com'
+    
+    # Set a custom user agent (Reddit requires this)
+    headers 'User-Agent' => 'Ruby Reddit Client/1.0'
+    
+    def initialize(topic)
+      @topic = topic
+    end
+    
+    # Search for posts about the topic
+    def search(limit: 25, sort: 'relevance', time: 'all')
+      options = {
+        query: {
+          q: @topic,
+          limit: limit,
+          sort: sort,
+          t: time,
+          raw_json: 1
+        }
+      }
+      
+      response = self.class.get('/search.json', options)
+      parse_response(response)
+    end
+    
+    # Get posts from a specific subreddit about the topic
+    def search_subreddit(subreddit, limit: 25, sort: 'hot')
+      options = {
+        query: {
+          limit: limit,
+          raw_json: 1
+        }
+      }
+      
+      response = self.class.get("/r/#{subreddit}/search.json?q=#{@topic}&restrict_sr=1", options)
+      parse_response(response)
+    end
+    
+    # Get hot posts from a subreddit
+    def get_subreddit_posts(subreddit, limit: 25, sort: 'hot')
+      options = {
+        query: {
+          limit: limit,
+          raw_json: 1
+        }
+      }
+      
+      response = self.class.get("/r/#{subreddit}/#{sort}.json", options)
+      parse_response(response)
+    end
+    
+    private
+    
+    def parse_response(response)
+      if response.success?
+        data = response.parsed_response
+        posts = data.dig('data', 'children') || []
+        
+        posts.map do |post|
+          post_data = post['data']
+          {
+            title: post_data['title'],
+            author: post_data['author'],
+            subreddit: post_data['subreddit'],
+            score: post_data['score'],
+            url: post_data['url'],
+            permalink: "https://www.reddit.com#{post_data['permalink']}",
+            created_utc: Time.at(post_data['created_utc']),
+            num_comments: post_data['num_comments'],
+            selftext: post_data['selftext']
+          }
+        end
+      else
+        puts "Error: #{response.code} - #{response.message}"
+        []
+      end
+    end
+  end
+  
+  # Example usage:
+  def self.reddit q
+    qq = RedditQuery.new(q).search(limit: 10, sort: 'hot', time: 'week').map { |post|
+      p = post[:selftext];
+      if p.length > 0;
+        p;
+      end;
+    }.flatten.compact.join("\n")
+    return %[#{q}:\n#{qq}]
+  end
+end

data/lib/pedicab/rank.rb

@@ -0,0 +1,92 @@
+module Pedicab
+  module RANK
+    class KNN
+      # Initialize with a collection of strings
+      def initialize(strings)
+        @strings = strings
+      end
+      
+      # Find k nearest neighbors to the query string
+      # Returns array of hashes with :string, :distance, and :similarity
+      def rank(id, query, k = 5, method: :levenshtein)
+        a, t = id.split("-") 
+        return [] if @strings.empty?
+        
+        # Calculate distances for all strings
+        distances = @strings.map do |str|
+          dist = levenshtein_distance(query, str)
+          {
+            book: id,
+            author: a,
+            title: t,
+            string: str.strip,
+            distance: dist,
+            similarity: 1.0 / (1.0 + dist)
+          }
+        end
+        
+        # Sort by distance (ascending) and take k nearest
+        distances.sort_by { |d| d[:distance] }.take([k, @strings.length].min)
+      end
+      
+      private
+      
+      # Calculate Levenshtein distance between two strings
+      def levenshtein_distance(s1, s2)
+        s1_lower = s1.downcase
+        s2_lower = s2.downcase
+        
+        return s2_lower.length if s1_lower.empty?
+        return s1_lower.length if s2_lower.empty?
+        
+        # Create distance matrix
+        d = Array.new(s1_lower.length + 1) { Array.new(s2_lower.length + 1) }
+        
+        (0..s1_lower.length).each { |i| d[i][0] = i }
+        (0..s2_lower.length).each { |j| d[0][j] = j }
+        
+        (1..s1_lower.length).each do |i|
+          (1..s2_lower.length).each do |j|
+            cost = s1_lower[i - 1] == s2_lower[j - 1] ? 0 : 1
+            
+            d[i][j] = [
+              d[i - 1][j] + 1,      # deletion
+              d[i][j - 1] + 1,      # insertion
+              d[i - 1][j - 1] + cost # substitution
+            ].min
+          end
+        end
+        
+        d[s1_lower.length][s2_lower.length]
+      end
+      
+      # Generate character n-grams from string
+      def generate_ngrams(str, n)
+        return {} if str.length < n
+        
+        ngrams = Hash.new(0)
+        (0..str.length - n).each do |i|
+          ngrams[str[i, n]] += 1
+        end
+        ngrams
+      end
+    end
+    @@Rank = Hash.new { |h,k| h[k] = Rank.new(k) }
+    class Rank
+      attr_accessor :data
+      def initialize k
+        @id = k
+        @data = []
+      end
+      def << i
+        @data << i
+      end
+      def [] k
+        KNN.new(@data.to_a).rank(@id, k, 5)
+      end
+    end
+    def self.[] k
+      @@Rank[k]
+    end
+  end
+end

data/lib/pedicab/rank.rb~

@@ -0,0 +1,89 @@
+module Pedicab
+  module RANK
+    class KNN
+      # Initialize with a collection of strings
+      def initialize(strings)
+        @strings = strings
+      end
+      
+      # Find k nearest neighbors to the query string
+      # Returns array of hashes with :string, :distance, and :similarity
+      def rank(id, query, k = 5, method: :levenshtein)
+        return [] if @strings.empty?
+        
+        # Calculate distances for all strings
+        distances = @strings.map do |str|
+          dist = levenshtein_distance(query, str)
+          {
+            book: id,
+            string: str,
+            distance: dist,
+            similarity: 1.0 / (1.0 + dist)
+          }
+        end
+        
+        # Sort by distance (ascending) and take k nearest
+        distances.sort_by { |d| d[:distance] }.take([k, @strings.length].min)
+      end
+      
+      private
+      
+      # Calculate Levenshtein distance between two strings
+      def levenshtein_distance(s1, s2)
+        s1_lower = s1.downcase
+        s2_lower = s2.downcase
+        
+        return s2_lower.length if s1_lower.empty?
+        return s1_lower.length if s2_lower.empty?
+        
+        # Create distance matrix
+        d = Array.new(s1_lower.length + 1) { Array.new(s2_lower.length + 1) }
+        
+        (0..s1_lower.length).each { |i| d[i][0] = i }
+        (0..s2_lower.length).each { |j| d[0][j] = j }
+        
+        (1..s1_lower.length).each do |i|
+          (1..s2_lower.length).each do |j|
+            cost = s1_lower[i - 1] == s2_lower[j - 1] ? 0 : 1
+            
+            d[i][j] = [
+              d[i - 1][j] + 1,      # deletion
+              d[i][j - 1] + 1,      # insertion
+              d[i - 1][j - 1] + cost # substitution
+            ].min
+          end
+        end
+        
+        d[s1_lower.length][s2_lower.length]
+      end
+      
+      # Generate character n-grams from string
+      def generate_ngrams(str, n)
+        return {} if str.length < n
+        
+        ngrams = Hash.new(0)
+        (0..str.length - n).each do |i|
+          ngrams[str[i, n]] += 1
+        end
+        ngrams
+      end
+    end
+    @@Rank = Hash.new { |h,k| h[k] = Rank.new(k) }
+    class Rank
+      attr_accessor :data, :outline
+      def initialize k
+        @id = k
+        @data = []
+      end
+      def << i
+        @data << i
+      end
+      def [] k
+        KNN.new(@data.to_a).rank(@id, k, 3)
+      end
+    end
+    def self.[] k
+      @@Rank[k]
+    end
+  end
+end

data/lib/pedicab/ride.rb

@@ -0,0 +1,109 @@
+module Pedicab
+  @@Ride = Hash.new { |h,k| h[k] = Ride.new(k) }
+  class Ride
+    attr_accessor :state, :action, :goal, :ride, :info, :tale, :path, :model
+    def initialize k
+      @id = k
+      @model = 'model'
+      reset!
+    end
+    def reset!
+      @state = {}
+      @ride = []
+      @path = []
+      @info = ""
+    end
+    
+    ##
+    # tell the "tale" of the ride.
+    def tale
+      a = []
+      if @ride.length > 0
+      	h = @ride[-1]
+        @ride.shift
+      	return %[#{h[:input]}\n#{h[:output]}\n]
+      else
+      	return ""
+      end
+    end
+    
+    ##
+    # process input.
+    def go i
+      @path << "go #{i}"
+      @state[:action] = "go"
+      @state[:input] = i
+      puts %[#===============[work]>\n#{i}\n#===============[work]];
+      Pedicab.on[:work].call(self)
+      @state[:output] = rider(role: 'user', model: 'work', content: "#{@info}#{tale}#{i}")
+      @ride << @state
+      @state[:output].gsub(/\n+/, "\n")
+    end
+    
+    ##
+    # process condition
+    def go? i
+      @path << "go? #{i}"
+      @state[:action] = "go?"
+      @state[:input] = i
+      @state[:yes] = false
+      puts %[#>>>>>[gate]>\n#{i}\n#>>>>>[gate]];
+      Pedicab.on[:gate].call(self)
+      if rider(role: 'system', model: 'gate', content: %[#{@info}#{tale}if the following statement is true respond 'yes', otherwise respond 'no':\n#{i}], response: 'bool' ) == 'yes'
+        @state[:yes] = true
+        Pedicab.on[:go].call(self)
+      end
+      @ride << @state
+      @state[:yes]
+    end
+    
+    ##
+    # process list
+    def go! i, p, &b
+      @path << "with #{i} of #{p}"
+      @state[:action] = "go! fork" 
+      @state[:input] = %[#{@info}#{tale}List only #{i} without repeating yourself:\n#{p}]
+      Pedicab.on[:fork].call(self)
+      @state[:list] = rider(role: 'user', model: 'fork', content: @state[:input]).split("\n").uniq.map { |e|
+        if e.strip.length > 0;
+          puts %[#----------[fork]>\nfor: #{i}\nin: #{p}\nat: #{e}\n#----------[fork]];
+          Pedicab.on[:with].call(self);
+          b.call(e.strip);
+        end;
+      }
+      @ride << @state
+      @state[:list]
+    end
+    
+    private
+
+    def rider h={}, &b
+      @state[:content] = "I don't know."
+      puts %[#====[ #{@ride.length} ][#{@state[:action]}]\n#{@state[:input]}]
+      Pedicab.on[:before].call(self)
+      @state[:took] = Benchmark.realtime do
+        Open3.popen3("sudo python3 bin/pedicab.py /models/#{h[:model]}.gguf") do |stdin, stdout, stderr, wait_thread|
+    	  x = lambda { stdin.puts(JSON.generate(h)); stdout.gets }
+    	  begin
+	    xx = x.call()
+   	    if "#{xx}".strip.length > 0                                                                                                                                                               
+       	      @state[:content] = JSON.parse("#{xx}")['content']
+       	    end
+          rescue => e
+  	    @state[:content] = "Error: #{e}"
+  	  end
+        end
+      end
+      Pedicab.on[:after].call(self)
+      puts %[#====[ #{@ride.length} ] took: #{@state[:took]} seconds.\n#{@state[:content].gsub(/\n+/,"\n")}]
+      if block_given?
+        return b.call(self).gsub(/\n+/, "\n")
+      else
+        return @state[:content].gsub(/\n+/, "\n")
+      end
+    end
+  end
+  def self.ride
+    @@Ride
+  end
+end