raggrep 0.14.2 → 0.15.0

package/dist/cli/main.js

@@ -16,7 +16,6 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -4536,6 +4535,153 @@ var init_phraseMatch = __esm(() => {
   ]);
 });
 
+// src/domain/services/simpleSearch.ts
+function isIdentifierQuery(query) {
+  const trimmed = query.trim();
+  if (trimmed.startsWith("`") && trimmed.endsWith("`") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return true;
+  }
+  for (const pattern of Object.values(IDENTIFIER_PATTERNS)) {
+    if (pattern.test(trimmed)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractSearchLiteral(query) {
+  const trimmed = query.trim();
+  if (trimmed.startsWith("`") && trimmed.endsWith("`")) {
+    return trimmed.slice(1, -1);
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function findOccurrences(content, literal, options = {}) {
+  const { maxOccurrences = 10, caseInsensitive = false } = options;
+  const occurrences = [];
+  const lines = content.split(`
+`);
+  const searchContent = caseInsensitive ? content.toLowerCase() : content;
+  const searchLiteral = caseInsensitive ? literal.toLowerCase() : literal;
+  let currentIndex = 0;
+  for (let lineNum = 0;lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    const searchLine = caseInsensitive ? line.toLowerCase() : line;
+    let columnStart = 0;
+    while (true) {
+      const column = searchLine.indexOf(searchLiteral, columnStart);
+      if (column === -1)
+        break;
+      occurrences.push({
+        line: lineNum + 1,
+        column,
+        lineContent: line,
+        contextBefore: lineNum > 0 ? lines[lineNum - 1] : undefined,
+        contextAfter: lineNum < lines.length - 1 ? lines[lineNum + 1] : undefined
+      });
+      if (occurrences.length >= maxOccurrences) {
+        return occurrences;
+      }
+      columnStart = column + 1;
+    }
+    currentIndex += line.length + 1;
+  }
+  return occurrences;
+}
+function searchFiles(files, literal, options = {}) {
+  const {
+    maxFiles = 20,
+    maxOccurrencesPerFile = 5,
+    caseInsensitive = false
+  } = options;
+  const matchingFiles = [];
+  let totalMatches = 0;
+  let totalFilesWithMatches = 0;
+  for (const [filepath, content] of files) {
+    const occurrences = findOccurrences(content, literal, {
+      maxOccurrences: maxOccurrencesPerFile,
+      caseInsensitive
+    });
+    if (occurrences.length > 0) {
+      totalFilesWithMatches++;
+      const searchContent = caseInsensitive ? content.toLowerCase() : content;
+      const searchLiteral = caseInsensitive ? literal.toLowerCase() : literal;
+      let matchCount = 0;
+      let index = 0;
+      while ((index = searchContent.indexOf(searchLiteral, index)) !== -1) {
+        matchCount++;
+        index += 1;
+      }
+      totalMatches += matchCount;
+      if (matchingFiles.length < maxFiles) {
+        matchingFiles.push({
+          filepath,
+          occurrences,
+          matchCount
+        });
+      }
+    }
+  }
+  matchingFiles.sort((a, b) => b.matchCount - a.matchCount);
+  return {
+    query: literal,
+    files: matchingFiles,
+    totalMatches,
+    totalFiles: totalFilesWithMatches,
+    truncated: totalFilesWithMatches > maxFiles
+  };
+}
+function isSearchableContent(content, filepath) {
+  if (content.length > 1024 * 1024) {
+    return false;
+  }
+  if (content.includes("\x00")) {
+    return false;
+  }
+  const binaryExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".webp",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".rar",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".avi"
+  ];
+  const ext = filepath.toLowerCase().slice(filepath.lastIndexOf("."));
+  if (binaryExtensions.includes(ext)) {
+    return false;
+  }
+  return true;
+}
+var IDENTIFIER_PATTERNS;
+var init_simpleSearch = __esm(() => {
+  IDENTIFIER_PATTERNS = {
+    screamingSnake: /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/,
+    camelCase: /^[a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]*)+$/,
+    pascalCase: /^[A-Z][a-z]+(?:[A-Z][a-z0-9]*)+$/,
+    snakeCase: /^[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/,
+    kebabCase: /^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/
+  };
+});
+
 // src/domain/services/index.ts
 var init_services = __esm(() => {
   init_keywords();
@@ -4547,6 +4693,7 @@ var init_services = __esm(() => {
   init_introspection();
   init_configValidator();
   init_phraseMatch();
+  init_simpleSearch();
 });
 
 // src/modules/language/typescript/parseCode.ts
@@ -9946,210 +10093,215 @@ var init_indexer = __esm(() => {
   DEFAULT_CONCURRENCY = getOptimalConcurrency();
 });
 
-// node_modules/balanced-match/index.js
-var require_balanced_match = __commonJS((exports, module) => {
-  module.exports = balanced;
-  function balanced(a, b, str) {
-    if (a instanceof RegExp)
-      a = maybeMatch(a, str);
-    if (b instanceof RegExp)
-      b = maybeMatch(b, str);
-    var r = range(a, b, str);
-    return r && {
-      start: r[0],
-      end: r[1],
-      pre: str.slice(0, r[0]),
-      body: str.slice(r[0] + a.length, r[1]),
-      post: str.slice(r[1] + b.length)
-    };
-  }
-  function maybeMatch(reg, str) {
-    var m = str.match(reg);
-    return m ? m[0] : null;
-  }
-  balanced.range = range;
-  function range(a, b, str) {
-    var begs, beg, left, right, result;
-    var ai = str.indexOf(a);
-    var bi = str.indexOf(b, ai + 1);
-    var i = ai;
-    if (ai >= 0 && bi > 0) {
-      if (a === b) {
-        return [ai, bi];
-      }
-      begs = [];
-      left = str.length;
-      while (i >= 0 && !result) {
-        if (i == ai) {
-          begs.push(i);
-          ai = str.indexOf(a, i + 1);
-        } else if (begs.length == 1) {
-          result = [begs.pop(), bi];
-        } else {
-          beg = begs.pop();
-          if (beg < left) {
-            left = beg;
-            right = bi;
-          }
-          bi = str.indexOf(b, i + 1);
+// node_modules/@isaacs/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+}, maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+}, range = (a, b, str) => {
+  let begs, beg, left, right = undefined, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== undefined)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== undefined && beg < left) {
+          left = beg;
+          right = bi;
         }
-        i = ai < bi && ai >= 0 ? ai : bi;
-      }
-      if (begs.length) {
-        result = [left, right];
+        bi = str.indexOf(b, i + 1);
       }
+      i = ai < bi && ai >= 0 ? ai : bi;
     }
-    return result;
-  }
-});
-
-// node_modules/brace-expansion/index.js
-var require_brace_expansion = __commonJS((exports, module) => {
-  var balanced = require_balanced_match();
-  module.exports = expandTop;
-  var escSlash = "\x00SLASH" + Math.random() + "\x00";
-  var escOpen = "\x00OPEN" + Math.random() + "\x00";
-  var escClose = "\x00CLOSE" + Math.random() + "\x00";
-  var escComma = "\x00COMMA" + Math.random() + "\x00";
-  var escPeriod = "\x00PERIOD" + Math.random() + "\x00";
-  function numeric(str) {
-    return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-  }
-  function escapeBraces(str) {
-    return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
-  }
-  function unescapeBraces(str) {
-    return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
-  }
-  function parseCommaParts(str) {
-    if (!str)
-      return [""];
-    var parts = [];
-    var m = balanced("{", "}", str);
-    if (!m)
-      return str.split(",");
-    var pre = m.pre;
-    var body = m.body;
-    var post = m.post;
-    var p = pre.split(",");
-    p[p.length - 1] += "{" + body + "}";
-    var postParts = parseCommaParts(post);
-    if (post.length) {
-      p[p.length - 1] += postParts.shift();
-      p.push.apply(p, postParts);
-    }
-    parts.push.apply(parts, p);
-    return parts;
-  }
-  function expandTop(str) {
-    if (!str)
-      return [];
-    if (str.substr(0, 2) === "{}") {
-      str = "\\{\\}" + str.substr(2);
+    if (begs.length && right !== undefined) {
+      result = [left, right];
     }
-    return expand(escapeBraces(str), true).map(unescapeBraces);
   }
-  function embrace(str) {
-    return "{" + str + "}";
-  }
-  function isPadded(el) {
-    return /^-?0\d/.test(el);
-  }
-  function lte(i, y) {
-    return i <= y;
+  return result;
+};
+
+// node_modules/@isaacs/brace-expansion/dist/esm/index.js
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
   }
-  function gte(i, y) {
-    return i >= y;
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand(str) {
+  if (!str) {
+    return [];
   }
-  function expand(str, isTop) {
-    var expansions = [];
-    var m = balanced("{", "}", str);
-    if (!m)
-      return [str];
-    var pre = m.pre;
-    var post = m.post.length ? expand(m.post, false) : [""];
-    if (/\$$/.test(m.pre)) {
-      for (var k = 0;k < post.length; k++) {
-        var expansion = pre + "{" + m.body + "}" + post[k];
-        expansions.push(expansion);
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0;k < post.length; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str);
       }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
     } else {
-      var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-      var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-      var isSequence = isNumericSequence || isAlphaSequence;
-      var isOptions = m.body.indexOf(",") >= 0;
-      if (!isSequence && !isOptions) {
-        if (m.post.match(/,(?!,).*\}/)) {
-          str = m.pre + "{" + m.body + escClose + m.post;
-          return expand(str);
-        }
-        return [str];
-      }
-      var n;
-      if (isSequence) {
-        n = m.body.split(/\.\./);
-      } else {
-        n = parseCommaParts(m.body);
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== undefined) {
+        n = expand_(n[0], false).map(embrace);
         if (n.length === 1) {
-          n = expand(n[0], false).map(embrace);
-          if (n.length === 1) {
-            return post.map(function(p) {
-              return m.pre + n[0] + p;
-            });
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== undefined && n[1] !== undefined) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x;test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
           }
-        }
-      }
-      var N;
-      if (isSequence) {
-        var x = numeric(n[0]);
-        var y = numeric(n[1]);
-        var width = Math.max(n[0].length, n[1].length);
-        var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-        var test = lte;
-        var reverse = y < x;
-        if (reverse) {
-          incr *= -1;
-          test = gte;
-        }
-        var pad = n.some(isPadded);
-        N = [];
-        for (var i = x;test(i, y); i += incr) {
-          var c;
-          if (isAlphaSequence) {
-            c = String.fromCharCode(i);
-            if (c === "\\")
-              c = "";
-          } else {
-            c = String(i);
-            if (pad) {
-              var need = width - c.length;
-              if (need > 0) {
-                var z = new Array(need + 1).join("0");
-                if (i < 0)
-                  c = "-" + z + c.slice(1);
-                else
-                  c = z + c;
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
               }
             }
           }
-          N.push(c);
-        }
-      } else {
-        N = [];
-        for (var j = 0;j < n.length; j++) {
-          N.push.apply(N, expand(n[j], false));
         }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0;j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], false));
       }
-      for (var j = 0;j < N.length; j++) {
-        for (var k = 0;k < post.length; k++) {
-          var expansion = pre + N[j] + post[k];
-          if (!isTop || isSequence || expansion)
-            expansions.push(expansion);
+    }
+    for (let j = 0;j < N.length; j++) {
+      for (let k = 0;k < post.length; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
         }
       }
     }
-    return expansions;
   }
+  return expansions;
+}
+var escSlash, escOpen, escClose, escComma, escPeriod, escSlashPattern, escOpenPattern, escClosePattern, escCommaPattern, escPeriodPattern, slashPattern, openPattern, closePattern, commaPattern, periodPattern;
+var init_esm = __esm(() => {
+  escSlash = "\x00SLASH" + Math.random() + "\x00";
+  escOpen = "\x00OPEN" + Math.random() + "\x00";
+  escClose = "\x00CLOSE" + Math.random() + "\x00";
+  escComma = "\x00COMMA" + Math.random() + "\x00";
+  escPeriod = "\x00PERIOD" + Math.random() + "\x00";
+  escSlashPattern = new RegExp(escSlash, "g");
+  escOpenPattern = new RegExp(escOpen, "g");
+  escClosePattern = new RegExp(escClose, "g");
+  escCommaPattern = new RegExp(escComma, "g");
+  escPeriodPattern = new RegExp(escPeriod, "g");
+  slashPattern = /\\\\/g;
+  openPattern = /\\{/g;
+  closePattern = /\\}/g;
+  commaPattern = /\\,/g;
+  periodPattern = /\\./g;
 });
 
 // node_modules/minimatch/dist/esm/assert-valid-pattern.js
@@ -10275,8 +10427,11 @@ var init_brace_expressions = __esm(() => {
 });
 
 // node_modules/minimatch/dist/esm/unescape.js
-var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
-  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+var unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+  }
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
 };
 
 // node_modules/minimatch/dist/esm/ast.js
@@ -10545,7 +10700,7 @@ class AST {
     if (this.#root === this)
       this.#fillNegs();
     if (!this.type) {
-      const noEmpty = this.isStart() && this.isEnd();
+      const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
       const src = this.#parts.map((p) => {
         const [re, _, hasMagic, uflag] = typeof p === "string" ? AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
         this.#hasMagic = this.#hasMagic || hasMagic;
@@ -10647,10 +10802,7 @@ class AST {
         }
       }
       if (c === "*") {
-        if (noEmpty && glob === "*")
-          re += starNoEmpty;
-        else
-          re += star;
+        re += noEmpty && glob === "*" ? starNoEmpty : star;
         hasMagic = true;
         continue;
       }
@@ -10676,7 +10828,10 @@ var init_ast = __esm(() => {
 });
 
 // node_modules/minimatch/dist/esm/escape.js
-var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
+  }
   return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
 };
 
@@ -11150,16 +11305,27 @@ globstar while`, file, fr, pattern, pr, swallowee);
             pp[i] = twoStar;
           }
         } else if (next === undefined) {
-          pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
         } else if (next !== GLOBSTAR) {
           pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
           pp[i + 1] = GLOBSTAR;
         }
       });
-      return pp.filter((p) => p !== GLOBSTAR).join("/");
+      const filtered = pp.filter((p) => p !== GLOBSTAR);
+      if (this.partial && filtered.length >= 1) {
+        const prefixes = [];
+        for (let i = 1;i <= filtered.length; i++) {
+          prefixes.push(filtered.slice(0, i).join("/"));
+        }
+        return "(?:" + prefixes.join("|") + ")";
+      }
+      return filtered.join("/");
     }).join("|");
     const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
     re = "^" + open + re + close + "$";
+    if (this.partial) {
+      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+    }
     if (this.negate)
       re = "^(?!" + re + ").+$";
     try {
@@ -11226,7 +11392,7 @@ globstar while`, file, fr, pattern, pr, swallowee);
     return minimatch.defaults(def).Minimatch;
   }
 }
