kreuzberg 4.3.5-aarch64-linux

data/lib/kreuzberg/djot_content.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+begin
+  require 'json'
+rescue LoadError
+  require 'json/pure'
+end
+
+module Kreuzberg
+  class Result
+    # Djot structured content representation
+    #
+    # Represents document content in Djot format with structured metadata about
+    # blocks, images, links, footnotes, and other document elements.
+    #
+    class DjotContent
+      attr_reader :plain_text, :blocks, :metadata_json, :tables, :images, :links, :footnotes, :attributes
+
+      # Represents a formatted block in Djot content
+      class FormattedBlock
+        attr_reader :block_type, :children, :attributes, :content, :level
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def initialize(hash_or_type = nil, children: nil, attributes: nil, content: nil, level: nil, block_type: nil)
+          if hash_or_type.is_a?(Hash)
+            # Initialize from hash
+            @block_type = hash_or_type[:block_type] || hash_or_type['block_type'] || ''
+            @children = hash_or_type[:children] || hash_or_type['children']
+            @attributes = hash_or_type[:attributes] || hash_or_type['attributes'] || {}
+            @content = hash_or_type[:content] || hash_or_type['content']
+            @level = hash_or_type[:level] || hash_or_type['level']
+          else
+            # Initialize from keyword arguments (for backward compatibility)
+            @block_type = block_type || hash_or_type || ''
+            @children = children || []
+            @attributes = attributes || {}
+            @content = content
+            @level = level
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def to_h
+          {
+            block_type: @block_type,
+            children: @children,
+            attributes: @attributes,
+            content: @content,
+            level: @level
+          }.compact
+        end
+      end
+
+      # Represents an image in Djot content
+      class DjotImage
+        attr_reader :url, :alt, :title, :width, :height
+        alias src url
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def initialize(hash_or_url = nil, alt: nil, title: nil, width: nil, height: nil, url: nil, src: nil)
+          if hash_or_url.is_a?(Hash)
+            # Initialize from hash (supports both 'url' and 'src' keys)
+            @url = hash_or_url[:url] || hash_or_url['url'] || hash_or_url[:src] || hash_or_url['src']
+            @alt = hash_or_url[:alt] || hash_or_url['alt']
+            @title = hash_or_url[:title] || hash_or_url['title']
+            @width = hash_or_url[:width] || hash_or_url['width']
+            @height = hash_or_url[:height] || hash_or_url['height']
+          else
+            # Initialize from keyword arguments
+            @url = url || src || hash_or_url
+            @alt = alt
+            @title = title
+            @width = width
+            @height = height
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def to_h
+          {
+            url: @url,
+            alt: @alt,
+            title: @title,
+            width: @width,
+            height: @height
+          }.compact
+        end
+      end
+
+      # Represents a link in Djot content
+      class DjotLink
+        attr_reader :url, :text, :title, :link_type
+        alias href url
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def initialize(hash_or_url = nil, text: nil, title: nil, url: nil, href: nil, link_type: nil)
+          if hash_or_url.is_a?(Hash)
+            # Initialize from hash (supports both 'url' and 'href' keys)
+            @url = hash_or_url[:url] || hash_or_url['url'] || hash_or_url[:href] || hash_or_url['href']
+            @text = hash_or_url[:text] || hash_or_url['text']
+            @title = hash_or_url[:title] || hash_or_url['title']
+            @link_type = hash_or_url[:link_type] || hash_or_url['link_type']
+          else
+            # Initialize from keyword arguments
+            @url = url || href || hash_or_url
+            @text = text
+            @title = title
+            @link_type = link_type
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def to_h
+          {
+            url: @url,
+            text: @text,
+            title: @title,
+            link_type: @link_type
+          }.compact
+        end
+      end
+
+      # Represents a footnote in Djot content
+      class Footnote
+        attr_reader :label, :content
+
+        def initialize(label:, content:)
+          @label = label
+          @content = content
+        end
+
+        def to_h
+          {
+            label: @label,
+            content: @content
+          }
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def initialize(hash)
+        @plain_text = hash['plain_text'] || hash[:plain_text] || ''
+        @blocks = parse_blocks(hash['blocks'] || hash[:blocks] || [])
+        @metadata_json = hash['metadata_json'] || hash[:metadata_json] || '{}'
+        @tables = hash['tables'] || hash[:tables] || []
+        @images = parse_images(hash['images'] || hash[:images] || [])
+        @links = parse_links(hash['links'] || hash[:links] || [])
+        @footnotes = parse_footnotes(hash['footnotes'] || hash[:footnotes] || [])
+        @attributes = hash['attributes'] || hash[:attributes] || {}
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def metadata
+        @metadata ||= parse_metadata(@metadata_json)
+      end
+
+      def to_h
+        {
+          plain_text: @plain_text,
+          blocks: @blocks.map(&:to_h),
+          metadata_json: @metadata_json,
+          tables: @tables,
+          images: @images.map(&:to_h),
+          links: @links.map(&:to_h),
+          footnotes: @footnotes.map(&:to_h),
+          attributes: @attributes
+        }
+      end
+
+      private
+
+      def parse_metadata(metadata_json)
+        JSON.parse(metadata_json)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def parse_blocks(blocks_data)
+        blocks_data.map do |block|
+          FormattedBlock.new(
+            block_type: block['block_type'] || block[:block_type] || '',
+            children: block['children'] || block[:children],
+            attributes: block['attributes'] || block[:attributes]
+          )
+        end
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def parse_images(images_data)
+        images_data.map do |image|
+          DjotImage.new(
+            url: image['url'] || image[:url] || image['src'] || image[:src],
+            alt: image['alt'] || image[:alt],
+            title: image['title'] || image[:title],
+            width: image['width'] || image[:width],
+            height: image['height'] || image[:height]
+          )
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def parse_links(links_data)
+        links_data.map do |link|
+          DjotLink.new(
+            url: link['url'] || link[:url] || link['href'] || link[:href],
+            text: link['text'] || link[:text],
+            title: link['title'] || link[:title],
+            link_type: link['link_type'] || link[:link_type]
+          )
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def parse_footnotes(footnotes_data)
+        footnotes_data.map do |note|
+          Footnote.new(
+            label: note['label'] || note[:label],
+            content: note['content'] || note[:content]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kreuzberg/document_structure.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Kreuzberg
+  class Result
+    # Structured document representation.
+    #
+    # Provides a hierarchical, tree-based representation of document content
+    # using a flat array of nodes with index-based parent/child references.
+    #
+    # @example
+    #   if result.document
+    #     result.document.nodes.each do |node|
+    #       puts "#{node.id}: #{node.content[0..50]}"
+    #     end
+    #   end
+    #
+    class DocumentStructure
+      attr_reader :nodes
+
+      def initialize(hash)
+        @nodes = parse_nodes(hash['nodes'] || hash[:nodes] || [])
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] Hash representation
+      #
+      def to_h
+        { nodes: @nodes.map(&:to_h) }
+      end
+
+      private
+
+      def parse_nodes(nodes_data)
+        return [] if nodes_data.nil? || nodes_data.empty?
+
+        nodes_data.map { |node_hash| DocumentNode.new(node_hash) }
+      end
+    end
+
+    # Single node in the document structure tree.
+    #
+    # Represents a logical unit of content with deterministic ID, content,
+    # tree structure information, and metadata.
+    #
+    class DocumentNode
+      attr_reader :id, :content, :parent, :children, :content_layer, :page, :page_end, :bbox, :annotations
+
+      def initialize(hash)
+        assign_core_fields(hash)
+        assign_tree_fields(hash)
+        assign_metadata_fields(hash)
+      end
+
+      private
+
+      def assign_core_fields(hash)
+        @id = hash['id'] || hash[:id] || ''
+        @content = hash['content'] || hash[:content] || {}
+        @content_layer = hash['content_layer'] || hash[:content_layer] || 'body'
+      end
+
+      def assign_tree_fields(hash)
+        @parent = hash['parent'] || hash[:parent]
+        @children = parse_children(hash['children'] || hash[:children] || [])
+      end
+
+      def assign_metadata_fields(hash)
+        @page = hash['page'] || hash[:page]
+        @page_end = hash['page_end'] || hash[:page_end]
+        @bbox = parse_bbox(hash['bbox'] || hash[:bbox])
+        @annotations = parse_annotations(hash['annotations'] || hash[:annotations] || [])
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] Hash representation
+      #
+      def to_h
+        {
+          id: @id,
+          content: @content,
+          parent: @parent,
+          children: @children,
+          content_layer: @content_layer,
+          page: @page,
+          page_end: @page_end,
+          bbox: @bbox&.to_h,
+          annotations: @annotations.map(&:to_h)
+        }.compact
+      end
+
+      def parse_children(children_data)
+        return [] if children_data.nil? || children_data.empty?
+
+        if children_data.is_a?(Array)
+          children_data.map { |c| extract_child_index(c) }
+        else
+          []
+        end
+      end
+
+      def extract_child_index(child)
+        if child.is_a?(Integer)
+          child
+        else
+          child['index'] || child[:index]
+        end
+      end
+
+      def parse_bbox(bbox_data)
+        return nil if bbox_data.nil?
+
+        DocumentBoundingBox.new(bbox_data)
+      end
+
+      def parse_annotations(annotations_data)
+        return [] if annotations_data.nil? || annotations_data.empty?
+
+        annotations_data.map { |ann| DocumentAnnotation.new(ann) }
+      end
+    end
+
+    # Bounding box for document node positioning.
+    #
+    # Represents rectangular coordinates for a node within the document.
+    #
+    class DocumentBoundingBox
+      attr_reader :x0, :y0, :x1, :y1
+
+      def initialize(hash)
+        @x0 = extract_float(hash, 'x0')
+        @y0 = extract_float(hash, 'y0')
+        @x1 = extract_float(hash, 'x1')
+        @y1 = extract_float(hash, 'y1')
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] Hash representation
+      #
+      def to_h
+        {
+          x0: @x0,
+          y0: @y0,
+          x1: @x1,
+          y1: @y1
+        }.compact
+      end
+
+      private
+
+      def extract_float(hash, key)
+        (hash[key] || hash[key.to_sym])&.to_f
+      end
+    end
+
+    # Annotation for a document node.
+    #
+    # Represents inline text annotations (formatting, links) with byte-range
+    # references into the node's text content.
+    #
+    class DocumentAnnotation
+      attr_reader :start, :end_offset, :annotation_type, :url, :title
+
+      def initialize(hash)
+        @start = (hash['start'] || hash[:start] || 0).to_i
+        @end_offset = (hash['end'] || hash[:end] || 0).to_i
+        parse_kind(hash['kind'] || hash[:kind] || {})
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] Hash representation
+      #
+      def to_h
+        kind_hash = { annotation_type: @annotation_type }
+        url = @url
+        kind_hash[:url] = url if url
+        title = @title
+        kind_hash[:title] = title if title
+
+        {
+          start: @start,
+          end: @end_offset,
+          kind: kind_hash
+        }
+      end
+
+      private
+
+      def parse_kind(kind_hash)
+        return if kind_hash.nil? || kind_hash.empty?
+
+        @annotation_type =
+          kind_hash['annotation_type'] ||
+          kind_hash[:annotation_type] ||
+          'bold'
+        @url = kind_hash['url'] || kind_hash[:url]
+        @title = kind_hash['title'] || kind_hash[:title]
+      end
+    end
+  end
+end

