sweet-search 2.6.2 → 2.6.4

package/core/infrastructure/language-patterns/registry-tooling.js

@@ -235,6 +235,95 @@ export const TOOLING_LANGUAGES = {
       skipCallObjects: [],
     },
   },
+  // ─── Solidity ────────────────────────────────────────────────────────────────
+  // Real chunking is done by tree-sitter-solidity (GRAMMAR_MAP); these regex
+  // patterns are the fallback used only when tree-sitter is unavailable.
+  solidity: {
+    indentBased: false,
+    endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    chunker: {
+      contract: /^\s*(?:abstract\s+)?contract\s+(\w+)/,
+      interface: /^\s*interface\s+(\w+)/,
+      library: /^\s*library\s+(\w+)/,
+      function: /^\s*function\s+(\w+)/,
+      struct: /^\s*struct\s+(\w+)/,
+    },
+    graph: {
+      entities: {
+        contract: /^\s*(?:abstract\s+)?contract\s+(\w+)/,
+        interface: /^\s*interface\s+(\w+)/,
+        library: /^\s*library\s+(\w+)/,
+        function: /^\s*function\s+(\w+)/,
+      },
+      relationships: {
+        import: /^\s*import\s+.*["']([^"']+)["']/,
+        inherit: /\bis\s+([A-Z]\w*)/,
+      },
+      skipCallObjects: ["require", "assert", "revert", "emit"],
+    },
+  },
+  // ─── OCaml ───────────────────────────────────────────────────────────────────
+  // tree-sitter-ocaml does the real chunking. OCaml has no line comment — only
+  // `(* … *)` blocks.
+  ocaml: {
+    indentBased: false,
+    endKeyword: null,
+    comment: { line: null, block: ["(*", "*)"] },
+    chunker: {
+      function: /^\s*let\s+(?:rec\s+)?(\w+)/,
+      type: /^\s*(?:and\s+)?type\s+(\w+)/,
+      module: /^\s*module\s+(\w+)/,
+    },
+    graph: {
+      entities: {
+        function: /^\s*let\s+(?:rec\s+)?(\w+)/,
+        type: /^\s*type\s+(\w+)/,
+        module: /^\s*module\s+(\w+)/,
+      },
+      relationships: { open: /^\s*open\s+([\w.]+)/ },
+      skipCallObjects: [],
+    },
+  },
+  // ─── ReScript ────────────────────────────────────────────────────────────────
+  rescript: {
+    indentBased: false,
+    endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    chunker: {
+      function: /^\s*let\s+(\w+)/,
+      type: /^\s*type\s+(\w+)/,
+      module: /^\s*module\s+(\w+)/,
+    },
+    graph: {
+      entities: {
+        function: /^\s*let\s+(\w+)/,
+        type: /^\s*type\s+(\w+)/,
+        module: /^\s*module\s+(\w+)/,
+      },
+      relationships: { open: /^\s*open\s+(\w+)/ },
+      skipCallObjects: [],
+    },
+  },
+  // ─── TLA+ ────────────────────────────────────────────────────────────────────
+  // tree-sitter-tlaplus does the real chunking. Comments are `\* …` / `(* … *)`.
+  tlaplus: {
+    indentBased: false,
+    endKeyword: null,
+    comment: { line: "\\*", block: ["(*", "*)"] },
+    chunker: {
+      module: /^-{2,}\s*MODULE\s+(\w+)/,
+      operator: /^(\w+)\s*==/,
+    },
+    graph: {
+      entities: {
+        module: /^-{2,}\s*MODULE\s+(\w+)/,
+        operator: /^(\w+)\s*==/,
+      },
+      relationships: { extends: /^EXTENDS\s+([\w,\s]+)/ },
+      skipCallObjects: [],
+    },
+  },
 };
 
 export default TOOLING_LANGUAGES;

package/core/infrastructure/tree-sitter-provider.js

