kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/sig/kreuzberg.rbs

@@ -3,16 +3,6 @@
 module Kreuzberg
   VERSION: String
 
-  # Error code constants
-  ERROR_CODE_SUCCESS: Integer
-  ERROR_CODE_GENERIC: Integer
-  ERROR_CODE_PANIC: Integer
-  ERROR_CODE_INVALID_ARGUMENT: Integer
-  ERROR_CODE_IO: Integer
-  ERROR_CODE_PARSING: Integer
-  ERROR_CODE_OCR: Integer
-  ERROR_CODE_MISSING_DEPENDENCY: Integer
-
   # Config namespace (defined in lib/kreuzberg/config.rb)
   module Config
     class OCR
@@ -74,21 +64,12 @@ module Kreuzberg
       def to_h: () -> Hash[Symbol, untyped]
     end
 
-    class FontConfig
-      attr_accessor enabled: bool
-      attr_accessor custom_font_dirs: Array[String]?
-
-      def initialize: (?enabled: bool, ?custom_font_dirs: Array[String]?) -> void
-      def to_h: () -> Hash[Symbol, untyped]
-    end
-
     class PDF
       attr_reader extract_images: bool
       attr_reader passwords: Array[String]?
       attr_reader extract_metadata: bool
-      attr_reader font_config: FontConfig?
 
-      def initialize: (?extract_images: bool, ?passwords: (Array[String] | String)?, ?extract_metadata: bool, ?font_config: (FontConfig | Hash[Symbol, untyped])?) -> void
+      def initialize: (?extract_images: bool, ?passwords: (Array[String] | String)?, ?extract_metadata: bool) -> void
       def to_h: () -> Hash[Symbol, untyped]
     end
 
@@ -177,15 +158,6 @@ module Kreuzberg
       def to_h: () -> Hash[Symbol, untyped]
     end
 
-    class PageConfig
-      attr_reader extract_pages: bool
-      attr_reader insert_page_markers: bool
-      attr_reader marker_format: String
-
-      def initialize: (?extract_pages: bool, ?insert_page_markers: bool, ?marker_format: String) -> void
-      def to_h: () -> Hash[Symbol, untyped]
-    end
-
     class Extraction
       attr_reader use_cache: bool
       attr_reader enable_quality_processing: bool
@@ -200,7 +172,6 @@ module Kreuzberg
       attr_reader token_reduction: TokenReduction?
       attr_reader keywords: Keywords?
       attr_reader html_options: HtmlOptions?
-      attr_reader pages: PageConfig?
       attr_reader max_concurrent_extractions: Integer?
 
       def self.from_file: (String path) -> Extraction
@@ -218,7 +189,6 @@ module Kreuzberg
         ?token_reduction: (TokenReduction | Hash[Symbol, untyped])?,
         ?keywords: (Keywords | Hash[Symbol, untyped])?,
         ?html_options: (HtmlOptions | Hash[Symbol, untyped])?,
-        ?pages: (PageConfig | Hash[Symbol, untyped])?,
         ?max_concurrent_extractions: Integer?
       ) -> void
       def to_h: () -> Hash[Symbol, untyped]
@@ -228,20 +198,13 @@ module Kreuzberg
       def normalize_config: [T] (T | Hash[Symbol, untyped] | nil value, Class klass) -> T?
     end
 
+    # Backwards compatibility alias
+    Ocr: singleton(OCR)
   end
 
   # Alias for Config::Extraction (for API consistency with other language bindings)
   ExtractionConfig: singleton(Config::Extraction)
 
