sweet-search 2.6.2 → 2.6.5

package/core/infrastructure/constants.js

@@ -3,6 +3,8 @@
  * Extracted to prevent drift between graph-search.js and sweet-search.js
  */
 
+import { EXTENSION_MAP } from './language-patterns/maps.js';
+
 export const SYMBOL_KIND_WEIGHTS = {
   class: 1.0,
   interface: 0.95,
@@ -26,25 +28,43 @@ export const DEFINITION_TYPES = new Set([
 ]);
 
 /**
- * Canonical set of code file extensions recognized by sweet-search.
- * Used by both the indexer (sparse gram builder) and the search pipeline
- * (ripgrep type filter + code file detection). Single source of truth.
+ * Canonical set of code file extensions recognized by sweet-search's
+ * grep/pattern path — the sparse-gram literal index, native-grep extension
+ * filter, ripgrep `--type-add code` fallback, and `isRipgrepCodePath`.
+ *
+ * DERIVED from EXTENSION_MAP (the single source of truth for which extensions
+ * sweet-search indexes) so ss-grep coverage can NEVER drift behind newly-added
+ * languages. This drift previously dropped Solidity, .cts/.mts, .cljc/.cljs/.edn,
+ * .mli, .rd/.rmd, shaders, build DSLs, etc. from ss-grep even though they were
+ * discovered + embedded (so ss-search worked but ss-grep silently returned
+ * nothing). Keys are stored bare + lowercase (no leading dot) to match
+ * `path.extname(f).slice(1).toLowerCase()` at the call sites.
+ *
+ * Pure document formats (Markdown/reStructuredText/plaintext) are intentionally
+ * EXCLUDED — they go through DocumentChunker and are not part of the grep
+ * code-path (isRipgrepCodePath('README.md') must stay false, and sparse-gram
+ * candidate lists drop doc files). Config/markup/style formats (json/yaml/xml/
+ * html/css/ini/…) stay in, matching the historical set.
+ *
+ * Plus a few historically grep-able languages that have no EXTENSION_MAP entry
+ * (no chunker grammar): Ada, D, V.
  */
+const DOC_FORMAT_LANGUAGE_IDS = new Set(['markdown', 'rst', 'plaintext']);
+const LEGACY_EXTRA_CODE_EXTENSIONS = ['ada', 'd', 'v'];
 export const CODE_FILE_EXTENSIONS = new Set([
-  'js', 'ts', 'jsx', 'tsx', 'py', 'rs', 'go', 'java', 'c', 'cpp', 'h', 'hpp',
-  'cs', 'rb', 'php', 'swift', 'kt', 'scala', 'lua', 'sh', 'zig', 'hs', 'ml',
-  'ex', 'exs', 'clj', 'erl', 'r', 'jl', 'dart', 'v', 'nim', 'cr', 'd', 'f90',
-  'ada', 'pas', 'cob', 'pl', 'pm', 'sql', 'graphql', 'proto', 'yaml', 'yml',
-  'json', 'toml', 'xml', 'html', 'css', 'scss', 'sass', 'less', 'svelte',
-  'vue', 'astro', 'mdx',
+  ...Object.entries(EXTENSION_MAP)
+    .filter(([, id]) => !DOC_FORMAT_LANGUAGE_IDS.has(id))
+    .map(([ext]) => ext.replace(/^\./, '').toLowerCase()),
+  ...LEGACY_EXTRA_CODE_EXTENSIONS,
 ]);
 
 /**
  * Ripgrep type definition glob matching CODE_FILE_EXTENSIONS.
- * Used with --type-add to define a custom 'code' type for ripgrep.
+ * Used with --type-add to define a custom 'code' type for ripgrep. Derived from
+ * the same set so it stays in lockstep.
  */
 export const RIPGREP_CODE_TYPE_GLOB =
-  'code:*.{js,ts,jsx,tsx,py,rs,go,java,c,cpp,h,hpp,cs,rb,php,swift,kt,scala,lua,sh,zig,hs,ml,ex,exs,clj,erl,r,jl,dart,v,nim,cr,d,f90,ada,pas,cob,pl,pm,sql,graphql,proto,yaml,yml,json,toml,xml,html,css,scss,sass,less,svelte,vue,astro,mdx}';
+  `code:*.{${Array.from(CODE_FILE_EXTENSIONS).join(',')}}`;
 
 /**
  * Sparse gram symbol type bitmasks.

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.5",
   "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.5",
+    "@sweet-search/native-darwin-x64": "2.6.5",
+    "@sweet-search/native-linux-arm64-gnu": "2.6.5",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.5",
+    "@sweet-search/native-linux-x64-gnu": "2.6.5",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.5",
+    "@sweet-search/bg-priority": "2.6.5"
   },
   "engines": {
     "node": ">=18.0.0"