@@ -46,6 +46,14 @@ const GRAMMAR_MAP = {
   // classes. Wiring tree-sitter-c-sharp puts C# on the same code path as
   // the other 13 languages (cAST sibling-merge over a proper AST).
   csharp: 'tree-sitter-c_sharp',
+  // Wired 2026-06 (v2.6.3) for first-class AST/cAST chunking. All four wasm
+  // grammars ship in tree-sitter-wasms and load on the installed web-tree-sitter
+  // ABI. (tree-sitter-elm / tree-sitter-ql also ship but are ABI 12/10 vs the
+  // required 13–15, so they stay on generic chunking.)
+  solidity: 'tree-sitter-solidity',
+  tlaplus: 'tree-sitter-tlaplus',
+  ocaml: 'tree-sitter-ocaml',
+  rescript: 'tree-sitter-rescript',
 };
 
 // Identifier node types — used to detect leaf-ident captures in extractSymbols()
@@ -56,6 +64,10 @@ const IDENT_TYPES = new Set([
   'name',                 // PHP all identifiers
   'simple_identifier',    // Kotlin functions, Swift functions
   'namespace_identifier', // C++ namespace names
+  // OCaml — names live in *_binding children (see _extractNodeName drill)
+  'value_name', 'type_constructor', 'module_name',
+  // ReScript — value/module binding names (type_identifier already covered)
+  'value_identifier', 'module_identifier',
 ]);
 
 // AST node types that represent meaningful chunk boundaries
@@ -156,6 +168,25 @@ const LANG_EXTRA_BOUNDARY_TYPES = {
     'local_function_statement',
     'event_declaration', 'event_field_declaration',
   ]),
+  // Solidity (tree-sitter-solidity). `function_definition` is already a global
+  // boundary; these are the contract-level declarations the grammar emits, all
+  // carrying a `name: (identifier)` field so _extractNodeName resolves them.
+  solidity: new Set([
+    'contract_declaration', 'interface_declaration', 'library_declaration',
+    'struct_declaration', 'enum_declaration', 'event_definition',
+    'modifier_definition', 'constructor_definition', 'error_declaration',
+  ]),
+  // TLA+ (tree-sitter-tlaplus). `module` is already global; operator_definition
+  // (`Foo == ...`) is the unit of definition, name via `name: (identifier)`.
+  tlaplus: new Set(['operator_definition']),
+  // OCaml (tree-sitter-ocaml). `type_definition` is already global; these wrap a
+  // *_binding whose name (value_name/type_constructor/module_name) is recovered
+  // by the _extractNodeName binding-wrapper drill. value_definition is top-level
+  // only (local `let … in` is a let_expression), so this doesn't over-chunk.
+  ocaml: new Set(['value_definition', 'module_definition', 'exception_definition']),
+  // ReScript (tree-sitter-rescript). `type_declaration` is already global; the
+  // let/module declarations wrap a *_binding handled by the same drill.
+  rescript: new Set(['let_declaration', 'module_declaration']),
 };
 
 // Per-language EXCLUSIONS from BOUNDARY_TYPES. Removes node-type names that
@@ -283,6 +314,37 @@ const NODE_TYPE_MAP = {
   'local_function_statement': 'function',
   'event_declaration': 'property',
   'event_field_declaration': 'field',
+  // Solidity (tree-sitter-solidity) — grammar-unique node names, so these are
+  // null-ops for every other language's chunking.
+  'contract_declaration': 'class',
+  'library_declaration': 'class',
+  'event_definition': 'event',
+  'modifier_definition': 'function',
+  'constructor_definition': 'method',
+  'error_declaration': 'type',
+  // TLA+
+  'operator_definition': 'function',
+  // OCaml
+  'value_definition': 'function',
+  'module_definition': 'module',
+  'exception_definition': 'class',
+  // ReScript
+  'let_declaration': 'function',
+  'module_declaration': 'module',
+};
+
+// OCaml / ReScript boundary node -> the `*_binding` child that carries the name.
+// Consulted only by _extractNodeName; the keys are grammar-unique node types.
+const OCAML_RESCRIPT_BINDING_WRAPPERS = {
+  // OCaml
+  value_definition: 'let_binding',
+  module_definition: 'module_binding',
+  // ReScript
+  let_declaration: 'let_binding',
+  module_declaration: 'module_binding',
+  // Shared (already a global boundary; name nested in *_binding for both langs)
+  type_definition: 'type_binding',
+  type_declaration: 'type_binding',
 };
 
 // Standard tags.scm query patterns for symbol extraction
