bookflow 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd8cba2fef6ce99676690119e530e7354737e6210d352a5d8c9f7d0da6b6eb57
+  data.tar.gz: c32011ded974d9ffa537b3a4b7799e772a63b2fe7a9680e8d346c0abf79c2e65
+SHA512:
+  metadata.gz: 76468692b7293a984e41839334069a8eba65b461489c24eeb2c4e1fd8073c3793cabad00a7b2b2b9e26f4841b6c1d9424a63a134a1c8abf1fdd2474dbd375bce
+  data.tar.gz: 0a65ba7ab9acd20a2872bcbdec671f8a759d7abe26d2751d425ba1bedbd7904fe732ca72d198106ee6113358d60b0f9a0f66a69c80b08c92a83b792ac5fddf49

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Meireles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,158 @@
+# Bookflow
+
+`bookflow` is a local Ruby CLI that exports Apple Books highlights and notes from macOS SQLite databases into deterministic Markdown files (one file per book).
+
+## Features
+
+- Reads Apple Books annotation and library metadata from local SQLite databases
+- Exports one Markdown file per book
+- Deterministic filenames and stable annotation ordering
+- Case-insensitive filtering by book title/author
+- Dry-run mode for previewing exports
+- Safe overwrite behavior (`--overwrite` required when files already exist)
+
+## Requirements
+
+- macOS (Apple Books database paths are macOS container paths)
+- Ruby `>= 3.1`
+- Bundler
+
+## Install
+
+From RubyGems (after publish):
+
+```bash
+gem install bookflow
+```
+
+For local development:
+
+```bash
+bundle install
+```
+
+## Usage
+
+Run the CLI via Bundler:
+
+```bash
+bundle exec ruby bin/bookflow export apple-books
+```
+
+Or directly after making it executable:
+
+```bash
+./bin/bookflow export apple-books
+```
+
+### Command
+
+```bash
+bookflow export apple-books [options]
+```
+
+### Options
+
+- `--output-dir <path>`
+  - Output directory for Markdown files
+  - Default: `./exports`
+- `--book <substring>`
+  - Case-insensitive filter applied to book title and author
+- `--overwrite`
+  - Overwrite existing output files
+- `--dry-run`
+  - Print files that would be written, without writing any files
+
+## Apple Books Database Paths
+
+By default, `bookflow` reads:
+
+- Annotation DB:
+  - `~/Library/Containers/com.apple.iBooksX/Data/Documents/AEAnnotation/AEAnnotation_v10312011_1727_local.sqlite`
+- Library DB:
+  - `~/Library/Containers/com.apple.iBooksX/Data/Documents/BKLibrary/BKLibrary-1-091020131601.sqlite`
+
+## Environment Variable Overrides
+
+You can override database paths:
+
+- `BOOKFLOW_APPLE_BOOKS_ANNOTATION_DB`
+- `BOOKFLOW_APPLE_BOOKS_LIBRARY_DB`
+
+Legacy-compatible aliases are also supported:
+
+- `APPLE_BOOKS_EXPORTER_ANNOTATION_DB`
+- `APPLE_BOOKS_EXPORTER_LIBRARY_DB`
+
+Example:
+
+```bash
+BOOKFLOW_APPLE_BOOKS_ANNOTATION_DB=/tmp/annotations.sqlite \
+BOOKFLOW_APPLE_BOOKS_LIBRARY_DB=/tmp/library.sqlite \
+bundle exec ruby bin/bookflow export apple-books --output-dir ./exports --dry-run
+```
+
+## Examples
+
+Export all annotations to `./exports`:
+
+```bash
+bundle exec ruby bin/bookflow export apple-books
+```
+
+Only export books matching `"metz"` in title or author:
+
+```bash
+bundle exec ruby bin/bookflow export apple-books --book metz
+```
+
+Preview output without writing files:
+
+```bash
+bundle exec ruby bin/bookflow export apple-books --dry-run
+```
+
+Overwrite existing files:
+
+```bash
+bundle exec ruby bin/bookflow export apple-books --overwrite
+```
+
+## Output
+
+Each exported Markdown file contains:
+
+- Book metadata (title, author, asset id, source path)
+- Export timestamp
+- Ordered annotations (highlight text, note text, location metadata, created timestamp)
+
+Annotation ordering is deterministic and prioritizes reading position:
+
+1. Absolute physical location
+2. Range start
+3. Creation timestamp
+4. Annotation primary key (`Z_PK`)
+
+## Run Tests
+
+```bash
+bundle exec rake test
+```
+
+## Release
+
+```bash
+bundle exec rake test
+gem build bookflow.gemspec
+gem signin
+gem push bookflow-$(ruby -Ilib -e 'require "bookflow/version"; print Bookflow::VERSION').gem
+```
+
+## Project Structure
+
+- `bin/bookflow`: CLI entrypoint
+- `lib/bookflow/cli.rb`: command parsing and orchestration
+- `lib/bookflow/apple_books/database.rb`: read-only SQLite access + schema validation
+- `lib/bookflow/apple_books/extract.rb`: grouping/filtering/sorting
+- `lib/bookflow/apple_books/render_markdown.rb`: markdown rendering
+- `test/`: unit and integration-style tests with fixture databases

