automatic 14.12.2 → 26.09

data/plugins/filter/join.rb

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+# Name::        Automatic::Plugin::Filter::Join
+# Description:: Join every item in the pipeline into one item.
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Aug 17, 2026
+# Updated::     Aug 17, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
+#
+# Many items in, one item out. That is the whole of it: no summarizing, no
+# fetching, no knowledge of what reads the result. What the joined description
+# is for is decided by whatever the Recipe puts next -- an AI filter, a publish
+# plugin, or nothing at all.
+#
+# The whole pipeline becomes one item rather than one item per feed, because
+# the point of joining is to have a single text; a Recipe that wants one item
+# per feed still has the feeds separate before this plugin runs.
+
+module Automatic::Plugin
+  class FilterJoin
+    require 'rss'
+
+    # A title an operator has not set. Short and predictable, in the manner of
+    # PublishMarkdown's `(untitled)`; a Recipe that publishes this item names
+    # it in `title`.
+    DEFAULT_TITLE = 'Joined items'.freeze
+
+    # Where one item ends and the next begins, for whatever reads the joined
+    # text. Plain lines rather than markup: the descriptions being joined may
+    # be HTML or text, and a delimiter that survives both is one that neither
+    # can be mistaken for.
+    HEADING = 'ARTICLE'.freeze
+
+    def initialize(config, pipeline = [])
+      @config   = config || {}
+      @pipeline = pipeline
+    end
+
+    # Returns one feed holding one item, or an empty pipeline when there was
+    # nothing to join. An item saying nothing is worse than no item: the
+    # plugins after this one would publish it.
+    def run
+      items = collect
+      if items.empty?
+        Automatic::Log.puts('warn', 'FilterJoin: no items to join')
+        return []
+      end
+
+      Automatic::Log.puts('info', "FilterJoin: joining #{items.size} items into one")
+      [feed(title, description(items))]
+    end
+
+    private
+
+    def collect
+      @pipeline.each_with_object([]) { |feeds, items|
+        next if feeds.nil?
+
+        items.concat(feeds.items)
+      }
+    end
+
+    def title
+      given = @config['title'].to_s
+      given.empty? ? DEFAULT_TITLE : given
+    end
+
+    def description(items)
+      items.each_with_index.map { |item, index| section(index + 1, item) }.join("\n\n")
+    end
+
+    def section(number, item)
+      ["#{HEADING} #{number}",
+       "Title: #{value(item, :title)}",
+       "URL: #{value(item, :link)}",
+       '',
+       value(item, :description)].join("\n")
+    end
+
+    # A field an item does not carry is empty rather than absent, so that every
+    # section has the same shape whatever the feed it came from left out.
+    def value(item, name)
+      return '' unless item.respond_to?(name)
+
+      item.public_send(name).to_s.strip
+    end
+
+    # This joined item deliberately has no link. It is several articles at once,
+    # so there is no single page it points at; using the first article's URL would
+    # name a source for text that is not only from it.
+    def feed(item_title, item_description)
+      RSS::Maker.make('2.0') { |maker|
+        maker.channel.title = 'Automatic Ruby'
+        maker.channel.description = 'Automatic::Plugin::FilterJoin'
+        maker.channel.link = 'https://github.com/id774/automaticruby'
+        item = maker.items.new_item
+        item.title = item_title
+        item.description = item_description
+        item.date = Time.now
+      }
+    end
+  end
+end

