added reposts importer

app/importers/reposts_importer.rb

···
+require 'time'
+
+require_relative '../at_uri'
+require_relative 'base_importer'
+
+class RepostsImporter < BaseImporter
+  def import_items
+    params = { repo: @did, collection: 'app.bsky.feed.repost', limit: 100 }
+    params[:cursor] = @import.cursor if @import.cursor
+
+    loop do
+      response = @minisky.get_request('com.atproto.repo.listRecords', params)
+
+      records = response['records']
+      cursor = response['cursor']
+
+      @imported_count += records.length
+      @report&.update(importers: { importer_name => { :imported_items => @imported_count }})
+      @report&.update(importers: { importer_name => { :oldest_date => Time.parse(records.last['value']['createdAt']) }}) unless records.empty?
+
+      records.each do |record|
+        begin
+          repost_rkey = AT_URI(record['uri']).rkey
+          next if @user.reposts.where(rkey: repost_rkey).exists?
+
+          repost_time = Time.parse(record['value']['createdAt'])
+          post_uri = record['value']['subject']['uri']
+
+          create_item_for_post(post_uri) do |args|
+            @user.reposts.create!(args.merge(rkey: repost_rkey, time: repost_time))
+          end
+        rescue StandardError => e
+          puts "Error in RepostsImporter: #{record['uri']}: #{e}"
+        end
+      end
+
+      params[:cursor] = cursor
+      @import.update!(cursor: cursor)
+
+      break if !cursor
+      break if @time_limit && records.any? { |x| Time.parse(x['value']['createdAt']) < @time_limit }
+    end
+  end
+end

app/models/import.rb

···
 class Import < ActiveRecord::Base
   belongs_to :user
 
-  validates_inclusion_of :collection, in: %w(likes)
+  validates_inclusion_of :collection, in: %w(likes reposts)
   validates_uniqueness_of :collection, scope: :user_id
 end

app/models/repost.rb

···
+require 'active_record'
+
+require_relative 'post'
+require_relative 'user'
+
+class Repost < ActiveRecord::Base
+  validates_presence_of :time, :rkey
+  validates_length_of :rkey, maximum: 13
+
+  validates_presence_of :post_uri, if: -> { post_id.nil? }
+
+  belongs_to :user, foreign_key: 'actor_id'
+  belongs_to :post, optional: true
+end

app/models/user.rb

···
 require_relative 'import'
 require_relative 'like'
 require_relative 'post'
+require_relative 'repost'
 
 class User < ActiveRecord::Base
   validates_presence_of :did
···
 
   has_many :posts
   has_many :likes, foreign_key: 'actor_id'
+  has_many :reposts, foreign_key: 'actor_id'
   has_many :imports
 end

db/migrate/20250906005748_add_reposts.rb

···
+class AddReposts < ActiveRecord::Migration[7.2]
+  def change
+    create_table :reposts do |t|
+      t.integer "actor_id", null: false
+      t.string "rkey", limit: 13, null: false
+      t.datetime "time", null: false
+      t.bigint "post_id"
+      t.string "post_uri"
+    end
+
+    add_index :reposts, [:actor_id, :time, :id], order: { time: :desc, id: :desc }
+    add_index :reposts, [:actor_id, :rkey], unique: true
+  end
+end

db/schema.rb

···
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.2].define(version: 2025_09_03_215014) do
+ActiveRecord::Schema[7.2].define(version: 2025_09_06_005748) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
 
···
     t.text "data", null: false
     t.index ["user_id", "rkey"], name: "index_posts_on_user_id_and_rkey", unique: true
     t.index ["user_id", "time", "id"], name: "index_posts_on_user_id_and_time_and_id", order: { time: :desc, id: :desc }
+  end
+
+  create_table "reposts", force: :cascade do |t|
+    t.integer "actor_id", null: false
+    t.string "rkey", limit: 13, null: false
+    t.datetime "time", null: false
+    t.bigint "post_id"
+    t.string "post_uri"
+    t.index ["actor_id", "rkey"], name: "index_reposts_on_actor_id_and_rkey", unique: true
+    t.index ["actor_id", "time", "id"], name: "index_reposts_on_actor_id_and_time_and_id", order: { time: :desc, id: :desc }
   end
 
   create_table "users", id: :serial, force: :cascade do |t|

lib/tasks/import.rake

···
 require_relative '../../app/importers/likes_importer'
+require_relative '../../app/importers/reposts_importer'
 require_relative '../../app/import_report'
 require_relative '../../app/item_queue'
 require_relative '../../app/post_downloader'
···
   when 'likes'
     queue = ItemQueue.new(Like.where(post: nil).to_a)
     importer = LikesImporter.new(ENV['USER'])
+  when 'reposts'
+    queue = ItemQueue.new(Repost.where(post: nil).to_a)
+    importer = RepostsImporter.new(ENV['USER'])
   when nil
     raise "Required COLLECTION parameter missing"
   else