raggrep 0.1.0 → 0.1.3

package/dist/domain/services/keywords.d.ts

@@ -9,6 +9,11 @@
  * These appear in almost every code file and don't add search value.
  */
 export declare const COMMON_KEYWORDS: Set<string>;
+/**
+ * Common architectural layer patterns in file names/paths.
+ * Used to detect the layer a file belongs to.
+ */
+export declare const LAYER_PATTERNS: Record<string, string[]>;
 /**
  * Extract keywords from code content and optional name.
  *
@@ -21,7 +26,47 @@ export declare function extractKeywords(content: string, name?: string, maxKeywo
 /**
  * Extract keywords from a file path.
  *
+ * Enhanced extraction that:
+ * - Splits camelCase/PascalCase filenames
+ * - Extracts directory segments
+ * - Recognizes common patterns (Service, Controller, etc.)
+ *
  * @param filepath - File path to extract keywords from
  * @returns Array of keywords from path segments
  */
 export declare function extractPathKeywords(filepath: string): string[];
+/**
+ * Path context information extracted from a file path.
+ */
+export interface PathContext {
+    /** Directory segments (excluding filename) */
+    segments: string[];
+    /** Detected architectural layer (service, controller, repository, etc.) */
+    layer?: string;
+    /** Detected feature domain (auth, users, payments, etc.) */
+    domain?: string;
+    /** Path depth (number of directory levels) */
+    depth: number;
+    /** Keywords extracted from the path */
+    keywords: string[];
+}
+/**
+ * Parse a file path and extract structural context.
+ *
+ * This helps with:
+ * - Boosting files in related directories
+ * - Understanding architectural layer
+ * - Grouping by feature domain
+ *
+ * @param filepath - File path to parse
+ * @returns Parsed path context
+ */
+export declare function parsePathContext(filepath: string): PathContext;
+/**
+ * Generate a path context string for embedding.
+ * This is prepended to content to give the embedding model path awareness.
+ *
+ * @param pathContext - Parsed path context
+ * @returns A string representation of the path context
+ */
+export declare function formatPathContextForEmbedding(pathContext: PathContext): string;

package/dist/index.js

@@ -544,10 +544,92 @@ function extractKeywords(content, name, maxKeywords = 50) {
   }
   return Array.from(keywords).slice(0, maxKeywords);
 }
+function splitIdentifier(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).map((s) => s.toLowerCase()).filter((s) => s.length > 1);
+}
 function extractPathKeywords(filepath) {
-  return filepath.split(/[/\\.]/).filter((p) => p.length > 2 && !COMMON_KEYWORDS.has(p.toLowerCase())).map((p) => p.toLowerCase());
+  const keywords = new Set;
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const segments = pathWithoutExt.split(/[/\\]/);
+  for (const segment of segments) {
+    if (segment.length < 2)
+      continue;
+    const lower = segment.toLowerCase();
+    if (!COMMON_KEYWORDS.has(lower) && lower.length > 2) {
+      keywords.add(lower);
+    }
+    const parts = splitIdentifier(segment);
+    for (const part of parts) {
+      if (!COMMON_KEYWORDS.has(part) && part.length > 2) {
+        keywords.add(part);
+      }
+    }
+  }
+  return Array.from(keywords);
 }