data/plugins/filter/kimi.rb

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+# Name::        Automatic::Plugin::Filter::Kimi
+# Description:: Replace each item's description with what the Kimi API answers.
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Sep 11, 2026
+# Updated::     Sep 11, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
+#
+# One transformation: the item's description goes to the Kimi API under the
+# Recipe's prompt, and the answer becomes the item's description. What that
+# transformation is -- a summary, a translation, an extraction, a
+# classification -- is the prompt's business, not this plugin's.
+#
+# Moonshot AI's Kimi offers an OpenAI-compatible chat completions interface,
+# and this plugin is still its own rather than a mode of FilterOpenAI. It is a
+# different service: a different endpoint, a different account, a different
+# set of models, its own limits and its own errors, and any of those may move
+# without OpenAI moving. A Recipe naming FilterKimi says which service the
+# text is sent to, which a `provider:` setting would not.
+#
+# Kimi may return a `reasoning_content` alongside the answer's own `content`.
+# That reasoning is never read, logged or written anywhere by this plugin --
+# only `content` is the answer, and only once `finish_reason` says the model
+# is done.
+#
+# @see https://platform.moonshot.ai/docs/api/chat
+
+module Automatic::Plugin
+  class FilterKimi
+    require 'json'
+    require 'net/http'
+    require 'openssl'
+    require 'uri'
+
+    # The one endpoint the service publishes for this. It is not a setting: an
+    # operator has no version of this plugin that talks to a different host,
+    # and a setting for it would be a way to send the token somewhere else.
+    ENDPOINT = URI('https://api.moonshot.ai/v1/chat/completions')
+
+    OPEN_TIMEOUT = 10
+
+    # Generous, and bounded. A model given several articles thinks for a while;
+    # an unattended run that waits forever is the failure this exists against.
+    READ_TIMEOUT = 300
+
+    # A failure that another attempt will not get past: a setting that is
+    # wrong, a request the service refuses, an answer this plugin cannot read.
+    class Error < StandardError; end
+
+    # A failure that another attempt may get past: the network, a rate limit, a
+    # server error.
+    class TemporaryError < StandardError; end
+
+    def initialize(config, pipeline = [])
+      @config   = config || {}
+      @pipeline = pipeline
+    end
+
+    # Replaces each item's description with the answer. Nothing else about an
+    # item is touched, and the feeds and their items arrive and leave in the
+    # same number and the same order.
+    def run
+      validate_settings
+
+      @pipeline.each { |feeds|
+        next if feeds.nil?
+
+        feeds.items.each { |item| transform(item) }
+      }
+      @pipeline
+    end
+
+    private
+
+    # Checked before the first request, because a Recipe this plugin cannot
+    # carry out is the operator's mistake and will be the same mistake on every
+    # item. The token is never named in a message.
+    def validate_settings
+      raise ArgumentError, 'FilterKimi needs a token' if token.empty?
+      raise ArgumentError, 'FilterKimi needs a model' if model.empty?
+      raise ArgumentError, 'FilterKimi needs a prompt' if prompt.empty?
+    end
+
+    def token
+      @config['token'].to_s
+    end
+
+    def model
+      @config['model'].to_s.strip
+    end
+
+    def prompt
+      @config['prompt'].to_s.strip
+    end
+
+    def transform(item)
+      text = item.description.to_s
+      if text.strip.empty?
+        Automatic::Log.puts('warn', "FilterKimi: nothing to send for #{item.link}")
+        return
+      end
+
+      Automatic::Log.puts('info', "FilterKimi: asking #{model} about #{item.link}")
+      item.description = answer(text)
+    end
+
+    # The retry shape of doc/PLUGINS.md section 3.6, applied only to what
+    # retrying can help. A missing setting, a refused request or an answer in a
+    # shape this plugin cannot read is raised at once: trying again would fail
+    # the same way, more slowly.
+    def answer(text)
+      retries   = 0
+      retry_max = @config['retry'].to_i
+      begin
+        completion(text)
+      rescue TemporaryError => e
+        retries += 1
+        Automatic::Log.puts('error', "ErrorCount: #{retries}, FilterKimi: #{e.message}")
+        if retries <= retry_max
+          sleep(@config['interval'].to_i)
+          retry
+        end
+        raise Error, "FilterKimi gave up after #{retries} attempts: #{e.message}"
+      end
+    end
+
+    def completion(text)
+      # The prompt is the system turn and the description is the user turn it
+      # is applied to. They are separate messages, so that what an article says
+      # is never read as an instruction to this plugin or to the model. Nothing
+      # else -- no sampling or tool-use parameter -- is sent.
+      body = {
+        'model' => model,
+        'messages' => [
+          { 'role' => 'system', 'content' => prompt },
+          { 'role' => 'user', 'content' => text }
+        ]
+      }
+      content(post(JSON.generate(body)))
+    end
+
+    def post(body)
+      request = Net::HTTP::Post.new(ENDPOINT)
+      request['Authorization'] = "Bearer #{token}"
+      request['Content-Type']  = 'application/json'
+      request.body = body
+
+      # TLS with the certificate verified, which is Net::HTTP's own default and
+      # is named here because it is not a thing to be turned off.
+      Net::HTTP.start(ENDPOINT.host, ENDPOINT.port,
+                      use_ssl: true,
+                      verify_mode: OpenSSL::SSL::VERIFY_PEER,
+                      open_timeout: OPEN_TIMEOUT,
+                      read_timeout: READ_TIMEOUT) { |http| http.request(request) }
+    rescue Timeout::Error, SystemCallError, SocketError, IOError,
+           OpenSSL::SSL::SSLError, Net::HTTPBadResponse => e
+      raise TemporaryError, "the request to Kimi failed: #{e.message}"
+    end
+
+    def content(response)
+      case response
+      when Net::HTTPSuccess
+        answer_text(parse(response.body))
+      when Net::HTTPTooManyRequests, Net::HTTPServerError
+        raise TemporaryError, "Kimi answered #{response.code}: #{reason(response)}"
+      else
+        raise Error, "Kimi answered #{response.code}: #{reason(response)}"
+      end
+    end
+
+    def parse(body)
+      JSON.parse(body.to_s)
+    rescue JSON::ParserError => e
+      raise Error, "Kimi answered with something that is not JSON: #{e.message}"
+    end
+
+    # The first choice's message content, once the model says it is actually
+    # done. `reasoning_content`, when Kimi sends one alongside `content`, is
+    # never read here: it is not the answer, and it never becomes one. An
+    # answer this plugin cannot find is an error and not an empty description:
+    # a Recipe that published the empty string here would have thrown the
+    # article away and reported success.
+    def answer_text(body)
+      choices = body['choices']
+      unless choices.is_a?(Array) && choices.first.is_a?(Hash)
+        raise Error, 'Kimi answered without a choice'
+      end
+
+      choice  = choices.first
+      message = choice['message']
+      raise Error, 'Kimi answered without a message' unless message.is_a?(Hash)
+      raise Error, "Kimi did not finish: #{choice['finish_reason']}" unless choice['finish_reason'] == 'stop'
+
+      text = message['content'].to_s.strip
+      raise Error, 'Kimi answered with no content' if text.empty?
+
+      text
+    end
+
+    # The service's own explanation where it gave one, the status line
+    # otherwise. Neither carries the token, and the settings are never logged
+    # or raised wholesale.
+    def reason(response)
+      body = JSON.parse(response.body.to_s)
+      error = body['error']
+      return error['message'].to_s if error.is_a?(Hash) && !error['message'].to_s.empty?
+
+      response.message.to_s
+    rescue JSON::ParserError
+      response.message.to_s
+    end
+  end
+end

