searchlink 2.3.92 → 2.3.93

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dbcb591ad73ea31904f2ebf8f7fd4fb8e3844ff74533c7f2e24529eeae7ba35
-  data.tar.gz: edb2a0b7bf70b769d72e94dd298886ff8471e8079582d9a8225a058149acf0b8
+  metadata.gz: 26563c3d6842264d4ee543dbac0cd7be148658c13b2020cc09009e94c1d9d8a0
+  data.tar.gz: 49c8165891b3f5713b2aada1db49bae241d7f9c41f92fe24f14af03e68930364
 SHA512:
-  metadata.gz: 50f36396f50480f84f72b5e3cd12b30f7f41b46770117da3481dc91ce79a4aecef8bc29c56e6d9f658436bf6b3e85be0df4886521b97bce229a8fd51dc3920e8
-  data.tar.gz: 2ae71428260f23ffbdb442fb6553ca6d66c519b79a47cc1356e125214eec2b23d7cc73abfa8e09dd6238c46950f8bc6cb6df2cbf1b0b8506af1b15ca1a231b2d
+  metadata.gz: 45b47101b11cb81b5b0ca2b74a5370a396cc7a1a95d0d27650498bf9cce8de590cbb855d8f9c9601aa75cffcb1911b23c44de53478b9797c4adc24356dd520cf
+  data.tar.gz: 8c2b3f6db03a379899ac14cc9ec21134e46f322f31080843c425a06f234cb245f6e1ccef1ead6100c71a795a9a4656845c6eb0ca4855c3a3fb29d8c02d3dc7ab

data/lib/searchlink/searches/helpers/firefox.rb

@@ -1,135 +1,214 @@
 # frozen_string_literal: true
 
+require "open3"
+require "tmpdir"
+
 module SL
   class HistorySearch
+    FIREFOX_DIR = "~/Library/Application Support/Firefox"
+    ZEN_DIR = "~/Library/Application Support/zen"
+
     class << self
+      # Search Firefox history
+      #
+      # @param term [String] the search terms
+      #
+      # @return [Array, false] [url, title, date] or false
+      #
       def search_firefox_history(term)
-        # Firefox history
-        base = File.expand_path("~/Library/Application Support/Firefox/Profiles")
-        Dir.chdir(base)
-        profile = Dir.glob("*default-release")
-        return false unless profile
-
-        src = File.join(base, profile[0], "places.sqlite")
-
-        exact_match = false
-        match_phrases = []
+        search_mozilla_history(mozilla_places_db(FIREFOX_DIR), term, "Firefox")
+      end
 
-        # If search terms start with ''term, only search for exact string matches
-        case term
-        when /^ *'/
-          exact_match = true
-          term.gsub!(/(^ *'+|'+ *$)/, "")
-        when /%22(.*?)%22/
-          match_phrases = term.scan(/%22(\S.*?\S)%22/)
-          term.gsub!(/%22(\S.*?\S)%22/, "")
-        end
+      # Search Firefox bookmarks
+      #
+      # @param term [String] the search terms
+      #
+      # @return [Array, false] [url, title, date, score] or false
+      #
+      def search_firefox_bookmarks(term)
+        search_mozilla_bookmarks(mozilla_places_db(FIREFOX_DIR), term, "Firefox")
+      end
 
-        if File.exist?(src)
-          SL.notify("Searching Firefox History", term)
-          tmpfile = "#{src}.tmp"
-          FileUtils.cp(src, tmpfile)
-
-          terms = []
-          terms.push("(moz_places.url NOT LIKE '%search/?%'
-                     AND moz_places.url NOT LIKE '%?q=%'
-                     AND moz_places.url NOT LIKE '%?s=%'
-                     AND moz_places.url NOT LIKE '%duckduckgo.com/?t%')")
-          if exact_match
-            terms.push("(moz_places.url LIKE '%#{term.strip.downcase}%' OR moz_places.title LIKE '%#{term.strip.downcase}%')")
-          else
-            terms.concat(term.split(/\s+/).map do |t|
-              "(moz_places.url LIKE '%#{t.strip.downcase}%' OR moz_places.title LIKE '%#{t.strip.downcase}%')"
-            end)
-            terms.concat(match_phrases.map do |t|
-              "(moz_places.url LIKE '%#{t[0].strip.downcase}%' OR moz_places.title LIKE '%#{t[0].strip.downcase}%')"
-            end)
-          end
-          query = terms.join(" AND ")
-          most_recent = `sqlite3 -json '#{tmpfile}' "select moz_places.title, moz_places.url,
-          datetime(moz_historyvisits.visit_date/1000000, 'unixepoch', 'localtime') as datum
-          from moz_places, moz_historyvisits where moz_places.id = moz_historyvisits.place_id
-          and #{query} order by datum desc limit 1 COLLATE NOCASE;"`.strip
-          FileUtils.rm_f(tmpfile)
+      # Search Zen history
+      #
+      # @param term [String] the search terms
+      #
+      # @return [Array, false] [url, title, date] or false
+      #
+      def search_zen_history(term)
+        search_mozilla_history(mozilla_places_db(ZEN_DIR), term, "Zen")
+      end
 
-          return false if most_recent.strip.empty?
+      # Search Zen bookmarks
+      #
+      # @param term [String] the search terms
+      #
+      # @return [Array, false] [url, title, date, score] or false
+      #
+      def search_zen_bookmarks(term)
+        search_mozilla_bookmarks(mozilla_places_db(ZEN_DIR), term, "Zen")
+      end
 
