tree_sitter_language_pack 1.6.2-aarch64-linux → 1.8.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95f119e809729eb6b4ac0ea5d504587098a8e2704ad98bafa25e5132f48b2186
-  data.tar.gz: 2663d7c69607f686fc12bd5e29cd81b8de649e9c54bfb644d8a3113c966a238d
+  metadata.gz: 2e72dc0757d8ce3712c76c57520f8d46df9da350bffcb31cbbc038726313d256
+  data.tar.gz: 5632e0484c40c1bfc535cdf1680c8013f3ac85fc7fb000f0393229c9c0237306
 SHA512:
-  metadata.gz: 2255dfcd30617901786e57a4ab5e095708878896d76e6bcdcd6126bb664b0240f8960b272da60061e3a3628cdfb116d89a885d91897355f60d5fccedf662fbfe
-  data.tar.gz: d531ea83ca585d66b9a6abd95c3032f0601927afa4a649351755550ea0489069d5cb2f075bc48ea877116f8ae0905ea3d5a75dc455346c81c4a0212edeac8069
+  metadata.gz: 806edc514539455973c47f17c78c9a58862a399412323aa861aa2867d9f5a4a44ca9c154adce10cc8109a7d10583c31b189851331b1a09b26db8f47e5a4c66dc
+  data.tar.gz: 37ed38d03056faa12b112999b19c3ea546ae0f15f9ae7f5ce8edb47ced63c32460c2857da3d94d604b27587c2ddeb80955cb9cf0b8b4748b0759823c057fdbdb

data/Steepfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+target :lib do
+  signature 'sig'
+  check 'lib'
+end

data/lib/tree_sitter_language_pack/native.rb

@@ -0,0 +1,46 @@
+# This file is auto-generated by alef — DO NOT EDIT.
+# alef:hash:f1cee06ff8900ef2d958db4c1c0a5cb8d233243dfa3834f678c826f070dc817d
+# To regenerate: alef generate
+# To verify freshness: alef verify --exit-code
+# Issues & docs: https://github.com/kreuzberg-dev/alef
+# frozen_string_literal: true
+
+require 'json'
+require 'ts_pack_core_rb'
+
+# Add accessor methods to Hash-based internally-tagged enum instances
+class Hash
+  # Support internally-tagged enum accessors like format.excel, format.email, etc.
+  # Also support direct field access like format.sheet_count
+  # rubocop:disable Metrics/CyclomaticComplexity
+  def method_missing(method_name, *args, &)
+    # Try symbol key first (how Magnus converts JSON keys)
+    return self[method_name] if key?(method_name)
+
+    # Try string key
+    return self[method_name.to_s] if key?(method_name.to_s)
+
+    # Check if this hash has a 'format_type' field (indicating an internally-tagged enum)
+    format_type = self[:format_type] || self['format_type']
+    return super unless format_type
+
+    # If the method name matches the format_type (snake_case), extract and return the variant's wrapped data
+    # Internally-tagged enums store variant data in the '_0' field (from alef's struct variant conversion)
+    # This allows format.excel to return the ExcelMetadata hash with sheet_count, sheet_names, etc.
+    snake_case_method = method_name.to_s.downcase
+    return self[:_0] || self['_0'] || self if snake_case_method == format_type.to_s.downcase
+
+    super
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+
+  def respond_to_missing?(method_name, include_private = false)
+    return true if key?(method_name) || key?(method_name.to_s)
+
+    format_type = self[:format_type] || self['format_type']
+    return false unless format_type
+
+    snake_case_method = method_name.to_s.downcase
+    snake_case_method == format_type.to_s.downcase || super
+  end
+end

data/lib/tree_sitter_language_pack/version.rb

@@ -0,0 +1,10 @@
+# This file is auto-generated by alef — DO NOT EDIT.
+# alef:hash:2780c47ba4a676fb85ddbc11c9e7bb4f659e63c0b90affd517b29c7cde7a84aa
+# To regenerate: alef generate
+# To verify freshness: alef verify --exit-code
+# Issues & docs: https://github.com/kreuzberg-dev/alef
+# frozen_string_literal: true
+
+module TreeSitterLanguagePack
+  VERSION = '1.8.0'
+end

data/lib/tree_sitter_language_pack.rb

@@ -1,7 +1,13 @@
+# This file is auto-generated by alef — DO NOT EDIT.
+# alef:hash:d6b009b67f6b2b81396e42b3a3a93d5a0ad50e680621fbda45fed6329de157df
+# To regenerate: alef generate
+# To verify freshness: alef verify --exit-code
+# Issues & docs: https://github.com/kreuzberg-dev/alef
 # frozen_string_literal: true
 
