mdcontext 0.0.1 → 0.2.0

package/dist/chunk-SJCDV2ST.js

@@ -0,0 +1,274 @@
+// src/config/schema.ts
+import { Config, Option } from "effect";
+
+var IndexConfig = Config.all({
+	/**
+	 * Maximum directory depth to traverse when indexing
+	 * Default: 10
+	 */
+	maxDepth: Config.number("maxDepth").pipe(Config.withDefault(10)),
+	/**
+	 * Glob patterns to exclude from indexing (comma-separated)
+	 * Default: ['node_modules', '.git', 'dist', 'build']
+	 */
+	excludePatterns: Config.array(Config.string(), "excludePatterns").pipe(
+		Config.withDefault(["node_modules", ".git", "dist", "build"]),
+	),
+	/**
+	 * File extensions to index (comma-separated)
+	 * Default: ['.md', '.mdx']
+	 */
+	fileExtensions: Config.array(Config.string(), "fileExtensions").pipe(
+		Config.withDefault([".md", ".mdx"]),
+	),
+	/**
+	 * Whether to follow symlinks when traversing directories
+	 * Default: false
+	 */
+	followSymlinks: Config.boolean("followSymlinks").pipe(
+		Config.withDefault(false),
+	),
+	/**
+	 * Directory where index files are stored (relative to project root)
+	 * Default: '.mdcontext'
+	 */
+	indexDir: Config.string("indexDir").pipe(Config.withDefault(".mdcontext")),
+});
+var SearchConfig = Config.all({
+	/**
+	 * Default number of search results to return
+	 * Default: 10
+	 */
+	defaultLimit: Config.number("defaultLimit").pipe(Config.withDefault(10)),
+	/**
+	 * Maximum number of search results allowed
+	 * Default: 100
+	 */
+	maxLimit: Config.number("maxLimit").pipe(Config.withDefault(100)),
+	/**
+	 * Minimum similarity score for semantic search results (0-1)
+	 * Default: 0.5
+	 */
+	minSimilarity: Config.number("minSimilarity").pipe(Config.withDefault(0.5)),
+	/**
+	 * Whether to include content snippets in search results
+	 * Default: true
+	 */
+	includeSnippets: Config.boolean("includeSnippets").pipe(
+		Config.withDefault(true),
+	),
+	/**
+	 * Maximum length of content snippets in characters
+	 * Default: 200
+	 */
+	snippetLength: Config.number("snippetLength").pipe(Config.withDefault(200)),
+	/**
+	 * Auto-create semantic index if estimated time is under this threshold (seconds)
+	 * Default: 10
+	 */
+	autoIndexThreshold: Config.number("autoIndexThreshold").pipe(
+		Config.withDefault(10),
+	),
+});
+var EmbeddingsConfig = Config.all({
+	/**
+	 * Embedding provider to use
+	 * Default: 'openai'
+	 */
+	provider: Config.literal("openai")("provider").pipe(
+		Config.withDefault("openai"),
+	),
+	/**
+	 * OpenAI embedding model to use
+	 * Default: 'text-embedding-3-small'
+	 */
+	model: Config.string("model").pipe(
+		Config.withDefault("text-embedding-3-small"),
+	),
+	/**
+	 * Number of dimensions for embeddings
+	 * Lower dimensions = faster search, higher = more accuracy
+	 * Default: 512
+	 */
+	dimensions: Config.number("dimensions").pipe(Config.withDefault(512)),
+	/**
+	 * Batch size for embedding API calls
+	 * Default: 100
+	 */
+	batchSize: Config.number("batchSize").pipe(Config.withDefault(100)),
+	/**
+	 * Maximum retries for failed API calls
+	 * Default: 3
+	 */
+	maxRetries: Config.number("maxRetries").pipe(Config.withDefault(3)),
+	/**
+	 * Delay between retries in milliseconds
+	 * Default: 1000
+	 */
+	retryDelayMs: Config.number("retryDelayMs").pipe(Config.withDefault(1e3)),
+	/**
+	 * Request timeout in milliseconds
+	 * Default: 30000 (30 seconds)
+	 */
+	timeoutMs: Config.number("timeoutMs").pipe(Config.withDefault(3e4)),
+	/**
+	 * OpenAI API key (usually from environment variable)
+	 * No default - must be provided
+	 */
+	apiKey: Config.option(Config.string("apiKey")),
+});
+var OutputConfig = Config.all({
+	/**
+	 * Default output format
+	 * Default: 'text'
+	 */
+	format: Config.literal(
+		"text",
+		"json",
+	)("format").pipe(Config.withDefault("text")),
+	/**
+	 * Whether to use colors in terminal output
+	 * Default: true
+	 */
+	color: Config.boolean("color").pipe(Config.withDefault(true)),
+	/**
+	 * Whether to pretty-print JSON output
+	 * Default: true
+	 */
+	prettyJson: Config.boolean("prettyJson").pipe(Config.withDefault(true)),
+	/**
+	 * Whether to show verbose output
+	 * Default: false
+	 */
+	verbose: Config.boolean("verbose").pipe(Config.withDefault(false)),
+	/**
+	 * Whether to show debug information
+	 * Default: false
+	 */
+	debug: Config.boolean("debug").pipe(Config.withDefault(false)),
+});
+var SummarizationConfig = Config.all({
+	/**
+	 * Token budget for 'brief' compression level
+	 * Default: 100
+	 */
+	briefTokenBudget: Config.number("briefTokenBudget").pipe(
+		Config.withDefault(100),
+	),
+	/**
+	 * Token budget for 'summary' compression level
+	 * Default: 500
+	 */
+	summaryTokenBudget: Config.number("summaryTokenBudget").pipe(
+		Config.withDefault(500),
+	),
+	/**
+	 * Target compression ratio for summaries (0-1)
+	 * Default: 0.3 (30% of original)
+	 */
+	compressionRatio: Config.number("compressionRatio").pipe(
+		Config.withDefault(0.3),
+	),
+	/**
+	 * Minimum tokens for any section summary
+	 * Default: 20
+	 */
+	minSectionTokens: Config.number("minSectionTokens").pipe(
+		Config.withDefault(20),
+	),
+	/**
+	 * Maximum topics to extract from a document
+	 * Default: 10
+	 */
+	maxTopics: Config.number("maxTopics").pipe(Config.withDefault(10)),
+	/**
+	 * Minimum remaining budget to include partial content
+	 * Default: 50
+	 */
+	minPartialBudget: Config.number("minPartialBudget").pipe(
+		Config.withDefault(50),
+	),
+});
+var PathsConfig = Config.all({
+	/**
+	 * Root directory for markdown files (default: current working directory)
+	 */
+	root: Config.option(Config.string("root")),
+	/**
+	 * Custom config file path (default: auto-detected)
+	 */
+	configFile: Config.option(Config.string("configFile")),
+	/**
+	 * Cache directory for temporary files
+	 * Default: '.mdcontext/cache'
+	 */
+	cacheDir: Config.string("cacheDir").pipe(
+		Config.withDefault(".mdcontext/cache"),
+	),
+});
+var MdContextConfig = Config.all({
+	index: Config.nested(IndexConfig, "index"),
+	search: Config.nested(SearchConfig, "search"),
+	embeddings: Config.nested(EmbeddingsConfig, "embeddings"),
+	summarization: Config.nested(SummarizationConfig, "summarization"),
+	output: Config.nested(OutputConfig, "output"),
+	paths: Config.nested(PathsConfig, "paths"),
+});
+var defaultConfig = {
+	index: {
+		maxDepth: 10,
+		excludePatterns: ["node_modules", ".git", "dist", "build"],
+		fileExtensions: [".md", ".mdx"],
+		followSymlinks: false,
+		indexDir: ".mdcontext",
+	},
+	search: {
+		defaultLimit: 10,
+		maxLimit: 100,
+		minSimilarity: 0.5,
+		includeSnippets: true,
+		snippetLength: 200,
+		autoIndexThreshold: 10,
+	},
+	embeddings: {
+		provider: "openai",
+		model: "text-embedding-3-small",
+		dimensions: 512,
+		batchSize: 100,
+		maxRetries: 3,
+		retryDelayMs: 1e3,
+		timeoutMs: 3e4,
+		apiKey: Option.none(),
+	},
+	summarization: {
+		briefTokenBudget: 100,
+		summaryTokenBudget: 500,
+		compressionRatio: 0.3,
+		minSectionTokens: 20,
+		maxTopics: 10,
+		minPartialBudget: 50,
+	},
+	output: {
+		format: "text",
+		color: true,
+		prettyJson: true,
+		verbose: false,
+		debug: false,
+	},
+	paths: {
+		root: Option.none(),
+		configFile: Option.none(),
+		cacheDir: ".mdcontext/cache",
+	},
+};
+
+export {
+	IndexConfig,
+	SearchConfig,
+	EmbeddingsConfig,
+	OutputConfig,
+	SummarizationConfig,
+	PathsConfig,
+	MdContextConfig,
+	defaultConfig,
+};

