raggrep 0.6.0 → 0.7.0

package/dist/infrastructure/storage/index.d.ts

@@ -5,3 +5,4 @@
  */
 export { FileIndexStorage } from "./fileIndexStorage";
 export { SymbolicIndex, getSymbolicPath } from "./symbolicIndex";
+export { LiteralIndex, getLiteralIndexPath } from "./literalIndex";

package/dist/infrastructure/storage/literalIndex.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Literal Index Storage
+ *
+ * Manages the literal index for exact-match boosting.
+ * Handles file I/O for persisting literal data.
+ *
+ * Structure:
+ *   .raggrep/index/<module>/literals/
+ *   └── _index.json    (literal → chunk mappings)
+ */
+import type { ExtractedLiteral, DetectedLiteral, LiteralMatch } from "../../domain/entities/literal";
+/**
+ * Literal Index Manager
+ *
+ * Manages the literal index for exact-match boosting.
+ * Provides O(1) lookup for literal matches.
+ */
+export declare class LiteralIndex {
+    private indexPath;
+    private moduleId;
+    /**
+     * In-memory index: lowercase literal value → entries
+     */
+    private entries;
+    /**
+     * Schema version for compatibility checking.
+     */
+    private static readonly VERSION;
+    constructor(indexDir: string, moduleId: string);
+    /**
+     * Initialize the literal index.
+     * Attempts to load from disk, creates empty index if not found.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Add literals from a chunk to the index.
+     *
+     * @param chunkId - Unique identifier for the chunk
+     * @param filepath - Path to the file containing the chunk
+     * @param literals - Extracted literals from the chunk
+     */
+    addLiterals(chunkId: string, filepath: string, literals: ExtractedLiteral[]): void;
+    /**
+     * Remove all literals for a chunk.
+     *
+     * @param chunkId - Chunk ID to remove
+     */
+    removeChunk(chunkId: string): void;
+    /**
+     * Find matches for query literals.
+     *
+     * @param queryLiterals - Literals detected in the query
+     * @returns Array of matches with chunk IDs and filepaths
+     */
+    findMatches(queryLiterals: DetectedLiteral[]): LiteralMatch[];
+    /**
+     * Get all chunk IDs that contain a specific literal.
+     *
+     * @param literal - The literal value to search for
+     * @returns Array of chunk IDs
+     */
+    getChunksForLiteral(literal: string): string[];
+    /**
+     * Save the index to disk.
+     */
+    save(): Promise<void>;
+    /**
+     * Load the index from disk.
+     */
+    load(): Promise<void>;
+    /**
+     * Check if the index exists on disk.
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Clear the index.
+     */
+    clear(): void;
+    /**
+     * Get the number of unique literals in the index.
+     */
+    get size(): number;
+    /**
+     * Get the total number of literal-to-chunk mappings.
+     */
+    get totalMappings(): number;
+    /**
+     * Get all unique literals in the index.
+     */
+    getAllLiterals(): string[];
+    /**
+     * Build a map from chunk ID to literal matches for a set of query literals.
+     * Convenience method for search integration.
+     *
+     * @param queryLiterals - Literals detected in the query
+     * @returns Map from chunk ID to array of matches
+     */
+    buildMatchMap(queryLiterals: DetectedLiteral[]): Map<string, LiteralMatch[]>;
+}
+/**
+ * Get the literal index path for a module.
+ */
+export declare function getLiteralIndexPath(rootDir: string, moduleId: string, indexDir?: string): string;

package/dist/modules/language/typescript/index.d.ts

@@ -39,21 +39,25 @@ export declare class TypeScriptModule implements IndexModule {
     supportsFile(filepath: string): boolean;
     private embeddingConfig;
     private symbolicIndex;
+    private literalIndex;
     private pendingSummaries;
+    /** Map from chunkId → { filepath, literals } for building literal index */
+    private pendingLiterals;
     private rootDir;
     private logger;
     initialize(config: ModuleConfig): Promise<void>;
     indexFile(filepath: string, content: string, ctx: IndexContext): Promise<FileIndex | null>;
     /**
-     * Finalize indexing by building and saving the symbolic index
+     * Finalize indexing by building and saving the symbolic and literal indexes
      */
     finalize(ctx: IndexContext): Promise<void>;
     /**
      * Search the semantic index for chunks matching the query.
      *
-     * Uses a tiered approach for efficient search:
-     * 1. Tier 1: Use BM25 on file summaries to find candidate files
-     * 2. Tier 2: Load only candidate files and compute semantic similarity
+     * Uses a three-source approach:
+     * 1. Semantic search with embeddings
+     * 2. BM25 keyword search
+     * 3. Literal index for exact-match boosting
      *
      * @param query - Natural language search query
      * @param ctx - Search context with index access

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raggrep",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   "type": "module",
   "main": "./dist/index.js",