-var COMMON_KEYWORDS;
+function parsePathContext(filepath) {
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const allSegments = pathWithoutExt.split(/[/\\]/);
+  const filename = allSegments[allSegments.length - 1];
+  const dirSegments = allSegments.slice(0, -1);
+  const keywords = extractPathKeywords(filepath);
+  let layer;
+  const allLower = [...dirSegments, filename].map((s) => s.toLowerCase()).join(" ");
+  const filenameLower = filename.toLowerCase();
+  for (const [layerName, patterns] of Object.entries(LAYER_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (filenameLower.includes(pattern)) {
+        layer = layerName;
+        break;
+      }
+      if (dirSegments.some((s) => s.toLowerCase() === pattern)) {
+        layer = layerName;
+        break;
+      }
+    }
+    if (layer)
+      break;
+  }
+  let domain;
+  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS).flat());
+  const reversedSegments = [...dirSegments].reverse();
+  for (const segment of reversedSegments) {
+    const lower = segment.toLowerCase();
+    if (["src", "lib", "app", "packages", "modules"].includes(lower))
+      continue;
+    if (layerPatternSet.has(lower))
+      continue;
+    if (lower.length > 2) {
+      domain = lower;
+      break;
+    }
+  }
+  return {
+    segments: dirSegments,
+    layer,
+    domain,
+    depth: dirSegments.length,
+    keywords
+  };
+}
+function formatPathContextForEmbedding(pathContext) {
+  const parts = [];
+  if (pathContext.domain) {
+    parts.push(pathContext.domain);
+  }
+  if (pathContext.layer) {
+    parts.push(pathContext.layer);
+  }
+  const significantSegments = pathContext.segments.slice(-3).filter((s) => s.length > 2 && !["src", "lib", "app"].includes(s.toLowerCase()));
+  if (significantSegments.length > 0) {
+    parts.push(...significantSegments.map((s) => s.toLowerCase()));
+  }
+  if (parts.length === 0)
+    return "";
+  const unique = [...new Set(parts)];
+  return `[${unique.join(" ")}]`;
+}
+var COMMON_KEYWORDS, LAYER_PATTERNS;
 var init_keywords = __esm(() => {
   COMMON_KEYWORDS = new Set([
     "const",
@@ -617,6 +699,19 @@ var init_keywords = __esm(() => {
     "has",
     "have"
   ]);
+  LAYER_PATTERNS = {
+    controller: ["controller", "controllers", "handler", "handlers", "route", "routes", "api"],
+    service: ["service", "services", "usecase", "usecases", "application"],
+    repository: ["repository", "repositories", "repo", "repos", "dao", "store", "storage"],
+    model: ["model", "models", "entity", "entities", "schema", "schemas"],
+    util: ["util", "utils", "utility", "utilities", "helper", "helpers", "common", "shared"],
+    config: ["config", "configs", "configuration", "settings"],
+    middleware: ["middleware", "middlewares", "interceptor", "interceptors"],
+    domain: ["domain", "core", "business"],
+    infrastructure: ["infrastructure", "infra", "external", "adapters"],
+    presentation: ["presentation", "view", "views", "component", "components", "ui"],
+    test: ["test", "tests", "spec", "specs", "__tests__", "__test__"]
+  };
 });
 
 // src/utils/tieredIndex.ts
@@ -795,7 +890,12 @@ class SemanticModule {
     if (parsedChunks.length === 0) {
       return null;
     }
-    const chunkContents = parsedChunks.map((c) => c.content);
+    const pathContext = parsePathContext(filepath);
+    const pathPrefix = formatPathContextForEmbedding(pathContext);
+    const chunkContents = parsedChunks.map((c) => {
+      const namePrefix = c.name ? `${c.name}: ` : "";
+      return `${pathPrefix} ${namePrefix}${c.content}`;
+    });
     const embeddings = await getEmbeddings(chunkContents);
     const chunks = parsedChunks.map((pc) => ({
       id: generateChunkId(filepath, pc.startLine, pc.endLine),
@@ -821,13 +921,20 @@ class SemanticModule {
       const keywords = extractKeywords(pc.content, pc.name);
       keywords.forEach((k) => allKeywords.add(k));
     }
+    pathContext.keywords.forEach((k) => allKeywords.add(k));
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
       chunkTypes,
       keywords: Array.from(allKeywords),
       exports,
-      lastModified: stats.lastModified
+      lastModified: stats.lastModified,
+      pathContext: {
+        segments: pathContext.segments,
+        layer: pathContext.layer,
+        domain: pathContext.domain,
+        depth: pathContext.depth
+      }
     };
     this.pendingSummaries.set(filepath, fileSummary);
     return {
@@ -904,11 +1011,32 @@ class SemanticModule {
     for (const result of bm25Results) {
       bm25Scores.set(result.id, normalizeScore(result.score, 3));
     }
+    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+    const pathBoosts = new Map;
+    for (const filepath of candidateFiles) {
+      const summary = symbolicIndex.getFileSummary(filepath);
+      if (summary?.pathContext) {
+        let boost = 0;
+        const ctx2 = summary.pathContext;
+        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
+          boost += 0.1;
+        }
+        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
+          boost += 0.05;
+        }
+        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
+        if (segmentMatch) {
+          boost += 0.05;
+        }
+        pathBoosts.set(filepath, boost);
+      }
+    }
     const results = [];
     for (const { filepath, chunk, embedding } of allChunksData) {
       const semanticScore = cosineSimilarity(queryEmbedding, embedding);
       const bm25Score = bm25Scores.get(chunk.id) || 0;
-      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score;
+      const pathBoost = pathBoosts.get(filepath) || 0;
+      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + pathBoost;
       if (hybridScore >= minScore || bm25Score > 0.3) {
         results.push({
           filepath,
@@ -917,7 +1045,8 @@ class SemanticModule {
           moduleId: this.id,
           context: {
             semanticScore,
-            bm25Score
+            bm25Score,
+            pathBoost
           }
         });
       }
@@ -956,6 +1085,7 @@ var init_semantic = __esm(() => {
   init_config2();
   init_parseCode();
   init_tieredIndex();
+  init_keywords();
 });
 
 // src/indexer/index.ts
@@ -990,6 +1120,10 @@ async function registerBuiltInModules() {
   registry.register(new SemanticModule2);
 }
 
+// src/indexer/watcher.ts
+import { watch } from "chokidar";
+init_config2();
+
 // src/indexer/index.ts
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
@@ -1375,4 +1509,4 @@ export {
   cleanup
 };
 
-//# debugId=3A2C4D6166478FB764756E2164756E21
+//# debugId=791A08B2C54816DA64756E2164756E21