raggrep 0.2.3 → 0.4.0

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

@@ -74,6 +74,17 @@ export interface SearchOptions {
     minScore?: number;
     /** Filter to specific file patterns (e.g., ['*.ts', '*.tsx']) */
     filePatterns?: string[];
+    /**
+     * Ensure the index is fresh before searching (default: true).
+     *
+     * When true, the search will automatically:
+     * - Create the index if it doesn't exist
+     * - Re-index any modified files
+     * - Remove entries for deleted files
+     *
+     * Set to false if you've already ensured freshness or want explicit control.
+     */
+    ensureFresh?: boolean;
 }
 /**
  * Default search options.

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

@@ -5,6 +5,7 @@
  * This allows the domain to remain independent of the actual embedding implementation
  * (e.g., Transformers.js, OpenAI API, local models).
  */
+import type { Logger } from "./logger";
 /**
  * Available embedding model names
  */
@@ -15,8 +16,10 @@ export type EmbeddingModelName = "all-MiniLM-L6-v2" | "all-MiniLM-L12-v2" | "bge
 export interface EmbeddingConfig {
     /** Model name to use */
     model: EmbeddingModelName;
-    /** Whether to show progress during model loading */
+    /** Whether to show progress during model loading (deprecated, use logger instead) */
     showProgress?: boolean;
+    /** Logger for reporting download progress */
+    logger?: Logger;
 }
 /**
  * Abstract embedding provider interface.

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

@@ -5,5 +5,6 @@
  * These are implemented by infrastructure adapters.
  */
 export type { FileSystem, FileStats } from "./filesystem";
-export type { EmbeddingProvider, EmbeddingConfig, EmbeddingModelName } from "./embedding";
+export type { EmbeddingProvider, EmbeddingConfig, EmbeddingModelName, } from "./embedding";
 export type { IndexStorage } from "./storage";
+export type { Logger, ProgressInfo, LoggerFactory } from "./logger";

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

@@ -0,0 +1,66 @@
+/**
+ * Logger Port
+ *
+ * Abstract interface for logging progress and messages.
+ * This allows the domain and application layers to remain independent
+ * of the actual logging implementation (console, file, etc.).
+ */
+/**
+ * Progress information for long-running operations
+ */
+export interface ProgressInfo {
+    /** Current item being processed */
+    current: number;
+    /** Total number of items */
+    total: number;
+    /** Optional descriptive message */
+    message?: string;
+}
+/**
+ * Abstract logger interface.
+ *
+ * Implementations might:
+ * - Log to console (ConsoleLogger)
+ * - Log to console with inline replacement for progress (InlineProgressLogger)
+ * - Be silent (SilentLogger)
+ * - Log to a file or external service
+ */
+export interface Logger {
+    /**
+     * Log an info message (general progress updates)
+     */
+    info(message: string): void;
+    /**
+     * Log a warning message
+     */
+    warn(message: string): void;
+    /**
+     * Log an error message
+     */
+    error(message: string): void;
+    /**
+     * Log a debug message (only shown in verbose mode)
+     */
+    debug(message: string): void;
+    /**
+     * Log a progress update that can replace the current line.
+     * Used for download progress, file processing counters, etc.
+     *
+     * In terminal environments, this may overwrite the current line.
+     * In non-terminal environments (SDK), this may just log normally.
+     *
+     * @param message - Progress message to display
+     */
+    progress(message: string): void;
+    /**
+     * Clear any inline progress output.
+     * Call this before switching from progress() to info/warn/error.
+     */
+    clearProgress(): void;
+}
+/**
+ * Factory function type for creating loggers
+ */
+export type LoggerFactory = (options?: {
+    verbose?: boolean;
+}) => Logger;

package/dist/index.d.ts

@@ -7,25 +7,42 @@
  * ```ts
  * import raggrep from 'raggrep';
  *
- * // Index a directory
+ * // Index a directory (automatically cleans up deleted files)
  * await raggrep.index('/path/to/project');
  *
  * // Search the index
  * const results = await raggrep.search('/path/to/project', 'user authentication');
  *
- * // Clean up stale entries
- * await raggrep.cleanup('/path/to/project');
+ * // Reset (clear) the index completely
+ * await raggrep.reset('/path/to/project');
+ * ```
+ *
+ * @example With custom logger
+ * ```ts
+ * import raggrep, { createLogger, createInlineLogger } from 'raggrep';
+ *
+ * // Create a logger (defaults to console)
+ * const logger = createLogger({ verbose: true });
+ *
+ * // Or use inline logger for CLI-style progress
+ * const inlineLogger = createInlineLogger({ verbose: false });
+ *
+ * await raggrep.index('/path/to/project', { logger: inlineLogger });
  * ```
  */
-import type { IndexResult, IndexOptions, CleanupResult } from "./app/indexer";
+import type { IndexResult, IndexOptions, CleanupResult, CleanupOptions, ResetResult } from "./app/indexer";
 import { formatSearchResults } from "./app/search";
 import type { SearchOptions, SearchResult } from "./types";
-export type { IndexResult, IndexOptions, CleanupResult } from "./app/indexer";
+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 { Logger, LoggerFactory } from "./domain/ports";
+export { ConsoleLogger, InlineProgressLogger, SilentLogger, createLogger, createInlineLogger, createSilentLogger, };
 /**
  * Index a directory for semantic search.
  *
  * Creates a `.raggrep/` folder with the index data.
+ * Automatically cleans up stale entries for deleted files.
  *
  * @param directory - Path to the directory to index
  * @param options - Index options
@@ -69,6 +86,9 @@ export declare function search(directory: string, query: string, options?: Searc
 /**
  * Clean up stale index entries for files that no longer exist.
  *
+ * Note: Cleanup is now automatic during indexing. This function is provided
+ * for explicit cleanup without re-indexing.
+ *
  * @param directory - Path to the indexed directory
  * @param options - Cleanup options
  * @returns Array of cleanup results per module
@@ -79,9 +99,25 @@ export declare function search(directory: string, query: string, options?: Searc
  * console.log(`Removed ${results[0].removed} stale entries`);
  * ```
  */
-export declare function cleanup(directory: string, options?: {
-    verbose?: boolean;
-}): Promise<CleanupResult[]>;
+export declare function cleanup(directory: string, options?: CleanupOptions): Promise<CleanupResult[]>;
+/**
+ * Reset (completely clear) the index for a directory.
+ *
+ * @param directory - Path to the indexed directory
+ * @returns Result with success status and removed index path
+ * @throws Error if no index exists for the directory
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const result = await raggrep.reset('./my-project');
+ *   console.log(`Cleared index at: ${result.indexDir}`);
+ * } catch (error) {
+ *   console.error('No index found');
+ * }
+ * ```
+ */
+export declare function reset(directory: string): Promise<ResetResult>;
 /**
  * Format search results for display.
  *
@@ -93,6 +129,7 @@ declare const raggrep: {
     index: typeof index;
     search: typeof search;
     cleanup: typeof cleanup;
+    reset: typeof reset;
     formatSearchResults: typeof formatSearchResults;
 };
 export default raggrep;