mdcontext 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,4 +1,110 @@
-import { Effect } from 'effect';
+import { Config, Option, Effect } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+
+/**
+ * Effect Config Schema Module
+ *
+ * Defines all configuration options using Effect's Config combinators.
+ * This provides native integration with Effect's ConfigProvider system,
+ * enabling compile-time tracking of config requirements through the type system.
+ *
+ * ## Configuration Structure
+ *
+ * - index: Settings for the indexing process
+ * - search: Settings for search operations
+ * - embeddings: Settings for semantic embeddings (OpenAI)
+ * - output: Settings for CLI output formatting
+ * - paths: Settings for file paths and directories
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { MdContextConfig, IndexConfig } from './config/schema.js'
+ * import { Effect } from 'effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const config = yield* MdContextConfig
+ *   console.log(`Max depth: ${config.index.maxDepth}`)
+ * })
+ * ```
+ */
+
+/**
+ * Complete mdcontext configuration
+ *
+ * Combines all configuration sections into a single nested config.
+ * Use with Effect's ConfigProvider to load from various sources.
+ */
+declare const MdContextConfig: Config.Config<{
+    index: {
+        maxDepth: number;
+        excludePatterns: string[] | readonly ["node_modules", ".git", "dist", "build"];
+        fileExtensions: string[] | readonly [".md", ".mdx"];
+        followSymlinks: boolean;
+        indexDir: string;
+    };
+    search: {
+        defaultLimit: number;
+        maxLimit: number;
+        minSimilarity: number;
+        includeSnippets: boolean;
+        snippetLength: number;
+        autoIndexThreshold: number;
+    };
+    embeddings: {
+        provider: "openai" | "ollama" | "lm-studio" | "openrouter" | "voyage";
+        baseURL: Option.Option<string>;
+        model: string;
+        dimensions: number;
+        batchSize: number;
+        maxRetries: number;
+        retryDelayMs: number;
+        timeoutMs: number;
+        apiKey: Option.Option<string>;
+        hnswM: number;
+        hnswEfConstruction: number;
+    };
+    summarization: {
+        briefTokenBudget: number;
+        summaryTokenBudget: number;
+        compressionRatio: number;
+        minSectionTokens: number;
+        maxTopics: number;
+        minPartialBudget: number;
+    };
+    aiSummarization: {
+        mode: "cli" | "api";
+        provider: "openai" | "claude" | "copilot" | "cline" | "aider" | "opencode" | "amp" | "deepseek" | "anthropic" | "gemini" | "qwen";
+        model: Option.Option<string>;
+        stream: boolean;
+        baseURL: Option.Option<string>;
+        apiKey: Option.Option<string>;
+    };
+    output: {
+        format: "text" | "json";
+        color: boolean;
+        prettyJson: boolean;
+        verbose: boolean;
+        debug: boolean;
+    };
+    paths: {
+        root: Option.Option<string>;
+        configFile: Option.Option<string>;
+        cacheDir: string;
+    };
+}>;
+/**
+ * Inferred type for the complete configuration
+ */
+type MdContextConfig = Config.Config.Success<typeof MdContextConfig>;
+
+/**
+ * Deeply partial type for MdContextConfig
+ */
+type PartialMdContextConfig = {
+    [K in keyof MdContextConfig]?: Partial<MdContextConfig[K]>;
+};
 
 /**
  * Core data types for mdcontext
@@ -57,6 +163,12 @@ interface MdCodeBlock {
     readonly startLine: number;
     readonly endLine: number;
 }
+/**
+ * Parse error from markdown parsing
+ *
+ * Note: This interface is used by parser.ts. For the TaggedError version
+ * that works with Effect's error handling, see src/errors/index.ts ParseError.
+ */
 interface ParseError {
     readonly _tag: 'ParseError';
     readonly message: string;
@@ -64,19 +176,192 @@ interface ParseError {
     readonly column?: number | undefined;
 }
 declare const ParseError: (message: string, line?: number, column?: number) => ParseError;
-interface IoError {
-    readonly _tag: 'IoError';
+
+/**
+ * Centralized error types for mdcontext
+ *
+ * This module defines all domain errors using Effect's Data.TaggedError pattern.
+ * Each error has a unique `_tag` discriminant that enables:
+ * - Exhaustive error handling with `catchTag` / `catchTags`
+ * - Type-safe error composition in Effect pipelines
+ * - Pattern matching for user-friendly error messages at CLI boundary
+ *
+ * ## Error Message Convention
+ *
+ * The `message` field in errors should contain **technical details** from the
+ * underlying operation, NOT user-facing formatted messages.
+ *
+ * **Good (technical):**
+ * ```typescript
+ * new FileReadError({
+ *   path: '/path/to/file',
+ *   message: e.message,  // e.g., "ENOENT: no such file or directory"
+ *   cause: e,
+ * })
+ * ```
+ *
+ * **Bad (user-facing):**
+ * ```typescript
+ * new FileReadError({
+ *   path: '/path/to/file',
+ *   message: 'Cannot read file. Please check permissions.',  // NO!
+ * })
+ * ```
+ *
+ * User-friendly messages are generated at the CLI boundary by the error handler
+ * in `src/cli/error-handler.ts`. This separation enables:
+ * - i18n/localization in the future
+ * - Testing error data without string matching
+ * - Consistent formatting in one place
+ *
+ * ## Error Taxonomy
+ *
+ * - File System: FileReadError, FileWriteError, DirectoryCreateError, DirectoryWalkError
+ * - Parsing: ParseError (for markdown parsing failures)
+ * - API: ApiKeyMissingError, ApiKeyInvalidError
+ * - Embeddings: EmbeddingError (rate limits, quota, network failures)
+ * - Index: IndexNotFoundError, IndexCorruptedError, IndexBuildError
+ * - Search: DocumentNotFoundError, EmbeddingsNotFoundError
+ * - Vector Store: VectorStoreError
+ * - Config: ConfigError
+ * - CLI: CliValidationError
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { FileReadError, ApiKeyMissingError } from './errors/index.js'
+ * import { Effect } from 'effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   // ... operations that may fail
+ * }).pipe(
+ *   Effect.catchTag('FileReadError', (e) => ...),
+ *   Effect.catchTag('ApiKeyMissingError', (e) => ...)
+ * )
+ * ```
+ */
+/**
+ * Standardized error codes for programmatic handling.
+ *
+ * Error codes enable:
+ * - Scripting and automation (check error codes in CI/CD)
+ * - Machine-readable error handling without parsing messages
+ * - Stable identifiers that don't change when messages are updated
+ *
+ * Naming convention: E{category}{number}
+ * - E1xx: File system errors
+ * - E2xx: Parse errors
+ * - E3xx: API/authentication errors
+ * - E4xx: Index errors
+ * - E5xx: Search errors
+ * - E6xx: Vector store errors
+ * - E7xx: Config errors
+ * - E8xx: Watch errors
+ * - E9xx: CLI errors
+ */
+declare const ErrorCode: {
+    readonly FILE_READ: "E100";
+    readonly FILE_WRITE: "E101";
+    readonly DIRECTORY_CREATE: "E102";
+    readonly DIRECTORY_WALK: "E103";
+    readonly PARSE: "E200";
+    readonly API_KEY_MISSING: "E300";
+    readonly API_KEY_INVALID: "E301";
+    readonly EMBEDDING_RATE_LIMIT: "E310";
+    readonly EMBEDDING_QUOTA: "E311";
+    readonly EMBEDDING_NETWORK: "E312";
+    readonly EMBEDDING_MODEL: "E313";
+    readonly EMBEDDING_UNKNOWN: "E319";
+    readonly INDEX_NOT_FOUND: "E400";
+    readonly INDEX_CORRUPTED: "E401";
+    readonly INDEX_BUILD: "E402";
+    readonly DOCUMENT_NOT_FOUND: "E500";
+    readonly EMBEDDINGS_NOT_FOUND: "E501";
+    readonly VECTOR_STORE: "E600";
+    readonly DIMENSION_MISMATCH: "E601";
+    readonly CONFIG: "E700";
+    readonly WATCH: "E800";
+    readonly CLI_VALIDATION: "E900";
+};
+declare const FileReadError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "FileReadError";
+} & Readonly<A>;
+/**
+ * Error reading a file from the filesystem
+ */
+declare class FileReadError extends FileReadError_base<{
+    readonly path: string;
     readonly message: string;
+    readonly cause?: unknown;
+}> {
+    get code(): typeof ErrorCode.FILE_READ;
+}
+declare const FileWriteError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "FileWriteError";
+} & Readonly<A>;
+/**
+ * Error writing a file to the filesystem
+ */
+declare class FileWriteError extends FileWriteError_base<{
     readonly path: string;
+    readonly message: string;
     readonly cause?: unknown;
+}> {
+    get code(): typeof ErrorCode.FILE_WRITE;
 }