data/bin/bookflow

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "bookflow"
+
+exit Bookflow::CLI.new.run(ARGV)

data/lib/bookflow/apple_books/database.rb

@@ -0,0 +1,107 @@
+require "set"
+require "sqlite3"
+
+module Bookflow
+  module AppleBooks
+    class Database
+      REQUIRED_ANNOTATION_COLUMNS = %w[
+        Z_PK
+        ZANNOTATIONASSETID
+        ZANNOTATIONDELETED
+        ZANNOTATIONTYPE
+        ZANNOTATIONSTYLE
+        ZANNOTATIONCREATIONDATE
+        ZANNOTATIONMODIFICATIONDATE
+        ZANNOTATIONNOTE
+        ZANNOTATIONREPRESENTATIVETEXT
+        ZANNOTATIONSELECTEDTEXT
+        ZPLABSOLUTEPHYSICALLOCATION
+        ZPLLOCATIONRANGESTART
+        ZPLLOCATIONRANGEEND
+      ].freeze
+
+      REQUIRED_LIBRARY_COLUMNS = %w[
+        ZASSETID
+        ZTITLE
+        ZAUTHOR
+        ZPATH
+      ].freeze
+
+      def initialize(annotation_db_path:, library_db_path:)
+        @annotation_db_path = annotation_db_path.to_s
+        @library_db_path = library_db_path.to_s
+      end
+
+      def valid_schema?
+        validate_schema!
+        true
+      rescue ArgumentError
+        false
+      end
+
+      def validate_schema!
+        validate_database!(
+          path: @annotation_db_path,
+          table: "ZAEANNOTATION",
+          columns: REQUIRED_ANNOTATION_COLUMNS
+        )
+        validate_database!(
+          path: @library_db_path,
+          table: "ZBKLIBRARYASSET",
+          columns: REQUIRED_LIBRARY_COLUMNS
+        )
+      end
+
+      def annotation_rows
+        open_readonly(@annotation_db_path) do |db|
+          db.execute(<<~SQL)
+            SELECT Z_PK, ZANNOTATIONASSETID, ZANNOTATIONDELETED, ZANNOTATIONTYPE, ZANNOTATIONSTYLE,
+                   ZANNOTATIONCREATIONDATE, ZANNOTATIONMODIFICATIONDATE, ZANNOTATIONNOTE,
+                   ZANNOTATIONREPRESENTATIVETEXT, ZANNOTATIONSELECTEDTEXT, ZPLABSOLUTEPHYSICALLOCATION,
+                   ZPLLOCATIONRANGESTART, ZPLLOCATIONRANGEEND
+            FROM ZAEANNOTATION
+            WHERE COALESCE(ZANNOTATIONDELETED, 0) = 0
+          SQL
+        end
+      end
+
+      def book_rows
+        open_readonly(@library_db_path) do |db|
+          db.execute(<<~SQL)
+            SELECT ZASSETID, ZTITLE, ZAUTHOR, ZPATH
+            FROM ZBKLIBRARYASSET
+            WHERE ZASSETID IS NOT NULL
+          SQL
+        end
+      end
+
+      private
+
+      def open_readonly(path)
+        raise ArgumentError, "Database missing: #{path}" unless File.exist?(path)
+
+        db = SQLite3::Database.new(path, readonly: true)
+        db.results_as_hash = true
+        yield db
+      ensure
+        db&.close
+      end
+
+      def validate_database!(path:, table:, columns:)
+        open_readonly(path) do |db|
+          tables = db.execute(
+            "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?",
+            [table]
+          )
+          raise ArgumentError, "Required table missing: #{table}" if tables.empty?
+
+          found_columns = db.execute("PRAGMA table_info(#{table})").map { |row| row["name"] }.to_set
+          missing_columns = columns.reject { |column| found_columns.include?(column) }
+          return if missing_columns.empty?
+
+          raise ArgumentError, "Required columns missing in #{table}: #{missing_columns.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/bookflow/apple_books/extract.rb