data/lib/kreuzberg/error_context.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kreuzberg
+  module ErrorContext
+    class << self
+      # @return [Integer] Error code constant (ERROR_CODE_* values), or 0 on success
+      # @example Check last error
+      def last_error_code
+        Kreuzberg._last_error_code_native
+      rescue StandardError
+        0
+      end
+
+      # Get panic context information from the last error.
+      #
+      # Returns a {Errors::PanicContext} object containing detailed information about
+      # the last panic that occurred in the Rust core. Includes file path, line number,
+      # function name, error message, and timestamp.
+      #
+      # @return [Errors::PanicContext, nil] Panic context if a panic occurred, nil otherwise
+      #
+      # @example Get panic details
+      #   panic = Kreuzberg::ErrorContext.last_panic_context
+      #   if panic
+      #     puts "Panic at #{panic.file}:#{panic.line} in #{panic.function}"
+      #     puts "Message: #{panic.message}"
+      #     puts "Time: #{panic.timestamp_secs}"
+      #   end
+      def last_panic_context
+        json_str = Kreuzberg._last_panic_context_json_native
+        return nil unless json_str
+
+        Errors::PanicContext.from_json(json_str)
+      rescue StandardError
+        nil
+      end
+
+      # Get panic context as raw JSON string.
+      #
+      # Returns the panic context information as a JSON string for raw access or
+      # custom parsing. Returns nil if no panic has occurred.
+      #
+      # @return [String, nil] JSON-serialized panic context, or nil if no panic
+      #
+      # @example Get raw JSON panic context
+      #   json = Kreuzberg::ErrorContext.last_panic_context_json
+      #   if json
+      #     panic_data = JSON.parse(json)
+      #     puts panic_data
+      #   end
+      def last_panic_context_json
+        Kreuzberg._last_panic_context_json_native
+      rescue StandardError
+        nil
+      end
+
+      # Get detailed error information from the last operation.
+      #
+      # Returns comprehensive error details including message, code, type, source location,
+      # and panic information.
+      #
+      # @return [Hash] Hash with keys: :message, :error_code, :error_type, :source_file,
+      #   :source_function, :source_line, :context_info, :is_panic
+      #
+      # @example Get error details
+      #   details = Kreuzberg::ErrorContext.error_details
+      #   puts "Error: #{details[:message]}"
+      #   puts "Code: #{details[:error_code]}"
+      #   puts "Type: #{details[:error_type]}"
+      def error_details
+        Kreuzberg._get_error_details_native
+      rescue StandardError
+        {}
+      end
+
+      # Classify an error message into a Kreuzberg error code.
+      #
+      # Analyzes an error message and returns the most likely error code (0-7).
+      # Useful for converting third-party error messages into Kreuzberg categories.
+      #
+      # @param message [String] The error message to classify
+      # @return [Integer] Error code (0-7)
+      #
+      # Error code mapping:
+      # - 0: Validation
+      # - 1: Parsing
+      # - 2: OCR
+      # - 3: MissingDependency
+      # - 4: IO
+      # - 5: Plugin
+      # - 6: UnsupportedFormat
+      # - 7: Internal
+      #
+      # @example Classify an error
+      #   code = Kreuzberg::ErrorContext.classify_error("File not found")
+      #   if code == 4
+      #     puts "This is an I/O error"
+      #   end
+      def classify_error(message)
+        Kreuzberg._classify_error_native(message)
+      rescue StandardError
+        7
+      end
+
+      # Get the human-readable name of an error code.
+      #
+      # @param code [Integer] Numeric error code (0-7)
+      # @return [String] Human-readable error code name (e.g., "validation", "io")
+      #
+      # @example Get error code name
+      #   name = Kreuzberg::ErrorContext.error_code_name(0)
+      #   puts name  # => "validation"
+      def error_code_name(code)
+        Kreuzberg._error_code_name_native(code)
+      rescue StandardError
+        'unknown'
+      end
+
+      # Get the description of an error code.
+      #
+      # @param code [Integer] Numeric error code (0-7)
+      # @return [String] Description of the error code
+      #
+      # @example Get error code description
+      #   desc = Kreuzberg::ErrorContext.error_code_description(0)
+      #   puts desc  # => "Input validation error"
+      def error_code_description(code)
+        Kreuzberg._error_code_description_native(code)
+      rescue StandardError
+        'Unknown error code'
+      end
+    end
+  end
+end