-declare const IoError: (message: string, path: string, cause?: unknown) => IoError;
-interface IndexError {
-    readonly _tag: 'IndexError';
-    readonly cause: 'DiskFull' | 'Permission' | 'Corrupted' | 'Unknown';
+declare const DirectoryCreateError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "DirectoryCreateError";
+} & Readonly<A>;
+/**
+ * Error creating a directory
+ */
+declare class DirectoryCreateError extends DirectoryCreateError_base<{
+    readonly path: string;
     readonly message: string;
+    readonly cause?: unknown;
+}> {
+    get code(): typeof ErrorCode.DIRECTORY_CREATE;
+}
+declare const DirectoryWalkError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "DirectoryWalkError";
+} & Readonly<A>;
+/**
+ * Error walking/traversing a directory tree
+ */
+declare class DirectoryWalkError extends DirectoryWalkError_base<{
+    readonly path: string;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+    get code(): typeof ErrorCode.DIRECTORY_WALK;
+}
+declare const IndexCorruptedError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "IndexCorruptedError";
+} & Readonly<A>;
+/**
+ * Index exists but is corrupted or invalid
+ */
+declare class IndexCorruptedError extends IndexCorruptedError_base<{
+    readonly path: string;
+    readonly reason: 'InvalidJson' | 'VersionMismatch' | 'MissingData' | 'Unknown';
+    readonly details?: string;
+}> {
+    get code(): typeof ErrorCode.INDEX_CORRUPTED;
+    get message(): string;
+}
+declare const WatchError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "WatchError";
+} & Readonly<A>;
+/**
+ * File watcher error
+ */
+declare class WatchError extends WatchError_base<{
+    readonly path: string;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+    get code(): typeof ErrorCode.WATCH;
 }