@@ -0,0 +1,96 @@
+require "time"
+
+module Bookflow
+  module AppleBooks
+    module Extract
+      module_function
+
+      def group_exports(annotation_rows:, book_rows:, book_filter:)
+        books_by_asset_id = build_books_lookup(book_rows)
+        grouped_annotations = Hash.new { |hash, key| hash[key] = [] }
+
+        annotation_rows.each do |row|
+          next if blank_text_row?(row)
+
+          asset_id = row["ZANNOTATIONASSETID"].to_s
+          book = books_by_asset_id[asset_id] || unknown_book(asset_id)
+          next if filtered_out?(book, book_filter)
+
+          grouped_annotations[book] << build_annotation(row)
+        end
+
+        grouped_annotations.map do |book, annotations|
+          BookExport.new(book: book, annotations: sort_annotations(annotations))
+        end.sort_by { |book_export| [book_export.book.title.to_s.downcase, book_export.book.asset_id.to_s] }
+      end
+
+      def sort_annotations(annotations)
+        annotations.sort_by do |annotation|
+          [
+            annotation.absolute_location || Float::INFINITY,
+            annotation.range_start || Float::INFINITY,
+            annotation.created_at || Time.at(0).utc,
+            annotation.annotation_id || 0
+          ]
+        end
+      end
+
+      def filtered_out?(book, book_filter)
+        return false if book_filter.nil? || book_filter.strip.empty?
+
+        haystack = "#{book.title} #{book.author}".downcase
+        !haystack.include?(book_filter.downcase)
+      end
+
+      def blank_text_row?(row)
+        selected = row["ZANNOTATIONSELECTEDTEXT"].to_s
+        representative = row["ZANNOTATIONREPRESENTATIVETEXT"].to_s
+        note = row["ZANNOTATIONNOTE"].to_s
+        selected.empty? && representative.empty? && note.empty?
+      end
+
+      def build_books_lookup(rows)
+        rows.each_with_object({}) do |row, memo|
+          asset_id = row["ZASSETID"].to_s
+          memo[asset_id] = Book.new(
+            asset_id: asset_id,
+            title: row["ZTITLE"],
+            author: row["ZAUTHOR"],
+            source_path: row["ZPATH"]
+          )
+        end
+      end
+
+      def build_annotation(row)
+        selected_text = row["ZANNOTATIONSELECTEDTEXT"].to_s
+        representative_text = row["ZANNOTATIONREPRESENTATIVETEXT"]
+        highlight_text = selected_text.empty? ? representative_text : selected_text
+
+        Annotation.new(
+          annotation_id: row["Z_PK"],
+          asset_id: row["ZANNOTATIONASSETID"],
+          highlight_text: highlight_text,
+          note_text: row["ZANNOTATIONNOTE"],
+          created_at: parse_time(row["ZANNOTATIONCREATIONDATE"]),
+          modified_at: parse_time(row["ZANNOTATIONMODIFICATIONDATE"]),
+          absolute_location: row["ZPLABSOLUTEPHYSICALLOCATION"],
+          range_start: row["ZPLLOCATIONRANGESTART"],
+          range_end: row["ZPLLOCATIONRANGEEND"]
+        )
+      end
+
+      def parse_time(value)
+        return value if value.is_a?(Time)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        Time.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def unknown_book(asset_id)
+        Book.new(asset_id: asset_id, title: "Unknown Book", author: nil, source_path: nil)
+      end
+    end
+  end
+end

data/lib/bookflow/apple_books/models.rb

@@ -0,0 +1,18 @@
+module Bookflow
+  module AppleBooks
+    Book = Struct.new(:asset_id, :title, :author, :source_path, keyword_init: true)
+    Annotation = Struct.new(
+      :annotation_id,
+      :asset_id,
+      :highlight_text,
+      :note_text,
+      :created_at,
+      :modified_at,
+      :absolute_location,
+      :range_start,
+      :range_end,
+      keyword_init: true
+    )
+    BookExport = Struct.new(:book, :annotations, keyword_init: true)
+  end
+end

data/lib/bookflow/apple_books/paths.rb