-var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
+var minimatch = (p, pattern, options = {}) => {
   assertValidPattern(pattern);
   if (!options.nocomment && pattern.charAt(0) === "#") {
     return false;
@@ -11300,7 +11466,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
   if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     return [pattern];
   }
-  return import_brace_expansion.default(pattern);
+  return expand(pattern);
 }, makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe(), match = (list, pattern, options = {}) => {
   const mm = new Minimatch(pattern, options);
   list = list.filter((f) => mm.match(f));
@@ -11309,11 +11475,11 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
   }
   return list;
 }, globMagic, regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var init_esm = __esm(() => {
+var init_esm2 = __esm(() => {
+  init_esm();
   init_assert_valid_pattern();
   init_ast();
   init_ast();
-  import_brace_expansion = __toESM(require_brace_expansion(), 1);
   starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
   starDotStarRE = /^\*+\.\*+$/;
   dotStarRE = /^\.\*+$/;
@@ -11345,17 +11511,196 @@ var init_esm = __esm(() => {
 var init_types = __esm(() => {
   init_entities();
 });
+// src/domain/usecases/exactSearch.ts
+function matchesPathFilter(relativePath, filters, matchFn) {
+  const normalizedPath = relativePath.replace(/\\/g, "/");
+  for (const filter2 of filters) {
+    const normalizedFilter = filter2.replace(/\\/g, "/").replace(/^\//, "").replace(/\/$/, "");
+    const isGlobPattern = /[*?[\]{}!]/.test(normalizedFilter);
+    if (isGlobPattern) {
+      const pattern = normalizedFilter.startsWith("**/") ? normalizedFilter : `**/${normalizedFilter}`;
+      if (matchFn(normalizedPath, pattern)) {
+        return true;
+      }
+    } else {
+      if (normalizedPath.startsWith(normalizedFilter + "/") || normalizedPath === normalizedFilter || normalizedPath.includes("/" + normalizedFilter + "/")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function executeExactSearch(fs9, options, matchFn) {
+  const {
+    rootDir,
+    literal,
+    pathFilter = [],
+    maxFiles = 20,
+    maxOccurrencesPerFile = 5,
+    caseInsensitive = false
+  } = options;
+  const files = new Map;
+  async function walkDir(dir, baseDir) {
+    try {
+      const entries = await fs9.readDir(dir);
+      for (const entry of entries) {
+        const fullPath = fs9.join(dir, entry);
+        const relativePath = fs9.relative(baseDir, fullPath);
+        let isDirectory = false;
+        try {
+          const stats = await fs9.getStats(fullPath);
+          isDirectory = stats.isDirectory ?? false;
+        } catch {
+          continue;
+        }
+        if (isDirectory) {
+          if (DEFAULT_IGNORED_DIRS.includes(entry)) {
+            continue;
+          }
+          await walkDir(fullPath, baseDir);
+        } else {
+          if (pathFilter.length > 0) {
+            if (!matchesPathFilter(relativePath, pathFilter, matchFn)) {
+              continue;
+            }
+          }
+          try {
+            const content = await fs9.readFile(fullPath);
+            if (isSearchableContent(content, fullPath)) {
+              files.set(relativePath, content);
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  await walkDir(rootDir, rootDir);
+  return searchFiles(files, literal, {
+    maxFiles,
+    maxOccurrencesPerFile,
+    caseInsensitive
+  });
+}
+var DEFAULT_IGNORED_DIRS;
+var init_exactSearch = __esm(() => {
+  init_simpleSearch();
+  DEFAULT_IGNORED_DIRS = [
+    "node_modules",
+    ".git",
+    ".raggrep",
+    "dist",
+    "build",
+    ".next",
+    "__pycache__",
+    ".venv",
+    "venv"
+  ];
+});
+
+// src/domain/usecases/index.ts
+var init_usecases = __esm(() => {
+  init_exactSearch();
+});
+
+// src/infrastructure/filesystem/nodeFileSystem.ts
+import * as fs9 from "fs/promises";
+import * as path24 from "path";
+import { glob } from "glob";
+
+class NodeFileSystem {
+  async readFile(filepath) {
+    return fs9.readFile(filepath, "utf-8");
+  }
+  async writeFile(filepath, content) {
+    await fs9.mkdir(path24.dirname(filepath), { recursive: true });
+    await fs9.writeFile(filepath, content, "utf-8");
+  }
+  async deleteFile(filepath) {
+    try {
+      await fs9.unlink(filepath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async getStats(filepath) {
+    const stats = await fs9.stat(filepath);
+    return {
+      lastModified: stats.mtime.toISOString(),
+      size: stats.isDirectory() ? undefined : stats.size,
+      isDirectory: stats.isDirectory()
+    };
+  }
+  async exists(filepath) {
+    try {
+      await fs9.access(filepath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(dirpath) {
+    await fs9.mkdir(dirpath, { recursive: true });
+  }
+  async readDir(dirpath) {
+    return fs9.readdir(dirpath);
+  }
+  async findFiles(rootDir, patterns, ignore) {
+    const ignorePatterns = ignore.map((p) => `**/${p}/**`);
+    const files = [];
+    for (const pattern of patterns) {
+      const matches = await glob(pattern, {
+        cwd: rootDir,
+        absolute: true,
+        ignore: ignorePatterns
+      });
+      files.push(...matches);
+    }
+    return [...new Set(files)];
+  }
+  join(...segments) {
+    return path24.join(...segments);
+  }
+  relative(from, to) {
+    return path24.relative(from, to);
+  }
+  resolve(...segments) {
+    return path24.resolve(...segments);
+  }
+  dirname(filepath) {
+    return path24.dirname(filepath);
+  }
+  extname(filepath) {
+    return path24.extname(filepath);
+  }
+}
+var nodeFileSystem;
+var init_nodeFileSystem = __esm(() => {
+  nodeFileSystem = new NodeFileSystem;
+});
+
+// src/infrastructure/filesystem/index.ts
+var init_filesystem = __esm(() => {
+  init_nodeFileSystem();
+});
 
 // src/app/search/index.ts
 var exports_search = {};
 __export(exports_search, {
   search: () => search,
-  formatSearchResults: () => formatSearchResults
+  hybridSearch: () => hybridSearch,
+  formatSearchResults: () => formatSearchResults2,
+  formatHybridSearchResults: () => formatHybridSearchResults
 });
-import * as fs9 from "fs/promises";
-import * as path24 from "path";
+import * as fs10 from "fs/promises";
+import * as path25 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path24.resolve(rootDir);
+  const hybridResults = await hybridSearch(rootDir, query, options);
+  return hybridResults.results;
+}
+async function hybridSearch(rootDir, query, options = {}) {
+  rootDir = path25.resolve(rootDir);
   const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
   if (ensureFresh) {
     await ensureIndexFresh(rootDir, { quiet: true });
@@ -11366,7 +11711,7 @@ async function search(rootDir, query, options = {}) {
   const globalManifest = await loadGlobalManifest2(rootDir, config);
   if (!globalManifest || globalManifest.modules.length === 0) {
     console.log('No index found. Run "raggrep index" first.');
-    return [];
+    return { results: [], fusionApplied: false };
   }
   const modulesToSearch = [];
   for (const moduleId of globalManifest.modules) {
@@ -11381,7 +11726,7 @@ async function search(rootDir, query, options = {}) {
   }
   if (modulesToSearch.length === 0) {
     console.log("No enabled modules with indexes found.");
-    return [];
+    return { results: [], fusionApplied: false };
   }
   const allResults = [];
   for (const module of modulesToSearch) {
@@ -11405,9 +11750,42 @@ async function search(rootDir, query, options = {}) {
       });
     });
   }
+  let exactMatches;
+  let fusionApplied = false;
+  if (isIdentifierQuery(query)) {
+    const literal = extractSearchLiteral(query);
+    exactMatches = await performExactSearch(rootDir, literal, config, options);
+    if (exactMatches && exactMatches.totalMatches > 0) {
+      const exactMatchFilepaths = new Set(exactMatches.files.map((f) => f.filepath));
+      for (const result of filteredResults) {
+        if (exactMatchFilepaths.has(result.filepath)) {
+          result.score *= 1.5;
+          if (!result.context)
+            result.context = {};
+          result.context.exactMatchFusion = true;
+          fusionApplied = true;
+        }
+      }
+    }
+  }
   filteredResults.sort((a, b) => b.score - a.score);
   const topK = options.topK ?? 10;
-  return filteredResults.slice(0, topK);
+  return {
+    results: filteredResults.slice(0, topK),
+    exactMatches,
+    fusionApplied
+  };
+}
+async function performExactSearch(rootDir, literal, config, options) {
+  const fs11 = new NodeFileSystem;
+  return executeExactSearch(fs11, {
+    rootDir,
+    literal,
+    pathFilter: options.pathFilter,
+    maxFiles: 20,
+    maxOccurrencesPerFile: 5,
+    caseInsensitive: false
+  }, (path26, pattern) => minimatch(path26, pattern, { matchBase: true }));
 }
 function createSearchContext(rootDir, moduleId, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
@@ -11416,9 +11794,9 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path24.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path24.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path25.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path25.join(indexPath, filepath + ".json");
       try {
-        const content = await fs9.readFile(indexFilePath, "utf-8");
+        const content = await fs10.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -11428,17 +11806,17 @@ function createSearchContext(rootDir, moduleId, config) {
       const files = [];
       await traverseDirectory(indexPath, files, indexPath);
       return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
-        const relative5 = path24.relative(indexPath, f);
-        return relative5.replace(/\.json$/, "");
+        const relative6 = path25.relative(indexPath, f);
+        return relative6.replace(/\.json$/, "");
       });
     }
   };
 }
 async function traverseDirectory(dir, files, basePath) {
   try {
-    const entries = await fs9.readdir(dir, { withFileTypes: true });
+    const entries = await fs10.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path24.join(dir, entry.name);
+      const fullPath = path25.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -11450,7 +11828,7 @@ async function traverseDirectory(dir, files, basePath) {
 async function loadGlobalManifest2(rootDir, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs9.readFile(manifestPath, "utf-8");
+    const content = await fs10.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11470,7 +11848,7 @@ function formatModuleName(moduleId) {
       return moduleId;
   }
 }
-function formatSearchResults(results) {
+function formatSearchResults2(results) {
   if (results.length === 0) {
     return "No results found.";
   }
@@ -11489,6 +11867,9 @@ function formatSearchResults(results) {
     if (chunk.isExported) {
       output += " | exported";
     }
+    if (result.context?.exactMatchFusion) {
+      output += " | exact match";
+    }
     output += `
 `;
     const lines = chunk.content.split(`
@@ -11503,12 +11884,84 @@ function formatSearchResults(results) {
   }
   return output;
 }
+function formatHybridSearchResults(hybridResults) {
+  let output = "";
+  if (hybridResults.exactMatches && hybridResults.exactMatches.totalMatches > 0) {
+    const em = hybridResults.exactMatches;
+    const showingCount = Math.min(em.files.length, 10);
+    output += `┌─ Exact Matches `;
+    if (em.truncated || em.files.length < em.totalFiles) {
+      output += `(showing ${showingCount} of ${em.totalFiles} files, ${em.totalMatches} total matches)`;
+    } else {
+      output += `(${em.totalFiles} files, ${em.totalMatches} matches)`;
+    }
+    output += ` ─┐
+`;
+    output += `│  Query: "${em.query}"
+`;
+    output += `└─────────────────────────────────────────────────────────────────────┘
+
+`;
+    for (let i = 0;i < Math.min(em.files.length, 10); i++) {
+      const file = em.files[i];
+      output += `  ${i + 1}. ${file.filepath}`;
+      if (file.matchCount > 1) {
+        output += ` (${file.matchCount} matches)`;
+      }
+      output += `
+`;
+      const firstOcc = file.occurrences[0];
+      if (firstOcc) {
+        if (firstOcc.contextBefore) {
+          const beforeLine = firstOcc.contextBefore.substring(0, 76);
+          output += `     ${(firstOcc.line - 1).toString().padStart(4)} │ ${beforeLine}${firstOcc.contextBefore.length > 76 ? "..." : ""}
+`;
+        }
+        const matchLine = firstOcc.lineContent.substring(0, 76);
+        output += `   ► ${firstOcc.line.toString().padStart(4)} │ ${matchLine}${firstOcc.lineContent.length > 76 ? "..." : ""}
+`;
+        if (firstOcc.contextAfter) {
+          const afterLine = firstOcc.contextAfter.substring(0, 76);
+          output += `     ${(firstOcc.line + 1).toString().padStart(4)} │ ${afterLine}${firstOcc.contextAfter.length > 76 ? "..." : ""}
+`;
+        }
+      }
+      output += `
+`;
+    }
+    if (hybridResults.results.length > 0) {
+      output += `
+`;
+    }
+  }
+  if (hybridResults.results.length > 0) {
+    if (hybridResults.exactMatches?.totalMatches) {
+      output += `┌─ Semantic Results `;
+      if (hybridResults.fusionApplied) {
+        output += `(boosted by exact matches) `;
+      }
+      output += `─┐
+`;
+      output += `└─────────────────────────────────────────────────────────────────────┘
+
+`;
+    }
+    output += formatSearchResults2(hybridResults.results);
+  } else if (!hybridResults.exactMatches?.totalMatches) {
+    output += `No results found.
+`;
+  }
+  return output;
+}
 var init_search = __esm(() => {
-  init_esm();
+  init_esm2();
   init_types();
   init_config2();
   init_registry();
   init_indexer();
+  init_services();
+  init_usecases();
+  init_filesystem();
 });
 
 // src/app/cli/opencode/version-check.ts
@@ -11545,17 +11998,17 @@ function getInstallationMethod(openCodeVersion) {
 async function detectOpenCodeVersion() {
   try {
     const os4 = await import("os");
-    const fs10 = await import("fs/promises");
-    const path25 = await import("path");
+    const fs11 = await import("fs/promises");
+    const path26 = await import("path");
     const homeDir = os4.homedir();
     const possiblePaths = [
-      path25.join(homeDir, ".local", "share", "opencode", "package.json"),
-      path25.join(homeDir, ".config", "opencode", "package.json"),
-      path25.join(homeDir, ".npm", "global", "node_modules", "opencode", "package.json")
+      path26.join(homeDir, ".local", "share", "opencode", "package.json"),
+      path26.join(homeDir, ".config", "opencode", "package.json"),
+      path26.join(homeDir, ".npm", "global", "node_modules", "opencode", "package.json")
     ];
     for (const packagePath of possiblePaths) {
       try {
-        const content = await fs10.readFile(packagePath, "utf-8");
+        const content = await fs11.readFile(packagePath, "utf-8");
         const pkg = JSON.parse(content);
         if (pkg.version) {
           return pkg.version;
@@ -11564,7 +12017,7 @@ async function detectOpenCodeVersion() {
     }
     try {
       const { spawn } = await import("child_process");
-      return new Promise((resolve6) => {
+      return new Promise((resolve7) => {
         const proc = spawn("opencode", ["--version"], { stdio: "pipe" });
         let version = "";
         proc.stdout.on("data", (data) => {
@@ -11573,14 +12026,14 @@ async function detectOpenCodeVersion() {
         proc.on("close", (code) => {
           if (code === 0) {
             const match2 = version.match(/v?(\d+\.\d+\.\d+)/);
-            resolve6(match2 ? match2[1] : null);
+            resolve7(match2 ? match2[1] : null);
           } else {
-            resolve6(null);
+            resolve7(null);
           }
         });
         setTimeout(() => {
           proc.kill();
-          resolve6(null);
+          resolve7(null);
         }, 3000);
       });
     } catch {}
@@ -11594,11 +12047,11 @@ async function detectOpenCodeVersion() {
 async function installTool(options = {}) {
   const { logger, checkForOldSkill = true } = options;
   const os4 = await import("os");
-  const fs10 = await import("fs/promises");
-  const path25 = await import("path");
+  const fs11 = await import("fs/promises");
+  const path26 = await import("path");
   const homeDir = os4.homedir();
-  const toolDir = path25.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path25.join(toolDir, "raggrep.ts");
+  const toolDir = path26.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path26.join(toolDir, "raggrep.ts");
   let removedOldSkill = false;
   const toolContent = `import { tool } from "@opencode-ai/plugin";
 
@@ -11681,11 +12134,11 @@ Please install raggrep globally:
 `;
   try {
     if (checkForOldSkill) {
-      const oldSkillDir = path25.join(homeDir, ".config", "opencode", "skill", "raggrep");
-      const oldSkillPath = path25.join(oldSkillDir, "SKILL.md");
+      const oldSkillDir = path26.join(homeDir, ".config", "opencode", "skill", "raggrep");
+      const oldSkillPath = path26.join(oldSkillDir, "SKILL.md");
       let oldSkillExists = false;
       try {
-        await fs10.access(oldSkillPath);
+        await fs11.access(oldSkillPath);
         oldSkillExists = true;
       } catch {}
       if (oldSkillExists) {
@@ -11703,18 +12156,18 @@ Please install raggrep globally:
           input: process.stdin,
           output: process.stdout
         });
-        const answer = await new Promise((resolve6) => {
-          rl.question("Remove the existing skill and install tool? (Y/n): ", resolve6);
+        const answer = await new Promise((resolve7) => {
+          rl.question("Remove the existing skill and install tool? (Y/n): ", resolve7);
         });
         rl.close();
         const shouldDelete = answer.toLowerCase() !== "n";
         if (shouldDelete) {
           try {
-            await fs10.unlink(oldSkillPath);
-            const skillDirContents = await fs10.readdir(oldSkillDir);
+            await fs11.unlink(oldSkillPath);
+            const skillDirContents = await fs11.readdir(oldSkillDir);
             if (skillDirContents.length === 0) {
               try {
-                await fs10.rmdir(oldSkillDir);
+                await fs11.rmdir(oldSkillDir);
                 console.log("✓ Removed old skill directory.");
               } catch (rmdirError) {
                 console.log("✓ Removed old skill file. (Directory not empty or other error)");
@@ -11751,8 +12204,8 @@ Please install raggrep globally:
         }
       }
     }
-    await fs10.mkdir(toolDir, { recursive: true });
-    await fs10.writeFile(toolPath, toolContent, "utf-8");
+    await fs11.mkdir(toolDir, { recursive: true });
+    await fs11.writeFile(toolPath, toolContent, "utf-8");
     const message = `Installed raggrep tool for OpenCode.
   Location: ${toolPath}
 
@@ -11786,11 +12239,11 @@ The raggrep tool is now available in OpenCode.`;
 async function installSkill(options = {}) {
   const { logger, checkForOldTool = true } = options;
   const os4 = await import("os");
-  const fs10 = await import("fs/promises");
-  const path25 = await import("path");
+  const fs11 = await import("fs/promises");
+  const path26 = await import("path");
   const homeDir = os4.homedir();
-  const skillDir = path25.join(homeDir, ".config", "opencode", "skill", "raggrep");
-  const skillPath = path25.join(skillDir, "SKILL.md");
+  const skillDir = path26.join(homeDir, ".config", "opencode", "skill", "raggrep");
+  const skillPath = path26.join(skillDir, "SKILL.md");
   const skillContent = `---
 name: raggrep
 description: AST-powered semantic code search that understands intent, not just text. Superior to grep/rg - finds functions, classes, and logic even when keywords differ. Saves 10x tool calls by searching the actual code structure.
@@ -11902,11 +12355,11 @@ Instead of using grep/rg or manually reading files:
   let removedOldTool = false;
   try {
     if (checkForOldTool) {
-      const oldToolDir = path25.join(homeDir, ".config", "opencode", "tool");
-      const oldToolPath = path25.join(oldToolDir, "raggrep.ts");
+      const oldToolDir = path26.join(homeDir, ".config", "opencode", "tool");
+      const oldToolPath = path26.join(oldToolDir, "raggrep.ts");
       let oldToolExists = false;
       try {
-        await fs10.access(oldToolPath);
+        await fs11.access(oldToolPath);
         oldToolExists = true;
       } catch {}
       if (oldToolExists) {
@@ -11924,18 +12377,18 @@ Instead of using grep/rg or manually reading files:
           input: process.stdin,
           output: process.stdout
         });
-        const answer = await new Promise((resolve6) => {
-          rl.question("Do you want to remove the old tool file? (Y/n): ", resolve6);
+        const answer = await new Promise((resolve7) => {
+          rl.question("Do you want to remove the old tool file? (Y/n): ", resolve7);
         });
         rl.close();
         const shouldDelete = answer.toLowerCase() !== "n";
         if (shouldDelete) {
           try {
-            await fs10.unlink(oldToolPath);
-            const toolDirContents = await fs10.readdir(oldToolDir);
+            await fs11.unlink(oldToolPath);
+            const toolDirContents = await fs11.readdir(oldToolDir);
             if (toolDirContents.length === 0) {
               try {
-                await fs10.rmdir(oldToolDir);
+                await fs11.rmdir(oldToolDir);
                 console.log("✓ Removed old tool directory.");
               } catch (rmdirError) {
                 console.log("✓ Removed old tool file. (Directory not empty or other error)");
@@ -11968,8 +12421,8 @@ Instead of using grep/rg or manually reading files:
         }
       }
     }
-    await fs10.mkdir(skillDir, { recursive: true });
-    await fs10.writeFile(skillPath, skillContent, "utf-8");
+    await fs11.mkdir(skillDir, { recursive: true });
+    await fs11.writeFile(skillPath, skillContent, "utf-8");
     const message = `Installed raggrep skill for OpenCode.
   Location: ${skillPath}
 
@@ -12022,7 +12475,7 @@ init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.14.2",
+  version: "0.15.0",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -12081,6 +12534,7 @@ var package_default = {
     chokidar: "^5.0.0",
     fdir: "^6.5.0",
     glob: "^10.0.0",
+    minimatch: "^10.1.1",
     typescript: "^5.0.0",
     "web-tree-sitter": "^0.26.3"
   },
@@ -12227,13 +12681,13 @@ Examples:
 `);
         process.exit(0);
       }
-      const { indexDirectory: indexDirectory2, watchDirectory: watchDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const { indexDirectory: indexDirectory3, watchDirectory: watchDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       const logger = createInlineLogger({ verbose: flags.verbose });
       console.log("RAGgrep Indexer");
       console.log(`================
 `);
       try {
-        const results = await indexDirectory2(process.cwd(), {
+        const results = await indexDirectory3(process.cwd(), {
           model: flags.model,
           verbose: flags.verbose,
           concurrency: flags.concurrency,
@@ -12338,7 +12792,6 @@ Examples:
 `);
         process.exit(0);
       }
-      const { search: search2, formatSearchResults: formatSearchResults2 } = await Promise.resolve().then(() => (init_search(), exports_search));
       const { ensureIndexFresh: ensureIndexFresh2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       const query = flags.remaining[0];
       if (!query) {
@@ -12388,14 +12841,15 @@ Examples:
 `);
         }
         const filePatterns = flags.fileType ? [`*.${flags.fileType}`] : undefined;
-        const results = await search2(process.cwd(), query, {
+        const { hybridSearch: hybridSearch2, formatHybridSearchResults: formatHybridSearchResults2 } = await Promise.resolve().then(() => (init_search(), exports_search));
+        const hybridResults = await hybridSearch2(process.cwd(), query, {
           topK: flags.topK ?? 10,
           minScore: flags.minScore,
           filePatterns,
           pathFilter: flags.pathFilter,
           ensureFresh: false
         });
-        console.log(formatSearchResults2(results));
+        console.log(formatHybridSearchResults2(hybridResults));
       } catch (error) {
         console.error("Error during search:", error);
         process.exit(1);
@@ -12618,4 +13072,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=71C6E22A4D7E91CE64756E2164756E21
+//# debugId=2B4BB49E8FD1AEE664756E2164756E21