-          marks = JSON.parse(most_recent)
+      # Locate the places.sqlite database for a Mozilla-based browser. Profiles
+      # listed in profiles.ini are tried in order of preference (install
+      # default, then the profile marked Default=1, then any other profile),
+      # falling back to a *default-release folder.
+      #
+      # @param app_dir [String] the browser's Application Support folder
+      #
+      # @return [String, false] path to places.sqlite or false
+      #
+      def mozilla_places_db(app_dir)
+        base = File.expand_path(app_dir)
+        return false unless File.directory?(base)
+
+        ini = File.join(base, "profiles.ini")
+        candidates = File.exist?(ini) ? mozilla_ini_profiles(File.read(ini), base) : []
+        candidates.concat(Dir.glob(File.join(base, "Profiles", "*default-release")))
+
+        db = candidates.uniq.map { |dir| File.join(dir, "places.sqlite") }.find { |f| File.exist?(f) }
+        db || false
+      end
 
-          marks.map! do |bm|
-            date = Time.parse(bm["datum"])
-            score = score_mark({ url: bm["url"], title: bm["title"] }, term)
-            { url: bm["url"], title: bm["title"], date: date, score: score }
+      # Parse profiles.ini into a list of profile directories, most preferred first
+      #
+      # @param contents [String] the contents of profiles.ini
+      # @param base [String] the folder containing profiles.ini
+      #
+      # @return [Array<String>] absolute profile directories
+      #
+      def mozilla_ini_profiles(contents, base)
+        sections = []
+        contents.each_line do |line|
+          line = line.strip
+          if line =~ /^\[(.+)\]$/
+            sections << { name: Regexp.last_match(1) }
+          elsif line =~ /^([^=]+)=(.*)$/ && sections.any?
+            sections.last[Regexp.last_match(1).strip] = Regexp.last_match(2).strip
           end
+        end
 
-          m = marks.max_by { |m| [m[:url].length * -1, m[:score]] }
+        absolute = ->(path) { path.start_with?("/") ? path : File.join(base, path) }
 
-          [m[:url], m[:title], m[:date]]
-        else
-          false
-        end
+        installs = sections.select { |s| s[:name] =~ /^Install/ && s["Default"] }
+                           .map { |s| absolute.call(s["Default"]) }
+                           .sort_by { |dir| -places_mtime(dir) }
+        profiles = sections.select { |s| s[:name] =~ /^Profile/ && s["Path"] }
+        defaults, others = profiles.partition { |s| s["Default"] == "1" }
+
+        installs + (defaults + others).map { |s| absolute.call(s["Path"]) }
       end
 
-      def search_firefox_bookmarks(term)
-        # Firefox history
-        base = File.expand_path("~/Library/Application Support/Firefox/Profiles")
-        Dir.chdir(base)
-        profile = Dir.glob("*default-release")
-        return false unless profile
-
-        src = File.join(base, profile[0], "places.sqlite")
-
-        exact_match = false
-        match_phrases = []
-
-        # If search terms start with ''term, only search for exact string matches
-        if term =~ /^ *'/
-          exact_match = true
-          term.gsub!(/(^ *'+|'+ *$)/, "")
-        elsif term =~ /%22(.*?)%22/
-          match_phrases = term.scan(/%22(\S.*?\S)%22/)
-          term.gsub!(/%22(\S.*?\S)%22/, "")
-        end
+      # Modification time of a profile's places.sqlite, used to prefer the
+      # most recently used install when several share a profiles.ini
+      #
+      # @param dir [String] the profile directory
+      #
+      # @return [Float] seconds since epoch, or 0 if there is no database
+      #
+      def places_mtime(dir)
+        db = File.join(dir, "places.sqlite")
+        File.exist?(db) ? File.mtime(db).to_f : 0
+      end
 