@@ -0,0 +1,24 @@
+require "pathname"
+
+module Bookflow
+  module AppleBooks
+    module Paths
+      ANNOTATION_DB_RELATIVE_PATH = "Library/Containers/com.apple.iBooksX/Data/Documents/AEAnnotation/AEAnnotation_v10312011_1727_local.sqlite".freeze
+      LIBRARY_DB_RELATIVE_PATH = "Library/Containers/com.apple.iBooksX/Data/Documents/BKLibrary/BKLibrary-1-091020131601.sqlite".freeze
+
+      module_function
+
+      def annotation_db_path(home: Dir.home)
+        Pathname.new(File.join(home, ANNOTATION_DB_RELATIVE_PATH))
+      end
+
+      def library_db_path(home: Dir.home)
+        Pathname.new(File.join(home, LIBRARY_DB_RELATIVE_PATH))
+      end
+
+      def output_dir(value, pwd: Dir.pwd)
+        Pathname.new(File.expand_path(value, pwd))
+      end
+    end
+  end
+end

data/lib/bookflow/apple_books/render_markdown.rb

@@ -0,0 +1,50 @@
+module Bookflow
+  module AppleBooks
+    module RenderMarkdown
+      module_function
+
+      def render(book_export, exported_at:)
+        lines = []
+        lines << "# #{book_export.book.title}"
+        lines << ""
+        lines << "- Author: #{book_export.book.author}"
+        lines << "- Asset ID: #{book_export.book.asset_id}"
+        lines << "- Source Path: #{book_export.book.source_path}"
+        lines << "- Exported At: #{Utils.format_timestamp(exported_at)}"
+        lines << "- Annotation Count: #{book_export.annotations.length}"
+        lines << ""
+        lines << "## Highlights"
+
+        book_export.annotations.each_with_index do |annotation, index|
+          lines << ""
+          lines << "### #{index + 1}"
+          lines << ""
+          lines << "> #{annotation.highlight_text.to_s.rstrip}"
+          lines << ""
+          lines << "- Created At: #{Utils.format_timestamp(annotation.created_at)}" if annotation.created_at
+          location = format_location(annotation)
+          lines << "- Location: #{location}" unless location.nil?
+
+          note = annotation.note_text.to_s.rstrip
+          next if note.empty?
+
+          lines << ""
+          lines << "Note:"
+          lines << note
+        end
+
+        "#{lines.join("\n")}\n"
+      end
+
+      def format_location(annotation)
+        parts = []
+        parts << "absolute=#{annotation.absolute_location.inspect}" unless annotation.absolute_location.nil?
+        parts << "start=#{annotation.range_start.inspect}" unless annotation.range_start.nil?
+        parts << "end=#{annotation.range_end.inspect}" unless annotation.range_end.nil?
+        return nil if parts.empty?
+
+        parts.join(", ")
+      end
+    end
+  end
+end

data/lib/bookflow/cli.rb

@@ -0,0 +1,111 @@
+require "optparse"
+require "fileutils"
+require "pathname"
+
+module Bookflow
+  class CLI
+    def initialize(stdout: $stdout, stderr: $stderr, env: ENV, pwd: Dir.pwd)
+      @stdout = stdout
+      @stderr = stderr
+      @env = env
+      @pwd = pwd
+    end
+
+    def run(argv)
+      command = argv.shift
+      unless command == "export"
+        return write_error("Usage: bookflow export apple-books [options]")
+      end
+
+      source = argv.shift
+      unless source == "apple-books"
+        return write_error("Usage: bookflow export apple-books [options]")
+      end
+
+      options = parse_export_apple_books_options(argv)
+      raise ArgumentError, "Unexpected arguments: #{argv.join(' ')}" unless argv.empty?
+
+      export_apple_books(options)
+      0
+    rescue OptionParser::ParseError, ArgumentError => e
+      write_error(e.message)
+    end
+
+    private
+
+    def parse_export_apple_books_options(argv)
+      options = { output_dir: "./exports", book: nil, overwrite: false, dry_run: false }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: bookflow export apple-books [options]"
+        opts.on("--output-dir PATH") { |value| options[:output_dir] = value }
+        opts.on("--book SUBSTRING") { |value| options[:book] = value }
+        opts.on("--overwrite") { options[:overwrite] = true }
+        opts.on("--dry-run") { options[:dry_run] = true }
+      end
+      parser.parse!(argv)
+      options
+    end
+
+    def export_apple_books(options)
+      annotation_db_path =
+        @env["BOOKFLOW_APPLE_BOOKS_ANNOTATION_DB"] ||
+        @env["APPLE_BOOKS_EXPORTER_ANNOTATION_DB"] ||
+        AppleBooks::Paths.annotation_db_path.to_s
+      library_db_path =
+        @env["BOOKFLOW_APPLE_BOOKS_LIBRARY_DB"] ||
+        @env["APPLE_BOOKS_EXPORTER_LIBRARY_DB"] ||
+        AppleBooks::Paths.library_db_path.to_s
+      output_dir = AppleBooks::Paths.output_dir(options[:output_dir], pwd: @pwd)
+
+      database = AppleBooks::Database.new(
+        annotation_db_path: annotation_db_path,
+        library_db_path: library_db_path
+      )
+      database.validate_schema!
+
+      exports = AppleBooks::Extract.group_exports(
+        annotation_rows: database.annotation_rows,
+        book_rows: database.book_rows,
+        book_filter: options[:book]
+      )
+
+      write_exports(
+        exports,
+        output_dir: output_dir,
+        overwrite: options[:overwrite],
+        dry_run: options[:dry_run],
+        exported_at: Time.now
+      )
+    end
+
+    def write_exports(exports, output_dir:, overwrite:, dry_run:, exported_at:)
+      used_filenames = {}
+      FileUtils.mkdir_p(output_dir) if !dry_run && !exports.empty?
+
+      exports.each do |book_export|
+        filename = Utils.output_filename(
+          title: book_export.book.title,
+          asset_id: book_export.book.asset_id,
+          used_filenames: used_filenames
+        )
+        used_filenames[filename] = true
+        path = output_dir.join(filename)
+
+        if dry_run
+          @stdout.puts("would write #{path}")
+          next
+        end
+
+        raise ArgumentError, "Output file exists: #{path}" if File.exist?(path) && !overwrite
+
+        File.write(path, AppleBooks::RenderMarkdown.render(book_export, exported_at: exported_at))
+        @stdout.puts("wrote #{path}")
+      end
+    end
+
+    def write_error(message)
+      @stderr.puts(message)
+      1
+    end
+  end
+end

