sweet-search 2.6.5 → 2.6.8

package/core/graph/graph-extractor.js

@@ -1394,7 +1394,11 @@ export class GraphExtractor {
 
       const groupEnd = j - 1;
       const groupContent = source.slice(start, groupEnd);
-      const isOptional = source[groupEnd + 1] === '?';
+      // A group quantified by `?` OR `*` can match zero times, so the tokens
+      // AFTER it (e.g. the real keyword) may start the line. Treating a `(?:…)*`
+      // modifier prefix as mandatory wrongly rejected lines like `class Foo`
+      // (QL/Vala/Haxe leading-modifier patterns), dropping all their entities.
+      const isOptional = source[groupEnd + 1] === '?' || source[groupEnd + 1] === '*';
       if (!isOptional) {
         const alternatives = groupContent.split('|').map((alt) => alt.trim()).filter(Boolean);
         const altTokens = [];
@@ -1409,7 +1413,14 @@ export class GraphExtractor {
       const optionalAlternatives = groupContent.split('|').map((alt) => alt.trim()).filter(Boolean);
       for (const alt of optionalAlternatives) {
         const token = this.extractLiteralPrefix(alt);
-        if (token) tokens.push(token);
+        // A nested group / non-literal alternative (e.g. `(?:(?:public|…)\s+)*`)
+        // means we cannot enumerate every literal this optional prefix could
+        // start with. Adding only the literals we *can* see would
+        // false-negative lines that begin with an un-enumerated one (Vala/Haxe
+        // `public class Foo`). Disabling the prefilter is the only
+        // correctness-preserving choice; the full regex still runs per line.
+        if (!token) return [];
+        tokens.push(token);
       }
       i = groupEnd + 2;
       while (skipLeadingWhitespace()) {}

package/core/infrastructure/config/search.js

@@ -67,7 +67,7 @@ export const FILE_PATTERNS = {
     '**/*.{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
+    '**/*.{zeek,bro,bif,pac,pac2,spicy,evt,hlt}', // Zeek + BiF + BinPAC + Spicy DSLs
     '**/*.{tcl,tk}',                       // Tcl
     '**/*.astro',                          // Astro (SFC)
     // GPU shaders
@@ -83,6 +83,23 @@ export const FILE_PATTERNS = {
     '**/*.php',                             // PHP
     '**/*.{swift,m,mm}',                   // Apple
     '**/*.{lua,zig,nim,ex,exs,dart}',      // Other
+    // ── Task-bench coverage audit (2026-07): additional source / DSL / template / build ──
+    '**/*.{pyx,pxd,pxi}',                   // Cython
+    '**/*.{sbt,sc}',                        // Scala build / worksheets
+    '**/*.{rake,gemspec,podspec,ru}',      // Ruby build/manifest DSLs
+    '**/*.{coffee,litcoffee}',             // CoffeeScript
+    '**/*.{pcss,styl}',                     // PostCSS / Stylus
+    '**/*.{twig,liquid,njk,hbs,handlebars,mustache,gohtml,eex,heex,leex}', // HTML templating
+    '**/*.{pug,jade,haml,slim}',           // Indentation templating
+    '**/*.{jinja,jinja2,j2,tera,tmpl,tpl,gotmpl}', // Text templating
+    '**/*.{props,targets,proj,vbproj,fsproj,resx,nuspec}', // .NET / MSBuild
+    '**/*.{m4,ac,am}',                     // Autotools
+    '**/*.{awk,sed}',                      // Text-processing scripts
+    '**/*.ipynb',                          // Jupyter notebooks (generic fixed-window chunking)
+    '**/*.in',                             // Autoconf/config templates (Makefile.in, *.py.in)
+    '**/*.sln',                            // Visual Studio solution
+    '**/go.mod', '**/go.work',             // Go module / workspace manifests
+    '**/Rakefile', '**/Gemfile',           // Ruby (extensionless)
     '**/*.{sh,bash,zsh,fish,ps1}',         // Shell
     '**/*.sql',                             // SQL
     '**/*.proto',                           // Protobuf

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

@@ -155,6 +155,9 @@ export const EXTENSION_MAP = {
   '.vim': 'vim',
   '.tcl': 'tcl', '.tk': 'tcl',
   '.zeek': 'zeek', '.bro': 'zeek',
+  // Zeek build-time DSLs: BiF declarations, BinPAC + Spicy parser sources (generic chunking)
+  '.bif': 'zeek', '.pac': 'zeek', '.pac2': 'zeek',
+  '.spicy': 'spicy', '.evt': 'spicy', '.hlt': 'spicy',
 
   // Scientific / legacy (lowercase keys cover the uppercase .F/.F90/.S forms)
   '.f': 'fortran', '.for': 'fortran', '.f90': 'fortran', '.f95': 'fortran',
@@ -183,6 +186,37 @@ export const EXTENSION_MAP = {
   '.ninja': 'ninja',
   '.bzl': 'starlark', '.star': 'starlark',
 
+  // ── Task-bench coverage audit (2026-07): additional source / DSL / template / build ──
+  // Cython (Python-like syntax → reuse the wired python chunker)
+  '.pyx': 'python', '.pxd': 'python', '.pxi': 'python',
+  // Scala build definitions / worksheets (→ scala grammar)
+  '.sbt': 'scala', '.sc': 'scala',
+  // Ruby build & manifest DSLs (→ ruby grammar)
+  '.rake': 'ruby', '.gemspec': 'ruby', '.podspec': 'ruby', '.ru': 'ruby',
+  // CoffeeScript (no bundled grammar → generic chunking)
+  '.coffee': 'coffeescript', '.litcoffee': 'coffeescript',
+  // Style preprocessors
+  '.pcss': 'css', '.styl': 'stylus',
+  // HTML-based templating (reuse the html SFC path, like .vue/.svelte)
+  '.twig': 'html', '.liquid': 'html', '.njk': 'html', '.hbs': 'html',
+  '.handlebars': 'html', '.mustache': 'html', '.gohtml': 'html',
+  '.eex': 'html', '.heex': 'html', '.leex': 'html',
+  // Indentation-based templating (generic chunking; not HTML syntax)
+  '.pug': 'pug', '.jade': 'pug', '.haml': 'haml', '.slim': 'slim',
+  // Polymorphic text templating (any target text → generic chunking)
+  '.jinja': 'jinja', '.jinja2': 'jinja', '.j2': 'jinja',
+  '.tera': 'jinja', '.tmpl': 'jinja', '.tpl': 'jinja', '.gotmpl': 'jinja',
+  // .NET / MSBuild project & resource files (XML dialects → xml grammar)
+  '.props': 'xml', '.targets': 'xml', '.proj': 'xml',
+  '.vbproj': 'xml', '.fsproj': 'xml', '.resx': 'xml', '.nuspec': 'xml',
+  // Autotools / text-processing script sources (generic chunking)
+  '.m4': 'm4', '.ac': 'm4', '.am': 'makefile',
+  '.awk': 'awk', '.sed': 'sed',
+  // Jupyter notebooks — chunker-less id → parseGenericFile (fixed-window, lossless)
+  // over the raw JSON. Not JSON-AST-chunked (that would emit one giant cells chunk).
+  // Image-heavy notebooks self-filter via the admission maxFileSize (1MB) gate.
+  '.ipynb': 'jupyter',
+
   // Document formats (dispatched to DocumentChunker in ast-chunker.js)
   '.md': 'markdown', '.mdx': 'markdown', '.markdown': 'markdown',
   '.rst': 'rst',
@@ -201,4 +235,7 @@ export const FILENAME_MAP = {
   Earthfile: 'earthfile',
   justfile: 'just',
   Justfile: 'just',
+  // Ruby extensionless build files (→ ruby grammar)
+  Rakefile: 'ruby',
+  Gemfile: 'ruby',
 };

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

@@ -235,6 +235,503 @@ export const TOOLING_LANGUAGES = {
       skipCallObjects: [],
     },
   },
+  // ─── Julia (graph-only spike) ────────────────────────────────────────────────
+  // No `chunker` key → getLanguageByExtension returns chunker:null → ast-chunker
+  // keeps Julia on generic windowing. The `graph` patterns alone enable
+  // regex-based entity extraction so ss-trace/code-graph works.
+  julia: {
+    indentBased: false,
+    endKeyword: null,
+    comment: { line: "#", block: ["#=", "=#"] },
+    graph: {
+      entities: {
+        function: /^\s*function\s+([A-Za-z_]\w*)/,
+        shortFunction: /^\s*([A-Za-z_]\w*)\((?:[^()]*)\)\s*(?:::[\w.<>{} ]+)?\s*=(?!=)/,
+        struct: /^\s*(?:mutable\s+)?struct\s+([A-Za-z_]\w*)/,
+        module: /^\s*module\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*(?:using|import)\s+([\w.]+)/,
+      },
+      skipCallObjects: [],
+    },
+  },
+  // ════════════════════════════════════════════════════════════════════════════
+  // GRAPH-ONLY language entries (no `chunker` key → chunking stays generic via
+  // parseGenericFile; the `graph` regexes enable ss-trace / code-graph symbol
+  // extraction). Authored 2026-06 from each language's tree-sitter tags.scm /
+  // universal-ctags conventions. Entity-type keys are free-form (the regex graph
+  // path accepts any label, like Rust's existing const/static/type).
+  // ════════════════════════════════════════════════════════════════════════════
+  clojure: {
+    indentBased: false, endKeyword: null,
+    comment: { line: ";", block: null },
+    graph: {
+      entities: {
+        function: /^\s*\(def(?:n-?|multi|method)\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        macro: /^\s*\(defmacro\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        struct: /^\s*\(def(?:record|type)\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        interface: /^\s*\(defprotocol\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        constant: /^\s*\(def\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        module: /^\s*\(ns\s+([A-Za-z0-9*+!?<>=.\/'-]+)/,
+      },
+      relationships: { import: /^\s*\(:?(?:require|use)\s+'?\[?([A-Za-z0-9.*_-]+)/ },
+      skipCallObjects: ["let", "let*", "if", "when", "do", "fn", "map", "filter", "reduce"],
+    },
+  },
+  elisp: {
+    indentBased: false, endKeyword: null,
+    comment: { line: ";", block: null },
+    graph: {
+      entities: {
+        function: /^\s*\((?:cl-)?def(?:un|subst)\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        macro: /^\s*\((?:cl-)?defmacro\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        variable: /^\s*\(def(?:var|custom)\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        constant: /^\s*\(defconst\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        module: /^\s*\(defgroup\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+      },
+      relationships: { import: /^\s*\(require\s+'([A-Za-z0-9*+!?<>=\/_-]+)/ },
+      skipCallObjects: ["let", "let*", "if", "when", "unless", "cond", "setq", "lambda", "progn"],
+    },
+  },
+  haskell: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "--", block: ["{-", "-}"] },
+    graph: {
+      entities: {
+        function: /^\s*([a-z_][\w']*)\s*::/,
+        type: /^\s*(?:data|newtype|type)\s+([A-Z]\w*)/,
+        class: /^\s*class\s+(?:.*?=>\s*)?([A-Z]\w*)/,
+        instance: /^\s*instance\s+(?:.*?=>\s*)?([A-Z]\w*)/,
+        module: /^\s*module\s+([A-Z][\w.]*)/,
+      },
+      relationships: { import: /^\s*import\s+(?:qualified\s+)?([A-Z][\w.]*)/ },
+      skipCallObjects: ["map", "filter", "foldr", "foldl", "return", "pure", "print", "putStrLn", "fmap", "show"],
+    },
+  },
+  erlang: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "%", block: null },
+    graph: {
+      entities: {
+        module: /^\s*-module\(\s*([a-z]\w*)/,
+        function: /^\s*(?!fun\b)([a-z]\w*)\s*\((?:(?!fun\b).)*\)\s*(?:when\b.*)?->/,
+        struct: /^\s*-record\(\s*([a-z]\w*)/,
+        macro: /^\s*-define\(\s*([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*-import\(\s*([a-z]\w*)/,
+        include: /^\s*-include(?:_lib)?\(\s*"([^"]+)"/,
+        inherit: /^\s*-behaviou?r\(\s*([a-z]\w*)/,
+      },
+      skipCallObjects: ["lists", "io", "erlang", "maps", "string", "proplists", "gen_server"],
+    },
+  },
+  elm: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "--", block: ["{-", "-}"] },
+    graph: {
+      entities: {
+        function: /^\s*([a-z]\w*)\s*:/,
+        type: /^\s*type\s+alias\s+([A-Z]\w*)/,
+        enum: /^\s*type\s+([A-Z]\w*)/,
+        port: /^\s*port\s+([a-z]\w*)\s*:/,
+        module: /^\s*(?:port\s+|effect\s+)?module\s+([A-Z][\w.]*)/,
+      },
+      relationships: { import: /^\s*import\s+([A-Z][\w.]*)/ },
+      skipCallObjects: ["List", "Maybe", "Result", "Html", "String", "Debug"],
+    },
+  },
+  r: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*([A-Za-z.][\w.]*)\s*(?:<<?-|=)\s*function\b/,
+        class: /^\s*set(?:Ref)?Class\s*\(\s*["']([A-Za-z.][\w.]*)["']/,
+        method: /^\s*setMethod\s*\(\s*["']([A-Za-z.][\w.]*)["']/,
+      },
+      relationships: {
+        import: /^\s*(?:library|require)\s*\(\s*["']?([A-Za-z.][\w.]*)["']?/,
+        source: /^\s*source\s*\(\s*["']([^"']+)["']/,
+      },
+      skipCallObjects: ["c", "list", "print", "cat", "paste", "paste0", "return", "stop", "warning"],
+    },
+  },
+  perl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*sub\s+([A-Za-z_]\w*)/,
+        module: /^\s*package\s+([\w:]+)/,
+        constant: /^\s*use\s+constant\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*(?:use|require)\s+([A-Z][\w:]*)/,
+        inherit: /^\s*use\s+(?:parent|base)\s+(?:-norequire\s*,?\s*)?(?:qw[(\/{[|]\s*)?["']?([\w:]+)["']?/,
+      },
+      skipCallObjects: ["print", "say", "shift", "push", "pop", "return", "my", "scalar", "keys", "values"],
+    },
+  },
+  tcl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*proc\s+([^\s{]+)/,
+        module: /^\s*namespace\s+eval\s+([^\s{]+)/,
+      },
+      relationships: {
+        import: /^\s*package\s+require\s+([\w:]+)/,
+        source: /^\s*source\s+(\S+)/,
+      },
+      skipCallObjects: ["set", "puts", "expr", "return", "string", "list", "lappend", "incr", "if", "foreach"],
+    },
+  },
+  vim: {
+    indentBased: false, endKeyword: null,
+    comment: { line: '"', block: null },
+    graph: {
+      entities: {
+        function: /^\s*func(?:tion)?!?\s+([A-Za-z_<][\w#:.>]*)/,
+        command: /^\s*command!?\s+(?:-\S+\s+)*([A-Z]\w*)/,
+        constant: /^\s*let\s+([gsb]:[A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*(?:source|runtime)!?\s+(\S+)/ },
+      skipCallObjects: ["echo", "echom", "call", "let", "set", "execute", "normal"],
+    },
+  },
+  crystal: {
+    indentBased: false, endKeyword: "end",
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        method: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?=]?)/,
+        class: /^\s*(?:abstract\s+)?class\s+([A-Z]\w*)/,
+        module: /^\s*module\s+([A-Z]\w*)/,
+        struct: /^\s*(?:abstract\s+)?struct\s+([A-Z]\w*)/,
+        enum: /^\s*enum\s+([A-Z]\w*)/,
+        macro: /^\s*macro\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*require\s+"([^"]+)"/,
+        inherit: /^\s*(?:abstract\s+)?(?:class|struct)\s+[A-Z]\w*\s*<\s*([A-Z][\w:]*)/,
+        include: /^\s*(?:include|extend)\s+([A-Z][\w:]*)/,
+      },
+      skipCallObjects: ["puts", "print", "p", "pp", "raise", "self"],
+    },
+  },
+  fortran: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "!", block: null },
+    graph: {
+      entities: {
+        module: /^\s*(?:module(?!\s+(?:procedure|subroutine|function)\b)|program)\s+([a-z_]\w*)/i,
+        function: /^\s*(?!end\b)(?:[\w()*,:=.]+\s+)*?(?:subroutine|function)\s+([a-z_]\w*)/i,
+        struct: /^\s*type\b\s*(?:,[^:]*)?(?:::\s*)?(?!is\b)([a-z_]\w*)/i,
+        interface: /^\s*interface\s+([a-z_]\w*)/i,
+      },
+      relationships: { use: /^\s*use\b\s*(?:,[^:]*::\s*)?([a-z_]\w*)/i },
+      skipCallObjects: [],
+    },
+  },
+  cobol: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "*>", block: null },
+    graph: {
+      entities: {
+        module: /^\s*program-id\s*\.\s*([a-z0-9][a-z0-9-]*)/i,
+        class: /^\s*([a-z0-9][a-z0-9-]*)\s+section\s*\./i,
+        function: /^\s*(?!(?:end-[a-z]+|exit|goback|continue|stop)\b)([a-z0-9][a-z0-9-]*)\s*\.\s*$/i,
+      },
+      relationships: {
+        copyFrom: /^\s*copy\s+([a-z0-9][a-z0-9-]*)/i,
+        // CALL "subprog" → dependency edge (`call` is not a mapped relationship
+        // type; `dep` is the canonical generic-dependency key).
+        dep: /^\s*call\s+["']([a-z0-9][a-z0-9-]*)/i,
+      },
+      skipCallObjects: [],
+    },
+  },
+  assembly: {
+    indentBased: false, endKeyword: null,
+    comment: { line: ";", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^([a-zA-Z_][\w$.]*)\s*:/,
+        macro: /^\s*(?:\.macro\s+|%macro\s+|%define\s+)([a-zA-Z_][\w$.]*)/i,
+        constant: /^\s*([a-zA-Z_][\w$.]*)\s+equ\b/i,
+      },
+      relationships: {
+        import: /^\s*(?:\.extern|extern)\s+([a-zA-Z_][\w$.]*)/i,
+        include: /^\s*(?:%include|\.include)\s+["']?([^"'\s,]+)/i,
+      },
+      skipCallObjects: [],
+    },
+  },
+  pascal: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["{", "}"] },
+    graph: {
+      entities: {
+        module: /^\s*(?:unit|program|library)\s+([a-z_]\w*)/i,
+        function: /^\s*(?:procedure|function)\s+([a-z_][\w.]*)/i,
+        class: /^\s*([a-z_]\w*)\s*=\s*class\b/i,
+        struct: /^\s*([a-z_]\w*)\s*=\s*(?:packed\s+)?(?:record|object)\b/i,
+        interface: /^\s*([a-z_]\w*)\s*=\s*interface\b/i,
+        enum: /^\s*([a-z_]\w*)\s*=\s*\(\s*[a-z_]\w*(?:\s*,\s*[a-z_]\w*)*\s*\)\s*;?/i,
+      },
+      relationships: { plainImport: /^\s*uses\s+([a-z_][\w.,\s]*)/i },
+      skipCallObjects: [],
+    },
+  },
+  vala: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        module: /^\s*(?:public\s+)?namespace\s+([A-Za-z_][\w.]*)/,
+        class: /^\s*(?:(?:public|private|protected|internal|abstract|sealed|static)\s+)*class\s+([A-Za-z_]\w*)/,
+        interface: /^\s*(?:(?:public|private|protected|internal)\s+)*interface\s+([A-Za-z_]\w*)/,
+        struct: /^\s*(?:(?:public|private|protected|internal)\s+)*struct\s+([A-Za-z_]\w*)/,
+        enum: /^\s*(?:(?:public|private|protected|internal)\s+)*enum\s+([A-Za-z_]\w*)/,
+        method: /^\s*(?!return\b|if\b|else\b|while\b|for\b|foreach\b|switch\b|case\b|do\b|new\b|throw\b|yield\b)(?:(?:public|private|protected|internal|static|virtual|override|abstract|async|extern|inline|sealed|weak|unowned|owned|const|signal|delegate)\s+)*[\w.<>?\[\]*]+\s+([a-z_]\w*)\s*\(/,
+      },
+      relationships: { using: /^\s*using\s+([A-Za-z_][\w.]*)/ },
+      skipCallObjects: [],
+    },
+  },
+  haxe: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        module: /^\s*package\s+([\w.]+)/,
+        class: /^\s*(?:(?:public|private|extern|final)\s+)*class\s+([A-Za-z_]\w*)/,
+        interface: /^\s*(?:(?:public|private|extern)\s+)*interface\s+([A-Za-z_]\w*)/,
+        enum: /^\s*(?:(?:public|private|extern)\s+)*enum\s+(?!abstract\b)([A-Za-z_]\w*)/,
+        type: /^\s*(?:(?:public|private)\s+)*typedef\s+([A-Za-z_]\w*)/,
+        struct: /^\s*(?:(?:public|private|extern)\s+)*(?:enum\s+)?abstract\s+([A-Za-z_]\w*)/,
+        method: /^\s*(?:[\w@:.]+\s+)*function\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*import\s+([\w.*]+)/,
+        using: /^\s*using\s+([\w.]+)/,
+      },
+      skipCallObjects: [],
+    },
+  },
+  nix: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: ["/*", "*/"] },
+    graph: {
+      // Require BOTH a space before `=` (rejects shell `VAR=val` in build-script
+      // strings) AND a trailing `;`/`{` (real Nix attrs always terminate with
+      // `;`, or open a nested attrset with `{`) — this drops the actively-harmful
+      // false positives from spaced `key = value` config embedded in `''…''`
+      // string literals (INI/systemd/gitconfig content), at the cost of missing
+      // multi-line string attrs (`x = ''`). Conservative by design.
+      entities: { constant: /^\s*([\w'.-]+)\s+=\s*(?!=).*?[;{]\s*$/ },
+      relationships: {},
+      skipCallObjects: [],
+    },
+  },
+  glsl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+        type: /^\s*layout\s*\([^)]*\)\s*(?:uniform|buffer)\s+([A-Za-z_]\w*)\s*\{/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["gl_Position", "gl_FragCoord", "gl_FragColor", "gl_FragDepth", "gl_VertexID", "gl_InstanceID"],
+    },
+  },
+  hlsl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+        type: /^\s*(?:cbuffer|tbuffer|ConstantBuffer)\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["input", "output", "SV_Target", "SV_Position", "SV_Depth"],
+    },
+  },
+  metal: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*#\s*(?:include|import)\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["metal", "simd", "threadgroup", "device", "constant"],
+    },
+  },
+  wgsl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*fn\s+([A-Za-z_]\w*)/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*(?:@\w+\([^)]*\)\s*)*(?:const|override|var(?:<[^>]*>)?)\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {},
+      skipCallObjects: [],
+    },
+  },
+  shaderlab: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        type: /^\s*Shader\s+"([^"]+)"/,
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*(_[A-Za-z]\w*)\s*\(\s*"/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["UNITY_MATRIX_MVP", "_Time", "_WorldSpaceCameraPos", "unity_ObjectToWorld"],
+    },
+  },
+  cg: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["UNITY_MATRIX_MVP", "_Time", "_WorldSpaceCameraPos"],
+    },
+  },
+  hcl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        resource: /^\s*resource\s+"[^"]+"\s+"([^"]+)"/,
+        data: /^\s*data\s+"[^"]+"\s+"([^"]+)"/,
+        variable: /^\s*variable\s+"([^"]+)"/,
+        module: /^\s*module\s+"([^"]+)"/,
+        output: /^\s*output\s+"([^"]+)"/,
+        provider: /^\s*provider\s+"([^"]+)"/,
+      },
+      relationships: { import: /^\s*source\s*=\s*"([^"]+)"/ },
+      skipCallObjects: [],
+    },
+  },
+  cmake: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*function\s*\(\s*([A-Za-z_]\w*)/i,
+        macro: /^\s*macro\s*\(\s*([A-Za-z_]\w*)/i,
+        constant: /^\s*set\s*\(\s*([A-Za-z_]\w*)/i,
+      },
+      relationships: { import: /^\s*(?:include|add_subdirectory|find_package)\s*\(\s*([A-Za-z_0-9./${}-]+)/i },
+      skipCallObjects: [],
+    },
+  },
+  gradle: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        task: /^\s*task\s+([A-Za-z_]\w*)/,
+        def: /^\s*def\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*import\s+([\w.]+)/ },
+      skipCallObjects: [],
+    },
+  },
+  starlark: {
+    indentBased: true, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*def\s+([A-Za-z_]\w*)/,
+        rule: /^\s*([A-Za-z_]\w*)\s*=\s*(?:rule|provider|aspect|repository_rule|tag_class|module_extension)\s*\(/,
+      },
+      relationships: { import: /^\s*load\s*\(\s*["']([^"']+)["']/ },
+      skipCallObjects: [],
+    },
+  },
+  ql: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        class: /^\s*(?:abstract\s+|final\s+|private\s+|library\s+|deprecated\s+|additional\s+|external\s+|extensible\s+)*class\s+([A-Za-z_]\w*)/,
+        function: /^\s*(?:abstract\s+|cached\s+|private\s+|final\s+|override\s+|additional\s+|deprecated\s+|library\s+|external\s+|extensible\s+|pragma\s*\[[^\]]*\]\s+|bindingset\s*\[[^\]]*\]\s+)*(?!(?:and|or|not|if|then|else|in|exists|forall|forex|count|sum|strictsum|strictcount|any|none|select|where|from|instanceof)\b)(?:[A-Za-z_][\w.]*)\s+([a-z_]\w*)\s*\(/,
+        module: /^\s*(?:private\s+|library\s+)*module\s+([A-Za-z_]\w*)/,
+        type: /^\s*newtype\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*(?:private\s+)?import\s+([\w.]+)/,
+        extends: /\bclass\s+\w+\s+extends\s+([\w.]+)/,
+      },
+      skipCallObjects: [],
+    },
+  },
+  systemrdl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        addrmap: /^\s*addrmap\s+([A-Za-z_]\w*)/,
+        regfile: /^\s*regfile\s+([A-Za-z_]\w*)/,
+        reg: /^\s*reg\s+([A-Za-z_]\w*)/,
+        field: /^\s*field\s+([A-Za-z_]\w*)/,
+        mem: /^\s*mem\s+([A-Za-z_]\w*)/,
+        signal: /^\s*signal\s+([A-Za-z_]\w*)/,
+        enum: /^\s*enum\s+([A-Za-z_]\w*)/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {},
+      skipCallObjects: [],
+    },
+  },
+  zeek: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*function\s+([A-Za-z_][\w:]*)/,
+        event: /^\s*event\s+([A-Za-z_][\w:]*)/,
+        hook: /^\s*hook\s+([A-Za-z_][\w:]*)/,
+        global: /^\s*global\s+(?!function\b|event\b|hook\b)([A-Za-z_]\w*)/,
+        constant: /^\s*const\s+([A-Za-z_]\w*)/,
+        type: /^\s*type\s+([A-Za-z_]\w*)/,
+        module: /^\s*module\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*@load\s+([\w./-]+)/ },
+      skipCallObjects: [],
+    },
+  },
+  embedded_template: {
+    indentBased: false, endKeyword: null,
+    comment: { line: null, block: ["<%#", "%>"] },
+    graph: {
+      entities: {},
+      relationships: { include: /<%[-=]?\s*include\s*\(\s*['"`]([^'"`]+)['"`]/ },
+      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.

package/package.json

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