-        if File.exist?(src)
-          SL.notify("Searching Firefox Bookmarks", term)
-          tmpfile = "#{src}.tmp"
-          FileUtils.cp(src, tmpfile)
-
-          terms = []
-          terms.push("(h.url NOT LIKE '%search/?%'
-                     AND h.url NOT LIKE '%?q=%'
-                     AND h.url NOT LIKE '%?s=%'
-                     AND h.url NOT LIKE '%duckduckgo.com/?t%')")
-          if exact_match
-            terms.push("(h.url LIKE '%#{term.strip.downcase}%' OR h.title LIKE '%#{term.strip.downcase}%')")
-          else
-            terms.concat(term.split(/\s+/).map do |t|
-              "(h.url LIKE '%#{t.strip.downcase}%' OR h.title LIKE '%#{t.strip.downcase}%')"
-            end)
-            terms.concat(match_phrases.map do |t|
-              "(h.url LIKE '%#{t[0].strip.downcase}%' OR h.title LIKE '%#{t[0].strip.downcase}%')"
-            end)
-          end
+      # Search the history of a Mozilla-based browser
+      #
+      # @param src [String, false] path to places.sqlite
+      # @param term [String] the search terms
+      # @param browser [String] browser name for notifications
+      #
+      # @return [Array, false] [url, title, date] or false
+      #
+      def search_mozilla_history(src, term, browser)
+        return false unless src && File.exist?(src)
+
+        SL.notify("Searching #{browser} History", term)
+        query = mozilla_query(term, "moz_places.url", "moz_places.title")
+        mark = query_places(src, "select moz_places.title, moz_places.url,
+          datetime(moz_historyvisits.visit_date/1000000, 'unixepoch', 'localtime') as datum
+          from moz_places, moz_historyvisits where moz_places.id = moz_historyvisits.place_id
+          and #{query} order by datum desc limit 1;")
+        return false unless mark
 
-          query = terms.join(" AND ")
+        [mark["url"], mark["title"], Time.parse(mark["datum"])]
+      end
 
-          most_recent = `sqlite3 -json '#{tmpfile}' "select h.url, b.title,
+      # Search the bookmarks of a Mozilla-based browser
+      #
+      # @param src [String, false] path to places.sqlite
+      # @param term [String] the search terms
+      # @param browser [String] browser name for notifications
+      #
+      # @return [Array, false] [url, title, date, score] or false
+      #
+      def search_mozilla_bookmarks(src, term, browser)
+        return false unless src && File.exist?(src)
+
+        SL.notify("Searching #{browser} Bookmarks", term)
+        query = mozilla_query(term, "h.url", "h.title")
+        mark = query_places(src, "select h.url, b.title,
           datetime(b.dateAdded/1000000, 'unixepoch', 'localtime') as datum
           FROM moz_places h JOIN moz_bookmarks b ON h.id = b.fk
-          where #{query} order by datum desc limit 1 COLLATE NOCASE;"`.strip
-          FileUtils.rm_f(tmpfile)
+          where #{query} order by datum desc limit 1;")
+        return false unless mark
 
-          return false if most_recent.strip.empty?
-
-          bm = JSON.parse(most_recent)[0]
+        score = score_mark({ url: mark["url"], title: mark["title"] }, term)
+        [mark["url"], mark["title"], Time.parse(mark["datum"]), score]
+      end
 
-          date = Time.parse(bm["datum"])
-          score = score_mark({ url: bm["url"], title: bm["title"] }, term)
-          [bm["url"], bm["title"], date, score]
+      # Build the WHERE clause for a places.sqlite search. Terms starting with
+      # a single quote match the exact string, %22-quoted phrases must match
+      # as a whole, and all other words must each match the url or title.
+      #
+      # @param term [String] the search terms
+      # @param url_col [String] the url column
+      # @param title_col [String] the title column
+      #
+      # @return [String] SQL conditions
+      #
+      def mozilla_query(term, url_col, title_col)
+        words = []
+        case term
+        when /^ *'/
+          words << term.gsub(/(^ *'+|'+ *$)/, "")
+        when /%22(.*?)%22/
+          words.concat(term.scan(/%22(\S.*?\S)%22/).flatten)
+          words.concat(term.gsub(/%22(\S.*?\S)%22/, "").split(/\s+/))
         else
-          false
+          words.concat(term.split(/\s+/))
         end
+
+        conditions = ["(#{url_col} NOT LIKE '%search/?%'
+                      AND #{url_col} NOT LIKE '%?q=%'
+                      AND #{url_col} NOT LIKE '%?s=%'
+                      AND #{url_col} NOT LIKE '%duckduckgo.com/?t%')"]
+        words.map(&:strip).reject(&:empty?).each do |word|
+          like = "'%#{word.downcase.gsub("'", "''")}%'"
+          conditions << "(#{url_col} LIKE #{like} OR #{title_col} LIKE #{like})"
+        end
+        conditions.join(" AND ")
+      end
+
+      # Run a query against a copy of places.sqlite, which the browser keeps
+      # locked while running. The write-ahead log is copied too so recent
+      # visits are included.
+      #
+      # @param src [String] path to places.sqlite
+      # @param sql [String] the query
+      #
+      # @return [Hash, nil] the first result row
+      #
+      def query_places(src, sql)
+        tmpfile = File.join(Dir.tmpdir, "searchlink-places-#{Process.pid}.sqlite")
+        FileUtils.cp(src, tmpfile)
+        FileUtils.cp("#{src}-wal", "#{tmpfile}-wal") if File.exist?("#{src}-wal")
+
+        out, status = Open3.capture2("sqlite3", "-json", tmpfile, sql)
+        return nil unless status.success? && !out.strip.empty?
+
+        JSON.parse(out).first
+      ensure
+        FileUtils.rm_f([tmpfile, "#{tmpfile}-wal", "#{tmpfile}-shm"]) if tmpfile
       end
     end
   end

data/lib/searchlink/searches/history.rb

@@ -12,10 +12,20 @@ require_relative "helpers/safari"
 module SL
   # Browser history/bookmark search
   class HistorySearch
+    BROWSERS = {
+      "s" => "safari",
+      "c" => "chrome",
+      "f" => "firefox",
+      "z" => "zen",
+      "e" => "edge",
+      "b" => "brave",
+      "a" => "arc"
+    }.freeze
+
     class << self
       def settings
         {
-          trigger: "h(([scfabe])([hb])?)*",
+          trigger: "h(([scfzabe])([hb])?)*",
           searches: [
             ["h", "Browser History/Bookmark Search"],
             ["hsh", "Safari History Search"],
@@ -30,6 +40,10 @@ module SL
             ["hfb", "Firefox Bookmark Search"],
             ["hfhb", nil],
             ["hfbh", nil],
+            ["hzh", "Zen History Search"],
+            ["hzb", "Zen Bookmark Search"],
+            ["hzhb", nil],
+            ["hzbh", nil],
             ["hah", "Arc History Search"],
             ["hab", "Arc Bookmark Search"],
             ["hahb", nil],
@@ -59,6 +73,8 @@ module SL
                 chrome_bookmarks
                 firefox_bookmarks
                 firefox_history
+                zen_bookmarks
+                zen_history
                 edge_bookmarks
                 edge_history
                 brave_bookmarks
@@ -72,92 +88,30 @@ module SL
       end
 
       def search(search_type, search_terms, link_text)
-        str = search_type.match(/^h(([scfabe])([hb])?)*$/)[1]
+        url, title = search_history(search_terms, history_types_for(search_type))
+        link_text = title if link_text == ""
+        [url, title, link_text]
+      end
 
+      # Convert a search type such as "hshcb" into history types. Each browser
+      # letter can be followed by "h" (history), "b" (bookmarks), or both;
+      # no suffix searches both.
+      #
+      # @param search_type [String] the search type, e.g. "hzh"
+      #
+      # @return [Array<String>] history types, e.g. ["zen_history"]
+      #
+      def history_types_for(search_type)
         types = []
-        while str&.length&.positive?
-          if str =~ /^s([hb]*)/
-            t = Regexp.last_match(1)
-            if t.length > 1 || t.empty?
-              types.push("safari_history")
-              types.push("safari_bookmarks")
-            elsif t == "h"
-              types.push("safari_history")
-            elsif t == "b"
-              types.push("safari_bookmarks")
-            end
-            str.sub!(/^s([hb]*)/, "")
-          end
-
-          if str =~ /^c([hb]*)/
-            t = Regexp.last_match(1)
-            if t.length > 1 || t.empty?
-              types.push("chrome_bookmarks")
-              types.push("chrome_history")
-            elsif t == "h"
-              types.push("chrome_history")
-            elsif t == "b"
-              types.push("chrome_bookmarks")
-            end
-            str.sub!(/^c([hb]*)/, "")
-          end
-
-          if str =~ /^f([hb]*)$/
-            t = Regexp.last_match(1)
-            if t.length > 1 || t.empty?
-              types.push("firefox_bookmarks")
-              types.push("firefox_history")
-            elsif t == "h"
-              types.push("firefox_history")
-            elsif t == "b"
-              types.push("firefox_bookmarks")
-            end
-            str.sub!(/^f([hb]*)/, "")
-          end
-
-          if str =~ /^e([hb]*)$/
-            t = Regexp.last_match(1)
-            if t.length > 1 || t.empty?
-              types.push("edge_bookmarks")
-              types.push("edge_history")
-            elsif t == "h"
-              types.push("edge_history")
-            elsif t == "b"
-              types.push("edge_bookmarks")
-            end
-            str.sub!(/^e([hb]*)/, "")
-          end
-
-          if str =~ /^b([hb]*)$/
-            t = Regexp.last_match(1)
-            if t.length > 1 || t.empty?
-              types.push("brave_bookmarks")
-              types.push("brave_history")
-            elsif t == "h"
-              types.push("brave_history")
-            elsif t == "b"
-              types.push("brave_bookmarks")
-            end
-            str.sub!(/^b([hb]*)/, "")
+        search_type.sub(/^h/, "").scan(/([scfzeba])([hb]*)/) do |browser, kinds|
+          name = BROWSERS[browser]
+          case kinds
+          when "h" then types.push("#{name}_history")
+          when "b" then types.push("#{name}_bookmarks")
+          else types.push("#{name}_history", "#{name}_bookmarks")
           end
-
-          next unless str =~ /^a([hb]*)$/
-
-          t = Regexp.last_match(1)
-          if t.length > 1 || t.empty?
-            types.push("arc_bookmarks")
-            types.push("arc_history")
-          elsif t == "h"
-            types.push("arc_history")
-          elsif t == "b"
-            types.push("arc_bookmarks")
-          end
-          str.sub!(/^a([hb]*)/, "")
         end
-
-        url, title = search_history(search_terms, types)
-        link_text = title if link_text == ""
-        [url, title, link_text]
+        types
       end
 
       def search_history(term, types = [])

data/lib/searchlink/searches/kagi.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module SL
+  # Kagi Search and FastGPT
+  class KagiSearch
+    class << self
+      # Returns the settings hash for the KagiSearch plugin.
+      #
+      # @return [Hash] settings including trigger, searches, and config entries
+      #
+      def settings
+        {
+          trigger: "(?:k|gpt)",
+          searches: [
+            ["k", "Kagi Search"],
+            ["gpt", "Kagi FastGPT Embed"]
+          ],
+          config: [
+            {
+              key: "kagi_api_key",
+              value: "xxxxxx",
+              required: false,
+              description: "Kagi Bot API key for paid search and FastGPT (see https://kagi.com/settings/api)"
+            }
+          ]
+        }
+      end
+
+      # Returns true if a usable Kagi API key is configured.
+      #
+      # @return [Boolean] true when a non-placeholder API key is present
+      #
+      def api_key?
+        return false unless SL.config.key?("kagi_api_key") && SL.config["kagi_api_key"]
+
+        key = SL.config["kagi_api_key"].to_s.strip
+        return false if key.empty? || key =~ /^(x{4,})?$/i
+
+        @api_key = key
+
+        true
+      end
+
+      # Perform a Kagi search or FastGPT request.
+      #
+      # @param search_type [String] the search shortcut ("k" or "gpt")
+      # @param search_terms [String] the search terms or FastGPT query
+      # @param link_text [String] the link text to display
+      #
+      # @return [Array] result array suitable for SearchLink: [url_or_embed, title_or_body, link_text]
+      #
+      def search(search_type, search_terms, link_text)
+        case search_type
+        when /^k$/
+          kagi_search(search_terms, link_text)
+        when /^gpt$/
+          kagi_fastgpt(search_terms, link_text)
+        else
+          SL.ddg(search_terms, link_text)
+        end
+      rescue StandardError => e
+        SL.notify("Kagi error", "Error fetching Kagi results, switching to DuckDuckGo")
+        SL.add_error("Kagi error", e.message)
+        SL.ddg(search_terms, link_text)
+      end
+
+      # Perform a Kagi web search for the given terms.
+      #
+      # @param search_terms [String] the terms to search for
+      # @param link_text [String] the text to display for the link
+      #
+      # @return [Array] [url, title, link_text] or DuckDuckGo fallback
+      #
+      def kagi_search(search_terms, link_text)
+        unless api_key?
+          SL.notify("Kagi not configured", "Missing Kagi API key, defaulting to DuckDuckGo")
+          return SL.ddg(search_terms, link_text, google: false)
+        end
+
+        query = ERB::Util.url_encode(search_terms.gsub("%22", '"'))
+        url = "https://kagi.com/api/v0/search?q=#{query}&limit=1"
+
+        headers = {
+          "Authorization" => "Bot #{@api_key}"
+        }
+
+        res = Curl::Json.new(url, headers: headers, symbolize_names: true)
+        return SL.ddg(search_terms, link_text, google: false) unless res && res.code.to_i == 200 && res.json
+
+        data = res.json[:data]
+        return SL.ddg(search_terms, link_text, google: false) unless data.is_a?(Array) && data.first.is_a?(Hash)
+
+        first = data.first
+        output_url = first[:url]
+        output_title = first[:title] || link_text
+
+        return SL.ddg(search_terms, link_text, google: false) unless output_url
+
+        if defined?(SL.config) && SL.config.respond_to?(:[]) && output_title && SL.config["remove_seo"]
+          output_title.remove_seo!(output_url)
+        end
+
+        [output_url, output_title, link_text]
+      rescue StandardError
+        SL.notify("Kagi error", "Error fetching Kagi results, switching to DuckDuckGo")
+        SL.ddg(search_terms, link_text, google: false)
+      end
+
+      # Perform a Kagi FastGPT query and return an embed response.
+      #
+      # @param search_terms [String] the FastGPT query
+      # @param link_text [String] the text to display for the link
+      #
+      # @return [Array] ["embed", embed_markdown, link_text]
+      #
+      def kagi_fastgpt(search_terms, link_text)
+        return ["embed", fastgpt_fallback(search_terms, "Kagi FastGPT is not configured."), link_text] unless api_key?
+
+        headers = {
+          "Authorization" => "Bot #{@api_key}",
+          "Content-Type" => "application/json"
+        }
+        body = { query: search_terms }.to_json
+
+        res = Curl::Json.new("https://kagi.com/api/v0/fastgpt", data: body, headers: headers, symbolize_names: true)
+        return ["embed", fastgpt_fallback(search_terms, "Kagi FastGPT request failed."), link_text] unless res && res.code.to_i == 200 && res.json
+
+        data = res.json[:data]
+        return ["embed", fastgpt_fallback(search_terms, "Kagi FastGPT response missing data."), link_text] unless data.is_a?(Hash)
+
+        output = data[:output].to_s
+        references = data[:references] || []
+
+        embed = build_fastgpt_embed(output, references, search_terms)
+        ["embed", embed, link_text]
+      rescue StandardError
+        ["embed", fastgpt_fallback(search_terms, "Kagi FastGPT encountered an error."), link_text]
+      end
+
+      # Build a Markdown embed string from FastGPT output and references.
+      #
+      # @param output [String] main answer text
+      # @param references [Array<Hash>] reference entries with :title, :snippet, and :url
+      # @param query [String] original query string
+      #
+      # @return [String] Markdown-formatted embed content
+      #
+      def build_fastgpt_embed(output, references, query)
+        header = "### Answer for: #{query}\n\n"
+        body = clean_fastgpt_output(output.to_s)
+
+        refs_section = ""
+        if references.is_a?(Array) && !references.empty?
+          lines = references.each_with_index.map do |ref, _idx|
+            url = ref[:url] || ref["url"]
+            next unless url
+
+            title = ref[:title] || ref["title"] || url
+            "- [#{title}](#{url})"
+          end.compact
+
+          refs_section = "\n\n**References:**\n#{lines.join("\n")}" unless lines.empty?
+        end
+
+        header + body + refs_section
+      end
+
+      # Build a fallback embed body when FastGPT is unavailable.
+      #
+      # @param query [String] the original query
+      # @param message [String] description of the failure
+      #
+      # @return [String] fallback embed content
+      #
+      def fastgpt_fallback(query, message)
+        "### Answer for: #{query}\n\n#{message}"
+      end
+
+      # Clean FastGPT output by removing in-text numeric reference markers and
+      # normalizing whitespace.
+      #
+      # @param output [String] raw FastGPT output text
+      #
+      # @return [String] cleaned output
+      #
+      def clean_fastgpt_output(output)
+        cleaned = output.dup
+        # Remove reference markers like [1], [23], and full-width 【1】, possibly with surrounding spaces
+        cleaned.gsub!(/\s*[\[\u3010]\d+[\]\u3011]\s*/, " ")
+        # Compress runs of whitespace to a single space, but preserve newlines
+        cleaned.gsub!(/[ \t]+/, " ")
+        # Remove spaces directly before sentence punctuation
+        cleaned.gsub!(/ +([.!?;:,])/, '\1')
+        cleaned.strip
+      end
+    end
+
+    SL::Searches.register "kagi", :search, self
+  end
+end

data/lib/searchlink/searches/linkding.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
 module SL
+  # Search a Linkding instance.
+  #
+  # Linkding authenticates with an API token and lists bookmarks at
+  # GET /api/bookmarks/. The q parameter uses the same search syntax as the
+  # Linkding UI (words, "phrases", #tags, and/or/not). Results are ranked
+  # the same way as Pinboard: an exact title or tag match wins, then an exact
+  # match in the description or notes, then the newest partial match.
   class LinkdingSearch
-    LINKDING_CACHE = SL::Util.cache_file_for("linkding")
+    PAGE_SIZE = 100
+    MAX_PAGES = 10
 
     class << self
       def settings
@@ -13,13 +21,13 @@ module SL
           ],
           config: [
             {
-              description: "Linkding server URL.",
+              description: "Linkding server URL, for example https://links.example.com",
               key: "linkding_server",
               value: "''",
               required: true
             },
             {
-              description: "Linkding API key.\nYou can find your api key here: https://your_server/settings/integrations",
+              description: "Linkding API token.\nCreate one under Settings, Integrations on your Linkding server.",
               key: "linkding_api_key",
               value: "''",
               required: true
@@ -28,197 +36,157 @@ module SL
         }
       end
 
-      def get_json(call)
-        curl = TTY::Which.which("curl")
-        bookmarks = `#{curl} -SsL -H "Authorization: Token #{SL.config["linkding_api_key"]}" "#{SL.config["linkding_server"]}#{call}"`
-
-        bookmarks = bookmarks.force_encoding("utf-8")
-        bookmarks.gsub!(/[^[:ascii:]]/) do |non_ascii|
-          non_ascii.force_encoding("utf-8")
-                   .encode("utf-16be")
-                   .unpack1("H*")
-                   .gsub(/(....)/, '\u\1')
+      # Search Linkding bookmarks.
+      #
+      # Begin the query with ' to require an exact phrase. Quoted phrases,
+      # #tags, and and/or/not are passed through to Linkding.
+      #
+      # @return [Array, false] [url, title, link_text] or false when nothing matches
+      def search(_, search_terms, link_text)
+        unless server
+          SL.add_error("Missing Linkding server",
+                       "Add your server URL to the configuration (linkding_server: https://YOUR_SERVER)")
+          return false
         end
 
-        bookmarks.gsub!(/[\u{1F600}-\u{1F6FF}]/, "")
+        unless api_key
+          SL.add_error("Missing Linkding API token",
+                       "Create a token under Settings, Integrations and add it to the configuration (linkding_api_key: YOURKEY)")
+          return false
+        end
 
-        JSON.parse(bookmarks)
-      end
+        query, exact = normalize_query(search_terms)
+        bookmarks = search_bookmarks(query)
+        return false if bookmarks.nil? || bookmarks.empty?
 
-      def get_linkding_bookmarks
-        TTY::Which.which("curl")
-        call = "/api/bookmarks/?limit=8000&format=json"
+        best = best_bookmark(bookmarks, query, exact: exact)
+        return false unless best
 
-        json = get_json(call)
-        bookmarks = json["results"]
-        offset = 0
+        [best["url"], bookmark_title(best), link_text]
+      end
 
-        while json["next"]
-          offset += 8000
-          json = get_json(call + "&offset=#{offset}")
-          bookmarks.concat(json["results"])
-        end
+      def server
+        value = configured_value("linkding_server")
+        return nil unless value
 
-        bookmarks
+        value.sub(%r{/+\z}, "").sub(%r{/api\z}i, "")
       end
 
-      def linkding_bookmarks
-        bookmarks = get_linkding_bookmarks
-        updated = Time.now
-        { "update_time" => updated, "bookmarks" => bookmarks }
+      def api_key
+        configured_value("linkding_api_key")
       end
 
-      def save_linkding_cache(cache)
-        cachefile = LINKDING_CACHE
+      private
 
-        # file = File.new(cachefile,'w')
-        # file = Zlib::GzipWriter.new(File.new(cachefile,'w'))
-        begin
-          File.open(cachefile, "wb") { |f| f.write(Marshal.dump(cache)) }
-        rescue IOError
-          SL.add_error("Linkding cache error", "Failed to write stash to disk")
-          return false
-        end
-        true
+      def configured_value(key)
+        value = SL.config[key].to_s.strip
+        return nil if value.empty? || value == "''"
+
+        value
       end
 
-      def linkding_cache
-        refresh_cache = false
-        cachefile = LINKDING_CACHE
-
-        if File.exist?(cachefile)
-          begin
-            # file = IO.read(cachefile) # Zlib::GzipReader.open(cachefile)
-            # cache = Marshal.load file
-            cache = Marshal.load(File.binread(cachefile))
-            # file.close
-          rescue IOError # Zlib::GzipFile::Error
-            SL.add_error("Error loading linkding cache", "IOError reading #{cachefile}")
-            cache = linkding_bookmarks
-            save_linkding_cache(cache)
-          rescue StandardError
-            SL.add_error("Error loading linkding cache", "StandardError reading #{cachefile}")
-            cache = linkding_bookmarks
-            save_linkding_cache(cache)
-          end
-          TTY::Which.which("curl")
-          updated = get_json("/api/bookmarks/?limit=1&format=json")["results"][0]
-          last_bookmark = Time.parse(updated["date_modified"])
-          if cache&.key?("update_time")
-            last_update = cache["update_time"]
-            refresh_cache = true if last_update < last_bookmark
-          else
-            refresh_cache = true
-          end
+      # A leading quote forces an exact phrase, matching Pinboard.
+      # %22 is accepted because some callers hand in an encoded query.
+      def normalize_query(search_terms)
+        terms = search_terms.to_s.gsub("%22", '"').strip
+        if terms =~ /\A'/
+          phrase = terms.gsub(/\A'+|'+\z/, "")
+          [%("#{phrase}"), true]
         else
-          refresh_cache = true
+          [terms, false]
         end
+      end
 
-        if refresh_cache
-          cache = linkding_bookmarks
-          save_linkding_cache(cache)
-        end
+      def search_bookmarks(query)
+        active = fetch_pages("/api/bookmarks/", query)
+        return nil if active.nil?
+
+        archived = fetch_pages("/api/bookmarks/archived/", query)
+        return nil if archived.nil?
 
-        cache
+        active + archived
       end
 
-      # Search linkding bookmarks
-      # Begin query with '' to force exact matching (including description text)
-      # Regular matching searches for each word of query and scores the bookmarks
-      # exact matches in title get highest score
-      # exact matches in description get second highest score
-      # other bookmarks are scored based on the number of words that match
-      #
-      # After sorting by score, bookmarks will be sorted by date and the most recent
-      # will be returned
-      #
-      # Exact matching is case and punctuation insensitive
-      def search(_, search_terms, link_text)
-        unless SL.config["linkding_server"] && !SL.config["linkding_server"].empty?
-          SL.add_error("Missing Linkding server",
-                       "add it to your configuration (linkding_server: https://YOUR_SERVER)")
-          return false
-        end
+      # Page with our own offset. Linkding's next URL can point at an
+      # internal hostname, so it is only used as a "more results" flag.
+      def fetch_pages(path, query)
+        bookmarks = []
+        offset = 0
 
-        unless SL.config["linkding_api_key"] && !SL.config["linkding_api_key"].empty?
-          SL.add_error("Missing Linkding API token",
-                       "Find your api key at https://your_server/settings/integrations and add it
-                        to your configuration (linkding_api_key: YOURKEY)")
-          return false
-        end
+        MAX_PAGES.times do
+          json = get_json(path, query, offset)
+          return nil if json.nil?
 
-        exact_match = false
-        match_phrases = []
-
-        # If search terms start with ''term, only search for exact string matches
-        case search_terms
-        when /^ *'/
-          exact_match = true
-          search_terms.gsub!(/(^ *'+|'+ *$)/, "")
-        when /%22(.*?)%22/
-          match_phrases = search_terms.scan(/%22(\S.*?\S)%22/)
-          search_terms.gsub!(/%22(\S.*?\S)%22/, "")
+          page = Array(json["results"])
+          bookmarks.concat(page)
+          offset += PAGE_SIZE
+          break if page.empty? || json["next"].nil? || bookmarks.size >= json["count"].to_i
         end
 
-        cache = linkding_cache
-        # cache = linkding_bookmarks
-        bookmarks = cache["bookmarks"]
+        bookmarks
+      end
+
+      def get_json(path, query, offset)
+        url = "#{server}#{path}?q=#{query.url_encode}&limit=#{PAGE_SIZE}&offset=#{offset}&sort=added_desc"
+        res = Curl::Json.new(url, headers: { "Authorization" => "Token #{api_key}" })
+        return json_error(res) unless res&.code.to_s == "200" && res.json.is_a?(Hash)
 
-        if exact_match
-          bookmarks.each do |bm|
-            text = [bm["title"], bm["description"], bm["tag_names"].join(" ")].join(" ")
+        res.json
+      rescue StandardError
+        SL.add_error("Linkding request failed", "Could not search #{server}")
+        nil
+      end
 
-            return [bm["url"], bm["title"]] if text.matches_exact(search_terms)
-          end
+      def json_error(res)
+        detail = res&.json.is_a?(Hash) ? res.json["detail"] : nil
+        SL.add_error("Linkding request failed", detail || "Could not search #{server}")
+        nil
+      end
 
-          return false
-        end
+      def best_bookmark(bookmarks, query, exact:)
+        terms = query.gsub(/\A["']+|["']+\z/, "")
+        matches = bookmarks.filter_map { |bm| score_bookmark(bm, terms, exact: exact) }
+        return nil if matches.empty? && exact
 
-        unless match_phrases.empty?
-          bookmarks.delete_if do |bm|
-            matched = tru
-            full_text = [bm["title"], bm["description"], bm["tag_names"].join(" ")].join(" ")
-            match_phrases.each do |phrase|
-              matched = false unless full_text.matches_exact(phrase)
-            end
-            !matched
-          end
-        end
+        picked = matches.max_by { |match| [match[:score], match[:date]] }
+        picked ? picked[:bookmark] : bookmarks.max_by { |bm| bm["date_added"].to_s }
+      end
 
-        matches = []
-        bookmarks.each do |bm|
-          title_tags = [bm["title"], bm["description"]].join(" ")
-          full_text = [bm["title"], bm["description"], bm["tag_names"].join(" ")].join(" ")
-
-          score = if title_tags.matches_exact(search_terms)
-                    14.0
-                  elsif full_text.matches_exact(search_terms)
-                    13.0
-                  elsif full_text.matches_any(search_terms)
-                    full_text.matches_score(search_terms)
-                  else
-                    0
-                  end
-
-          return [bm["url"], bm["title"]] if score == 14
-
-          next unless score.positive?
-
-          matches.push({
-                         score: score,
-                         href: bm["url"],
-                         title: bm["title"],
-                         date: bm["date_added"]
-                       })
+      def score_bookmark(bookmark, terms, exact:)
+        title_tags = bookmark_text(bookmark, "title", "tag_names")
+        full_text = bookmark_text(bookmark, "title", "description", "notes", "tag_names", "url")
+
+        if exact
+          return nil unless full_text.matches_exact(terms)
+
+          return { score: 14.0, date: bookmark["date_added"].to_s, bookmark: bookmark }
         end
 
-        return false if matches.empty?
+        score = if title_tags.matches_exact(terms)
+                  14.0
+                elsif full_text.matches_exact(terms)
+                  13.0
+                elsif full_text.matches_any(terms)
+                  full_text.matches_score(terms)
+                else
+                  0
+                end
+        return nil unless score.positive?
+
+        { score: score, date: bookmark["date_added"].to_s, bookmark: bookmark }
+      end
 
-        top = matches.max_by { |bm| [bm[:score], bm[:date]] }
+      def bookmark_text(bookmark, *fields)
+        fields.map { |field| field_text(bookmark[field]) }.join(" ")
+      end
 
-        return false unless top
+      def field_text(value)
+        value.is_a?(Array) ? value.join(" ") : value.to_s
+      end
 
-        [top[:href], top[:title], link_text]
+      def bookmark_title(bookmark)
+        title = bookmark["title"].to_s.strip
+        title.empty? ? bookmark["url"] : title
       end
     end
 

data/lib/searchlink/searches/shorteners/tinyurl.rb

@@ -42,17 +42,35 @@ module SL
           "Authorization" => "Bearer #{SL.config['tinyurl_access_token']}"
         }
         data_obj = {
-          "url" => url
+          "url" => url,
+          "domain" => "tinyurl.com"
         }
-        data = Curl::Json.new("https://tinyurl.ph/api/url/add", data: data_obj.to_json, headers: headers,
-                                                                symbolize_names: true)
+        data = Curl::Json.new("https://api.tinyurl.com/create",
+                              data: data_obj.to_json,
+                              headers: headers,
+                              symbolize_names: true)
 
-        if data.json[:error].positive?
-          SL.add_error("Error creating tinyurl", data.json[:error])
-          return false
+        return false unless data && data.json
+
+        json = data.json
+
+        if json.is_a?(Hash)
+          errors = json[:errors]
+          code = json[:code]
+          if (errors.is_a?(Array) && !errors.empty?) || (code && code.to_i != 0)
+            SL.add_error("Error creating tinyurl", errors || code)
+            return false
+          end
+
+          data_hash = json[:data] || {}
+          link = data_hash[:tiny_url]
+        else
+          link = false
         end
 
-        data.json[:shorturl]
+        return false unless link && SL::URL.valid_link?(link)
+
+        link
       end
 
       def tinyurl_config?

data/lib/searchlink/searches.rb

@@ -202,6 +202,9 @@ require_relative "searches/duckduckgo"
 # import
 require_relative "searches/github"
 
+# import
+require_relative "searches/kagi"
+
 # import
 require_relative "searches/google"
 

data/lib/searchlink/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SL
-  VERSION = '2.3.92'
+  VERSION = '2.3.93'
 end
 
 # Main module

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchlink
 version: !ruby/object:Gem::Version
-  version: 2.3.92
+  version: 2.3.93
 platform: ruby
 authors:
 - Brett Terpstra
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-01 00:00:00.000000000 Z
+date: 2026-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -300,6 +301,7 @@ files:
 - lib/searchlink/searches/history.rb
 - lib/searchlink/searches/hook.rb
 - lib/searchlink/searches/itunes.rb
+- lib/searchlink/searches/kagi.rb
 - lib/searchlink/searches/lastfm.rb
 - lib/searchlink/searches/linkding.rb
 - lib/searchlink/searches/lyrics.rb
@@ -331,6 +333,7 @@ homepage: https://github.com/ttscoff/searchlink
 licenses:
 - MIT
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -345,7 +348,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.5.3
+signing_key:
 specification_version: 4
 summary: Create Markdown links from web searches without leaving your editor.
 test_files: []