data/lib/bookflow/utils.rb

@@ -0,0 +1,51 @@
+require "time"
+
+module Bookflow
+  module Utils
+    module_function
+
+    def slugify(value)
+      ascii = value.to_s.unicode_normalize(:nfkd).encode(
+        "ASCII",
+        invalid: :replace,
+        undef: :replace,
+        replace: ""
+      )
+      ascii.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
+    end
+
+    def short_asset_id(asset_id)
+      text = asset_id.to_s
+      text[-8, 8] || text
+    end
+
+    def format_timestamp(time)
+      value =
+        case time
+        when Time
+          time
+        else
+          Time.parse(time.to_s)
+        end
+      value.getlocal.strftime("%Y-%m-%d %H:%M:%S %z")
+    end
+
+    def output_filename(title:, asset_id:, used_filenames: {})
+      base = slugify(title)
+      base = slugify(asset_id) if base.empty?
+      base = "book" if base.empty?
+
+      first_choice = "#{base}.md"
+      return first_choice unless used_filenames.key?(first_choice)
+
+      suffix = short_asset_id(asset_id)
+      candidate = "#{base}-#{suffix}.md"
+      counter = 2
+      while used_filenames.key?(candidate)
+        candidate = "#{base}-#{suffix}-#{counter}.md"
+        counter += 1
+      end
+      candidate
+    end
+  end
+end

data/lib/bookflow/version.rb

@@ -0,0 +1,3 @@
+module Bookflow
+  VERSION = "0.1.0"
+end

data/lib/bookflow.rb

@@ -0,0 +1,11 @@
+require_relative "bookflow/version"
+require_relative "bookflow/utils"
+require_relative "bookflow/cli"
+require_relative "bookflow/apple_books/paths"
+require_relative "bookflow/apple_books/models"
+require_relative "bookflow/apple_books/database"
+require_relative "bookflow/apple_books/extract"
+require_relative "bookflow/apple_books/render_markdown"
+
+module Bookflow
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: bookflow
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pedro Meireles
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: A local macOS CLI to export Apple Books highlights and notes from SQLite
+  to deterministic Markdown files.
+executables:
+- bookflow
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/bookflow
+- lib/bookflow.rb
+- lib/bookflow/apple_books/database.rb
+- lib/bookflow/apple_books/extract.rb
+- lib/bookflow/apple_books/models.rb
+- lib/bookflow/apple_books/paths.rb
+- lib/bookflow/apple_books/render_markdown.rb
+- lib/bookflow/cli.rb
+- lib/bookflow/utils.rb
+- lib/bookflow/version.rb
+homepage: https://github.com/pedromeireles/apple-books-exporter
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/pedromeireles/apple-books-exporter
+  bug_tracker_uri: https://github.com/pedromeireles/apple-books-exporter/issues
+  changelog_uri: https://github.com/pedromeireles/apple-books-exporter/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Export Apple Books highlights and notes to Markdown
+test_files: []