-declare const IndexError: (cause: IndexError["cause"], message: string) => IndexError;
 
 /**
  * Index data types for mdcontext
@@ -128,6 +413,26 @@ interface LinkIndex {
     readonly backward: Record<string, readonly string[]>;
     readonly broken: readonly string[];
 }
+/**
+ * Reason why a file was skipped during indexing
+ */
+type SkipReason = 'unchanged' | 'excluded' | 'hidden' | 'not-markdown' | 'binary' | 'oversized';
+/**
+ * Information about a skipped file
+ */
+interface SkippedFile {
+    readonly path: string;
+    readonly reason: SkipReason;
+}
+/**
+ * Summary of skipped files by reason
+ */
+interface SkipSummary {
+    readonly unchanged: number;
+    readonly excluded: number;
+    readonly hidden: number;
+    readonly total: number;
+}
 interface IndexResult {
     readonly documentsIndexed: number;
     readonly sectionsIndexed: number;
@@ -136,9 +441,18 @@ interface IndexResult {
     readonly totalSections: number;
     readonly totalLinks: number;
     readonly duration: number;
-    readonly errors: readonly IndexBuildError[];
+    /** Non-fatal file processing errors (files that couldn't be indexed) */
+    readonly errors: readonly FileProcessingError[];
+    readonly skipped: SkipSummary;
 }
-interface IndexBuildError {
+/**
+ * Non-fatal error during file processing in index build.
+ * These are collected and reported but don't stop the build.
+ *
+ * Note: This is distinct from IndexBuildError in errors/index.ts,
+ * which is a TaggedError for fatal build failures.
+ */
+interface FileProcessingError {
     readonly path: string;
     readonly message: string;
 }
@@ -158,14 +472,45 @@ declare const getIndexPaths: (rootPath: string) => {
  * Indexer service for building and updating indexes
  */
 
+interface IndexProgress {
+    readonly current: number;
+    readonly total: number;
+    readonly filePath: string;
+}
 interface IndexOptions {
+    readonly force?: boolean | undefined;
+    /** CLI/config exclude patterns (overrides ignore files) */
+    readonly exclude?: readonly string[] | undefined;
+    /** Whether to honor .gitignore (default: true) */
+    readonly honorGitignore?: boolean | undefined;
+    /** Whether to honor .mdcontextignore (default: true) */
+    readonly honorMdcontextignore?: boolean | undefined;
+    /** Callback for progress updates during file indexing */
+    readonly onProgress?: ((progress: IndexProgress) => void) | undefined;
+}
+declare const buildIndex: (rootPath: string, options?: IndexOptions) => Effect.Effect<IndexResult, DirectoryWalkError | DirectoryCreateError | FileReadError | FileWriteError | IndexCorruptedError>;
+declare const getOutgoingLinks: (rootPath: string, filePath: string) => Effect.Effect<readonly string[], FileReadError | IndexCorruptedError>;
+declare const getIncomingLinks: (rootPath: string, filePath: string) => Effect.Effect<readonly string[], FileReadError | IndexCorruptedError>;
+declare const getBrokenLinks: (rootPath: string) => Effect.Effect<readonly string[], FileReadError | IndexCorruptedError>;
+interface BuildBM25Options {
     readonly force?: boolean;
-    readonly exclude?: readonly string[];
+    readonly onProgress?: (progress: {
+        current: number;
+        total: number;
+    }) => void;
+}
+interface BuildBM25Result {
+    readonly sectionsIndexed: number;
+    readonly duration: number;
 }
-declare const buildIndex: (rootPath: string, options?: IndexOptions) => Effect.Effect<IndexResult, Error>;
-declare const getOutgoingLinks: (rootPath: string, filePath: string) => Effect.Effect<readonly string[], Error>;
-declare const getIncomingLinks: (rootPath: string, filePath: string) => Effect.Effect<readonly string[], Error>;
-declare const getBrokenLinks: (rootPath: string) => Effect.Effect<readonly string[], Error>;
+/**
+ * Build BM25 keyword index for all sections.
+ *
+ * @param rootPath - Root directory containing indexed markdown files
+ * @param options - Build options (force rebuild, progress callback)
+ * @returns Result with section count and timing
+ */
+declare const buildBM25Index: (rootPath: string, options?: BuildBM25Options) => Effect.Effect<BuildBM25Result, FileReadError | IndexCorruptedError | FileWriteError>;
 
 /**
  * Index storage operations
@@ -177,36 +522,63 @@ interface IndexStorage {
     readonly paths: ReturnType<typeof getIndexPaths>;
 }
 declare const createStorage: (rootPath: string) => IndexStorage;
-declare const initializeIndex: (storage: IndexStorage) => Effect.Effect<void, Error>;
-declare const loadConfig: (storage: IndexStorage) => Effect.Effect<IndexConfig | null, Error>;
-declare const saveConfig: (storage: IndexStorage, config: IndexConfig) => Effect.Effect<void, Error>;
-declare const loadDocumentIndex: (storage: IndexStorage) => Effect.Effect<DocumentIndex | null, Error>;
-declare const saveDocumentIndex: (storage: IndexStorage, index: DocumentIndex) => Effect.Effect<void, Error>;
+declare const initializeIndex: (storage: IndexStorage) => Effect.Effect<void, DirectoryCreateError | FileReadError | FileWriteError | IndexCorruptedError>;
+declare const loadConfig: (storage: IndexStorage) => Effect.Effect<IndexConfig | null, FileReadError | IndexCorruptedError>;
+declare const saveConfig: (storage: IndexStorage, config: IndexConfig) => Effect.Effect<void, DirectoryCreateError | FileWriteError>;
+declare const loadDocumentIndex: (storage: IndexStorage) => Effect.Effect<DocumentIndex | null, FileReadError | IndexCorruptedError>;
+declare const saveDocumentIndex: (storage: IndexStorage, index: DocumentIndex) => Effect.Effect<void, DirectoryCreateError | FileWriteError>;
 declare const createEmptyDocumentIndex: (rootPath: string) => DocumentIndex;
-declare const loadSectionIndex: (storage: IndexStorage) => Effect.Effect<SectionIndex | null, Error>;
-declare const saveSectionIndex: (storage: IndexStorage, index: SectionIndex) => Effect.Effect<void, Error>;
+declare const loadSectionIndex: (storage: IndexStorage) => Effect.Effect<SectionIndex | null, FileReadError | IndexCorruptedError>;
+declare const saveSectionIndex: (storage: IndexStorage, index: SectionIndex) => Effect.Effect<void, DirectoryCreateError | FileWriteError>;
 declare const createEmptySectionIndex: () => SectionIndex;
-declare const loadLinkIndex: (storage: IndexStorage) => Effect.Effect<LinkIndex | null, Error>;
-declare const saveLinkIndex: (storage: IndexStorage, index: LinkIndex) => Effect.Effect<void, Error>;
+declare const loadLinkIndex: (storage: IndexStorage) => Effect.Effect<LinkIndex | null, FileReadError | IndexCorruptedError>;
+declare const saveLinkIndex: (storage: IndexStorage, index: LinkIndex) => Effect.Effect<void, DirectoryCreateError | FileWriteError>;
 declare const createEmptyLinkIndex: () => LinkIndex;
-declare const indexExists: (storage: IndexStorage) => Effect.Effect<boolean, Error>;
+declare const indexExists: (storage: IndexStorage) => Effect.Effect<boolean, FileReadError>;
 
 /**
  * File watcher for automatic re-indexing
+ *
+ * ## Why Not Effect Streams?
+ *
+ * We evaluated using Effect Streams (ALP-101) but decided the current approach is better:
+ *
+ * 1. **chokidar is battle-tested** - Handles OS-specific quirks (FSEvents on macOS,
+ *    inotify on Linux, ReadDirectoryChangesW on Windows)
+ *
+ * 2. **Debouncing handles backpressure** - The 300ms debounce already batches rapid
+ *    changes, so Stream backpressure isn't needed
+ *
+ * 3. **Simple use case** - File change → rebuild index. No complex transformations
+ *    or compositions that would benefit from Stream operators
+ *
+ * 4. **Already Effect-based** - The setup/teardown is wrapped in Effect for proper
+ *    error handling, and we use typed errors (WatchError, IndexBuildError)
+ *
+ * If future requirements need more sophisticated event processing (filtering by
+ * content type, incremental updates, event replay), reconsider Streams then.
  */
 
+/**
+ * Union of errors that can occur during watch operations
+ */
+type WatchDirectoryError = WatchError | DirectoryWalkError | DirectoryCreateError | FileReadError | FileWriteError | IndexCorruptedError;
 interface WatcherOptions extends IndexOptions {
     readonly debounceMs?: number;
     readonly onIndex?: (result: {
         documentsIndexed: number;
         duration: number;
     }) => void;
-    readonly onError?: (error: Error) => void;
+    readonly onError?: (error: WatchError) => void;
+    /** Whether to honor .gitignore for file watching (default: true) */
+    readonly honorGitignore?: boolean;
+    /** Whether to honor .mdcontextignore for file watching (default: true) */
+    readonly honorMdcontextignore?: boolean;
 }
 interface Watcher {
     readonly stop: () => void;
 }
-declare const watchDirectory: (rootPath: string, options?: WatcherOptions) => Effect.Effect<Watcher, Error>;
+declare const watchDirectory: (rootPath: string, options?: WatcherOptions) => Effect.Effect<Watcher, WatchDirectoryError>;
 
 /**
  * Markdown parser using remark/unified
@@ -220,12 +592,11 @@ interface ParseOptions {
 declare const parse: (content: string, options?: ParseOptions) => Effect.Effect<MdDocument, ParseError>;
 /**
  * Parse a markdown file from the filesystem
+ *
+ * @throws ParseError - File content cannot be parsed
+ * @throws FileReadError - File cannot be read from filesystem
  */
-declare const parseFile: (filePath: string) => Effect.Effect<MdDocument, ParseError | {
-    _tag: "IoError";
-    message: string;
-    path: string;
-}>;
+declare const parseFile: (filePath: string) => Effect.Effect<MdDocument, ParseError | FileReadError>;
 
 /**
  * Token counting utilities using tiktoken
@@ -263,4 +634,20 @@ declare const countWords: (text: string) => number;
  */
 declare const freeEncoder: () => void;
 
-export { type DocumentEntry, type DocumentIndex, type DocumentMetadata, type HeadingLevel, INDEX_DIR, INDEX_VERSION, type IndexBuildError, type IndexConfig, IndexError, type IndexOptions, type IndexResult, type IndexStorage, IoError, type LinkIndex, type LinkType, type MdCodeBlock, type MdDocument, type MdLink, type MdSection, ParseError, type ParseOptions, type SectionEntry, type SectionIndex, type SectionMetadata, type Watcher, type WatcherOptions, buildIndex, computeHash, countTokens, countTokensApprox, countWords, createEmptyDocumentIndex, createEmptyLinkIndex, createEmptySectionIndex, createStorage, freeEncoder, getBrokenLinks, getIncomingLinks, getIndexPaths, getOutgoingLinks, indexExists, initializeIndex, loadConfig, loadDocumentIndex, loadLinkIndex, loadSectionIndex, parse, parseFile, saveConfig, saveDocumentIndex, saveLinkIndex, saveSectionIndex, watchDirectory };
+/**
+ * Type-safe configuration helper for mdcontext.config.ts files.
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from 'mdcontext'
+ *
+ * export default defineConfig({
+ *   index: {
+ *     maxDepth: 5,
+ *   },
+ * })
+ * ```
+ */
+declare const defineConfig: <T extends PartialMdContextConfig>(config: T) => T;
+
+export { type BuildBM25Options, type BuildBM25Result, type DocumentEntry, type DocumentIndex, type DocumentMetadata, type FileProcessingError, type HeadingLevel, INDEX_DIR, INDEX_VERSION, type IndexConfig, type IndexOptions, type IndexProgress, type IndexResult, type IndexStorage, type LinkIndex, type LinkType, type MdCodeBlock, type MdDocument, type MdLink, type MdSection, ParseError, type ParseOptions, type PartialMdContextConfig, type SectionEntry, type SectionIndex, type SectionMetadata, type SkipReason, type SkipSummary, type SkippedFile, type WatchDirectoryError, type Watcher, type WatcherOptions, buildBM25Index, buildIndex, computeHash, countTokens, countTokensApprox, countWords, createEmptyDocumentIndex, createEmptyLinkIndex, createEmptySectionIndex, createStorage, defineConfig, freeEncoder, getBrokenLinks, getIncomingLinks, getIndexPaths, getOutgoingLinks, indexExists, initializeIndex, loadConfig, loadDocumentIndex, loadLinkIndex, loadSectionIndex, parse, parseFile, saveConfig, saveDocumentIndex, saveLinkIndex, saveSectionIndex, watchDirectory };

package/dist/index.js

@@ -1,9 +1,10 @@
 import {
   watchDirectory
-} from "./chunk-KRYIFLQR.js";
+} from "./chunk-SYE5XLF3.js";
 import {
   INDEX_DIR,
   INDEX_VERSION,
+  buildBM25Index,
   buildIndex,
   computeHash,
   countTokens,
@@ -30,7 +31,7 @@ import {
   saveDocumentIndex,
   saveLinkIndex,
   saveSectionIndex
-} from "./chunk-S7E6TFX6.js";
+} from "./chunk-MUJELQQ6.js";
 
 // src/core/types.ts
 var ParseError = (message, line, column) => ({
@@ -39,23 +40,14 @@ var ParseError = (message, line, column) => ({
   line,
   column
 });
-var IoError = (message, path, cause) => ({
-  _tag: "IoError",
-  message,
-  path,
-  cause
-});
-var IndexError = (cause, message) => ({
-  _tag: "IndexError",
-  cause,
-  message
-});
+
+// src/index.ts
+var defineConfig = (config) => config;
 export {
   INDEX_DIR,
   INDEX_VERSION,
-  IndexError,
-  IoError,
   ParseError,
+  buildBM25Index,
   buildIndex,
   computeHash,
   countTokens,
@@ -65,6 +57,7 @@ export {
   createEmptyLinkIndex,
   createEmptySectionIndex,
   createStorage,
+  defineConfig,
   freeEncoder,
   getBrokenLinks,
   getIncomingLinks,