data/plugins/filter/limit.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# Name::        Automatic::Plugin::Filter::Limit
+# Description:: Limit the number of items passed by the whole pipeline.
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Aug 24, 2026
+# Updated::     Aug 24, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
+
+module Automatic::Plugin
+  class FilterLimit
+    def initialize(config, pipeline = [])
+      @config    = config || {}
+      @pipeline  = pipeline
+      @max_items = validated_max_items
+    end
+
+    # Selects items in feed order, item order, up to max_items shared across the
+    # whole pipeline rather than reset per feed. A feed that contributed no item
+    # is dropped from the output; the walk stops as soon as the limit is met.
+    def run
+      remaining = @max_items
+      returned  = []
+
+      @pipeline.each do |feeds|
+        next if feeds.nil?
+        break if remaining <= 0
+
+        selected = feeds.items.first(remaining)
+        next if selected.empty?
+
+        returned << Automatic::FeedMaker.create_pipeline(selected)
+        remaining -= selected.size
+      end
+
+      returned
+    end
+
+    private
+
+    def validated_max_items
+      value = begin
+        Integer(@config['max_items'].to_s, 10)
+      rescue ArgumentError
+        nil
+      end
+
+      if value.nil? || value < 1
+        raise ArgumentError, 'FilterLimit needs max_items to be a positive integer'
+      end
+
+      value
+    end
+  end
+end

data/plugins/filter/one.rb

@@ -1,37 +1,30 @@
 # -*- coding: utf-8 -*-
-# Name::      Automatic::Plugin::Filter::One
-# Author::    soramugi <http://soramugi.net>
-#             774 <http://id774.net>
-# Created::   May  8, 2013
-# Updated::   Feb 21, 2014
-# Copyright:: Copyright (c) 2012-2014 Automatic Ruby Developers.
-# License::   Licensed under the GNU GENERAL PUBLIC LICENSE, Version 3.0.
+# Name::        Automatic::Plugin::Filter::One
+# Author:       soramugi (More info: http://soramugi.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     May  8, 2013
+# Updated::     Aug 15, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
 
 module Automatic::Plugin
   class FilterOne