-require_relative 'tree_sitter_language_pack/ts_pack_ruby'
+require_relative 'tree_sitter_language_pack/version'
+require_relative 'tree_sitter_language_pack/native'
 
-# Ruby bindings for the tree-sitter language pack.
 module TreeSitterLanguagePack
+  # Re-export all types and functions from native extension
 end

data/sig/types.rbs

@@ -0,0 +1,433 @@
+# This file is auto-generated by alef — DO NOT EDIT.
+# alef:hash:3cbc9b7f5a084fe4fe656040ca379c3bbdd7a966ad4403cba58d0411a75cce07
+# To regenerate: alef generate
+# To verify freshness: alef verify --exit-code
+# Issues & docs: https://github.com/kreuzberg-dev/alef
+
+module TreeSitterLanguagePack
+
+  VERSION: String
+
+  class Span
+    # Byte and line/column range in source code.
+    #
+    # Represents both byte offsets (for slicing) and human-readable line/column
+    # positions (for display and diagnostics).
+
+    attr_accessor start_byte: Integer?
+    attr_accessor end_byte: Integer?
+    attr_accessor start_line: Integer?
+    attr_accessor start_column: Integer?
+    attr_accessor end_line: Integer?
+    attr_accessor end_column: Integer?
+
+    def initialize: (start_byte: Integer, end_byte: Integer, start_line: Integer, start_column: Integer, end_line: Integer, end_column: Integer) -> void
+  end
+
+  class ProcessResult
+    # Complete analysis result from processing a source file.
+    #
+    # Contains metrics, structural analysis, imports/exports, comments,
+    # docstrings, symbols, diagnostics, and optionally chunked code segments.
+    # Fields are populated based on the `ProcessConfig` flags.
+    #
+    # # Fields
+    #
+    # - `language` - The language used for parsing
+    # - `metrics` - Always computed: line counts, byte sizes, error counts
+    # - `structure` - Functions, classes, structs (when `config.structure = true`)
+    # - `imports` - Import statements (when `config.imports = true`)
+    # - `exports` - Export statements (when `config.exports = true`)
+    # - `comments` - Comments (when `config.comments = true`)
+    # - `docstrings` - Docstrings (when `config.docstrings = true`)
+    # - `symbols` - Symbol definitions (when `config.symbols = true`)
+    # - `diagnostics` - Parse errors (when `config.diagnostics = true`)
+    # - `chunks` - Chunked code segments (when `config.chunk_max_size` is set)
+
+    attr_accessor language: String?
+    attr_accessor metrics: FileMetrics?
+    attr_accessor structure: Array[StructureItem]?
+    attr_accessor imports: Array[ImportInfo]?
+    attr_accessor exports: Array[ExportInfo]?
+    attr_accessor comments: Array[CommentInfo]?
+    attr_accessor docstrings: Array[DocstringInfo]?
+    attr_accessor symbols: Array[SymbolInfo]?
+    attr_accessor diagnostics: Array[Diagnostic]?
+    attr_accessor chunks: Array[CodeChunk]?
+
+    def initialize: (language: String, metrics: FileMetrics, structure: Array[StructureItem], imports: Array[ImportInfo], exports: Array[ExportInfo], comments: Array[CommentInfo], docstrings: Array[DocstringInfo], symbols: Array[SymbolInfo], diagnostics: Array[Diagnostic], chunks: Array[CodeChunk]) -> void
+  end
+
+  class FileMetrics
+    # Aggregate metrics for a source file.
+
+    attr_accessor total_lines: Integer?
+    attr_accessor code_lines: Integer?
+    attr_accessor comment_lines: Integer?
+    attr_accessor blank_lines: Integer?
+    attr_accessor total_bytes: Integer?
+    attr_accessor node_count: Integer?
+    attr_accessor error_count: Integer?
+    attr_accessor max_depth: Integer?
+
+    def initialize: (total_lines: Integer, code_lines: Integer, comment_lines: Integer, blank_lines: Integer, total_bytes: Integer, node_count: Integer, error_count: Integer, max_depth: Integer) -> void
+  end
+
+  class StructureItem
+    # A structural item (function, class, struct, etc.) in source code.
+
+    attr_accessor kind: StructureKind?
+    attr_accessor name: String?
+    attr_accessor visibility: String?
+    attr_accessor span: Span?
+    attr_accessor children: Array[StructureItem]?
+    attr_accessor decorators: Array[String]?
+    attr_accessor doc_comment: String?
+    attr_accessor signature: String?
+    attr_accessor body_span: Span?
+
+    def initialize: (kind: StructureKind, ?name: String, ?visibility: String, span: Span, children: Array[StructureItem], decorators: Array[String], ?doc_comment: String, ?signature: String, ?body_span: Span) -> void
+  end
+
+  class CommentInfo
+    # A comment extracted from source code.
+
+    attr_accessor text: String?
+    attr_accessor kind: CommentKind?
+    attr_accessor span: Span?
+    attr_accessor associated_node: String?
+
+    def initialize: (text: String, kind: CommentKind, span: Span, ?associated_node: String) -> void
+  end
+
+  class DocstringInfo
+    # A docstring extracted from source code.
+
+    attr_accessor text: String?
+    attr_accessor format: DocstringFormat?
+    attr_accessor span: Span?
+    attr_accessor associated_item: String?
+    attr_accessor parsed_sections: Array[DocSection]?
+
+    def initialize: (text: String, format: DocstringFormat, span: Span, ?associated_item: String, parsed_sections: Array[DocSection]) -> void
+  end
+
+  class DocSection
+    # A section within a docstring (e.g., Args, Returns, Raises).
+
+    attr_accessor kind: String?
+    attr_accessor name: String?
+    attr_accessor description: String?
+
+    def initialize: (kind: String, ?name: String, description: String) -> void
+  end
+
+  class ImportInfo
+    # An import statement extracted from source code.
+
+    attr_accessor source: String?
+    attr_accessor items: Array[String]?
+    attr_accessor alias: String?
+    attr_accessor is_wildcard: bool?
+    attr_accessor span: Span?
+
+    def initialize: (source: String, items: Array[String], ?alias: String, is_wildcard: bool, span: Span) -> void
+  end
+
+  class ExportInfo
+    # An export statement extracted from source code.
+
+    attr_accessor name: String?
+    attr_accessor kind: ExportKind?
+    attr_accessor span: Span?
+
+    def initialize: (name: String, kind: ExportKind, span: Span) -> void
+  end
+
+  class SymbolInfo
+    # A symbol (variable, function, type, etc.) extracted from source code.
+
+    attr_accessor name: String?
+    attr_accessor kind: SymbolKind?
+    attr_accessor span: Span?
+    attr_accessor type_annotation: String?
+    attr_accessor doc: String?
+
+    def initialize: (name: String, kind: SymbolKind, span: Span, ?type_annotation: String, ?doc: String) -> void
+  end
+
+  class Diagnostic
+    # A diagnostic (syntax error, missing node, etc.) from parsing.
+
+    attr_accessor message: String?
+    attr_accessor severity: DiagnosticSeverity?
+    attr_accessor span: Span?
+
+    def initialize: (message: String, severity: DiagnosticSeverity, span: Span) -> void
+  end
+
+  class CodeChunk
+    # A chunk of source code with rich metadata.
+
+    attr_accessor content: String?
+    attr_accessor start_byte: Integer?
+    attr_accessor end_byte: Integer?
+    attr_accessor start_line: Integer?
+    attr_accessor end_line: Integer?
+    attr_accessor metadata: ChunkContext?
+
+    def initialize: (content: String, start_byte: Integer, end_byte: Integer, start_line: Integer, end_line: Integer, metadata: ChunkContext) -> void
+  end
+
+  class ChunkContext
+    # Metadata for a single chunk of source code.
+
+    attr_accessor language: String?
+    attr_accessor chunk_index: Integer?
+    attr_accessor total_chunks: Integer?
+    attr_accessor node_types: Array[String]?
+    attr_accessor context_path: Array[String]?
+    attr_accessor symbols_defined: Array[String]?
+    attr_accessor comments: Array[CommentInfo]?
+    attr_accessor docstrings: Array[DocstringInfo]?
+    attr_accessor has_error_nodes: bool?
+
+    def initialize: (language: String, chunk_index: Integer, total_chunks: Integer, node_types: Array[String], context_path: Array[String], symbols_defined: Array[String], comments: Array[CommentInfo], docstrings: Array[DocstringInfo], has_error_nodes: bool) -> void
+  end
+
+  class PackConfig
+    # Configuration for the tree-sitter language pack.
+    #
+    # Controls cache directory and which languages to pre-download.
+    # Can be loaded from a TOML file, constructed programmatically,
+    # or passed as a dict/object from language bindings.
+    #
+    # # Example
+    #
+    # ```no_run
+    # use tree_sitter_language_pack::PackConfig;
+    #
+    # let config = PackConfig {
+    #     cache_dir: None,
+    #     languages: Some(vec!["python".to_string(), "rust".to_string()]),
+    #     groups: None,
+    # };
+    # ```
+
+    attr_accessor cache_dir: String?
+    attr_accessor languages: Array[String]?
+    attr_accessor groups: Array[String]?
+
+    def initialize: (?cache_dir: String, ?languages: Array[String], ?groups: Array[String]) -> void
+    def self.from_toml_file: (String path) -> PackConfig
+    def self.discover: () -> PackConfig?
+  end
+
+  class ProcessConfig
+    # Configuration for the `process()` function.
+    #
+    # Controls which analysis features are enabled and whether chunking is performed.
+    #
+    # # Examples
+    #
+    # ```
+    # use tree_sitter_language_pack::ProcessConfig;
+    #
+    # // Defaults: structure + imports + exports enabled
+    # let config = ProcessConfig::new("python");
+    #
+    # // With chunking
+    # let config = ProcessConfig::new("python").with_chunking(1000);
+    #
+    # // Everything enabled
+    # let config = ProcessConfig::new("python").all();
+    # ```
+
+    attr_accessor language: String?
+    attr_accessor structure: bool?
+    attr_accessor imports: bool?
+    attr_accessor exports: bool?
+    attr_accessor comments: bool?
+    attr_accessor docstrings: bool?
+    attr_accessor symbols: bool?
+    attr_accessor diagnostics: bool?
+    attr_accessor chunk_max_size: Integer?
+
+    def initialize: (language: String, structure: bool, imports: bool, exports: bool, comments: bool, docstrings: bool, symbols: bool, diagnostics: bool, ?chunk_max_size: Integer) -> void
+    def with_chunking: (Integer max_size) -> ProcessConfig
+    def all: () -> ProcessConfig
+    def minimal: () -> ProcessConfig
+    def self.default: () -> ProcessConfig
+  end
+
+  class LanguageRegistry
+    # Thread-safe registry of tree-sitter language parsers.
+    #
+    # Manages both statically compiled and dynamically loaded language grammars.
+    # Use [`LanguageRegistry::new()`] for the default registry, or access the
+    # global instance via the module-level convenience functions
+    # (`get_language`, `available_languages`, etc.).
+    #
+    # # Example
+    #
+    # ```no_run
+    # use tree_sitter_language_pack::{LanguageRegistry, ProcessConfig};
+    #
+    # let registry = LanguageRegistry::new();
+    # let langs = registry.available_languages();
+    # println!("Available: {:?}", langs);
+    #
+    # let config = ProcessConfig::new("python").all();
+    # let result = registry.process("def hello(): pass", &config).unwrap();
+    # println!("Structure: {:?}", result.structure);
+    # ```
+
+    def add_extra_libs_dir: (String dir) -> void
+    def get_language: (String name) -> Language
+    def available_languages: () -> Array[String]
+    def has_language: (String name) -> bool
+    def language_count: () -> Integer
+    def process: (String source, ProcessConfig config) -> ProcessResult
+    def self.with_libs_dir: (String libs_dir) -> LanguageRegistry
+    def self.default: () -> LanguageRegistry
+  end
+
+  class ParserManifest
+    # Manifest describing available parser downloads for a specific version.
+
+    attr_reader version: String
+    attr_reader platforms: Hash[String, PlatformBundle]
+    attr_reader languages: Hash[String, LanguageInfo]
+    attr_reader groups: Hash[String, Array[String]]
+
+    def initialize: (version: String, platforms: Hash[String, PlatformBundle], languages: Hash[String, LanguageInfo], groups: Hash[String, Array[String]]) -> void
+  end
+
+  class PlatformBundle
+    attr_reader url: String
+    attr_reader sha256: String
+    attr_reader size: Integer
+
+    def initialize: (url: String, sha256: String, size: Integer) -> void
+  end
+
+  class LanguageInfo
+    attr_reader group: String
+    attr_reader size: Integer
+
+    def initialize: (group: String, size: Integer) -> void
+  end
+
+  class DownloadManager
+    # Manages downloading and caching of pre-built parser shared libraries.
+
+    def cache_dir: () -> String
+    def installed_languages: () -> Array[String]
+    def ensure_languages: (Array[String] names) -> void
+    def ensure_group: (String group) -> void
+    def lib_path: (String name) -> String
+    def fetch_manifest: () -> ParserManifest
+    def download_all_best_effort: () -> Integer
+    def clean_cache: () -> void
+    def self.new: (String version) -> DownloadManager
+    def self.with_cache_dir: (String version, String cache_dir) -> DownloadManager
+    def self.default_cache_dir: (String version) -> String
+  end
+
+  class Language
+  end
+
+  class Parser
+  end
+
+  class Tree
+  end
+
+  class StructureKind
+    # The kind of structural item found in source code.
+    #
+    # Categorizes top-level and nested declarations such as functions, classes,
+    # structs, enums, traits, and more. Use [`Other`](StructureKind::Other) for
+    # language-specific constructs that do not fit a standard category.
+  end
+
+  class CommentKind
+    # The kind of a comment found in source code.
+    #
+    # Distinguishes between single-line comments, block (multi-line) comments,
+    # and documentation comments.
+    type instance = :line | :block | :doc
+  end
+
+  class DocstringFormat
+    # The format of a docstring extracted from source code.
+    #
+    # Identifies the docstring convention used, which varies by language
+    # (e.g., Python triple-quoted strings, JSDoc, Rustdoc `///` comments).
+  end
+
+  class ExportKind
+    # The kind of an export statement found in source code.
+    #
+    # Covers named exports, default exports, and re-exports from other modules.
+    type instance = :named | :default | :re_export
+  end
+
+  class SymbolKind
+    # The kind of a symbol definition found in source code.
+    #
+    # Categorizes symbol definitions such as variables, constants, functions,
+    # classes, types, interfaces, enums, and modules.
+  end
+
+  class DiagnosticSeverity
+    # Severity level of a diagnostic produced during parsing.
+    #
+    # Used to classify parse errors, warnings, and informational messages
+    # found in the syntax tree.
+    type instance = :error | :warning | :info
+  end
+
+  def self.detect_language_from_extension: (String ext) -> String?
+
+  def self.detect_language_from_path: (String path) -> String?
+
+  def self.detect_language_from_content: (String content) -> String?
+
+  def self.get_highlights_query: (String language) -> String?
+
+  def self.get_injections_query: (String language) -> String?
+
+  def self.get_locals_query: (String language) -> String?
+
+  def self.get_language: (String name) -> Language
+
+  def self.get_parser: (String name) -> Parser
+
+  def self.detect_language: (String path) -> String?
+
+  def self.available_languages: () -> Array[String]
+
+  def self.has_language: (String name) -> bool
+
+  def self.language_count: () -> Integer
+
+  def self.process: (String source, ProcessConfig config) -> ProcessResult
+
+  def self.init: (PackConfig config) -> void
+
+  def self.configure: (PackConfig config) -> void
+
+  def self.download: (Array[String] names) -> Integer
+
+  def self.download_all: () -> Integer
+
+  def self.manifest_languages: () -> Array[String]
+
+  def self.downloaded_languages: () -> Array[String]
+
+  def self.clean_cache: () -> void
+
+  def self.cache_dir: () -> String
+
+end

