raggrep 0.7.1 → 0.8.0

package/README.md

@@ -12,6 +12,7 @@ RAGgrep indexes your code and lets you search it using natural language. Everyth
 - **Watch mode** — Keep the index fresh in real-time as you code.
 - **Hybrid search** — Combines semantic similarity with keyword matching for best results.
 - **Literal boosting** — Exact identifier matches get priority. Use backticks for precise matching: `` `AuthService` ``.
+- **Semantic expansion** — Domain-specific synonyms improve recall (function ↔ method, auth ↔ authentication).
 
 ## Installation
 

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
@@ -2950,6 +2967,586 @@ 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/index.ts
 var init_services = __esm(() => {
   init_keywords();
@@ -2957,6 +3554,7 @@ var init_services = __esm(() => {
   init_queryLiteralParser();
   init_literalExtractor();
   init_literalScorer();
+  init_lexicon2();
 });
 
 // src/modules/language/typescript/parseCode.ts
@@ -3659,7 +4257,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 +4342,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
           }
         });
       }
@@ -5636,7 +6240,7 @@ init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.7.1",
+  version: "0.8.0",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -6097,4 +6701,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=D5C2A5C0F122D20164756E2164756E21
+//# debugId=400EC2685467A28B64756E2164756E21