tree-sitter-swi-prolog 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Piotr Franczyk
+
+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.

package/README.md

@@ -1,3 +1,81 @@
-# Temporary Holding Version
+# tree-sitter-swi-prolog
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Kibi requirement health](https://looted.github.io/tree-sitter-swi-prolog/kibi-report/badge.svg)](https://looted.github.io/tree-sitter-swi-prolog/kibi-report/)
+
+[SWI-Prolog](https://www.swi-prolog.org) grammar for [tree-sitter](https://tree-sitter.github.io/tree-sitter/).
+
+It parses the Prolog that real SWI-Prolog projects are written in, not only ISO core:
+
+- the default SWI-Prolog operator table, including `:` module qualification, `=>` single-sided unification, `=@=`, `>:<`, `:<`, `as`, `$`, and declaration prefixes such as `dynamic`, `discontiguous`, `meta_predicate`, `multifile` and `table`
+- operators from common libraries: `library(clpfd)` (`#=`, `in`, `..`, ...), `library(chr)` (`<=>`, `==>`, `\`), `library(semweb/rdf_db)` (`^^`), `library(wasm)` (`#Value`, `Expr[Index]`) and the `rdf_meta`, `persistent`, `record` and `html_meta` declarations
+- dicts (`_{name: "x"}`, `Tag{...}`) and functional notation on dicts (`D.key`, `D.put(k, V)`)
+- strings, back-quoted strings, `0'c` character codes, radix integers (`16'FF`), digit groups (`1 000 000`), rationals (`1r3`) and special floats (`1.0Inf`)
+- Unicode atoms and variables, multi-line quoted text, `%` and `/* */` comments, and a leading `#!` line
+
+Clauses are structured for tools: every top-level term is a `clause` (with `head`, `neck` and `body` fields), a `directive` or a `query`.
+
+```
+max(X, Y, X) :- X >= Y, !.
+
+(clause
+  head: (compound_term functor: (atom) arguments: (arguments (variable) (variable) (variable)))
+  neck: (operator)
+  body: (binary_operation left: (binary_operation ...) operator: (operator) right: (atom))
+  (end))
+```
+
+## Coverage
+
+CI parses SWI-Prolog's own `boot/` and `library/` sources and fails if fewer than 99.5% of top-level terms parse without errors. On SWI-Prolog's current `boot/` and `library/` 99.88% of terms parse cleanly, and on the full SWI-Prolog 10.0.2 library with packages (413 files, about 240,000 lines) 99.91%; the rest use prefix operators their files declare themselves.
+
+## Limits
+
+A tree-sitter grammar has a fixed operator table, so operators declared at load time with `op/3` are not known while parsing:
+
+- an unknown infix operator between two operands, symbolic or alphanumeric (for example `X ===> Y` or `X cis Y`), is read as an infix operator at priority 700, so the clause still parses, with the grouping that priority gives
+- unknown prefix and postfix operators produce an `ERROR` node for that term only; the parser recovers at the next clause
+- the parser does not lower operator priorities the way SWI-Prolog does in some argument positions, so `foo(:- a)` or `foo(a|b)` are errors
+
+A negative number literal is parsed as the prefix operator `-` applied to the number.
+
+## Queries
+
+- `queries/highlights.scm`: syntax highlighting
+- `queries/tags.scm`: predicate definitions (clause heads, including module-qualified heads and single-sided-unification heads with guards), module declarations, and calls. `@name` is the predicate name without arity; count the head's arguments for the arity, and add two for DCG rules (neck `-->`)
+- `queries/locals.scm`: variables are local to their clause, directive or query
+
+## Usage
+
+Node, Rust, Python, Go, Swift and C bindings are generated by `tree-sitter init`. For the browser or other WebAssembly hosts, build the parser with:
+
+```sh
+npx tree-sitter build --wasm
+```
+
+and load `tree-sitter-swi_prolog.wasm` with [`web-tree-sitter`](https://www.npmjs.com/package/web-tree-sitter).
+
+## Development
+
+```sh
+npm install
+npx tree-sitter generate
+npx tree-sitter test
+npx tree-sitter build --wasm
+node scripts/check-corpus.mjs path/to/prolog/sources
+```
+
+`grammar.js` lists the operator tables at the top. To support another library's operators, add them to the matching table with their SWI-Prolog priority and type.
+
+## Releasing
+
+Releases are made from [changesets](https://github.com/changesets/changesets).
+
+1. A pull request with a user-visible change adds a changeset: run `npx changeset`, pick the bump and describe the change for users.
+2. When it is merged, the **Release** workflow opens (or updates) a **Version packages** pull request that applies all pending changesets: it bumps the version in every manifest and writes their text into `CHANGELOG.md`.
+3. Merging that pull request releases the new version: the `vX.Y.Z` tag and GitHub release (with the changelog section as notes and the Wasm parser attached), npm, crates.io and PyPI.
+
+The release step publishes only what is missing for the current version, so if a registry fails, run the **Release** workflow again from the Actions tab. Don't create tags or releases by hand.
+
+## License
+
+MIT

package/binding.gyp

@@ -0,0 +1,35 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_swi_prolog_binding",
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
+      ],
+      "include_dirs": [
+        "src",
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+      ],
+      "variables": {
+        "has_scanner": "<!(node -p \"fs.existsSync('src/scanner.c')\")"
+      },
+      "conditions": [
+        ["has_scanner=='true'", {
+          "sources+": ["src/scanner.c"],
+        }],
+        ["OS!='win'", {
+          "cflags_c": [
+            "-std=c11",
+          ],
+        }, { # OS == "win"
+          "cflags_c": [
+            "/std:c11",
+            "/utf-8",
+          ],
+        }],
+      ],
+    }
+  ]
+}

package/bindings/node/binding.cc

@@ -0,0 +1,19 @@
+#include <napi.h>
+
+typedef struct TSLanguage TSLanguage;
+
+extern "C" TSLanguage *tree_sitter_swi_prolog();
+
+// "tree-sitter", "language" hashed with BLAKE2
+const napi_type_tag LANGUAGE_TYPE_TAG = {
+    0x8AF2E5212AD58ABF, 0xD5006CAD83ABBA16
+};
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    auto language = Napi::External<TSLanguage>::New(env, tree_sitter_swi_prolog());
+    language.TypeTag(&LANGUAGE_TYPE_TAG);
+    exports["language"] = language;
+    return exports;
+}
+
+NODE_API_MODULE(tree_sitter_swi_prolog_binding, Init)