data/lib/kreuzberg/errors.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kreuzberg
+  ERROR_CODE_SUCCESS = 0
+  ERROR_CODE_GENERIC = 1
+  ERROR_CODE_PANIC = 2
+  ERROR_CODE_INVALID_ARGUMENT = 3
+  ERROR_CODE_IO = 4
+  ERROR_CODE_PARSING = 5
+  ERROR_CODE_OCR = 6
+  ERROR_CODE_MISSING_DEPENDENCY = 7
+
+  module Errors
+    class PanicContext
+      attr_reader :file, :line, :function, :message, :timestamp_secs
+
+      def initialize(file:, line:, function:, message:, timestamp_secs:)
+        @file = file
+        @line = line
+        @function = function
+        @message = message
+        @timestamp_secs = timestamp_secs
+      end
+
+      def to_s
+        "#{file}:#{line}:#{function}: #{message}"
+      end
+
+      def to_h
+        {
+          file:,
+          line:,
+          function:,
+          message:,
+          timestamp_secs:
+        }
+      end
+
+      def self.from_json(json_string)
+        return nil if json_string.nil? || json_string.empty?
+
+        data = JSON.parse(json_string, symbolize_names: true)
+        sliced = data.slice(:file, :line, :function, :message, :timestamp_secs)
+        new(**with_defaults(sliced))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def self.with_defaults(sliced)
+        {
+          file: sliced[:file] || '',
+          line: sliced[:line] || 0,
+          function: sliced[:function] || '',
+          message: sliced[:message] || '',
+          timestamp_secs: sliced[:timestamp_secs] || 0
+        }
+      end
+      private_class_method :with_defaults
+    end
+
+    # Base error class for all Kreuzberg errors
+    class Error < StandardError
+      attr_reader :panic_context, :error_code
+
+      def initialize(message, panic_context: nil, error_code: nil)
+        super(message)
+        @panic_context = panic_context
+        @error_code = error_code
+      end
+    end
+
+    # Raised when validation fails
+    class ValidationError < Error; end
+
+    # Raised when document parsing fails
+    class ParsingError < Error
+      attr_reader :context
+
+      def initialize(message, context: nil, panic_context: nil, error_code: nil)
+        super(message, panic_context:, error_code:)
+        @context = context
+      end
+    end
+
+    # Raised when OCR processing fails
+    class OCRError < Error
+      attr_reader :context
+
+      def initialize(message, context: nil, panic_context: nil, error_code: nil)
+        super(message, panic_context:, error_code:)
+        @context = context
+      end
+    end
+
+    # Raised when a required dependency is missing
+    class MissingDependencyError < Error
+      attr_reader :dependency
+
+      def initialize(message, dependency: nil, panic_context: nil, error_code: nil)
+        super(message, panic_context:, error_code:)
+        @dependency = dependency
+      end
+    end
+
+    # Raised when an I/O operation fails
+    class IOError < Error; end
+
+    # Raised when plugin operations fail
+    class PluginError < Error; end
+
+    # Raised when an unsupported file format or MIME type is encountered
+    class UnsupportedFormatError < Error; end
+  end
+end