metadata

@@ -1,31 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: tree_sitter_language_pack
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.8.0
 platform: aarch64-linux
 authors:
-- kreuzberg.dev
+- Kreuzberg Team
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: 305 pre-compiled tree-sitter language parsers with Ruby bindings via
-  Magnus native extensions.
-email:
-- dev@kreuzberg.dev
+description: Pre-compiled tree-sitter grammars for 305 programming languages
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Cargo.toml
+- Steepfile
 - lib/tree_sitter_language_pack.rb
-- lib/tree_sitter_language_pack/ts_pack_ruby.so
-- src/lib.rs
+- lib/tree_sitter_language_pack/native.rb
+- lib/tree_sitter_language_pack/version.rb
+- lib/ts_pack_core_rb.so
+- sig/types.rbs
 homepage: https://github.com/kreuzberg-dev/tree-sitter-language-pack
 licenses:
 - MIT
 metadata:
-  cargo_crate_name: ts-pack-ruby
+  keywords: tree-sitter,parser,syntax,language-pack
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -33,7 +33,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.4.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -42,5 +42,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Ruby bindings for tree-sitter-language-pack
+summary: Pre-compiled tree-sitter grammars for 305 programming languages
 test_files: []

data/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "ts-pack-ruby"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Ruby Magnus bindings for tree-sitter language pack"
-publish = false
-
-[package.metadata.cargo-machete]
-ignored = ["rb-sys"]
-
-[lib]
-name = "ts_pack_ruby"
-crate-type = ["cdylib"]
-
-[dependencies]
-magnus = "0.8"
-rb-sys = "0.9"
-serde_json = { workspace = true }
-tree-sitter = { workspace = true }
-tree-sitter-language-pack = { workspace = true, features = ["serde", "download"] }

