pedicab 0.3.1 → 0.3.3

data/lib/pedicab/calc.rb~

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

data/lib/pedicab/link.rb

@@ -1,38 +0,0 @@
-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~

@@ -1,14 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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~

@@ -1,5 +0,0 @@
-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

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

data/lib/pedicab/on.rb~

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

data/lib/pedicab/poke.rb

@@ -1,14 +0,0 @@
-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~

@@ -1,15 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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~

@@ -1,93 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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~

@@ -1,89 +0,0 @@
-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~

@@ -1,101 +0,0 @@
-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
-      @tale = 3
-      @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] 
-      	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
-      Pedicab.on[:work].call(self)
-      @state[:output] = rider(role: 'user', model: 'planner', 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
-      Pedicab.on[:gate].call(self)
-      if rider(role: 'system', model: 'model', 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: 'model', content: @state[:input]).split("\n").uniq.map { |e| if e.strip.length > 0; puts %[#[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]}\n##{Array.new(80,'=').join('')}#]
-      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

data/lib/pedicab.sh~

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-python3 /usr/bin/pedicab/pedicab.py