mdcontext 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,653 @@
+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
+ * Based on DESIGN.md specifications
+ */
+interface MdDocument {
+    readonly id: string;
+    readonly path: string;
+    readonly title: string;
+    readonly frontmatter: Record<string, unknown>;
+    readonly sections: readonly MdSection[];
+    readonly links: readonly MdLink[];
+    readonly codeBlocks: readonly MdCodeBlock[];
+    readonly metadata: DocumentMetadata;
+}
+interface DocumentMetadata {
+    readonly wordCount: number;
+    readonly tokenCount: number;
+    readonly headingCount: number;
+    readonly linkCount: number;
+    readonly codeBlockCount: number;
+    readonly lastModified: Date;
+    readonly indexedAt: Date;
+}
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+interface MdSection {
+    readonly id: string;
+    readonly heading: string;
+    readonly level: HeadingLevel;
+    readonly content: string;
+    readonly plainText: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly children: readonly MdSection[];
+    readonly metadata: SectionMetadata;
+}
+interface SectionMetadata {
+    readonly wordCount: number;
+    readonly tokenCount: number;
+    readonly hasCode: boolean;
+    readonly hasList: boolean;
+    readonly hasTable: boolean;
+}
+type LinkType = 'internal' | 'external' | 'image';
+interface MdLink {
+    readonly type: LinkType;
+    readonly href: string;
+    readonly text: string;
+    readonly sectionId: string;
+    readonly line: number;
+}
+interface MdCodeBlock {
+    readonly language: string | null;
+    readonly content: string;
+    readonly sectionId: string;
+    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;
+    readonly line?: number | undefined;
+    readonly column?: number | undefined;
+}
+declare const ParseError: (message: string, line?: number, column?: number) => ParseError;
+
+/**
+ * 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 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;
+}
+
+/**
+ * Index data types for mdcontext
+ */
+interface IndexConfig {
+    readonly version: number;
+    readonly rootPath: string;
+    readonly include: readonly string[];
+    readonly exclude: readonly string[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface DocumentIndex {
+    readonly version: number;
+    readonly rootPath: string;
+    readonly documents: Record<string, DocumentEntry>;
+}
+interface DocumentEntry {
+    readonly id: string;
+    readonly path: string;
+    readonly title: string;
+    readonly mtime: number;
+    readonly hash: string;
+    readonly tokenCount: number;
+    readonly sectionCount: number;
+}
+interface SectionIndex {
+    readonly version: number;
+    readonly sections: Record<string, SectionEntry>;
+    readonly byHeading: Record<string, readonly string[]>;
+    readonly byDocument: Record<string, readonly string[]>;
+}
+interface SectionEntry {
+    readonly id: string;
+    readonly documentId: string;
+    readonly documentPath: string;
+    readonly heading: string;
+    readonly level: number;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly tokenCount: number;
+    readonly hasCode: boolean;
+    readonly hasList: boolean;
+    readonly hasTable: boolean;
+}
+interface LinkIndex {
+    readonly version: number;
+    readonly forward: Record<string, readonly string[]>;
+    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;
+    readonly linksIndexed: number;
+    readonly totalDocuments: number;
+    readonly totalSections: number;
+    readonly totalLinks: number;
+    readonly duration: number;
+    /** Non-fatal file processing errors (files that couldn't be indexed) */
+    readonly errors: readonly FileProcessingError[];
+    readonly skipped: SkipSummary;
+}
+/**
+ * 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;
+}
+declare const INDEX_DIR = ".mdcontext";
+declare const INDEX_VERSION = 1;
+declare const getIndexPaths: (rootPath: string) => {
+    root: string;
+    config: string;
+    documents: string;
+    sections: string;
+    links: string;
+    cache: string;
+    parsed: 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 onProgress?: (progress: {
+        current: number;
+        total: number;
+    }) => void;
+}
+interface BuildBM25Result {
+    readonly sectionsIndexed: number;
+    readonly duration: number;
+}
+/**
+ * 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
+ */
+
+declare const computeHash: (content: string) => string;
+interface IndexStorage {
+    readonly rootPath: string;
+    readonly paths: ReturnType<typeof getIndexPaths>;
+}
+declare const createStorage: (rootPath: string) => IndexStorage;
+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, 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, 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, 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: 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, WatchDirectoryError>;
+
+/**
+ * Markdown parser using remark/unified
+ * Handles GFM (tables, task lists) and YAML frontmatter
+ */
+
+interface ParseOptions {
+    readonly path?: string;
+    readonly lastModified?: Date;
+}
+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 | FileReadError>;
+
+/**
+ * Token counting utilities using tiktoken
+ */
+
+/**
+ * Count tokens in a string using the cl100k_base encoding
+ * (compatible with GPT-4, GPT-3.5-turbo, and Claude models)
+ */
+declare const countTokens: (text: string) => Effect.Effect<number, never, never>;
+/**
+ * Synchronous token counting with improved approximation
+ *
+ * Uses heuristics calibrated against cl100k_base encoding:
+ * - Base prose: ~3.5 chars/token (conservative to never under-count)
+ * - Code blocks: Content at ~2.8 chars/token + fixed overhead per block
+ * - Inline code: ~2.5 chars/token + 2 tokens per backtick pair
+ * - Paths: ~3.0 chars/token (slashes tokenize separately)
+ * - Newlines: ~1 token each (they often become separate tokens)
+ * - Punctuation/symbols: adds ~0.8 tokens per mark
+ * - CJK characters: ~1.2 tokens per character
+ * - Emojis: ~2.5 tokens per emoji
+ *
+ * Safety margin of 10% to handle edge cases and ensure budget compliance.
+ * The conservative ratios combined with safety margin ensure we NEVER under-count.
+ */
+declare const countTokensApprox: (text: string) => number;
+/**
+ * Count words in text
+ */
+declare const countWords: (text: string) => number;
+/**
+ * Free the tiktoken encoder to release WebAssembly resources.
+ * Call this in test teardown to prevent process hang.
+ */
+declare const freeEncoder: () => void;
+
+/**
+ * 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 };