-  # Alias for Config::PageConfig (for API consistency with other language bindings)
-  PageConfig: singleton(Config::PageConfig)
-
-  # Keyword algorithm constants
-  module KeywordAlgorithm
-    YAKE: Symbol
-    RAKE: Symbol
-  end
-
   # Extraction result type
   type extraction_result_hash = {
     content: String,
@@ -261,13 +224,11 @@ module Kreuzberg
 
   type chunk_hash = {
     content: String,
-    byte_start: Integer,
-    byte_end: Integer,
+    char_start: Integer,
+    char_end: Integer,
     token_count: Integer?,
     chunk_index: Integer?,
     total_chunks: Integer?,
-    first_page: Integer?,
-    last_page: Integer?,
     embedding: Array[Float]?
   }
 
@@ -307,24 +268,20 @@ module Kreuzberg
     # Text chunk
     class Chunk
       attr_reader content: String
-      attr_reader byte_start: Integer
-      attr_reader byte_end: Integer
+      attr_reader char_start: Integer
+      attr_reader char_end: Integer
       attr_reader token_count: Integer?
       attr_reader chunk_index: Integer?
       attr_reader total_chunks: Integer?
-      attr_reader first_page: Integer?
-      attr_reader last_page: Integer?
       attr_reader embedding: Array[Float]?
 
       def initialize: (
         content: String,
-        byte_start: Integer,
-        byte_end: Integer,
+        char_start: Integer,
+        char_end: Integer,
         token_count: Integer?,
         chunk_index: Integer?,
         total_chunks: Integer?,
-        first_page: Integer?,
-        last_page: Integer?,
         embedding: Array[Float]?
       ) -> void
       def to_h: () -> chunk_hash
@@ -434,14 +391,6 @@ module Kreuzberg
   # Config loading (native method)
   def self._config_from_file_native: (String path) -> Hash[Symbol, untyped]
 
-  # Error introspection (native methods)
-  def self._last_error_code_native: () -> Integer
-  def self._last_panic_context_json_native: () -> String?
-  def self._get_error_details_native: () -> Hash[Symbol, untyped]
-  def self._classify_error_native: (String message) -> Integer
-  def self._error_code_name_native: (Integer code) -> String
-  def self._error_code_description_native: (Integer code) -> String
-
   # Plugin registration
   def self.register_post_processor: (String name, _PostProcessor processor, ?stage: Symbol?) -> void
   def self.unregister_post_processor: (String name) -> void
@@ -464,67 +413,25 @@ module Kreuzberg
     def extract_text: (String file_path_or_bytes, Hash[Symbol, untyped] config) -> String
   end
 
-  module ErrorContext
-    def self.last_error_code: () -> Integer
-    def self.last_panic_context: () -> Errors::PanicContext?
-    def self.last_panic_context_json: () -> String?
-    def self.error_details: () -> Hash[Symbol, untyped]
-    def self.classify_error: (String message) -> Integer
-    def self.error_code_name: (Integer code) -> String
-    def self.error_code_description: (Integer code) -> String
-  end
-
   module Errors
-    # Panic context information from FFI error introspection
-    class PanicContext
-      attr_reader file: String
-      attr_reader line: Integer
-      attr_reader function: String
-      attr_reader message: String
-      attr_reader timestamp_secs: Integer
-
-      def initialize: (
-        file: String,
-        line: Integer,
-        function: String,
-        message: String,
-        timestamp_secs: Integer
-      ) -> void
-      def to_s: () -> String
-      def to_h: () -> Hash[Symbol, String | Integer]
-      def self.from_json: (String) -> PanicContext?
-
-      private
-
-      def self.with_defaults: (Hash[Symbol, untyped] sliced) -> {file: String, line: Integer, function: String, message: String, timestamp_secs: Integer}
-    end
-
     class Error < StandardError
-      attr_reader panic_context: PanicContext?
-      attr_reader error_code: Integer?
-
-      def initialize: (String message, ?panic_context: PanicContext?, ?error_code: Integer?) -> void
     end
 
     class ValidationError < Error
     end
 
     class ParsingError < Error
-      attr_reader context: Hash[untyped, untyped]?
-
-      def initialize: (String message, ?context: Hash[untyped, untyped]?, ?panic_context: PanicContext?, ?error_code: Integer?) -> void
+      def initialize: (String message, ?context: Hash[untyped, untyped]?) -> void
     end
 
     class OCRError < Error
-      attr_reader context: Hash[untyped, untyped]?
-
-      def initialize: (String message, ?context: Hash[untyped, untyped]?, ?panic_context: PanicContext?, ?error_code: Integer?) -> void
+      def initialize: (String message, ?context: Hash[untyped, untyped]?) -> void
     end
 
     class MissingDependencyError < Error
       attr_reader dependency: String?
 
-      def initialize: (String message, ?dependency: String?, ?panic_context: PanicContext?, ?error_code: Integer?) -> void
+      def initialize: (String message, ?dependency: String?) -> void
     end
 
     class IOError < Error

data/spec/binding/cache_spec.rb

@@ -19,8 +19,8 @@ RSpec.describe 'Cache Management' do
 
   describe 'clear_cache' do
     it 'removes all cached results' do
-      Kreuzberg.extract_file_sync(path: test_pdf)
-      Kreuzberg.extract_file_sync(path: test_text)
+      Kreuzberg.extract_file_sync(test_pdf)
+      Kreuzberg.extract_file_sync(test_text)
 
       stats_before = Kreuzberg.cache_stats
       expect(stats_before['total_entries']).to be_positive
@@ -47,10 +47,10 @@ RSpec.describe 'Cache Management' do
     end
 
     it 'does not affect future extractions' do
-      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(test_pdf)
       Kreuzberg.clear_cache
 
-      result = Kreuzberg.extract_file_sync(path: test_pdf)
+      result = Kreuzberg.extract_file_sync(test_pdf)
 
       expect(result).to be_a(Kreuzberg::Result)
       expect(result.content).not_to be_empty
@@ -77,7 +77,7 @@ RSpec.describe 'Cache Management' do
     it 'shows entries after extractions' do
       Kreuzberg.clear_cache
 
-      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(test_pdf)
       stats = Kreuzberg.cache_stats
 
       expect(stats['total_entries']).to be_positive
@@ -86,7 +86,7 @@ RSpec.describe 'Cache Management' do
     it 'shows total size in bytes' do
       Kreuzberg.clear_cache
 
-      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(test_pdf)
       stats = Kreuzberg.cache_stats
 
       expect(stats['total_size_bytes']).to be_positive
@@ -95,10 +95,10 @@ RSpec.describe 'Cache Management' do
     it 'increases stats with multiple extractions' do
       Kreuzberg.clear_cache
 
-      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(test_pdf)
       stats_after_one = Kreuzberg.cache_stats
 
-      Kreuzberg.extract_file_sync(path: test_text)
+      Kreuzberg.extract_file_sync(test_text)
       stats_after_two = Kreuzberg.cache_stats
 
       expect(stats_after_two['total_entries']).to be >= stats_after_one['total_entries']
@@ -111,11 +111,11 @@ RSpec.describe 'Cache Management' do
       stats_initial = Kreuzberg.cache_stats
       expect(stats_initial['total_entries']).to eq(0)
 
-      result1 = Kreuzberg.extract_file_sync(path: test_pdf)
+      result1 = Kreuzberg.extract_file_sync(test_pdf)
       stats_after_first = Kreuzberg.cache_stats
       expect(stats_after_first['total_entries']).to be_positive
 
-      result2 = Kreuzberg.extract_file_sync(path: test_pdf)
+      result2 = Kreuzberg.extract_file_sync(test_pdf)
       stats_after_second = Kreuzberg.cache_stats
 
       expect(result1.content).to eq(result2.content)
@@ -125,10 +125,10 @@ RSpec.describe 'Cache Management' do
     it 'tracks different files separately' do
       Kreuzberg.clear_cache
 
-      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(test_pdf)
       stats_after_pdf = Kreuzberg.cache_stats
 
-      Kreuzberg.extract_file_sync(path: test_text)
+      Kreuzberg.extract_file_sync(test_text)
       stats_after_text = Kreuzberg.cache_stats
 
       expect(stats_after_text['total_entries']).to be >= stats_after_pdf['total_entries']
@@ -138,11 +138,11 @@ RSpec.describe 'Cache Management' do
       Kreuzberg.clear_cache
 
       Time.now
-      result1 = Kreuzberg.extract_file_sync(path: test_pdf)
+      result1 = Kreuzberg.extract_file_sync(test_pdf)
       Time.now
 
       Time.now
-      result2 = Kreuzberg.extract_file_sync(path: test_pdf)
+      result2 = Kreuzberg.extract_file_sync(test_pdf)
       Time.now
 
       expect(result1.content).to eq(result2.content)
@@ -150,11 +150,11 @@ RSpec.describe 'Cache Management' do
     end
 
     it 'clears cache between extractions when requested' do
-      result1 = Kreuzberg.extract_file_sync(path: test_pdf)
+      result1 = Kreuzberg.extract_file_sync(test_pdf)
 
       Kreuzberg.clear_cache
 
-      result2 = Kreuzberg.extract_file_sync(path: test_pdf)
+      result2 = Kreuzberg.extract_file_sync(test_pdf)
 
       expect(result1.content).to eq(result2.content)
     end
@@ -167,10 +167,10 @@ RSpec.describe 'Cache Management' do
       config1 = Kreuzberg::Config::Extraction.new(use_cache: true)
       config2 = Kreuzberg::Config::Extraction.new(use_cache: false)
 
-      Kreuzberg.extract_file_sync(path: test_pdf, config: config1)
+      Kreuzberg.extract_file_sync(test_pdf, config: config1)
       stats_after_first = Kreuzberg.cache_stats
 
-      Kreuzberg.extract_file_sync(path: test_pdf, config: config2)
+      Kreuzberg.extract_file_sync(test_pdf, config: config2)
       stats_after_second = Kreuzberg.cache_stats
 
       expect(stats_after_second['total_entries']).to eq(stats_after_first['total_entries'])
@@ -179,8 +179,8 @@ RSpec.describe 'Cache Management' do
 
   describe 'cache stats consistency' do
     it 'stats remain consistent after clear' do
-      Kreuzberg.extract_file_sync(path: test_pdf)
-      Kreuzberg.extract_file_sync(path: test_text)
+      Kreuzberg.extract_file_sync(test_pdf)
+      Kreuzberg.extract_file_sync(test_text)
 
       Kreuzberg.clear_cache
       stats = Kreuzberg.cache_stats
@@ -192,12 +192,12 @@ RSpec.describe 'Cache Management' do
     it 'stats update correctly after new extractions' do
       Kreuzberg.clear_cache
 
-      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(test_pdf)
       Kreuzberg.cache_stats
 
       Kreuzberg.clear_cache
 
-      Kreuzberg.extract_file_sync(path: test_text)
+      Kreuzberg.extract_file_sync(test_text)
       stats2 = Kreuzberg.cache_stats
 
       expect(stats2['total_entries']).to be_positive

data/spec/binding/cli_proxy_spec.rb

@@ -3,7 +3,8 @@
 RSpec.describe Kreuzberg::CLIProxy do
   describe '.find_cli_binary' do
     context 'when binary exists' do
-      it 'finds the binary in search paths' do
+      it 'finds the binary in search paths', :skip do
+        # Skip in CI/test environments where binary might not be built
         binary = described_class.find_cli_binary
         expect(binary).to be_a(Pathname)
         expect(binary.file?).to be true
@@ -24,8 +25,9 @@ RSpec.describe Kreuzberg::CLIProxy do
   end
 
   describe '.call' do
-    context 'when binary is available' do
+    context 'when binary is available', :skip do
       it 'executes CLI command successfully' do
+        # Skip in environments without built binary
         output = described_class.call(['--version'])
         expect(output).to be_a(String)
         expect(output).not_to be_empty

data/spec/binding/cli_spec.rb

@@ -1,35 +1,34 @@
 # frozen_string_literal: true
 
 RSpec.describe Kreuzberg::CLI do
-  describe '.extract' do
+  describe '.extract', :skip do
     it 'extracts content from a file' do
-      path = test_document_path('documents/simple.odt')
+      # Skip in environments without CLI binary
+      path = create_test_file('CLI test content')
       output = described_class.extract(path)
 
       expect(output).to be_a(String)
-      expect(output).not_to be_empty
+      expect(output).to include('CLI test content')
     end
 
     it 'accepts output format option' do
-      path = test_document_path('documents/simple.odt')
+      path = create_test_file('JSON output test')
       output = described_class.extract(path, output: 'json')
 
       expect(output).to be_a(String)
-      expect(output).not_to be_empty
     end
 
     it 'accepts OCR option' do
-      path = test_document_path('pdfs/100_g_networking_technology_overview_slides_toronto_august_2016.pdf')
-      output = described_class.extract(path, ocr: false)
+      path = create_test_file('OCR test')
+      output = described_class.extract(path, ocr: true)
 
       expect(output).to be_a(String)
-      expect(output).not_to be_empty
     end
   end
 
-  describe '.detect' do
+  describe '.detect', :skip do
     it 'detects MIME type' do
-      path = test_document_path('documents/simple.odt')
+      path = create_test_file('MIME detection test')
       mime_type = described_class.detect(path)
 
       expect(mime_type).to be_a(String)
@@ -37,7 +36,7 @@ RSpec.describe Kreuzberg::CLI do
     end
   end
 
-  describe '.version' do
+  describe '.version', :skip do
     it 'returns version string' do
       version = described_class.version
       expect(version).to be_a(String)
@@ -45,7 +44,7 @@ RSpec.describe Kreuzberg::CLI do
     end
   end
 
-  describe '.help' do
+  describe '.help', :skip do
     it 'returns help text' do
       help_text = described_class.help
       expect(help_text).to be_a(String)

data/spec/binding/config_spec.rb

@@ -86,47 +86,6 @@ RSpec.describe Kreuzberg::Config do
     end
   end
 
-  describe Kreuzberg::Config::FontConfig do
-    it 'creates with default values' do
-      font_config = described_class.new
-
-      expect(font_config.enabled).to be true
-      expect(font_config.custom_font_dirs).to be_nil
-    end
-
-    it 'creates with custom values' do
-      dirs = ['/usr/share/fonts', '/home/user/.fonts']
-      font_config = described_class.new(
-        enabled: false,
-        custom_font_dirs: dirs
-      )
-
-      expect(font_config.enabled).to be false
-      expect(font_config.custom_font_dirs).to eq(dirs)
-    end
-
-    it 'converts to hash' do
-      dirs = ['/usr/share/fonts']
-      font_config = described_class.new(
-        enabled: true,
-        custom_font_dirs: dirs
-      )
-      hash = font_config.to_h
-
-      expect(hash).to be_a(Hash)
-      expect(hash[:enabled]).to be true
-      expect(hash[:custom_font_dirs]).to eq(dirs)
-    end
-
-    it 'compacts nil values in hash' do
-      font_config = described_class.new(enabled: true)
-      hash = font_config.to_h
-
-      expect(hash).to be_a(Hash)
-      expect(hash.key?(:custom_font_dirs)).to be false
-    end
-  end
-
   describe Kreuzberg::Config::PDF do
     it 'creates with default values' do
       pdf = described_class.new
@@ -134,7 +93,6 @@ RSpec.describe Kreuzberg::Config do
       expect(pdf.extract_images).to be false
       expect(pdf.passwords).to be_nil
       expect(pdf.extract_metadata).to be true
-      expect(pdf.font_config).to be_nil
     end
 
     it 'creates with custom values' do
@@ -147,23 +105,6 @@ RSpec.describe Kreuzberg::Config do
       expect(pdf.passwords).to eq(%w[secret backup])
     end
 
-    it 'creates with font_config as instance' do
-      font_config = Kreuzberg::Config::FontConfig.new(enabled: true)
-      pdf = described_class.new(font_config: font_config)
-
-      expect(pdf.font_config).to be_a(Kreuzberg::Config::FontConfig)
-      expect(pdf.font_config.enabled).to be true
-    end
-
-    it 'creates with font_config as hash' do
-      font_config_hash = { enabled: false, custom_font_dirs: ['/fonts'] }
-      pdf = described_class.new(font_config: font_config_hash)
-
-      expect(pdf.font_config).to be_a(Kreuzberg::Config::FontConfig)
-      expect(pdf.font_config.enabled).to be false
-      expect(pdf.font_config.custom_font_dirs).to eq(['/fonts'])
-    end
-
     it 'converts to hash' do
       pdf = described_class.new(extract_images: true, passwords: ['test'])
       hash = pdf.to_h
@@ -172,21 +113,6 @@ RSpec.describe Kreuzberg::Config do
       expect(hash[:extract_images]).to be true
       expect(hash[:passwords]).to eq(['test'])
     end
-
-    it 'includes font_config in hash when present' do
-      font_config = Kreuzberg::Config::FontConfig.new(enabled: true)
-      pdf = described_class.new(font_config: font_config)
-      hash = pdf.to_h
-
-      expect(hash[:font_config]).to be_a(Hash)
-      expect(hash[:font_config][:enabled]).to be true
-    end
-
-    it 'raises error with invalid font_config type' do
-      expect do
-        described_class.new(font_config: 'invalid')
-      end.to raise_error(ArgumentError)
-    end
   end
 
   describe Kreuzberg::Config::Extraction do