-
-    def initialize(config, pipeline=[])
-      @config   = config
+    def initialize(config, pipeline = [])
+      @config   = config || {}
       @pipeline = pipeline
+      @last     = @config['pick'].to_s == 'last'
     end
 
+    # Reduces each feed to a single item. A feed that has none is dropped
+    # rather than reduced to one nil.
     def run
-      @return_feeds = []
-      @pipeline.each {|feed|
-        unless feed.nil?
-          item = []
-          unless @config.nil? or @config['pick'].nil?
-            if @config['pick'] == 'last'
-              item << feed.items.pop
-            end
-          end
-          if item.count == 0
-            item << feed.items.shift
-          end
-          @return_feeds << Automatic::FeedMaker.create_pipeline(item)
-        end
-      }
-      @return_feeds
+      @pipeline.each_with_object([]) do |feeds, returned|
+        next if feeds.nil? || feeds.items.empty?
+
+        item = @last ? feeds.items.last : feeds.items.first
+        returned << Automatic::FeedMaker.create_pipeline([item])
+      end
     end
   end
 end

data/plugins/filter/open_ai.rb

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+# Name::        Automatic::Plugin::Filter::OpenAI
+# Description:: Replace each item's description with what the OpenAI API answers.
+# Author:       id774 (More info: https://id774.net)
+# Source Code:: https://github.com/id774/automaticruby
+# License::     The GPL version 3, or LGPL version 3 (Dual License).
+# Contact::     idnanashi@gmail.com
+# Created::     Aug 17, 2026
+# Updated::     Aug 17, 2026
+# Copyright::   Copyright (c) 2012-2026 Automatic Ruby Developers.
+#
+# One transformation: the item's description goes to the OpenAI API under the
+# Recipe's prompt, and the answer becomes the item's description. What that
+# transformation is -- a summary, a translation, an extraction, a
+# classification -- is the prompt's business, not this plugin's.
+#
+# This plugin knows OpenAI and nothing else. Anthropic, Google and Sakura have
+# their own plugins, because their endpoints, authentication, request bodies,
+# responses and errors are their own and will keep diverging. A Recipe changes
+# service by naming a different plugin.
+#
+# It speaks the Responses API, which is the interface OpenAI recommends for new
+# integrations. @see https://platform.openai.com/docs/api-reference/responses
+
+module Automatic::Plugin
+  class FilterOpenAI
+    require 'json'
+    require 'net/http'
+    require 'openssl'
+    require 'uri'
+
+    ENDPOINT = URI('https://api.openai.com/v1/responses')
+
+    OPEN_TIMEOUT = 10
+
+    # Generous, and bounded. A model given several articles thinks for a while;
+    # an unattended run that waits forever is the failure this exists against.
+    READ_TIMEOUT = 300
+
+    # A failure that another attempt will not get past: a setting that is
+    # wrong, a request the service refuses, an answer this plugin cannot read.
+    class Error < StandardError; end
+
+    # A failure that another attempt may get past: the network, a rate limit, a
+    # server error.
+    class TemporaryError < StandardError; end
+
+    def initialize(config, pipeline = [])
+      @config   = config || {}
+      @pipeline = pipeline
+    end
+
+    # Replaces each item's description with the answer. Nothing else about an
+    # item is touched, and the feeds and their items arrive and leave in the
+    # same order and number.
+    def run
+      validate_settings
+
+      @pipeline.each { |feeds|
+        next if feeds.nil?
+
+        feeds.items.each { |item| transform(item) }
+      }
+      @pipeline
+    end
+
+    private
+
+    # Checked before the first request, because a Recipe this plugin cannot
+    # carry out is the operator's mistake and will be the same mistake on every
+    # item. The token is never named in a message.
+    def validate_settings
+      raise ArgumentError, 'FilterOpenAI needs a token' if token.empty?
+      raise ArgumentError, 'FilterOpenAI needs a model' if model.empty?
+      raise ArgumentError, 'FilterOpenAI needs a prompt' if prompt.empty?
+    end
+
+    def token
+      @config['token'].to_s
+    end
+
+    def model
+      @config['model'].to_s.strip
+    end
+
+    def prompt
+      @config['prompt'].to_s.strip
+    end
+
+    def transform(item)
+      text = item.description.to_s
+      if text.strip.empty?
+        Automatic::Log.puts('warn', "FilterOpenAI: nothing to send for #{item.link}")
+        return
+      end
+
+      Automatic::Log.puts('info', "FilterOpenAI: asking #{model} about #{item.link}")
+      item.description = answer(text)
+    end
+
+    # The retry shape of doc/PLUGINS.md section 3.6, applied only to what
+    # retrying can help. A missing setting, a refused request or an answer in a
+    # shape this plugin cannot read is raised at once: trying again would fail
+    # the same way, more slowly.
+    def answer(text)
+      retries   = 0
+      retry_max = @config['retry'].to_i
+      begin
+        completion(text)
+      rescue TemporaryError => e
+        retries += 1
+        Automatic::Log.puts('error', "ErrorCount: #{retries}, FilterOpenAI: #{e.message}")
+        if retries <= retry_max
+          sleep(@config['interval'].to_i)
+          retry
+        end
+        raise Error, "FilterOpenAI gave up after #{retries} attempts: #{e.message}"
+      end
+    end
+
+    def completion(text)
+      # The prompt is the instruction and the description is the text it is
+      # applied to. They are separate fields, so that what an article says is
+      # never read as an instruction to this plugin or to the model.
+      body = {
+        'model' => model,
+        'instructions' => prompt,
+        'input' => text
+      }
+      content(post(JSON.generate(body)))
+    end
+
+    def post(body)
+      request = Net::HTTP::Post.new(ENDPOINT)
+      request['Authorization'] = "Bearer #{token}"
+      request['Content-Type']  = 'application/json'
+      request.body = body
+
+      # TLS with the certificate verified, which is Net::HTTP's own default and
+      # is named here because it is not a thing to be turned off.
+      Net::HTTP.start(ENDPOINT.host, ENDPOINT.port,
+                      use_ssl: true,
+                      verify_mode: OpenSSL::SSL::VERIFY_PEER,
+                      open_timeout: OPEN_TIMEOUT,
+                      read_timeout: READ_TIMEOUT) { |http| http.request(request) }
+    rescue Timeout::Error, SystemCallError, SocketError, IOError,
+           OpenSSL::SSL::SSLError, Net::HTTPBadResponse => e
+      raise TemporaryError, "the request to OpenAI failed: #{e.message}"
+    end
+
+    def content(response)
+      case response
+      when Net::HTTPSuccess
+        answer_text(parse(response.body))
+      when Net::HTTPTooManyRequests, Net::HTTPServerError
+        raise TemporaryError, "OpenAI answered #{response.code}: #{reason(response)}"
+      else
+        raise Error, "OpenAI answered #{response.code}: #{reason(response)}"
+      end
+    end
+
+    def parse(body)
+      JSON.parse(body.to_s)
+    rescue JSON::ParserError => e
+      raise Error, "OpenAI answered with something that is not JSON: #{e.message}"
+    end
+
+    # The text of the assistant's message, out of the typed output array the
+    # Responses API returns. An answer this plugin cannot find is an error and
+    # not an empty description: a Recipe that published the empty string here
+    # would have thrown the article away and reported success.
+    def answer_text(body)
+      output = body['output']
+      raise Error, 'OpenAI answered without an output array' unless output.is_a?(Array)
+
+      text = output.select { |item| item.is_a?(Hash) && item['type'] == 'message' }.
+             flat_map { |item| Array(item['content']) }.
+             select { |part| part.is_a?(Hash) && part['type'] == 'output_text' }.
+             map { |part| part['text'].to_s }.join.strip
+      raise Error, 'OpenAI answered with no output text' if text.empty?
+
+      text
+    end
+
+    # The service's own explanation where it gave one, the status line
+    # otherwise. Neither carries the token, and the settings are never logged
+    # or raised wholesale.
+    def reason(response)
+      body = JSON.parse(response.body.to_s)
+      error = body['error']
+      return error['message'].to_s if error.is_a?(Hash) && !error['message'].to_s.empty?
+
+      response.message.to_s
+    rescue JSON::ParserError
+      response.message.to_s
+    end
+  end
+end