raggrep 0.14.2 → 0.15.0

package/dist/domain/entities/index.d.ts

@@ -8,7 +8,7 @@ export type { Chunk, ChunkType } from "./chunk";
 export { createChunkId } from "./chunk";
 export type { FileIndex, FileManifestEntry, ModuleManifest, GlobalManifest, } from "./fileIndex";
 export type { FileSummary, SymbolicIndexMeta, Tier1Manifest, } from "./fileSummary";
-export type { SearchResult, SearchOptions, SearchContributions, CoreContribution, LanguageContribution, IntrospectionContribution, } from "./searchResult";
+export type { SearchResult, SearchOptions, SearchContributions, CoreContribution, LanguageContribution, IntrospectionContribution, ExactMatchOccurrence, ExactMatchFile, ExactMatchResults, HybridSearchResults, } from "./searchResult";
 export { DEFAULT_SEARCH_OPTIONS } from "./searchResult";
 export type { Config, ModuleConfig } from "./config";
 export { DEFAULT_IGNORE_PATHS, DEFAULT_EXTENSIONS, createDefaultConfig, } from "./config";

package/dist/domain/entities/searchResult.d.ts

@@ -104,3 +104,57 @@ export interface SearchOptions {
  * Default search options.
  */
 export declare const DEFAULT_SEARCH_OPTIONS: Required<SearchOptions>;
+/**
+ * A single exact match occurrence in a file.
+ * Represents a grep-like match with surrounding context.
+ */
+export interface ExactMatchOccurrence {
+    /** Line number where the match was found (1-indexed) */
+    line: number;
+    /** Column where the match starts (0-indexed) */
+    column: number;
+    /** The full line containing the match */
+    lineContent: string;
+    /** Line before the match (if available) */
+    contextBefore?: string;
+    /** Line after the match (if available) */
+    contextAfter?: string;
+}
+/**
+ * Exact matches found in a single file.
+ */
+export interface ExactMatchFile {
+    /** Path to the file */
+    filepath: string;
+    /** All occurrences of the literal in this file */
+    occurrences: ExactMatchOccurrence[];
+    /** Total number of matches in this file */
+    matchCount: number;
+}
+/**
+ * Result of exact/literal search across the codebase.
+ * This is separate from semantic search results.
+ */
+export interface ExactMatchResults {
+    /** The literal that was searched for */
+    query: string;
+    /** Files containing exact matches, sorted by match count */
+    files: ExactMatchFile[];
+    /** Total number of matches across all files */
+    totalMatches: number;
+    /** Total number of files with matches */
+    totalFiles: number;
+    /** Whether results were truncated (more matches exist) */
+    truncated: boolean;
+}
+/**
+ * Combined search results with both semantic and exact match tracks.
+ */
+export interface HybridSearchResults {
+    /** Semantic/BM25 search results (existing behavior) */
+    results: SearchResult[];
+    /** Exact match results for literal queries (optional) */
+    exactMatches?: ExactMatchResults;
+    /** Whether exact matches influenced the semantic result ranking */
+    fusionApplied: boolean;
+}

package/dist/domain/ports/filesystem.d.ts

@@ -10,8 +10,10 @@
 export interface FileStats {
     /** ISO timestamp of last modification */
     lastModified: string;
-    /** File size in bytes */
+    /** File size in bytes (undefined for directories) */
     size?: number;
+    /** Whether this is a directory */
+    isDirectory?: boolean;
 }
 /**
  * Abstract filesystem interface.

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

@@ -17,3 +17,4 @@ export { extractJsonPaths, extractJsonKeywords } from "./jsonPathExtractor";
 export { introspectFile, findNearestReadme, introspectionToKeywords, detectScopeFromName, findProjectForFile, calculateIntrospectionBoost, type IntrospectFileOptions, } from "./introspection";
 export { validateConfig, formatValidationIssues, type ValidationIssue, type ValidationResult, } from "./configValidator";
 export { calculatePhraseMatch, hasExactPhrase, calculateTokenCoverage, tokenizeForMatching, PHRASE_MATCH_CONSTANTS, type PhraseMatchResult, } from "./phraseMatch";
+export { isIdentifierQuery, extractSearchLiteral, findOccurrences, searchFiles, extractIdentifiersFromContent, isSearchableContent, } from "./simpleSearch";

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

@@ -0,0 +1,75 @@
+/**
+ * Simple Search Service
+ *
+ * Provides grep-like exact text matching across files.
+ * This is a pure domain service - no file I/O, just algorithms.
+ *
+ * Used for:
+ * - Finding exact occurrences of identifiers (SCREAMING_SNAKE, camelCase)
+ * - Providing a guaranteed "exact match" track separate from semantic search
+ * - Context lines around matches (+/- 1 line)
+ */
+import type { ExactMatchOccurrence, ExactMatchResults } from "../entities/searchResult";
+/**
+ * Check if a query string looks like a programming identifier.
+ * These queries should trigger simple search in addition to semantic search.
+ *
+ * @param query - The search query
+ * @returns true if the query looks like an identifier
+ */
+export declare function isIdentifierQuery(query: string): boolean;
+/**
+ * Extract the literal to search for from a query.
+ * Removes quoting if present.
+ *
+ * @param query - The search query
+ * @returns The literal to search for
+ */
+export declare function extractSearchLiteral(query: string): string;
+/**
+ * Find all occurrences of a literal in file content.
+ *
+ * @param content - The file content to search
+ * @param literal - The exact string to find
+ * @param options - Search options
+ * @returns Array of match occurrences with context
+ */
+export declare function findOccurrences(content: string, literal: string, options?: {
+    /** Maximum occurrences to return per file */
+    maxOccurrences?: number;
+    /** Whether to do case-insensitive matching */
+    caseInsensitive?: boolean;
+}): ExactMatchOccurrence[];
+/**
+ * Search multiple files for exact matches of a literal.
+ *
+ * @param files - Map of filepath to content
+ * @param literal - The exact string to find
+ * @param options - Search options
+ * @returns Exact match results
+ */
+export declare function searchFiles(files: Map<string, string>, literal: string, options?: {
+    /** Maximum files to return */
+    maxFiles?: number;
+    /** Maximum occurrences per file */
+    maxOccurrencesPerFile?: number;
+    /** Case-insensitive matching */
+    caseInsensitive?: boolean;
+}): ExactMatchResults;
+/**
+ * Extract all identifier-like literals from content.
+ * Used during indexing to build a literal index for plain text files.
+ *
+ * @param content - File content to extract from
+ * @returns Array of unique identifier literals found
+ */
+export declare function extractIdentifiersFromContent(content: string): string[];
+/**
+ * Check if a file should be included in simple search based on its content.
+ * Excludes binary files and very large files.
+ *
+ * @param content - File content
+ * @param filepath - File path for extension checking
+ * @returns true if file should be searchable
+ */
+export declare function isSearchableContent(content: string, filepath: string): boolean;

package/dist/domain/usecases/exactSearch.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Exact Search Use Case
+ *
+ * Orchestrates grep-like exact text search across source files.
+ * This use case coordinates filesystem access and the simple search service.
+ */
+import type { FileSystem } from "../ports";
+import type { ExactMatchResults } from "../entities";
+/**
+ * Options for exact search operation.
+ */
+export interface ExactSearchOptions {
+    /** Root directory to search in */
+    rootDir: string;
+    /** The literal string to search for */
+    literal: string;
+    /** Optional path filter patterns */
+    pathFilter?: string[];
+    /** Maximum number of files to return */
+    maxFiles?: number;
+    /** Maximum occurrences per file */
+    maxOccurrencesPerFile?: number;
+    /** Case-insensitive matching */
+    caseInsensitive?: boolean;
+}
+/**
+ * Check if a file path matches any of the given filters.
+ *
+ * Supports two modes:
+ * - Glob patterns: Contains wildcards like *, ?, etc.
+ * - Path prefixes: Plain directory paths
+ *
+ * @param relativePath - File path relative to root
+ * @param filters - Array of filters (glob patterns or path prefixes)
+ * @param matchFn - Function to test glob patterns (e.g., minimatch)
+ * @returns true if the path matches any filter
+ */
+export declare function matchesPathFilter(relativePath: string, filters: string[], matchFn: (path: string, pattern: string) => boolean): boolean;
+/**
+ * Execute exact search across the codebase.
+ *
+ * This use case:
+ * 1. Walks the filesystem to find searchable files
+ * 2. Filters files based on path patterns
+ * 3. Uses the simple search service to find exact matches
+ * 4. Returns results sorted by match count
+ *
+ * @param fs - FileSystem implementation (injected dependency)
+ * @param options - Search options
+ * @param matchFn - Glob pattern matching function (e.g., minimatch)
+ * @returns Exact match results
+ */
+export declare function executeExactSearch(fs: FileSystem, options: ExactSearchOptions, matchFn: (path: string, pattern: string) => boolean): Promise<ExactMatchResults>;

package/dist/domain/usecases/index.d.ts

@@ -7,3 +7,4 @@
 export { indexDirectory, type IndexResult, type IndexDirectoryOptions, type IndexDirectoryDependencies } from './indexDirectory';
 export { searchIndex, formatSearchResults, type SearchIndexOptions, type SearchIndexDependencies } from './searchIndex';
 export { cleanupIndex, type CleanupResult, type CleanupIndexOptions, type CleanupIndexDependencies } from './cleanupIndex';
+export { executeExactSearch, matchesPathFilter, type ExactSearchOptions, } from './exactSearch';

package/dist/index.d.ts

@@ -31,11 +31,11 @@
  * ```
  */
 import type { IndexResult, IndexOptions, CleanupResult, CleanupOptions, ResetResult } from "./app/indexer";
-import { formatSearchResults } from "./app/search";
-import type { SearchOptions, SearchResult } from "./types";
+import { formatSearchResults, formatHybridSearchResults } from "./app/search";
+import type { SearchOptions, SearchResult, HybridSearchResults } from "./types";
 import { ConsoleLogger, InlineProgressLogger, SilentLogger, createLogger, createInlineLogger, createSilentLogger } from "./infrastructure/logger";
 export type { IndexResult, IndexOptions, CleanupResult, CleanupOptions, ResetResult, } from "./app/indexer";
-export type { SearchOptions, SearchResult, Chunk, FileIndex } from "./types";
+export type { SearchOptions, SearchResult, HybridSearchResults, Chunk, FileIndex, } from "./types";
 export type { Logger, LoggerFactory } from "./domain/ports";
 export { ConsoleLogger, InlineProgressLogger, SilentLogger, createLogger, createInlineLogger, createSilentLogger, };
 /**
@@ -118,6 +118,32 @@ export declare function cleanup(directory: string, options?: CleanupOptions): Pr
  * ```
  */
 export declare function reset(directory: string): Promise<ResetResult>;
+/**
+ * Hybrid search with both semantic and exact match tracks.
+ *
+ * Returns semantic results with optional exact match results for identifier queries.
+ * Exact matches are found using grep-like text search and are displayed separately.
+ *
+ * @param directory - Path to the indexed directory
+ * @param query - Natural language or identifier search query
+ * @param options - Search options
+ * @returns Hybrid search results with both tracks
+ *
+ * @example
+ * ```ts
+ * // Search for an identifier (triggers exact match)
+ * const results = await raggrep.hybridSearch('./my-project', 'AUTH_SERVICE_URL');
+ *
+ * // Check for exact matches
+ * if (results.exactMatches) {
+ *   console.log(`Found ${results.exactMatches.totalMatches} exact matches`);
+ * }
+ *
+ * // Semantic results (with fusion boost if exact matches found)
+ * console.log(`${results.results.length} semantic results`);
+ * ```
+ */
+export declare function hybridSearch(directory: string, query: string, options?: SearchOptions): Promise<HybridSearchResults>;
 /**
  * Format search results for display.
  *
@@ -125,11 +151,20 @@ export declare function reset(directory: string): Promise<ResetResult>;
  * @returns Formatted string for console output
  */
 export { formatSearchResults };
+/**
+ * Format hybrid search results including exact matches.
+ *
+ * @param results - Hybrid search results
+ * @returns Formatted string for console output
+ */
+export { formatHybridSearchResults };
 declare const raggrep: {
     index: typeof index;
     search: typeof search;
+    hybridSearch: typeof hybridSearch;
     cleanup: typeof cleanup;
     reset: typeof reset;
     formatSearchResults: typeof formatSearchResults;
+    formatHybridSearchResults: typeof formatHybridSearchResults;
 };
 export default raggrep;