package/dist/chunk-SYE5XLF3.js

@@ -0,0 +1,104 @@
+import {
+  WatchError,
+  buildIndex,
+  createStorage,
+  getChokidarIgnorePatterns,
+  indexExists
+} from "./chunk-MUJELQQ6.js";
+
+// src/index/watcher.ts
+import * as path from "path";
+import { watch } from "chokidar";
+import { Effect } from "effect";
+var isMarkdownFile = (filePath) => filePath.endsWith(".md") || filePath.endsWith(".mdx");
+var watchDirectory = (rootPath, options = {}) => Effect.gen(function* () {
+  const resolvedRoot = path.resolve(rootPath);
+  const storage = createStorage(resolvedRoot);
+  const debounceMs = options.debounceMs ?? 300;
+  const exists = yield* indexExists(storage);
+  if (!exists) {
+    const result = yield* buildIndex(resolvedRoot, options);
+    options.onIndex?.({
+      documentsIndexed: result.documentsIndexed,
+      duration: result.duration
+    });
+  }
+  const pendingPaths = /* @__PURE__ */ new Set();
+  let debounceTimer = null;
+  const scheduleReindex = () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(async () => {
+      if (pendingPaths.size === 0) return;
+      pendingPaths.clear();
+      try {
+        const result = await Effect.runPromise(
+          buildIndex(resolvedRoot, options)
+        );
+        options.onIndex?.({
+          documentsIndexed: result.documentsIndexed,
+          duration: result.duration
+        });
+      } catch (error) {
+        options.onError?.(
+          new WatchError({
+            path: resolvedRoot,
+            message: error instanceof Error ? error.message : "Index rebuild failed",
+            cause: error
+          })
+        );
+      }
+    }, debounceMs);
+  };
+  const ignorePatterns = yield* getChokidarIgnorePatterns({
+    rootPath: resolvedRoot,
+    cliPatterns: options.exclude,
+    honorGitignore: options.honorGitignore ?? true,
+    honorMdcontextignore: options.honorMdcontextignore ?? true
+  });
+  const watcher = watch(resolvedRoot, {
+    ignored: ignorePatterns,
+    persistent: true,
+    ignoreInitial: true
+  });
+  watcher.on("add", (filePath) => {
+    if (isMarkdownFile(filePath)) {
+      pendingPaths.add(filePath);
+      scheduleReindex();
+    }
+  });
+  watcher.on("change", (filePath) => {
+    if (isMarkdownFile(filePath)) {
+      pendingPaths.add(filePath);
+      scheduleReindex();
+    }
+  });
+  watcher.on("unlink", (filePath) => {
+    if (isMarkdownFile(filePath)) {
+      pendingPaths.add(filePath);
+      scheduleReindex();
+    }
+  });
+  watcher.on("error", (error) => {
+    options.onError?.(
+      new WatchError({
+        path: resolvedRoot,
+        message: error instanceof Error ? error.message : "File watcher error",
+        cause: error
+      })
+    );
+  });
+  return {
+    stop: () => {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      watcher.close();
+    }
+  };
+});
+
+export {
+  watchDirectory
+};