package/bindings/node/binding_test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { test } from "node:test";
+import Parser from "tree-sitter";
+
+test("can load grammar", () => {
+  const parser = new Parser();
+  assert.doesNotReject(async () => {
+    const { default: language } = await import("./index.js");
+    parser.setLanguage(language);
+  });
+});

package/bindings/node/index.d.ts

@@ -0,0 +1,60 @@
+type BaseNode = {
+  type: string;
+  named: boolean;
+};
+
+type ChildNode = {
+  multiple: boolean;
+  required: boolean;
+  types: BaseNode[];
+};
+
+type NodeInfo =
+  | (BaseNode & {
+      subtypes: BaseNode[];
+    })
+  | (BaseNode & {
+      fields: { [name: string]: ChildNode };
+      children: ChildNode[];
+    });
+
+/**
+ * The tree-sitter language object for this grammar.
+ *
+ * @see {@linkcode https://tree-sitter.github.io/node-tree-sitter/interfaces/Parser.Language.html Parser.Language}
+ *
+ * @example
+ * import Parser from "tree-sitter";
+ * import SwiProlog from "tree-sitter-swi-prolog";
+ *
+ * const parser = new Parser();
+ * parser.setLanguage(SwiProlog);
+ */
+declare const binding: {
+  /**
+   * The inner language object.
+   * @private
+   */
+  language: unknown;
+
+  /**
+   * The content of the `node-types.json` file for this grammar.
+   *
+   * @see {@linkplain https://tree-sitter.github.io/tree-sitter/using-parsers/6-static-node-types Static Node Types}
+   */
+  nodeTypeInfo: NodeInfo[];
+
+  /** The syntax highlighting query for this grammar. */
+  HIGHLIGHTS_QUERY?: string;
+
+  /** The language injection query for this grammar. */
+  INJECTIONS_QUERY?: string;
+
+  /** The local variable query for this grammar. */
+  LOCALS_QUERY?: string;
+
+  /** The symbol tagging query for this grammar. */
+  TAGS_QUERY?: string;
+};
+
+export default binding;

