raggrep 0.7.1 → 0.8.1

package/dist/cli/main.js

@@ -433,11 +433,28 @@ var init_config = __esm(() => {
 // src/domain/entities/literal.ts
 var init_literal = () => {};
 
+// src/domain/entities/lexicon.ts
+var DEFAULT_EXPANSION_OPTIONS, EXPANSION_WEIGHTS;
+var init_lexicon = __esm(() => {
+  DEFAULT_EXPANSION_OPTIONS = {
+    maxDepth: 1,
+    includeWeak: true,
+    maxTerms: 20,
+    minTermLength: 2
+  };
+  EXPANSION_WEIGHTS = {
+    strong: 0.9,
+    moderate: 0.6,
+    weak: 0.3
+  };
+});
+
 // src/domain/entities/index.ts
 var init_entities = __esm(() => {
   init_searchResult();
   init_config();
   init_literal();
+  init_lexicon();
 });
 
 // src/infrastructure/config/configLoader.ts
@@ -2625,44 +2642,10 @@ var init_queryIntent = __esm(() => {
 });
 
 // src/domain/services/chunking.ts
-function createLineBasedChunks(content, options = {}) {
-  const {
-    chunkSize = DEFAULT_CHUNK_SIZE,
-    overlap = DEFAULT_OVERLAP,
-    minLinesForMultipleChunks = chunkSize
-  } = options;
-  const lines = content.split(`
-`);
-  const chunks = [];
-  if (lines.length <= minLinesForMultipleChunks) {
-    return [
-      {
-        content,
-        startLine: 1,
-        endLine: lines.length,
-        type: "file"
-      }
-    ];
-  }
-  for (let i = 0;i < lines.length; i += chunkSize - overlap) {
-    const endIdx = Math.min(i + chunkSize, lines.length);
-    chunks.push({
-      content: lines.slice(i, endIdx).join(`
-`),
-      startLine: i + 1,
-      endLine: endIdx,
-      type: "block"
-    });
-    if (endIdx >= lines.length)
-      break;
-  }
-  return chunks;
-}
 function generateChunkId(filepath, startLine, endLine) {
   const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
   return `${safePath}-${startLine}-${endLine}`;
 }
-var DEFAULT_CHUNK_SIZE = 30, DEFAULT_OVERLAP = 5;
 
 // src/domain/services/queryLiteralParser.ts
 function parseQueryLiterals(query) {
@@ -2950,6 +2933,643 @@ var init_literalScorer = __esm(() => {
   };
 });
 
+// src/domain/services/lexicon.ts
+function buildLookupMap(lexicon) {
+  const map = new Map;
+  for (const entry of lexicon.entries) {
+    map.set(entry.term.toLowerCase(), entry);
+  }
+  return map;
+}
+function getSynonyms(term, lexicon = DEFAULT_LEXICON) {
+  const lookupMap = lexicon === DEFAULT_LEXICON ? defaultLookupMap : buildLookupMap(lexicon);
+  const entry = lookupMap.get(term.toLowerCase());
+  return entry ? entry.synonyms : [];
+}
+function tokenizeQuery(query) {
+  const stopWords = new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "ought",
+    "used",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "here",
+    "there",
+    "when",
+    "where",
+    "why",
+    "how",
+    "all",
+    "each",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "nor",
+    "not",
+    "only",
+    "own",
+    "same",
+    "so",
+    "than",
+    "too",
+    "very",
+    "just",
+    "and",
+    "but",
+    "if",
+    "or",
+    "because",
+    "until",
+    "while",
+    "this",
+    "that",
+    "these",
+    "those",
+    "what",
+    "which",
+    "who",
+    "whom",
+    "i",
+    "me",
+    "my",
+    "we",
+    "our",
+    "you",
+    "your",
+    "he",
+    "him",
+    "his",
+    "she",
+    "her",
+    "it",
+    "its",
+    "they",
+    "them",
+    "their"
+  ]);
+  return query.toLowerCase().split(/\s+/).filter((term) => term.length > 0 && !stopWords.has(term));
+}
+function expandQuery(query, lexicon = DEFAULT_LEXICON, options = {}) {
+  const opts = { ...DEFAULT_EXPANSION_OPTIONS, ...options };
+  const originalTerms = tokenizeQuery(query);
+  const expandedTerms = [];
+  const seenTerms = new Set;
+  for (const term of originalTerms) {
+    if (term.length >= opts.minTermLength && !seenTerms.has(term)) {
+      expandedTerms.push({
+        term,
+        weight: 1,
+        source: "original"
+      });
+      seenTerms.add(term);
+    }
+  }
+  if (opts.maxDepth >= 1) {
+    for (const term of originalTerms) {
+      if (term.length < opts.minTermLength)
+        continue;
+      const synonyms = getSynonyms(term, lexicon);
+      for (const syn of synonyms) {
+        if (syn.grade === "weak" && !opts.includeWeak)
+          continue;
+        const synLower = syn.term.toLowerCase();
+        if (seenTerms.has(synLower))
+          continue;
+        if (expandedTerms.length >= opts.maxTerms)
+          break;
+        expandedTerms.push({
+          term: syn.term,
+          weight: EXPANSION_WEIGHTS[syn.grade],
+          source: syn.grade,
+          expandedFrom: term
+        });
+        seenTerms.add(synLower);
+      }
+      if (expandedTerms.length >= opts.maxTerms)
+        break;
+    }
+  }
+  const originalPart = originalTerms.join(" ");
+  const synonymPart = expandedTerms.filter((t) => t.source !== "original").map((t) => t.term).join(" ");
+  const expandedQueryString = synonymPart ? `${originalPart} ${synonymPart}` : originalPart;
+  return {
+    originalQuery: query,
+    originalTerms,
+    expandedTerms,
+    expandedQueryString,
+    wasExpanded: expandedTerms.some((t) => t.source !== "original")
+  };
+}
+var DEFAULT_LEXICON, defaultLookupMap;
+var init_lexicon2 = __esm(() => {
+  init_lexicon();
+  DEFAULT_LEXICON = {
+    version: "1.0.0",
+    entries: [
+      {
+        term: "function",
+        synonyms: [
+          { term: "method", grade: "strong" },
+          { term: "func", grade: "strong" },
+          { term: "handler", grade: "moderate" },
+          { term: "callback", grade: "moderate" },
+          { term: "procedure", grade: "weak" },
+          { term: "routine", grade: "weak" }
+        ]
+      },
+      {
+        term: "method",
+        synonyms: [
+          { term: "function", grade: "strong" },
+          { term: "func", grade: "strong" },
+          { term: "handler", grade: "moderate" }
+        ]
+      },
+      {
+        term: "class",
+        synonyms: [
+          { term: "type", grade: "moderate" },
+          { term: "interface", grade: "moderate" },
+          { term: "struct", grade: "moderate" },
+          { term: "model", grade: "weak" },
+          { term: "entity", grade: "weak" }
+        ]
+      },
+      {
+        term: "interface",
+        synonyms: [
+          { term: "type", grade: "strong" },
+          { term: "contract", grade: "moderate" },
+          { term: "protocol", grade: "weak" }
+        ]
+      },
+      {
+        term: "type",
+        synonyms: [
+          { term: "interface", grade: "strong" },
+          { term: "typedef", grade: "strong" },
+          { term: "schema", grade: "moderate" }
+        ]
+      },
+      {
+        term: "variable",
+        synonyms: [
+          { term: "var", grade: "strong" },
+          { term: "const", grade: "strong" },
+          { term: "constant", grade: "strong" },
+          { term: "property", grade: "moderate" },
+          { term: "field", grade: "moderate" }
+        ]
+      },
+      {
+        term: "constant",
+        synonyms: [
+          { term: "const", grade: "strong" },
+          { term: "variable", grade: "moderate" },
+          { term: "config", grade: "weak" }
+        ]
+      },
+      {
+        term: "auth",
+        synonyms: [
+          { term: "authentication", grade: "strong" },
+          { term: "authorization", grade: "strong" },
+          { term: "login", grade: "moderate" },
+          { term: "signin", grade: "moderate" },
+          { term: "session", grade: "weak" },
+          { term: "security", grade: "weak" }
+        ]
+      },
+      {
+        term: "authentication",
+        synonyms: [
+          { term: "auth", grade: "strong" },
+          { term: "login", grade: "moderate" },
+          { term: "signin", grade: "moderate" },
+          { term: "identity", grade: "weak" }
+        ]
+      },
+      {
+        term: "authorization",
+        synonyms: [
+          { term: "auth", grade: "strong" },
+          { term: "permission", grade: "moderate" },
+          { term: "access", grade: "moderate" },
+          { term: "role", grade: "weak" }
+        ]
+      },
+      {
+        term: "login",
+        synonyms: [
+          { term: "signin", grade: "strong" },
+          { term: "auth", grade: "moderate" },
+          { term: "authenticate", grade: "moderate" }
+        ]
+      },
+      {
+        term: "logout",
+        synonyms: [
+          { term: "signout", grade: "strong" },
+          { term: "logoff", grade: "strong" }
+        ]
+      },
+      {
+        term: "password",
+        synonyms: [
+          { term: "pwd", grade: "strong" },
+          { term: "pass", grade: "strong" },
+          { term: "credential", grade: "moderate" },
+          { term: "secret", grade: "weak" }
+        ]
+      },
+      {
+        term: "token",
+        synonyms: [
+          { term: "jwt", grade: "strong" },
+          { term: "bearer", grade: "moderate" },
+          { term: "credential", grade: "weak" }
+        ]
+      },
+      {
+        term: "database",
+        synonyms: [
+          { term: "db", grade: "strong" },
+          { term: "datastore", grade: "strong" },
+          { term: "storage", grade: "moderate" },
+          { term: "repository", grade: "weak" }
+        ]
+      },
+      {
+        term: "query",
+        synonyms: [
+          { term: "select", grade: "moderate" },
+          { term: "find", grade: "moderate" },
+          { term: "fetch", grade: "moderate" },
+          { term: "search", grade: "weak" }
+        ]
+      },
+      {
+        term: "insert",
+        synonyms: [
+          { term: "create", grade: "strong" },
+          { term: "add", grade: "strong" },
+          { term: "save", grade: "moderate" },
+          { term: "store", grade: "moderate" }
+        ]
+      },
+      {
+        term: "update",
+        synonyms: [
+          { term: "modify", grade: "strong" },
+          { term: "edit", grade: "strong" },
+          { term: "patch", grade: "moderate" },
+          { term: "change", grade: "moderate" }
+        ]
+      },
+      {
+        term: "delete",
+        synonyms: [
+          { term: "remove", grade: "strong" },
+          { term: "destroy", grade: "strong" },
+          { term: "drop", grade: "moderate" },
+          { term: "erase", grade: "weak" }
+        ]
+      },
+      {
+        term: "cache",
+        synonyms: [
+          { term: "redis", grade: "moderate" },
+          { term: "memcache", grade: "moderate" },
+          { term: "store", grade: "weak" },
+          { term: "buffer", grade: "weak" }
+        ]
+      },
+      {
+        term: "api",
+        synonyms: [
+          { term: "endpoint", grade: "strong" },
+          { term: "route", grade: "moderate" },
+          { term: "rest", grade: "moderate" },
+          { term: "service", grade: "weak" }
+        ]
+      },
+      {
+        term: "endpoint",
+        synonyms: [
+          { term: "api", grade: "strong" },
+          { term: "route", grade: "strong" },
+          { term: "path", grade: "moderate" }
+        ]
+      },
+      {
+        term: "request",
+        synonyms: [
+          { term: "req", grade: "strong" },
+          { term: "call", grade: "moderate" },
+          { term: "fetch", grade: "moderate" }
+        ]
+      },
+      {
+        term: "response",
+        synonyms: [
+          { term: "res", grade: "strong" },
+          { term: "reply", grade: "moderate" },
+          { term: "result", grade: "weak" }
+        ]
+      },
+      {
+        term: "middleware",
+        synonyms: [
+          { term: "interceptor", grade: "moderate" },
+          { term: "filter", grade: "moderate" },
+          { term: "handler", grade: "weak" }
+        ]
+      },
+      {
+        term: "error",
+        synonyms: [
+          { term: "exception", grade: "strong" },
+          { term: "err", grade: "strong" },
+          { term: "failure", grade: "moderate" },
+          { term: "fault", grade: "weak" }
+        ]
+      },
+      {
+        term: "exception",
+        synonyms: [
+          { term: "error", grade: "strong" },
+          { term: "throw", grade: "moderate" },
+          { term: "catch", grade: "moderate" }
+        ]
+      },
+      {
+        term: "validate",
+        synonyms: [
+          { term: "verify", grade: "strong" },
+          { term: "check", grade: "strong" },
+          { term: "assert", grade: "moderate" },
+          { term: "ensure", grade: "moderate" }
+        ]
+      },
+      {
+        term: "config",
+        synonyms: [
+          { term: "configuration", grade: "strong" },
+          { term: "settings", grade: "strong" },
+          { term: "options", grade: "moderate" },
+          { term: "env", grade: "weak" },
+          { term: "environment", grade: "weak" }
+        ]
+      },
+      {
+        term: "environment",
+        synonyms: [
+          { term: "env", grade: "strong" },
+          { term: "config", grade: "moderate" },
+          { term: "settings", grade: "weak" }
+        ]
+      },
+      {
+        term: "test",
+        synonyms: [
+          { term: "spec", grade: "strong" },
+          { term: "unittest", grade: "strong" },
+          { term: "check", grade: "moderate" },
+          { term: "verify", grade: "weak" }
+        ]
+      },
+      {
+        term: "mock",
+        synonyms: [
+          { term: "stub", grade: "strong" },
+          { term: "fake", grade: "strong" },
+          { term: "spy", grade: "moderate" },
+          { term: "double", grade: "weak" }
+        ]
+      },
+      {
+        term: "async",
+        synonyms: [
+          { term: "asynchronous", grade: "strong" },
+          { term: "await", grade: "moderate" },
+          { term: "promise", grade: "moderate" }
+        ]
+      },
+      {
+        term: "callback",
+        synonyms: [
+          { term: "handler", grade: "strong" },
+          { term: "listener", grade: "moderate" },
+          { term: "hook", grade: "moderate" }
+        ]
+      },
+      {
+        term: "event",
+        synonyms: [
+          { term: "emit", grade: "moderate" },
+          { term: "trigger", grade: "moderate" },
+          { term: "signal", grade: "weak" },
+          { term: "message", grade: "weak" }
+        ]
+      },
+      {
+        term: "util",
+        synonyms: [
+          { term: "utility", grade: "strong" },
+          { term: "utils", grade: "strong" },
+          { term: "helper", grade: "strong" },
+          { term: "common", grade: "weak" }
+        ]
+      },
+      {
+        term: "helper",
+        synonyms: [
+          { term: "util", grade: "strong" },
+          { term: "utility", grade: "strong" },
+          { term: "support", grade: "weak" }
+        ]
+      },
+      {
+        term: "parse",
+        synonyms: [
+          { term: "decode", grade: "moderate" },
+          { term: "deserialize", grade: "moderate" },
+          { term: "extract", grade: "weak" }
+        ]
+      },
+      {
+        term: "serialize",
+        synonyms: [
+          { term: "encode", grade: "moderate" },
+          { term: "stringify", grade: "moderate" },
+          { term: "convert", grade: "weak" }
+        ]
+      },
+      {
+        term: "get",
+        synonyms: [
+          { term: "fetch", grade: "strong" },
+          { term: "retrieve", grade: "strong" },
+          { term: "find", grade: "moderate" },
+          { term: "load", grade: "moderate" }
+        ]
+      },
+      {
+        term: "set",
+        synonyms: [
+          { term: "assign", grade: "strong" },
+          { term: "store", grade: "moderate" },
+          { term: "save", grade: "moderate" }
+        ]
+      },
+      {
+        term: "find",
+        synonyms: [
+          { term: "search", grade: "strong" },
+          { term: "locate", grade: "strong" },
+          { term: "lookup", grade: "moderate" },
+          { term: "get", grade: "moderate" }
+        ]
+      },
+      {
+        term: "create",
+        synonyms: [
+          { term: "make", grade: "strong" },
+          { term: "build", grade: "strong" },
+          { term: "new", grade: "moderate" },
+          { term: "generate", grade: "moderate" }
+        ]
+      },
+      {
+        term: "send",
+        synonyms: [
+          { term: "emit", grade: "moderate" },
+          { term: "dispatch", grade: "moderate" },
+          { term: "post", grade: "moderate" },
+          { term: "transmit", grade: "weak" }
+        ]
+      },
+      {
+        term: "receive",
+        synonyms: [
+          { term: "accept", grade: "moderate" },
+          { term: "handle", grade: "moderate" },
+          { term: "process", grade: "weak" }
+        ]
+      }
+    ]
+  };
+  defaultLookupMap = buildLookupMap(DEFAULT_LEXICON);
+});
+
+// src/domain/services/jsonPathExtractor.ts
+function extractJsonPaths(obj, fileBasename) {
+  const paths = extractPathsRecursive(obj, fileBasename);
+  return paths.map((path8) => ({
+    value: path8,
+    type: "identifier",
+    matchType: "definition"
+  }));
+}
+function extractPathsRecursive(obj, prefix) {
+  const paths = [];
+  if (obj === null || obj === undefined) {
+    return paths;
+  }
+  if (Array.isArray(obj)) {
+    obj.forEach((item, index) => {
+      const indexedPrefix = `${prefix}[${index}]`;
+      paths.push(indexedPrefix);
+      if (item !== null && typeof item === "object") {
+        paths.push(...extractPathsRecursive(item, indexedPrefix));
+      }
+    });
+  } else if (typeof obj === "object") {
+    for (const [key, value] of Object.entries(obj)) {
+      const fullPath = `${prefix}.${key}`;
+      paths.push(fullPath);
+      if (value !== null && typeof value === "object") {
+        paths.push(...extractPathsRecursive(value, fullPath));
+      }
+    }
+  }
+  return paths;
+}
+function extractJsonKeywords(obj) {
+  const keywords = new Set;
+  const extract = (value, parentKey) => {
+    if (value === null || value === undefined) {
+      return;
+    }
+    if (typeof value === "string") {
+      const words = value.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_\-./]+/).filter((w) => w.length > 2);
+      words.forEach((w) => keywords.add(w));
+    } else if (Array.isArray(value)) {
+      value.forEach((item) => extract(item));
+    } else if (typeof value === "object") {
+      for (const [key, val] of Object.entries(value)) {
+        keywords.add(key.toLowerCase());
+        const keyWords = key.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_\-]+/).filter((w) => w.length > 2);
+        keyWords.forEach((w) => keywords.add(w));
+        extract(val, key);
+      }
+    }
+  };
+  extract(obj);
+  return Array.from(keywords);
+}
+
 // src/domain/services/index.ts
 var init_services = __esm(() => {
   init_keywords();
@@ -2957,6 +3577,7 @@ var init_services = __esm(() => {
   init_queryLiteralParser();
   init_literalExtractor();
   init_literalScorer();
+  init_lexicon2();
 });
 
 // src/modules/language/typescript/parseCode.ts
@@ -3659,7 +4280,12 @@ class TypeScriptModule {
       });
     }
     const semanticQuery = remainingQuery.trim() || query;
