sweet-search 2.6.1 → 2.6.4

package/core/infrastructure/config/search.js

@@ -51,9 +51,29 @@ export const ROUTING_CONFIG = {
 export const FILE_PATTERNS = {
   include: [
     // Source code (all major languages)
-    '**/*.{js,jsx,ts,tsx,mjs,cjs}',      // JavaScript/TypeScript
+    '**/*.{js,jsx,ts,tsx,mjs,cjs,cts,mts}', // JavaScript/TypeScript (incl. CommonJS/ESM TS)
     '**/*.{java,kt,kts,scala,groovy}',    // JVM
     '**/*.{clj,cljc,cljs,edn}',           // Clojure / ClojureScript / EDN
+    '**/*.jl',                             // Julia
+    '**/*.{R,r,Rd,rd,Rmd,rmd}',            // R (case-sensitive matcher: list both cases)
+    '**/*.{ml,mli,mll,mly}',               // OCaml
+    '**/*.{res,resi}',                     // ReScript
+    '**/*.{hs,lhs}',                       // Haskell
+    '**/*.{erl,hrl}',                      // Erlang
+    '**/*.{pl,pm,pod}',                    // Perl
+    '**/*.{f,for,f90,f95,f03,f08,F,F90,F95}', // Fortran (case-sensitive)
+    '**/*.{cob,cbl}',                      // COBOL
+    '**/*.{asm,s,S}',                      // Assembly (case-sensitive)
+    '**/*.{cr,vala,hx,pas,nix,vim}',       // Crystal / Vala / Haxe / Pascal / Nix / Vim
+    '**/*.{elm,sol,tla,rdl,el,ejs}',       // Elm / Solidity / TLA+ / SystemRDL / Emacs Lisp / EJS
+    '**/*.{ql,qll}',                       // CodeQL
+    '**/*.{zeek,bro}',                     // Zeek
+    '**/*.{tcl,tk}',                       // Tcl
+    '**/*.astro',                          // Astro (SFC)
+    // GPU shaders
+    '**/*.{glsl,vert,frag,comp,geom,tesc,tese}', // GLSL
+    '**/*.{hlsl,hlsli}',                   // HLSL
+    '**/*.{metal,wgsl,shader,cg,cginc}',   // Metal / WGSL / ShaderLab / Cg
     '**/*.{py,pyi}',                       // Python
     '**/*.go',                              // Go
     '**/*.rs',                              // Rust
@@ -72,7 +92,10 @@ export const FILE_PATTERNS = {
     '**/*.{yaml,yml}',                      // YAML
     '**/*.toml',                             // TOML
     '**/*.{xml,xsl,xsd,wsdl,pom,csproj}',  // XML
-    '**/*.{md,mdx,mdc,rst,txt}',           // Documentation + Cursor rules
+    '**/*.{tf,tfvars,hcl}',                // Terraform / HCL
+    '**/*.{ini,cfg}',                      // INI / config
+    '**/*.properties',                     // Java properties
+    '**/*.{md,mdx,mdc,rst,txt,markdown}',  // Documentation + Cursor rules
     '**/*.{html,htm,xhtml,vue,svelte}',    // Web markup/SFC
     '**/*.{css,scss,sass,less}',           // Stylesheets
     '**/*.svg',                             // SVG
@@ -82,6 +105,15 @@ export const FILE_PATTERNS = {
     '**/*.dockerfile',                     // Dockerfile alt extension
     '**/Makefile',                         // Makefile
     '**/*.mk',                            // Makefile includes
+    '**/*.cmake',                          // CMake modules
+    '**/*.gradle',                         // Gradle (Groovy DSL)
+    '**/*.ninja',                          // Ninja
+    '**/*.{bzl,star}',                     // Bazel / Starlark
+    '**/BUILD', '**/BUILD.bazel',          // Bazel BUILD
+    '**/WORKSPACE', '**/WORKSPACE.bazel',  // Bazel WORKSPACE
+    '**/meson.build',                      // Meson
+    '**/Earthfile',                        // Earthly
+    '**/justfile', '**/Justfile',          // Just
     // Project markers
     '**/CLAUDE.md',
     '**/AGENTS.md',

package/core/infrastructure/language-patterns/maps.js

@@ -119,8 +119,72 @@ export const EXTENSION_MAP = {
   // F# / VB (.NET additional)
   // '.vb' omitted — no LANGUAGES.vb entry exists
 
+  // Julia
+  '.jl': 'julia',
+
+  // R — the lookup lowercases the key, so '.r'/'.rd'/'.rmd' also resolve the
+  // canonical uppercase on-disk forms (.R/.Rd/.Rmd). Keep keys lowercase only.
+  '.r': 'r', '.rd': 'r', '.rmd': 'r',
+
+  // OCaml (tree-sitter-ocaml ships in the bundle but is unwired → generic chunking)
+  '.ml': 'ocaml', '.mli': 'ocaml', '.mll': 'ocaml', '.mly': 'ocaml',
+
+  // TypeScript modules (CommonJS / ESM) — reuse the wired typescript grammar.
+  // Map to 'typescript' not 'tsx': .cts/.mts cannot contain JSX.
+  '.cts': 'typescript', '.mts': 'typescript',
+
+  // Other bundled-grammar languages (unwired → lossless generic chunking)
+  '.elm': 'elm',
+  '.sol': 'solidity',
+  '.res': 'rescript', '.resi': 'rescript',
+  '.ql': 'ql', '.qll': 'ql',
+  '.tla': 'tlaplus',
+  '.rdl': 'systemrdl',
+  '.el': 'elisp',
+  '.ejs': 'embedded_template',
+
+  // Functional / systems / scripting
+  '.hs': 'haskell', '.lhs': 'haskell',
+  '.erl': 'erlang', '.hrl': 'erlang',
+  '.cr': 'crystal',
+  '.vala': 'vala',
+  '.hx': 'haxe',
+  '.pas': 'pascal',
+  '.nix': 'nix',
+  '.pl': 'perl', '.pm': 'perl', '.pod': 'perl',
+  '.vim': 'vim',
+  '.tcl': 'tcl', '.tk': 'tcl',
+  '.zeek': 'zeek', '.bro': 'zeek',
+
+  // Scientific / legacy (lowercase keys cover the uppercase .F/.F90/.S forms)
+  '.f': 'fortran', '.for': 'fortran', '.f90': 'fortran', '.f95': 'fortran',
+  '.f03': 'fortran', '.f08': 'fortran',
+  '.cob': 'cobol', '.cbl': 'cobol',
+  '.asm': 'assembly', '.s': 'assembly',
+
+  // GPU shaders
+  '.glsl': 'glsl', '.vert': 'glsl', '.frag': 'glsl', '.comp': 'glsl',
+  '.geom': 'glsl', '.tesc': 'glsl', '.tese': 'glsl',
+  '.hlsl': 'hlsl', '.hlsli': 'hlsl',
+  '.metal': 'metal',
+  '.wgsl': 'wgsl',
+  '.shader': 'shaderlab',
+  '.cg': 'cg', '.cginc': 'cg',
+
+  // Web framework SFC — reuse the html SFC path (like .vue/.svelte)
+  '.astro': 'html',
+
+  // Infra / build / config DSLs
+  '.tf': 'hcl', '.tfvars': 'hcl', '.hcl': 'hcl',
+  '.ini': 'ini', '.cfg': 'ini',
+  '.properties': 'properties',
+  '.cmake': 'cmake',
+  '.gradle': 'gradle',
+  '.ninja': 'ninja',
+  '.bzl': 'starlark', '.star': 'starlark',
+
   // Document formats (dispatched to DocumentChunker in ast-chunker.js)
-  '.md': 'markdown', '.mdx': 'markdown',
+  '.md': 'markdown', '.mdx': 'markdown', '.markdown': 'markdown',
   '.rst': 'rst',
   '.txt': 'plaintext',
 };
@@ -130,4 +194,11 @@ export const FILENAME_MAP = {
   Dockerfile: 'dockerfile',
   Makefile: 'makefile',
   GNUmakefile: 'makefile',
+  // Extensionless build / project files (mirrors the Dockerfile/Makefile pattern)
+  BUILD: 'starlark',
+  WORKSPACE: 'starlark',
+  'meson.build': 'meson',
+  Earthfile: 'earthfile',
+  justfile: 'just',
+  Justfile: 'just',
 };

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.1",
+  "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.1",
-    "@sweet-search/native-darwin-x64": "2.6.1",
-    "@sweet-search/native-linux-arm64-gnu": "2.6.1",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.1",
-    "@sweet-search/native-linux-x64-gnu": "2.6.1",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.1",
-    "@sweet-search/bg-priority": "2.6.1"
+    "@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"