@@ -534,6 +596,34 @@ const TAGS_QUERIES = {
     (field_declaration (variable_declaration (variable_declarator name: (identifier) @field.definition)))
     (local_function_statement name: (identifier) @function.definition)
   `,
+  // Solidity (tree-sitter-solidity) — every declaration carries name: (identifier).
+  solidity: `
+    (contract_declaration name: (identifier) @class.definition)
+    (interface_declaration name: (identifier) @interface.definition)
+    (library_declaration name: (identifier) @class.definition)
+    (struct_declaration name: (identifier) @struct.definition)
+    (enum_declaration name: (identifier) @enum.definition)
+    (function_definition name: (identifier) @function.definition)
+    (modifier_definition name: (identifier) @function.definition)
+    (event_definition name: (identifier) @function.definition)
+  `,
+  // TLA+ (tree-sitter-tlaplus)
+  tlaplus: `
+    (module name: (identifier) @namespace.definition)
+    (operator_definition name: (identifier) @function.definition)
+  `,
+  // OCaml (tree-sitter-ocaml) — names nested in the *_binding child.
+  ocaml: `
+    (value_definition (let_binding (value_name) @function.definition))
+    (type_definition (type_binding (type_constructor) @type.definition))
+    (module_definition (module_binding (module_name) @namespace.definition))
+  `,
+  // ReScript (tree-sitter-rescript) — names nested in the *_binding child.
+  rescript: `
+    (let_declaration (let_binding (value_identifier) @function.definition))
+    (type_declaration (type_binding (type_identifier) @type.definition))
+    (module_declaration (module_binding (module_identifier) @namespace.definition))
+  `,
 };
 
 // Names that tree-sitter-c / tree-sitter-cpp sometimes emit as the `name:`
@@ -1361,6 +1451,24 @@ export class TreeSitterProvider {
       }
     }
 
+    // OCaml / ReScript — the definition's name lives one level down in the
+    // grammar's `*_binding` child (value_definition → let_binding → value_name;
+    // type_definition → type_binding → type_constructor/type_identifier;
+    // module_definition → module_binding → module_name/module_identifier). The
+    // wrapper node-type strings below are unique to tree-sitter-ocaml/rescript,
+    // so this branch is a null-op for every other grammar.
+    const BINDING_WRAPPER = OCAML_RESCRIPT_BINDING_WRAPPERS[node.type];
+    if (BINDING_WRAPPER) {
+      for (let i = 0; i < node.childCount; i++) {
+        const binding = node.child(i);
+        if (binding.type !== BINDING_WRAPPER) continue;
+        for (let j = 0; j < binding.childCount; j++) {
+          const nm = binding.child(j);
+          if (IDENT_TYPES.has(nm.type)) return nm.text;
+        }
+      }
+    }
+
     // Fallback: look for identifier-type children (uses IDENT_TYPES set).
     // Visibility-keyword stoplist: tree-sitter-ruby parses bare `private`,
     // `protected`, `public` (with no args) as standalone `identifier`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sweet-search",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "Sweet Search - SOTA Hybrid Code Search Engine with WASM CatBoost Query Router, Semantic/Lexical/Structural Search, and Multilingual Support",
   "type": "module",
   "main": "core/search/sweet-search.js",
@@ -167,13 +167,13 @@
     "vitest": "^4.0.16"
   },
   "optionalDependencies": {
-    "@sweet-search/native-darwin-arm64": "2.6.2",
-    "@sweet-search/native-darwin-x64": "2.6.2",
-    "@sweet-search/native-linux-arm64-gnu": "2.6.2",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.2",
-    "@sweet-search/native-linux-x64-gnu": "2.6.2",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.2",
-    "@sweet-search/bg-priority": "2.6.2"
+    "@sweet-search/native-darwin-arm64": "2.6.4",
+    "@sweet-search/native-darwin-x64": "2.6.4",
+    "@sweet-search/native-linux-arm64-gnu": "2.6.4",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.4",
+    "@sweet-search/native-linux-x64-gnu": "2.6.4",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.4",
+    "@sweet-search/bg-priority": "2.6.4"
   },
   "engines": {
     "node": ">=18.0.0"