-    const queryEmbedding = await getEmbedding(semanticQuery);
+    const expandedQuery = expandQuery(semanticQuery, undefined, {
+      maxDepth: 1,
+      includeWeak: false,
+      maxTerms: 10
+    });
+    const queryEmbedding = await getEmbedding(expandedQuery.expandedQueryString);
     const bm25Index = new BM25Index;
     const allChunksData = [];
     for (const filepath of filesToSearch) {
@@ -3739,7 +4365,8 @@ class TypeScriptModule {
             literalMultiplier: literalContribution.multiplier,
             literalMatchType: literalContribution.bestMatchType,
             literalConfidence: literalContribution.bestConfidence,
-            literalMatchCount: literalContribution.matchCount
+            literalMatchCount: literalContribution.matchCount,
+            synonymsUsed: expandedQuery.wasExpanded ? expandedQuery.expandedTerms.filter((t) => t.source !== "original").map((t) => t.term) : undefined
           }
         });
       }
@@ -3873,113 +4500,66 @@ function isJsonFile(filepath) {
   const ext = path11.extname(filepath).toLowerCase();
   return JSON_EXTENSIONS.includes(ext);
 }
-function extractJsonKeys(obj, prefix = "") {
-  const keys = [];
-  if (obj === null || obj === undefined) {
-    return keys;
-  }
-  if (Array.isArray(obj)) {
-    obj.forEach((item, index) => {
-      keys.push(...extractJsonKeys(item, `${prefix}[${index}]`));
-    });
-  } else if (typeof obj === "object") {
-    for (const [key, value] of Object.entries(obj)) {
-      const fullKey = prefix ? `${prefix}.${key}` : key;
-      keys.push(key);
-      keys.push(...extractJsonKeys(value, fullKey));
-    }
-  }
-  return keys;
-}
-function extractJsonKeywords(content) {
-  try {
-    const parsed = JSON.parse(content);
-    const keys = extractJsonKeys(parsed);
-    const stringValues = [];
-    const extractStrings = (obj) => {
-      if (typeof obj === "string") {
-        const words = obj.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-        stringValues.push(...words);
-      } else if (Array.isArray(obj)) {
-        obj.forEach(extractStrings);
-      } else if (obj && typeof obj === "object") {
-        Object.values(obj).forEach(extractStrings);
-      }
-    };
-    extractStrings(parsed);
-    return [...new Set([...keys, ...stringValues])];
-  } catch {
-    return [];
-  }
-}
 
 class JsonModule {
   id = "data/json";
   name = "JSON Search";
-  description = "JSON file search with structure-aware indexing";
-  version = "1.0.0";
+  description = "JSON file search with literal-based key path indexing";
+  version = "2.0.0";
   supportsFile(filepath) {
     return isJsonFile(filepath);
   }
-  embeddingConfig = null;
   symbolicIndex = null;
+  literalIndex = null;
   pendingSummaries = new Map;
+  pendingLiterals = new Map;
   rootDir = "";
   logger = undefined;
   async initialize(config) {
-    this.embeddingConfig = getEmbeddingConfigFromModule(config);
     this.logger = config.options?.logger;
-    if (this.logger) {
-      this.embeddingConfig = {
-        ...this.embeddingConfig,
-        logger: this.logger
-      };
-    }
-    configureEmbeddings(this.embeddingConfig);
     this.pendingSummaries.clear();
+    this.pendingLiterals.clear();
   }
   async indexFile(filepath, content, ctx) {
     if (!isJsonFile(filepath)) {
       return null;
     }
     this.rootDir = ctx.rootDir;
-    const textChunks = createLineBasedChunks(content, {
-      chunkSize: 50,
-      overlap: 10
-    });
-    if (textChunks.length === 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
       return null;
     }
-    const chunkContents = textChunks.map((c) => {
-      const filename = path11.basename(filepath);
-      return `${filename}: ${c.content}`;
-    });
-    const embeddings = await getEmbeddings(chunkContents);
-    const chunks = textChunks.map((tc, i) => ({
-      id: generateChunkId(filepath, tc.startLine, tc.endLine),
-      content: tc.content,
-      startLine: tc.startLine,
-      endLine: tc.endLine,
-      type: tc.type
-    }));
-    const jsonKeys = extractJsonKeys((() => {
-      try {
-        return JSON.parse(content);
-      } catch {
-        return {};
+    const fileBasename = path11.basename(filepath, path11.extname(filepath));
+    const jsonPathLiterals = extractJsonPaths(parsed, fileBasename);
+    const lines = content.split(`
+`);
+    const lineCount = lines.length;
+    const chunkId = generateChunkId(filepath, 1, lineCount);
+    const chunks = [
+      {
+        id: chunkId,
+        content,
+        startLine: 1,
+        endLine: lineCount,
+        type: "file"
       }
-    })());
+    ];
+    if (jsonPathLiterals.length > 0) {
+      this.pendingLiterals.set(chunkId, {
+        filepath,
+        literals: jsonPathLiterals
+      });
+    }
     const stats = await ctx.getFileStats(filepath);
-    const currentConfig = getEmbeddingConfig();
     const moduleData = {
-      embeddings,
-      embeddingModel: currentConfig.model,
-      jsonKeys
+      jsonPaths: jsonPathLiterals.map((l) => l.value)
     };
-    const keywords = extractJsonKeywords(content);
+    const keywords = extractJsonKeywords(parsed);
     const fileSummary = {
       filepath,
-      chunkCount: chunks.length,
+      chunkCount: 1,
       chunkTypes: ["file"],
       keywords,
       exports: [],
@@ -4002,7 +4582,24 @@ class JsonModule {
     }
     this.symbolicIndex.buildBM25Index();
     await this.symbolicIndex.save();
+    this.literalIndex = new LiteralIndex(indexDir, this.id);
+    await this.literalIndex.initialize();
+    const indexedFilepaths = new Set;
+    for (const filepath of this.pendingSummaries.keys()) {
+      indexedFilepaths.add(filepath);
+    }
+    for (const { filepath } of this.pendingLiterals.values()) {
+      indexedFilepaths.add(filepath);
+    }
+    for (const filepath of indexedFilepaths) {
+      this.literalIndex.removeFile(filepath);
+    }
+    for (const [chunkId, { filepath, literals }] of this.pendingLiterals) {
+      this.literalIndex.addLiterals(chunkId, filepath, literals);
+    }
+    await this.literalIndex.save();
     this.pendingSummaries.clear();
+    this.pendingLiterals.clear();
   }
   async search(query, ctx, options = {}) {
     const {
@@ -4010,8 +4607,15 @@ class JsonModule {
       minScore = DEFAULT_MIN_SCORE3,
       filePatterns
     } = options;
+    const { literals: queryLiterals, remainingQuery } = parseQueryLiterals(query);
     const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
     const symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    const literalIndex = new LiteralIndex(indexDir, this.id);
+    let literalMatchMap = new Map;
+    try {
+      await literalIndex.initialize();
+      literalMatchMap = literalIndex.buildMatchMap(queryLiterals);
+    } catch {}
     let allFiles;
     try {
       await symbolicIndex.initialize();
@@ -4031,25 +4635,16 @@ class JsonModule {
         });
       });
     }
-    const queryEmbedding = await getEmbedding(query);
     const bm25Index = new BM25Index;
     const allChunksData = [];
     for (const filepath of filesToSearch) {
       const fileIndex = await ctx.loadFileIndex(filepath);
       if (!fileIndex)
         continue;
-      const moduleData = fileIndex.moduleData;
-      if (!moduleData?.embeddings)
-        continue;
-      for (let i = 0;i < fileIndex.chunks.length; i++) {
-        const chunk = fileIndex.chunks[i];
-        const embedding = moduleData.embeddings[i];
-        if (!embedding)
-          continue;
+      for (const chunk of fileIndex.chunks) {
         allChunksData.push({
           filepath: fileIndex.filepath,
-          chunk,
-          embedding
+          chunk
         });
         bm25Index.addDocuments([{ id: chunk.id, content: chunk.content }]);
       }
@@ -4059,32 +4654,70 @@ class JsonModule {
     for (const result of bm25Results) {
       bm25Scores.set(result.id, normalizeScore(result.score, 3));
     }
-    const queryTerms = extractQueryTerms(query);
     const results = [];
-    for (const { filepath, chunk, embedding } of allChunksData) {
-      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
+    const processedChunkIds = new Set;
+    for (const { filepath, chunk } of allChunksData) {
       const bm25Score = bm25Scores.get(chunk.id) || 0;
-      const hybridScore = SEMANTIC_WEIGHT2 * semanticScore + BM25_WEIGHT2 * bm25Score;
-      if (hybridScore >= minScore || bm25Score > 0.3) {
+      const literalMatches = literalMatchMap.get(chunk.id) || [];
+      const literalContribution = calculateLiteralContribution(literalMatches, bm25Score > 0);
+      const baseScore = BM25_WEIGHT2 * bm25Score;
+      const boostedScore = applyLiteralBoost(baseScore, literalMatches, bm25Score > 0);
+      const literalBase = literalMatches.length > 0 && bm25Score === 0 ? LITERAL_SCORING_CONSTANTS.BASE_SCORE * LITERAL_WEIGHT : 0;
+      const finalScore = boostedScore + literalBase;
+      processedChunkIds.add(chunk.id);
+      if (finalScore >= minScore || literalMatches.length > 0) {
         results.push({
           filepath,
           chunk,
-          score: hybridScore,
+          score: finalScore,
           moduleId: this.id,
           context: {
-            semanticScore,
-            bm25Score
+            bm25Score,
+            literalMultiplier: literalContribution.multiplier,
+            literalMatchType: literalContribution.bestMatchType,
+            literalConfidence: literalContribution.bestConfidence,
+            literalMatchCount: literalContribution.matchCount
           }
         });
       }
     }
+    for (const [chunkId, matches] of literalMatchMap) {
+      if (processedChunkIds.has(chunkId)) {
+        continue;
+      }
+      const filepath = matches[0]?.filepath;
+      if (!filepath)
+        continue;
+      const fileIndex = await ctx.loadFileIndex(filepath);
+      if (!fileIndex)
+        continue;
+      const chunk = fileIndex.chunks.find((c) => c.id === chunkId);
+      if (!chunk)
+        continue;
+      const literalContribution = calculateLiteralContribution(matches, false);
+      const score = LITERAL_SCORING_CONSTANTS.BASE_SCORE * literalContribution.multiplier;
+      processedChunkIds.add(chunkId);
+      results.push({
+        filepath,
+        chunk,
+        score,
+        moduleId: this.id,
+        context: {
+          bm25Score: 0,
+          literalMultiplier: literalContribution.multiplier,
+          literalMatchType: literalContribution.bestMatchType,
+          literalConfidence: literalContribution.bestConfidence,
+          literalMatchCount: literalContribution.matchCount,
+          literalOnly: true
+        }
+      });
+    }
     results.sort((a, b) => b.score - a.score);
     return results.slice(0, topK);
   }
 }
-var DEFAULT_MIN_SCORE3 = 0.15, DEFAULT_TOP_K3 = 10, SEMANTIC_WEIGHT2 = 0.7, BM25_WEIGHT2 = 0.3, JSON_EXTENSIONS, supportsFile2;
+var DEFAULT_MIN_SCORE3 = 0.1, DEFAULT_TOP_K3 = 10, BM25_WEIGHT2 = 0.4, LITERAL_WEIGHT = 0.6, JSON_EXTENSIONS, supportsFile2;
 var init_json = __esm(() => {
-  init_embeddings();
   init_services();
   init_config2();
   init_storage();
@@ -4354,7 +4987,7 @@ ${section.content}` : section.content,
       ].includes(t))) {
         docBoost = 0.05;
       }
-      const hybridScore = SEMANTIC_WEIGHT3 * semanticScore + BM25_WEIGHT3 * bm25Score + docBoost;
+      const hybridScore = SEMANTIC_WEIGHT2 * semanticScore + BM25_WEIGHT3 * bm25Score + docBoost;
       if (hybridScore >= minScore || bm25Score > 0.3) {
         results.push({
           filepath,
@@ -4373,7 +5006,7 @@ ${section.content}` : section.content,
     return results.slice(0, topK);
   }
 }
-var DEFAULT_MIN_SCORE4 = 0.15, DEFAULT_TOP_K4 = 10, SEMANTIC_WEIGHT3 = 0.7, BM25_WEIGHT3 = 0.3, MARKDOWN_EXTENSIONS, supportsFile3;
+var DEFAULT_MIN_SCORE4 = 0.15, DEFAULT_TOP_K4 = 10, SEMANTIC_WEIGHT2 = 0.7, BM25_WEIGHT3 = 0.3, MARKDOWN_EXTENSIONS, supportsFile3;
 var init_markdown = __esm(() => {
   init_embeddings();
   init_services();
@@ -5636,7 +6269,7 @@ init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.7.1",
+  version: "0.8.1",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -6097,4 +6730,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=D5C2A5C0F122D20164756E2164756E21
+//# debugId=7B73D156971632D164756E2164756E21