package/dist/chunk-T5VLYBZD.js

@@ -0,0 +1,103 @@
+import { watch } from "chokidar";
+import { Effect } from "effect";
+// src/index/watcher.ts
+import * as path from "path";
+import {
+	buildIndex,
+	createStorage,
+	indexExists,
+	WatchError,
+} from "./chunk-IP3FRFEB.js";
+
+var isMarkdownFile = (filePath) =>
+	filePath.endsWith(".md") || filePath.endsWith(".mdx");
+var watchDirectory = (rootPath, options = {}) =>
+	Effect.gen(function* () {
+		const resolvedRoot = path.resolve(rootPath);
+		const storage = createStorage(resolvedRoot);
+		const debounceMs = options.debounceMs ?? 300;
+		const exists = yield* indexExists(storage);
+		if (!exists) {
+			const result = yield* buildIndex(resolvedRoot, options);
+			options.onIndex?.({
+				documentsIndexed: result.documentsIndexed,
+				duration: result.duration,
+			});
+		}
+		const pendingPaths = /* @__PURE__ */ new Set();
+		let debounceTimer = null;
+		const scheduleReindex = () => {
+			if (debounceTimer) {
+				clearTimeout(debounceTimer);
+			}
+			debounceTimer = setTimeout(async () => {
+				if (pendingPaths.size === 0) return;
+				pendingPaths.clear();
+				try {
+					const result = await Effect.runPromise(
+						buildIndex(resolvedRoot, options),
+					);
+					options.onIndex?.({
+						documentsIndexed: result.documentsIndexed,
+						duration: result.duration,
+					});
+				} catch (error) {
+					options.onError?.(
+						new WatchError({
+							path: resolvedRoot,
+							message:
+								error instanceof Error ? error.message : "Index rebuild failed",
+							cause: error,
+						}),
+					);
+				}
+			}, debounceMs);
+		};
+		const watcher = watch(resolvedRoot, {
+			ignored: [
+				/(^|[/\\])\../,
+				// Ignore dotfiles
+				"**/node_modules/**",
+			],
+			persistent: true,
+			ignoreInitial: true,
+		});
+		watcher.on("add", (filePath) => {
+			if (isMarkdownFile(filePath)) {
+				pendingPaths.add(filePath);
+				scheduleReindex();
+			}
+		});
+		watcher.on("change", (filePath) => {
+			if (isMarkdownFile(filePath)) {
+				pendingPaths.add(filePath);
+				scheduleReindex();
+			}
+		});
+		watcher.on("unlink", (filePath) => {
+			if (isMarkdownFile(filePath)) {
+				pendingPaths.add(filePath);
+				scheduleReindex();
+			}
+		});
+		watcher.on("error", (error) => {
+			options.onError?.(
+				new WatchError({
+					path: resolvedRoot,
+					message:
+						error instanceof Error ? error.message : "File watcher error",
+					cause: error,
+				}),
+			);
+		});
+		return {
+			stop: () => {
+				if (debounceTimer) {
+					clearTimeout(debounceTimer);
+				}
+				watcher.close();
+			},
+		};
+	});
+
+export { watchDirectory };