package/bindings/node/index.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL("../..", import.meta.url));
+
+const binding = typeof process.versions.bun === "string"
+  // Support `bun build --compile` by being statically analyzable enough to find the .node file at build-time
+  ? await import(`${root}/prebuilds/${process.platform}-${process.arch}/tree-sitter-swi-prolog.node`)
+  : (await import("node-gyp-build")).default(root);
+
+try {
+  const nodeTypes = await import(`${root}/src/node-types.json`, { with: { type: "json" } });
+  binding.nodeTypeInfo = nodeTypes.default;
+} catch { }
+
+const queries = [
+  ["HIGHLIGHTS_QUERY", `${root}/queries/highlights.scm`],
+  ["INJECTIONS_QUERY", `${root}/queries/injections.scm`],
+  ["LOCALS_QUERY", `${root}/queries/locals.scm`],
+  ["TAGS_QUERY", `${root}/queries/tags.scm`],
+];
+
+for (const [prop, path] of queries) {
+  Object.defineProperty(binding, prop, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      delete binding[prop];
+      try {
+        binding[prop] = readFileSync(path, "utf8");
+      } catch { }
+      return binding[prop];
+    }
+  });
+}
+
+export default binding;

package/grammar.js

@@ -0,0 +1,346 @@
+/**
+ * @file SWI-Prolog grammar for tree-sitter
+ * @license MIT
+ */
+
+/// <reference types="tree-sitter-cli/dsl" />
+// @ts-check
+
+// Default SWI-Prolog operator table (see `current_op/3` in a fresh `swipl`).
+// Prolog priorities run the other way from tree-sitter precedences, so each
+// rule uses `1200 - priority`.
+//
+// Operators at priority 1200 only appear as the neck of a clause, in a
+// directive, or inside parentheses; see `clause`, `directive` and `_term_1200`.
+const INFIX_HIGH = [
+  // [priority, type, operators]
+  // library(chr)
+  [1190, 'xfx', ['==>', '<=>']],
+  [1180, 'xfx', ['\\']],
+  [1150, 'xfx', ['pragma']],
+  [1105, 'xfy', ['|']],
+  [1100, 'xfy', [';']],
+  [1050, 'xfy', ['->', '*->']],
+  [1000, 'xfy', [',']],
+];
+
+const INFIX_LOW = [
+  [990, 'xfx', [':=']],
+  // library(clpfd)
+  [760, 'yfx', ['#<==>']],
+  [750, 'xfy', ['#==>']],
+  [750, 'yfx', ['#<==']],
+  [740, 'yfx', ['#\\/']],
+  [730, 'yfx', ['#\\']],
+  [720, 'yfx', ['#/\\']],
+  [700, 'xfx', ['#>', '#<', '#>=', '#=<', '#=', '#\\=', 'in', 'ins', 'in_set']],
+  [450, 'xfx', ['..']],
+  [700, 'xfx', [
+    '=', '\\=', '==', '\\==', '@<', '@>', '@=<', '@>=', '=..', 'is', '=:=',
+    '=\\=', '<', '>', '=<', '>=', '>:<', ':<', 'as', '=@=', '\\=@=', '?=',
+  ]],
+  [600, 'xfy', [':']],
+  [500, 'yfx', ['+', '-', '/\\', '\\/', 'xor']],
+  [400, 'yfx', ['*', '/', '//', 'rem', 'mod', 'div', '<<', '>>', 'divmod', 'rdiv']],
+  [200, 'xfx', ['**']],
+  [200, 'xfy', ['^']],
+  // library(semweb/rdf_db) literals: Value^^Type, Text@Lang
+  [110, 'xfx', ['^^']],
+];
+
+const PREFIX_HIGH = [
+  [1150, 'fx', [
+    'dynamic', 'discontiguous', 'initialization', 'meta_predicate',
+    'module_transparent', 'multifile', 'public', 'thread_local',
+    'thread_initialization', 'volatile', 'table',
+    // declarations from common libraries
+    'rdf_meta', 'persistent', 'record', 'html_meta', 'chr_constraint', 'chr_type', 'chr_option',
+  ]],
+];
+
+const PREFIX_LOW = [
+  [900, 'fy', ['\\+']],
+  [710, 'fy', ['#\\']],
+  [500, 'fx', ['?']],
+  [200, 'fy', ['-', '+', '\\']],
+  [100, 'fx', ['@']],
+  // library(wasm)
+  [50, 'fx', ['#']],
+  [1, 'fx', ['$']],
+];
+
+const NECKS = [':-', '-->', '=>'];
+
+// Every operator name. Each one is also a plain atom wherever an operand is
+// not expected, e.g. `foo(-, +)` or `X = (=)`.
+const OPERATOR_NAMES = [...new Set([
+  ...NECKS, '?-',
+  ...[...INFIX_HIGH, ...INFIX_LOW, ...PREFIX_HIGH, ...PREFIX_LOW]
+    .flatMap(([, , ops]) => ops),
+])].filter(op => op !== ',' && op !== '|');
+
+const precOf = priority => 1200 - priority;
+
+function infix($, [priority, type, ops], operand) {
+  const op = field('operator', choice(...ops.map(o => alias(o, $.operator))));
+  const body = seq(field('left', operand), op, field('right', operand));
+  const p = precOf(priority);
+  return type === 'xfy' ? prec.right(p, body) : prec.left(p, body);
+}
+
+function prefix($, [priority, type, ops], operand) {
+  const op = field('operator', choice(...ops.map(o => alias(o, $.operator))));
+  const body = seq(op, field('argument', operand));
+  const p = precOf(priority);
+  return type === 'fy' ? prec.right(p, body) : prec.left(p, body);
+}
+
+const LOWER = /[\p{Ll}]/u.source;
+const UPPER = /[\p{Lu}_]/u.source;
+const ALNUM = /[\p{L}\p{N}_]/u.source;
+
+export default grammar({
+  name: 'swi_prolog',
+
+  extras: $ => [/\s/, $.comment],
+
+  externals: $ => [$.end, $._error_sentinel],
+
+  word: $ => $._name,
+
+
+  rules: {
+    source_file: $ => seq(optional($.shebang), repeat(choice(
+      $.directive,
+      $.query,
+      $.clause,
+    ))),
+
+    shebang: _ => token(prec(2, /#![^\n]*/)),
+
+    directive: $ => seq(':-', field('body', $._term), $.end),
+
+    query: $ => seq('?-', field('body', $._term), $.end),
+
+    // A fact, rule, DCG rule or single-sided-unification rule. The head of a
+    // rule is any term below 1200, which covers `Head, Guard => Body`.
+    clause: $ => seq(
+      field('head', $._term),
+      optional(seq(
+        field('neck', choice(...NECKS.map(n => alias(n, $.operator)))),
+        field('body', $._term),
+      )),
+      $.end,
+    ),
+
+    // Priority 1199 and below.
+    _term: $ => choice(
+      $._arg,
+      alias($._binary_operation_high, $.binary_operation),
+      alias($._prefix_operation_high, $.prefix_operation),
+    ),
+
+    _binary_operation_high: $ => choice(
+      ...INFIX_HIGH.map(op => infix($, op, $._term)),
+    ),
+
+    _prefix_operation_high: $ => choice(
+      ...PREFIX_HIGH.map(op => prefix($, op, $._term)),
+    ),
+
+    // Priority 999 and below: list elements and arguments.
+    _arg: $ => choice(
+      $._primary,
+      $.binary_operation,
+      $.prefix_operation,
+    ),
+
+    binary_operation: $ => choice(
+      ...INFIX_LOW.map(op => infix($, op, $._arg)),
+      // Operators declared with op/3 are not known to the parser. A symbol
+      // atom or a plain name between two operands is read as an infix operator
+      // at 700: two adjacent operands are never valid Prolog otherwise.
+      prec.left(precOf(700), seq(
+        field('left', $._arg),
+        field('operator', alias(choice($._graphic, $._name), $.operator)),
+        field('right', $._arg),
+      )),
+    ),
+
+    prefix_operation: $ => choice(
+      ...PREFIX_LOW.map(op => prefix($, op, $._arg)),
+    ),
+
+    // Full 1200 term, only reachable inside brackets.
+    _term_1200: $ => choice(
+      $._term,
+      alias($._neck_operation, $.binary_operation),
+      alias($._prefix_neck_operation, $.prefix_operation),
+    ),
+
+    _neck_operation: $ => prec.left(0, seq(
+      field('left', $._term),
+      field('operator', choice(...NECKS.map(n => alias(n, $.operator)))),
+      field('right', $._term),
+    )),
+
+    _prefix_neck_operation: $ => seq(
+      field('operator', alias(choice(':-', '?-'), $.operator)),
+      field('argument', $._term),
+    ),
+
+    _primary: $ => choice(
+      $.atom,
+      $.variable,
+      $.integer,
+      $.float,
+      $.rational,
+      $.char_code,
+      $.string,
+      $.back_quoted_string,
+      $.compound_term,
+      $.list,
+      $.curly_term,
+      $.dict,
+      $.dict_call,
+      $.index_term,
+      $.parenthesized_term,
+    ),
+
+    // `Expr[Index]`, the postfix `[]` operator of library(wasm).
+    index_term: $ => prec.left(precOf(40), seq(
+      field('object', choice($.variable, $.dict_call, $.index_term)),
+      token.immediate('['),
+      field('index', $._arg),
+      ']',
+    )),
+
+    parenthesized_term: $ => seq('(', $._term_1200, ')'),
+
+    // `foo(...)`: the functor must touch the opening bracket.
+    compound_term: $ => seq(
+      field('functor', $.atom),
+      token.immediate('('),
+      field('arguments', $.arguments),
+      ')',
+    ),
+
+    arguments: $ => seq($._arg, repeat(seq(',', $._arg))),
+
+    list: $ => seq(
+      '[',
+      $._arg,
+      repeat(seq(',', $._arg)),
+      optional(seq('|', field('tail', $._arg))),
+      ']',
+    ),
+
+    curly_term: $ => seq('{', $._term_1200, '}'),
+
+    // `Tag{Key: Value, ...}`
+    dict: $ => seq(
+      field('tag', choice($.atom, $.variable)),
+      token.immediate('{'),
+      optional(seq(
+        $.dict_pair,
+        repeat(seq(',', $.dict_pair)),
+      )),
+      '}',
+    ),
+
+    dict_pair: $ => seq(
+      field('key', choice($.atom, $.integer)),
+      ':',
+      field('value', $._arg),
+    ),
+
+    // `Dict.key` and `Dict.put(...)`: the dot touches both sides.
+    dict_call: $ => prec.left(precOf(100), seq(
+      field('dict', choice($.variable, $.atom, $.dict, $.dict_call, $.index_term)),
+      token.immediate('.'),
+      field('function', choice(
+        alias($._immediate_name, $.atom),
+        alias($._immediate_variable, $.variable),
+        alias($._immediate_quoted_atom, $.atom),
+        alias($._immediate_compound, $.compound_term),
+        alias($._immediate_integer, $.integer),
+      )),
+    )),
+
+    _immediate_name: _ => token.immediate(new RegExp(`${LOWER}${ALNUM}*`, 'u')),
+    _immediate_variable: _ => token.immediate(new RegExp(`${UPPER}${ALNUM}*`, 'u')),
+    _immediate_quoted_atom: _ => token.immediate(seq(
+      '\'',
+      repeat(choice(/[^'\\]/, '\'\'', /\\(.|\n)/)),
+      '\'',
+    )),
+    _immediate_integer: _ => token.immediate(/\d+/),
+    _immediate_compound: $ => seq(
+      field('functor', alias($._immediate_name, $.atom)),
+      token.immediate('('),
+      field('arguments', $.arguments),
+      ')',
+    ),
+
+    atom: $ => choice(
+      $._name,
+      $._graphic,
+      $._quoted_atom,
+      seq('[', ']'),
+      seq('{', '}'),
+      '!',
+      ';',
+      prec(-10, choice(...OPERATOR_NAMES)),
+    ),
+
+    _name: _ => new RegExp(`${LOWER}${ALNUM}*`, 'u'),
+
+    // Symbol-character atoms that are not in the default operator table.
+    // A dot directly before layout is handled by the external `end` token.
+    _graphic: _ => token(/[#$&*+\-./:<=>?@^~\\]+/),
+
+    _quoted_atom: _ => token(seq(
+      '\'',
+      repeat(choice(/[^'\\]/, '\'\'', /\\(.|\n)/, /\\x[0-9a-fA-F]+\\?/, /\\[0-7]+\\?/)),
+      '\'',
+    )),
+
+    variable: _ => new RegExp(`${UPPER}${ALNUM}*`, 'u'),
+
+    integer: _ => token(choice(
+      /\d(_?\d)*/,
+      /0x[0-9a-fA-F](_?[0-9a-fA-F])*/,
+      /0o[0-7](_?[0-7])*/,
+      /0b[01](_?[01])*/,
+      /[1-9]\d*'[0-9a-zA-Z]+/,
+      // SWI digit groups: 1 000 000
+      /\d{1,3}( \d{3})+/,
+    )),
+
+    float: _ => token(choice(
+      /\d(_?\d)*\.\d+([eE][+-]?\d+)?(Inf|NaN)?/,
+      /\d(_?\d)*[eE][+-]?\d+/,
+    )),
+
+    rational: _ => token(/\d+r\d+/),
+
+    char_code: _ => token(seq('0\'', choice(/\\(.|x[0-9a-fA-F]+\\?|[0-7]+\\?)/, '\'\'', '\'', /[^\\']/))),
+
+    string: _ => token(seq(
+      '"',
+      repeat(choice(/[^"\\]/, '""', /\\(.|\n)/)),
+      '"',
+    )),
+
+    back_quoted_string: _ => token(seq(
+      '`',
+      repeat(choice(/[^`\\]/, '``', /\\(.|\n)/)),
+      '`',
+    )),
+
+    comment: _ => token(prec(1, choice(
+      seq('%', /.*/),
+      seq('/*', /[^*]*\*+([^/*][^*]*\*+)*/, '/'),
+    ))),
+  },
+});

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "tree-sitter-swi-prolog",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "SWI-Prolog grammar for tree-sitter",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Looted/tree-sitter-swi-prolog.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Piotr Franczyk"
+  },
+  "main": "bindings/node",
+  "types": "bindings/node",
+  "keywords": [
+    "incremental",
+    "parsing",
+    "tree-sitter",
+    "prolog",
+    "swi-prolog"
+  ],
+  "files": [
+    "grammar.js",
+    "tree-sitter.json",
+    "binding.gyp",
+    "prebuilds/**",
+    "bindings/node/*",
+    "queries/*",
+    "src/**",
+    "*.wasm"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.5.0",
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.31.1",
+    "kibi-cli": "^2.38.0",
+    "kibi-core": "^0.27.0",
+    "kibi-mcp": "^3.22.0",
+    "prebuildify": "^6.0.1",
+    "tree-sitter": "^0.25.0",
+    "tree-sitter-cli": "^0.26.7",
+    "web-tree-sitter": "^0.27.0"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.25.0"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "install": "node-gyp-build",
+    "prestart": "tree-sitter build --wasm",
+    "start": "tree-sitter playground",
+    "test": "node --test bindings/node/*_test.js",
+    "test:corpus": "node scripts/check-corpus.mjs",
+    "version-packages": "node scripts/version-packages.mjs",
+    "changeset": "changeset"
+  }
+}