data/src/lib.rs

@@ -1,296 +0,0 @@
-use magnus::{Error, IntoValue, Ruby, Value as RbValue, function, method, prelude::*};
-use std::sync::Mutex;
-
-/// Wraps a tree-sitter Tree for safe sharing across the Ruby boundary.
-#[magnus::wrap(class = "TreeSitterLanguagePack::Tree")]
-struct TreeWrapper(Mutex<tree_sitter::Tree>);
-
-/// Helper to create a runtime error from instance methods where `&Ruby` is not available.
-fn lock_error() -> Error {
-    // SAFETY: This is called from Ruby-invoked methods, so the Ruby VM is active.
-    let ruby = unsafe { Ruby::get_unchecked() };
-    Error::new(ruby.exception_runtime_error(), "lock poisoned")
-}
-
-impl TreeWrapper {
-    fn root_node_type(&self) -> Result<String, Error> {
-        let guard = self.0.lock().map_err(|_| lock_error())?;
-        Ok(guard.root_node().kind().to_string())
-    }
-
-    fn root_child_count(&self) -> Result<usize, Error> {
-        let guard = self.0.lock().map_err(|_| lock_error())?;
-        Ok(guard.root_node().named_child_count())
-    }
-
-    fn contains_node_type(&self, node_type: String) -> Result<bool, Error> {
-        let guard = self.0.lock().map_err(|_| lock_error())?;
-        Ok(tree_sitter_language_pack::tree_contains_node_type(&guard, &node_type))
-    }
-
-    fn has_error_nodes(&self) -> Result<bool, Error> {
-        let guard = self.0.lock().map_err(|_| lock_error())?;
-        Ok(tree_sitter_language_pack::tree_has_error_nodes(&guard))
-    }
-}
-
-fn available_languages() -> Vec<String> {
-    tree_sitter_language_pack::available_languages()
-}
-
-fn has_language(name: String) -> bool {
-    tree_sitter_language_pack::has_language(&name)
-}
-
-fn detect_language(path: String) -> Option<String> {
-    tree_sitter_language_pack::detect_language_from_path(&path).map(String::from)
-}
-
-fn detect_language_from_content(content: String) -> Option<String> {
-    tree_sitter_language_pack::detect_language_from_content(&content).map(String::from)
-}
-
-fn detect_language_from_extension(ext: String) -> Option<String> {
-    tree_sitter_language_pack::detect_language_from_extension(&ext).map(String::from)
-}
-
-fn detect_language_from_path(path: String) -> Option<String> {
-    tree_sitter_language_pack::detect_language_from_path(&path).map(String::from)
-}
-
-/// Returns extension ambiguity information as a JSON string, or nil.
-fn extension_ambiguity(ext: String) -> Option<String> {
-    tree_sitter_language_pack::extension_ambiguity_json(&ext)
-}
-
-fn get_highlights_query(language: String) -> Option<String> {
-    tree_sitter_language_pack::get_highlights_query(&language).map(String::from)
-}
-
-fn get_injections_query(language: String) -> Option<String> {
-    tree_sitter_language_pack::get_injections_query(&language).map(String::from)
-}
-
-fn get_locals_query(language: String) -> Option<String> {
-    tree_sitter_language_pack::get_locals_query(&language).map(String::from)
-}
-
-fn language_count() -> usize {
-    tree_sitter_language_pack::language_count()
-}
-
-fn get_language_ptr(ruby: &Ruby, name: String) -> Result<u64, Error> {
-    let language = tree_sitter_language_pack::get_language(&name)
-        .map_err(|_| Error::new(ruby.exception_runtime_error(), format!("language not found: {name}")))?;
-    let raw_ptr = language.into_raw();
-    Ok(raw_ptr as u64)
-}
-
-fn parse_string(ruby: &Ruby, language: String, source: String) -> Result<TreeWrapper, Error> {
-    let tree = tree_sitter_language_pack::parse_string(&language, source.as_bytes())
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))?;
-    Ok(TreeWrapper(Mutex::new(tree)))
-}
-
-/// Convert a serde_json::Value to a native Ruby object (Hash, Array, String, Integer, Float, true/false, nil).
-fn json_value_to_ruby(ruby: &Ruby, value: &serde_json::Value) -> Result<RbValue, Error> {
-    Ok(match value {
-        serde_json::Value::Null => ruby.qnil().as_value(),
-        serde_json::Value::Bool(b) => (*b).into_value_with(ruby),
-        serde_json::Value::Number(n) => {
-            if let Some(i) = n.as_i64() {
-                i.into_value_with(ruby)
-            } else if let Some(u) = n.as_u64() {
-                u.into_value_with(ruby)
-            } else if let Some(f) = n.as_f64() {
-                f.into_value_with(ruby)
-            } else {
-                ruby.qnil().as_value()
-            }
-        }
-        serde_json::Value::String(s) => s.as_str().into_value_with(ruby),
-        serde_json::Value::Array(arr) => {
-            let ary = ruby.ary_new_capa(arr.len());
-            for item in arr {
-                ary.push(json_value_to_ruby(ruby, item)?)?;
-            }
-            ary.as_value()
-        }
-        serde_json::Value::Object(map) => {
-            let hash = ruby.hash_new();
-            for (k, v) in map {
-                hash.aset(k.as_str(), json_value_to_ruby(ruby, v)?)?;
-            }
-            hash.as_value()
-        }
-    })
-}
-
-/// Unified process method that accepts a JSON config string and returns a native Ruby Hash.
-///
-/// The config JSON must contain at least `"language"`. Optional fields:
-/// - `structure`, `imports`, `exports`, `comments`, `docstrings`, `symbols`, `diagnostics` (booleans, default true)
-/// - `chunk_max_size` (integer or null, default null meaning no chunking)
-fn process(ruby: &Ruby, source: String, config_json: String) -> Result<RbValue, Error> {
-    let core_config: tree_sitter_language_pack::ProcessConfig = serde_json::from_str(&config_json)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("invalid config JSON: {e}")))?;
-
-    let result = tree_sitter_language_pack::process(&source, &core_config)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))?;
-
-    let json_value = serde_json::to_value(&result)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("serialization failed: {e}")))?;
-    json_value_to_ruby(ruby, &json_value)
-}
-
-/// Extract patterns from source code using a JSON configuration.
-///
-/// The config JSON must contain:
-/// - `language` (string): the language name
-/// - `patterns` (object): named patterns to run, each with a `query` field
-///
-/// Returns a native Ruby Hash with extraction results.
-fn extract(ruby: &Ruby, source: String, config_json: String) -> Result<RbValue, Error> {
-    let config: tree_sitter_language_pack::ExtractionConfig = serde_json::from_str(&config_json)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("invalid config JSON: {e}")))?;
-
-    let result = tree_sitter_language_pack::extract_patterns(&source, &config)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))?;
-
-    let json_value = serde_json::to_value(&result)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("serialization failed: {e}")))?;
-    json_value_to_ruby(ruby, &json_value)
-}
-
-/// Validate extraction patterns without running them.
-///
-/// The config JSON must contain:
-/// - `language` (string): the language name
-/// - `patterns` (object): named patterns to validate
-///
-/// Returns a native Ruby Hash with validation results.
-fn validate_extraction(ruby: &Ruby, config_json: String) -> Result<RbValue, Error> {
-    let config: tree_sitter_language_pack::ExtractionConfig = serde_json::from_str(&config_json)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("invalid config JSON: {e}")))?;
-
-    let result = tree_sitter_language_pack::validate_extraction(&config)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))?;
-
-    let json_value = serde_json::to_value(&result)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("serialization failed: {e}")))?;
-    json_value_to_ruby(ruby, &json_value)
-}
-
-/// Initialize the language pack with configuration.
-///
-/// Accepts a JSON string with optional fields:
-/// - `cache_dir` (string): override default cache directory
-/// - `languages` (array): language names to pre-download
-/// - `groups` (array): language groups to pre-download
-fn rb_init(ruby: &Ruby, config_json: String) -> Result<(), Error> {
-    let config: tree_sitter_language_pack::PackConfig = serde_json::from_str(&config_json)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("invalid config JSON: {e}")))?;
-
-    tree_sitter_language_pack::init(&config).map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))
-}
-
-/// Configure the language pack without downloading.
-///
-/// Accepts a JSON string with optional fields:
-/// - `cache_dir` (string): override default cache directory
-fn rb_configure(ruby: &Ruby, config_json: String) -> Result<(), Error> {
-    let config: tree_sitter_language_pack::PackConfig = serde_json::from_str(&config_json)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("invalid config JSON: {e}")))?;
-
-    tree_sitter_language_pack::configure(&config)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))
-}
-
-/// Download specific languages to the cache.
-///
-/// Returns the number of newly downloaded languages.
-fn rb_download(ruby: &Ruby, names: Vec<String>) -> Result<usize, Error> {
-    let refs: Vec<&str> = names.iter().map(String::as_str).collect();
-    tree_sitter_language_pack::download(&refs).map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))
-}
-
-/// Download all available languages from the remote manifest.
-///
-/// Returns the number of newly downloaded languages.
-fn rb_download_all(ruby: &Ruby) -> Result<usize, Error> {
-    tree_sitter_language_pack::download_all().map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))
-}
-
-/// Get all language names available in the remote manifest.
-fn rb_manifest_languages(ruby: &Ruby) -> Result<Vec<String>, Error> {
-    tree_sitter_language_pack::manifest_languages()
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))
-}
-
-/// Get all languages that are already downloaded and cached locally.
-fn rb_downloaded_languages() -> Vec<String> {
-    tree_sitter_language_pack::downloaded_languages()
-}
-
-/// Delete all cached parser shared libraries.
-fn rb_clean_cache(ruby: &Ruby) -> Result<(), Error> {
-    tree_sitter_language_pack::clean_cache().map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))
-}
-
-/// Get the effective cache directory path as a string.
-fn rb_cache_dir(ruby: &Ruby) -> Result<String, Error> {
-    tree_sitter_language_pack::cache_dir()
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))
-        .and_then(|path| {
-            path.to_str()
-                .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "cache path is not valid UTF-8"))
-                .map(|s| s.to_string())
-        })
-}
-
-#[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    let module = ruby.define_module("TreeSitterLanguagePack")?;
-
-    // Registry and parsing functions
-    module.define_module_function("available_languages", function!(available_languages, 0))?;
-    module.define_module_function("has_language", function!(has_language, 1))?;
-    module.define_module_function("detect_language", function!(detect_language, 1))?;
-    module.define_module_function(
-        "detect_language_from_content",
-        function!(detect_language_from_content, 1),
-    )?;
-    module.define_module_function(
-        "detect_language_from_extension",
-        function!(detect_language_from_extension, 1),
-    )?;
-    module.define_module_function("detect_language_from_path", function!(detect_language_from_path, 1))?;
-    module.define_module_function("extension_ambiguity", function!(extension_ambiguity, 1))?;
-    module.define_module_function("get_highlights_query", function!(get_highlights_query, 1))?;
-    module.define_module_function("get_injections_query", function!(get_injections_query, 1))?;
-    module.define_module_function("get_locals_query", function!(get_locals_query, 1))?;
-    module.define_module_function("language_count", function!(language_count, 0))?;
-    module.define_module_function("get_language_ptr", function!(get_language_ptr, 1))?;
-    module.define_module_function("parse_string", function!(parse_string, 2))?;
-    module.define_module_function("process", function!(process, 2))?;
-    module.define_module_function("extract", function!(extract, 2))?;
-    module.define_module_function("validate_extraction", function!(validate_extraction, 1))?;
-
-    // Download API functions
-    module.define_module_function("init", function!(rb_init, 1))?;
-    module.define_module_function("configure", function!(rb_configure, 1))?;
-    module.define_module_function("download", function!(rb_download, 1))?;
-    module.define_module_function("download_all", function!(rb_download_all, 0))?;
-    module.define_module_function("manifest_languages", function!(rb_manifest_languages, 0))?;
-    module.define_module_function("downloaded_languages", function!(rb_downloaded_languages, 0))?;
-    module.define_module_function("clean_cache", function!(rb_clean_cache, 0))?;
-    module.define_module_function("cache_dir", function!(rb_cache_dir, 0))?;
-
-    let tree_class = module.define_class("Tree", ruby.class_object())?;
-    tree_class.define_method("root_node_type", method!(TreeWrapper::root_node_type, 0))?;
-    tree_class.define_method("root_child_count", method!(TreeWrapper::root_child_count, 0))?;
-    tree_class.define_method("contains_node_type", method!(TreeWrapper::contains_node_type, 1))?;
-    tree_class.define_method("has_error_nodes", method!(TreeWrapper::has_error_nodes, 0))?;
-
-    Ok(())
-}