@karmaniverous/jeeves-watcher 0.1.0

package/dist/index.iife.js

@@ -0,0 +1,1562 @@
+(function (exports, Fastify, node_crypto, promises, node_path, picomatch, chokidar, Ajv, cosmiconfig, googleGenai, pino, textsplitters, cheerio, yaml, mammoth, uuid, addFormats, jsClientRest) {
+    'use strict';
+
+    function _interopNamespaceDefault(e) {
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var cheerio__namespace = /*#__PURE__*/_interopNamespaceDefault(cheerio);
+
+    /**
+     * Normalise a file path for deterministic mapping: lowercase, forward slashes, strip leading drive letter colon.
+     *
+     * @param filePath - The original file path.
+     * @returns The normalised path string.
+     */
+    function normalisePath$1(filePath) {
+        return filePath
+            .replace(/\\/g, '/')
+            .replace(/^([A-Za-z]):/, (_m, letter) => letter.toLowerCase())
+            .toLowerCase();
+    }
+    /**
+     * Derive a deterministic `.meta.json` path for a given file.
+     *
+     * @param filePath - The watched file path.
+     * @param metadataDir - The root metadata directory.
+     * @returns The full path to the metadata file.
+     */
+    function metadataPath(filePath, metadataDir) {
+        const normalised = normalisePath$1(filePath);
+        const hash = node_crypto.createHash('sha256').update(normalised, 'utf8').digest('hex');
+        return node_path.join(metadataDir, `${hash}.meta.json`);
+    }
+    /**
+     * Read persisted metadata for a file.
+     *
+     * @param filePath - The watched file path.
+     * @param metadataDir - The root metadata directory.
+     * @returns The parsed metadata object, or `null` if not found.
+     */
+    async function readMetadata(filePath, metadataDir) {
+        try {
+            const raw = await promises.readFile(metadataPath(filePath, metadataDir), 'utf8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Write metadata for a file.
+     *
+     * @param filePath - The watched file path.
+     * @param metadataDir - The root metadata directory.
+     * @param metadata - The metadata to persist.
+     */
+    async function writeMetadata(filePath, metadataDir, metadata) {
+        const dest = metadataPath(filePath, metadataDir);
+        await promises.mkdir(node_path.dirname(dest), { recursive: true });
+        await promises.writeFile(dest, JSON.stringify(metadata, null, 2), 'utf8');
+    }
+    /**
+     * Delete metadata for a file.
+     *
+     * @param filePath - The watched file path.
+     * @param metadataDir - The root metadata directory.
+     */
+    async function deleteMetadata(filePath, metadataDir) {
+        try {
+            await promises.rm(metadataPath(filePath, metadataDir));
+        }
+        catch {
+            // Ignore if file doesn't exist.
+        }
+    }
+
+    /**
+     * Best-effort base directory inference for a glob pattern.
+     *
+     * For our use (watch paths in config), this only needs to be good enough
+     * to scan the directory tree in integration tests.
+     */
+    function globBase(pattern) {
+        const normalised = pattern.replace(/\\/g, '/');
+        // eslint-disable-next-line no-useless-escape
+        const globIdx = normalised.search(/[*?\[]/);
+        if (globIdx === -1)
+            return node_path.resolve(pattern);
+        const prefix = normalised.slice(0, globIdx);
+        // If prefix ends mid-segment, dirname to get a real directory
+        const base = prefix.endsWith('/') ? prefix.slice(0, -1) : node_path.dirname(prefix);
+        return node_path.resolve(base);
+    }
+    async function* walk(dir) {
+        let entries;
+        try {
+            const dirents = await promises.readdir(dir, { withFileTypes: true });
+            entries = dirents.map((d) => ({
+                name: d.name,
+                isDirectory: d.isDirectory(),
+            }));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = node_path.resolve(dir, entry.name);
+            if (entry.isDirectory) {
+                yield* walk(full);
+            }
+            else {
+                // ensure it's a file
+                try {
+                    const st = await promises.stat(full);
+                    if (st.isFile())
+                        yield full;
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    /**
+     * List files matching a set of globs, with optional ignore globs.
+     */
+    async function listFilesFromGlobs(patterns, ignored = []) {
+        const normPatterns = patterns.map((p) => p.replace(/\\/g, '/'));
+        const normIgnored = ignored.map((p) => p.replace(/\\/g, '/'));
+        const match = picomatch(normPatterns, { dot: true });
+        const ignore = normIgnored.length
+            ? picomatch(normIgnored, { dot: true })
+            : () => false;
+        const bases = Array.from(new Set(patterns.map(globBase)));
+        const seen = new Set();
+        for (const base of bases) {
+            for await (const file of walk(base)) {
+                const rel = file.replace(/\\/g, '/');
+                if (ignore(rel))
+                    continue;
+                if (!match(rel))
+                    continue;
+                seen.add(file);
+            }
+        }
+        return Array.from(seen);
+    }
+
+    /**
+     * Create the Fastify API server with all routes registered.
+     *
+     * The returned instance is not yet listening — call `server.listen()` to start.
+     *
+     * @param options - The server options.
+     * @returns A configured Fastify instance.
+     */
+    function createApiServer(options) {
+        const { processor, vectorStore, embeddingProvider, logger } = options;
+        const app = Fastify({ logger: false });
+        app.get('/status', () => ({
+            status: 'ok',
+            uptime: process.uptime(),
+        }));
+        app.post('/metadata', async (request, reply) => {
+            try {
+                const { path, metadata } = request.body;
+                await processor.processMetadataUpdate(path, metadata);
+                return { ok: true };
+            }
+            catch (error) {
+                logger.error({ error }, 'Metadata update failed');
+                return reply.status(500).send({ error: 'Internal server error' });
+            }
+        });
+        app.post('/search', async (request, reply) => {
+            try {
+                const { query, limit = 10 } = request.body;
+                const vectors = await embeddingProvider.embed([query]);
+                const results = await vectorStore.search(vectors[0], limit);
+                return results;
+            }
+            catch (error) {
+                logger.error({ error }, 'Search failed');
+                return reply.status(500).send({ error: 'Internal server error' });
+            }
+        });
+        app.post('/reindex', async (_request, reply) => {
+            try {
+                const files = await listFilesFromGlobs(options.config.watch.paths, options.config.watch.ignored);
+                for (const file of files) {
+                    // Sequential on purpose to avoid surprising load.
+                    // Queue integration can come later.
+                    await processor.processFile(file);
+                }
+                return await reply
+                    .status(200)
+                    .send({ ok: true, filesIndexed: files.length });
+            }
+            catch (error) {
+                logger.error({ error }, 'Reindex failed');
+                return await reply.status(500).send({ error: 'Internal server error' });
+            }
+        });
+        app.post('/rebuild-metadata', async (_request, reply) => {
+            try {
+                const metadataDir = options.config.metadataDir ?? '.jeeves-metadata';
+                for await (const point of vectorStore.scroll()) {
+                    const payload = point.payload;
+                    const filePath = payload['file_path'];
+                    if (typeof filePath !== 'string' || filePath.length === 0)
+                        continue;
+                    // Persist only enrichment-ish fields, not chunking/index fields.
+                    const rest = { ...payload };
+                    delete rest.file_path;
+                    delete rest.chunk_index;
+                    delete rest.total_chunks;
+                    delete rest.content_hash;
+                    delete rest.chunk_text;
+                    await writeMetadata(filePath, metadataDir, rest);
+                }
+                return await reply.status(200).send({ ok: true });
+            }
+            catch (error) {
+                logger.error({ error }, 'Rebuild metadata failed');
+                return await reply.status(500).send({ error: 'Internal server error' });
+            }
+        });
+        app.post('/config-reindex', async (request, reply) => {
+            try {
+                const scope = request.body.scope ?? 'rules';
+                // Return immediately and run async
+                void (async () => {
+                    try {
+                        if (scope === 'rules') {
+                            // Re-apply inference rules to all files, update Qdrant payloads (no re-embedding)
+                            const files = await listFilesFromGlobs(options.config.watch.paths, options.config.watch.ignored);
+                            for (const file of files) {
+                                // Use the new processRulesUpdate method
+                                await processor.processRulesUpdate(file);
+                            }
+                            logger.info({ scope, filesProcessed: files.length }, 'Config reindex (rules) completed');
+                        }
+                        else {
+                            // Full reindex: re-extract, re-embed, re-upsert
+                            const files = await listFilesFromGlobs(options.config.watch.paths, options.config.watch.ignored);
+                            for (const file of files) {
+                                await processor.processFile(file);
+                            }
+                            logger.info({ scope, filesProcessed: files.length }, 'Config reindex (full) completed');
+                        }
+                    }
+                    catch (error) {
+                        logger.error({ error, scope }, 'Config reindex failed');
+                    }
+                })();
+                return await reply.status(200).send({ status: 'started', scope });
+            }
+            catch (error) {
+                logger.error({ error }, 'Config reindex request failed');
+                return await reply.status(500).send({ error: 'Internal server error' });
+            }
+        });
+        return app;
+    }
+
+    const MODULE_NAME = 'jeeves-watcher';
+    /** JSON Schema for validating jeeves-watcher configuration. */
+    const configSchema = {
+        type: 'object',
+        required: ['watch', 'embedding', 'vectorStore'],
+        properties: {
+            watch: {
+                type: 'object',
+                required: ['paths'],
+                properties: {
+                    paths: { type: 'array', items: { type: 'string' }, minItems: 1 },
+                    ignored: { type: 'array', items: { type: 'string' } },
+                    pollIntervalMs: { type: 'number' },
+                    usePolling: { type: 'boolean' },
+                    debounceMs: { type: 'number' },
+                    stabilityThresholdMs: { type: 'number' },
+                },
+                additionalProperties: false,
+            },
+            configWatch: {
+                type: 'object',
+                properties: {
+                    enabled: { type: 'boolean' },
+                    debounceMs: { type: 'number' },
+                },
+                additionalProperties: false,
+            },
+            embedding: {
+                type: 'object',
+                required: ['provider', 'model'],
+                properties: {
+                    provider: { type: 'string' },
+                    model: { type: 'string' },
+                    chunkSize: { type: 'number' },
+                    chunkOverlap: { type: 'number' },
+                    dimensions: { type: 'number' },
+                    apiKey: { type: 'string' },
+                    rateLimitPerMinute: { type: 'number' },
+                    concurrency: { type: 'number' },
+                },
+                additionalProperties: false,
+            },
+            vectorStore: {
+                type: 'object',
+                required: ['url', 'collectionName'],
+                properties: {
+                    url: { type: 'string' },
+                    collectionName: { type: 'string' },
+                    apiKey: { type: 'string' },
+                },
+                additionalProperties: false,
+            },
+            metadataDir: { type: 'string' },
+            api: {
+                type: 'object',
+                properties: {
+                    host: { type: 'string' },
+                    port: { type: 'number' },
+                },
+                additionalProperties: false,
+            },
+            extractors: { type: 'object' },
+            inferenceRules: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    required: ['match', 'set'],
+                    properties: {
+                        match: { type: 'object' },
+                        set: { type: 'object' },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            logging: {
+                type: 'object',
+                properties: {
+                    level: { type: 'string' },
+                    file: { type: 'string' },
+                },
+                additionalProperties: false,
+            },
+            shutdownTimeoutMs: { type: 'number' },
+        },
+        additionalProperties: false,
+    };
+    const ajv = new Ajv({ allErrors: true });
+    const validate = ajv.compile(configSchema);
+    /** Default values for optional configuration fields. */
+    const DEFAULTS = {
+        configWatch: { enabled: true, debounceMs: 1000 },
+        metadataDir: '.jeeves-watcher',
+        api: { host: '127.0.0.1', port: 3100 },
+        logging: { level: 'info' },
+        shutdownTimeoutMs: 10000,
+    };
+    /** Default values for watch configuration. */
+    const WATCH_DEFAULTS = {
+        debounceMs: 300,
+        stabilityThresholdMs: 500,
+        usePolling: false,
+        pollIntervalMs: 1000,
+    };
+    /** Default values for embedding configuration. */
+    const EMBEDDING_DEFAULTS = {
+        chunkSize: 1000,
+        chunkOverlap: 200,
+        dimensions: 768,
+        rateLimitPerMinute: 300,
+        concurrency: 5,
+    };
+    /**
+     * Merge sensible defaults into a loaded configuration.
+     *
+     * @param raw - The raw loaded configuration.
+     * @returns The configuration with defaults applied.
+     */
+    function applyDefaults(raw) {
+        return {
+            ...DEFAULTS,
+            ...raw,
+            watch: { ...WATCH_DEFAULTS, ...raw.watch },
+            configWatch: { ...DEFAULTS.configWatch, ...raw.configWatch },
+            embedding: { ...EMBEDDING_DEFAULTS, ...raw.embedding },
+            api: { ...DEFAULTS.api, ...raw.api },
+            logging: { ...DEFAULTS.logging, ...raw.logging },
+        };
+    }
+    /**
+     * Load the jeeves-watcher configuration.
+     *
+     * @param configPath - Optional explicit path to a config file.
+     * @returns The loaded configuration.
+     * @throws If no configuration is found or validation fails.
+     */
+    async function loadConfig(configPath) {
+        const explorer = cosmiconfig.cosmiconfig(MODULE_NAME);
+        const result = configPath
+            ? await explorer.load(configPath)
+            : await explorer.search();
+        if (!result || result.isEmpty) {
+            throw new Error('No jeeves-watcher configuration found. Create a .jeeves-watcherrc or jeeves-watcher.config.{js,ts,json,yaml} file.');
+        }
+        const raw = result.config;
+        if (!validate(raw)) {
+            const errors = validate.errors
+                ?.map((e) => {
+                const instancePath = 'instancePath' in e
+                    ? e.instancePath
+                    : undefined;
+                return `${instancePath ?? '/'}: ${e.message ?? 'unknown error'}`;
+            })
+                .join('; ');
+            throw new Error(`Invalid jeeves-watcher configuration: ${errors ?? 'unknown error'}`);
+        }
+        return applyDefaults(raw);
+    }
+
+    /**
+     * Create a mock embedding provider that generates deterministic vectors from content hashes.
+     *
+     * @param dimensions - The number of dimensions for the output vectors.
+     * @returns A mock {@link EmbeddingProvider}.
+     */
+    function createMockProvider(dimensions) {
+        return {
+            dimensions,
+            embed(texts) {
+                return Promise.resolve(texts.map((text) => {
+                    const hash = node_crypto.createHash('sha256').update(text, 'utf8').digest();
+                    const vector = [];
+                    for (let i = 0; i < dimensions; i++) {
+                        // Use bytes cyclically from the hash to generate deterministic floats in [-1, 1]
+                        const byte = hash[i % hash.length];
+                        vector.push(byte / 127.5 - 1);
+                    }
+                    return vector;
+                }));
+            },
+        };
+    }
+    /**
+     * Create a Gemini embedding provider using the Google Generative AI SDK.
+     *
+     * @param config - The embedding configuration.
+     * @returns A Gemini {@link EmbeddingProvider}.
+     * @throws If the API key is missing.
+     */
+    function createGeminiProvider(config) {
+        if (!config.apiKey) {
+            throw new Error('Gemini embedding provider requires config.embedding.apiKey');
+        }
+        const dimensions = config.dimensions ?? 3072;
+        const embedder = new googleGenai.GoogleGenerativeAIEmbeddings({
+            apiKey: config.apiKey,
+            model: config.model,
+        });
+        return {
+            dimensions,
+            async embed(texts) {
+                // embedDocuments returns vectors for multiple texts
+                const vectors = await embedder.embedDocuments(texts);
+                // Validate dimensions
+                for (const vector of vectors) {
+                    if (vector.length !== dimensions) {
+                        throw new Error(`Gemini embedding returned invalid dimensions: expected ${String(dimensions)}, got ${String(vector.length)}`);
+                    }
+                }
+                return vectors;
+            },
+        };
+    }
+    /**
+     * Create an embedding provider based on the given configuration.
+     *
+     * @param config - The embedding configuration.
+     * @returns An {@link EmbeddingProvider} instance.
+     * @throws If the configured provider is not supported.
+     */
+    function createEmbeddingProvider(config) {
+        const dimensions = config.dimensions ?? 768;
+        switch (config.provider) {
+            case 'mock':
+                return createMockProvider(dimensions);
+            case 'gemini':
+                return createGeminiProvider(config);
+            default:
+                throw new Error(`Unsupported embedding provider: ${config.provider}`);
+        }
+    }
+
+    /**
+     * Create a pino logger instance.
+     *
+     * @param config - Optional logging configuration.
+     * @returns A configured pino logger.
+     */
+    function createLogger(config) {
+        const level = config?.level ?? 'info';
+        if (config?.file) {
+            const transport = pino.transport({
+                target: 'pino/file',
+                options: { destination: config.file, mkdir: true },
+            });
+            return pino({ level }, transport);
+        }
+        return pino({ level });
+    }
+
+    /**
+     * Extract YAML frontmatter from a Markdown document.
+     *
+     * @param markdown - The raw markdown content.
+     * @returns The extracted frontmatter (if any) and body.
+     */
+    function extractMarkdownFrontmatter(markdown) {
+        const trimmed = markdown.replace(/^\uFEFF/, '');
+        const match = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/m.exec(trimmed);
+        if (!match)
+            return { body: markdown };
+        const [, rawYaml, body] = match;
+        const parsed = yaml.load(rawYaml);
+        const frontmatter = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+        return { frontmatter, body };
+    }
+    const JSON_TEXT_FIELDS = [
+        'content',
+        'body',
+        'text',
+        'snippet',
+        'subject',
+        'description',
+        'summary',
+        'transcript',
+    ];
+    /**
+     * Extract meaningful text from a parsed JSON object.
+     *
+     * @param obj - Parsed JSON content.
+     * @returns A text representation for embedding.
+     */
+    function extractJsonText(obj) {
+        if (!obj || typeof obj !== 'object')
+            return JSON.stringify(obj);
+        const rec = obj;
+        for (const field of JSON_TEXT_FIELDS) {
+            const value = rec[field];
+            if (typeof value === 'string' && value.trim())
+                return value;
+        }
+        return JSON.stringify(obj);
+    }
+    /**
+     * Extract text from a file based on extension.
+     *
+     * @param filePath - Path to the file.
+     * @param extension - File extension (including leading dot).
+     * @returns Extracted text and optional structured data.
+     */
+    async function extractText(filePath, extension) {
+        const ext = extension.toLowerCase();
+        if (ext === '.md' || ext === '.markdown') {
+            const raw = await promises.readFile(filePath, 'utf8');
+            const { frontmatter, body } = extractMarkdownFrontmatter(raw);
+            return { text: body, frontmatter };
+        }
+        if (ext === '.txt' || ext === '.text') {
+            const raw = await promises.readFile(filePath, 'utf8');
+            return { text: raw };
+        }
+        if (ext === '.json') {
+            const raw = await promises.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            const json = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                ? parsed
+                : undefined;
+            return { text: extractJsonText(parsed), json };
+        }
+        if (ext === '.pdf') {
+            const buffer = await promises.readFile(filePath);
+            const uint8Array = new Uint8Array(buffer);
+            const { extractText: extractPdfText } = await import('unpdf');
+            const { text } = await extractPdfText(uint8Array);
+            // unpdf returns an array of strings (one per page)
+            const content = Array.isArray(text) ? text.join('\n\n') : text;
+            return { text: content };
+        }
+        if (ext === '.docx') {
+            const buffer = await promises.readFile(filePath);
+            const result = await mammoth.extractRawText({ buffer });
+            return { text: result.value };
+        }
+        if (ext === '.html' || ext === '.htm') {
+            const raw = await promises.readFile(filePath, 'utf8');
+            const $ = cheerio__namespace.load(raw);
+            // Remove script and style elements
+            $('script, style').remove();
+            // Extract text content
+            const text = $('body').text().trim() || $.text().trim();
+            return { text };
+        }
+        // Default: treat as plaintext.
+        const raw = await promises.readFile(filePath, 'utf8');
+        return { text: raw };
+    }
+
+    /**
+     * Compute a SHA-256 hex digest of the given text.
+     *
+     * @param text - The input text to hash.
+     * @returns The hex-encoded SHA-256 hash.
+     */
+    function contentHash(text) {
+        return node_crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+    }
+
+    /** Namespace UUID for jeeves-watcher point IDs. */
+    const NAMESPACE = '6a6f686e-6761-4c74-ad6a-656576657321';
+    /**
+     * Normalise a file path for deterministic point ID generation.
+     *
+     * @param filePath - The original file path.
+     * @returns The normalised path string.
+     */
+    function normalisePath(filePath) {
+        return filePath.replace(/\\/g, '/').toLowerCase();
+    }
+    /**
+     * Generate a deterministic UUID v5 point ID for a file (and optional chunk index).
+     *
+     * @param filePath - The file path.
+     * @param chunkIndex - Optional chunk index within the file.
+     * @returns A deterministic UUID v5 string.
+     */
+    function pointId(filePath, chunkIndex) {
+        const key = chunkIndex !== undefined
+            ? `${normalisePath(filePath)}#${String(chunkIndex)}`
+            : normalisePath(filePath);
+        return uuid.v5(key, NAMESPACE);
+    }
+
+    /**
+     * Build {@link FileAttributes} from a file path and stat info.
+     *
+     * @param filePath - The file path.
+     * @param stats - The file stats.
+     * @param extractedFrontmatter - Optional extracted frontmatter.
+     * @param extractedJson - Optional parsed JSON content.
+     * @returns The constructed file attributes.
+     */
+    function buildAttributes(filePath, stats, extractedFrontmatter, extractedJson) {
+        const normalised = filePath.replace(/\\/g, '/');
+        const attrs = {
+            file: {
+                path: normalised,
+                directory: node_path.dirname(normalised).replace(/\\/g, '/'),
+                filename: node_path.basename(normalised),
+                extension: node_path.extname(normalised),
+                sizeBytes: stats.size,
+                modified: stats.mtime.toISOString(),
+            },
+        };
+        if (extractedFrontmatter)
+            attrs.frontmatter = extractedFrontmatter;
+        if (extractedJson)
+            attrs.json = extractedJson;
+        return attrs;
+    }
+    /**
+     * Create an ajv instance with a custom `glob` format for picomatch glob matching.
+     *
+     * @returns The configured ajv instance.
+     */
+    function createRuleAjv() {
+        const ajv = new Ajv({ allErrors: true });
+        addFormats(ajv);
+        ajv.addKeyword({
+            keyword: 'glob',
+            type: 'string',
+            schemaType: 'string',
+            validate: (pattern, data) => picomatch.isMatch(data, pattern),
+        });
+        return ajv;
+    }
+    /**
+     * Compile an array of inference rules into executable validators.
+     *
+     * @param rules - The inference rule definitions.
+     * @returns An array of compiled rules.
+     */
+    function compileRules(rules) {
+        const ajv = createRuleAjv();
+        return rules.map((rule, idx) => ({
+            rule,
+            validate: ajv.compile({
+                $id: `rule-${String(idx)}`,
+                ...rule.match,
+            }),
+        }));
+    }
+    /**
+     * Resolve `$\{template.vars\}` in a value against the given attributes.
+     *
+     * @param value - The value to resolve.
+     * @param attributes - The file attributes for variable lookup.
+     * @returns The resolved value.
+     */
+    function resolveTemplateVars(value, attributes) {
+        if (typeof value !== 'string')
+            return value;
+        return value.replace(/\$\{([^}]+)\}/g, (_match, varPath) => {
+            const parts = varPath.split('.');
+            let current = attributes;
+            for (const part of parts) {
+                if (current === null || current === undefined)
+                    return '';
+                current = current[part];
+            }
+            if (current === null || current === undefined)
+                return '';
+            return typeof current === 'string' ? current : JSON.stringify(current);
+        });
+    }
+    /**
+     * Resolve all template variables in a `set` object.
+     *
+     * @param setObj - The key-value pairs to resolve.
+     * @param attributes - The file attributes for variable lookup.
+     * @returns The resolved key-value pairs.
+     */
+    function resolveSet(setObj, attributes) {
+        const result = {};
+        for (const [key, value] of Object.entries(setObj)) {
+            result[key] = resolveTemplateVars(value, attributes);
+        }
+        return result;
+    }
+    /**
+     * Apply compiled inference rules to file attributes, returning merged metadata.
+     *
+     * Rules are evaluated in order; later rules override earlier ones.
+     *
+     * @param compiledRules - The compiled rules to evaluate.
+     * @param attributes - The file attributes to match against.
+     * @returns The merged metadata from all matching rules.
+     */
+    function applyRules(compiledRules, attributes) {
+        let merged = {};
+        for (const { rule, validate } of compiledRules) {
+            if (validate(attributes)) {
+                merged = { ...merged, ...resolveSet(rule.set, attributes) };
+            }
+        }
+        return merged;
+    }
+
+    /**
+     * Core document processing pipeline.
+     *
+     * Handles extracting text, computing embeddings, and syncing with the vector store.
+     */
+    class DocumentProcessor {
+        config;
+        embeddingProvider;
+        vectorStore;
+        compiledRules;
+        logger;
+        metadataDir;
+        /**
+         * Create a new DocumentProcessor.
+         *
+         * @param config - The application configuration.
+         * @param embeddingProvider - The embedding provider.
+         * @param vectorStore - The vector store client.
+         * @param compiledRules - The compiled inference rules.
+         * @param logger - The logger instance.
+         */
+        constructor(config, embeddingProvider, vectorStore, compiledRules, logger) {
+            this.config = config;
+            this.embeddingProvider = embeddingProvider;
+            this.vectorStore = vectorStore;
+            this.compiledRules = compiledRules;
+            this.logger = logger;
+            this.metadataDir = config.metadataDir ?? '.jeeves-metadata';
+        }
+        /**
+         * Process a file through the full pipeline: extract, hash, chunk, embed, upsert.
+         *
+         * @param filePath - The file to process.
+         */
+        async processFile(filePath) {
+            try {
+                const ext = node_path.extname(filePath);
+                const stats = await promises.stat(filePath);
+                // 1. Extract text
+                const extracted = await extractText(filePath, ext);
+                if (!extracted.text.trim()) {
+                    this.logger.debug({ filePath }, 'Skipping empty file');
+                    return;
+                }
+                // 2. Content hash check — skip if unchanged
+                const hash = contentHash(extracted.text);
+                const baseId = pointId(filePath, 0);
+                const existingPayload = await this.vectorStore.getPayload(baseId);
+                if (existingPayload && existingPayload['content_hash'] === hash) {
+                    this.logger.debug({ filePath }, 'Content unchanged, skipping');
+                    return;
+                }
+                const oldTotalChunks = typeof existingPayload?.['total_chunks'] === 'number'
+                    ? existingPayload['total_chunks']
+                    : 0;
+                // 3. Build attributes + apply rules → inferred metadata
+                const attributes = buildAttributes(filePath, stats, extracted.frontmatter, extracted.json);
+                const inferred = applyRules(this.compiledRules, attributes);
+                // 4. Read enrichment metadata (merge, enrichment wins)
+                const enrichment = await readMetadata(filePath, this.metadataDir);
+                const metadata = {
+                    ...inferred,
+                    ...(enrichment ?? {}),
+                };
+                // 5. Chunk text
+                const chunkSize = this.config.embedding.chunkSize ?? 1000;
+                const chunkOverlap = this.config.embedding.chunkOverlap ?? 200;
+                const splitter = this.createSplitter(ext, chunkSize, chunkOverlap);
+                const chunks = await splitter.splitText(extracted.text);
+                // 6. Embed all chunks
+                const vectors = await this.embeddingProvider.embed(chunks);
+                // 7. Upsert all chunk points
+                const points = chunks.map((chunk, i) => ({
+                    id: pointId(filePath, i),
+                    vector: vectors[i],
+                    payload: {
+                        ...metadata,
+                        file_path: filePath.replace(/\\/g, '/'),
+                        chunk_index: i,
+                        total_chunks: chunks.length,
+                        content_hash: hash,
+                        chunk_text: chunk,
+                    },
+                }));
+                await this.vectorStore.upsert(points);
+                // 8. Clean up orphaned chunks
+                if (oldTotalChunks > chunks.length) {
+                    const orphanIds = [];
+                    for (let i = chunks.length; i < oldTotalChunks; i++) {
+                        orphanIds.push(pointId(filePath, i));
+                    }
+                    await this.vectorStore.delete(orphanIds);
+                }
+                this.logger.info({ filePath, chunks: chunks.length }, 'File processed successfully');
+            }
+            catch (error) {
+                this.logger.error({ filePath, error }, 'Failed to process file');
+            }
+        }
+        /**
+         * Delete all chunks for a file from the vector store and remove metadata.
+         *
+         * @param filePath - The file to delete.
+         */
+        async deleteFile(filePath) {
+            try {
+                // Get the existing payload to find total chunks
+                const baseId = pointId(filePath, 0);
+                const existingPayload = await this.vectorStore.getPayload(baseId);
+                const totalChunks = typeof existingPayload?.['total_chunks'] === 'number'
+                    ? existingPayload['total_chunks']
+                    : 1;
+                const ids = [];
+                for (let i = 0; i < totalChunks; i++) {
+                    ids.push(pointId(filePath, i));
+                }
+                await this.vectorStore.delete(ids);
+                await deleteMetadata(filePath, this.metadataDir);
+                this.logger.info({ filePath }, 'File deleted from index');
+            }
+            catch (error) {
+                this.logger.error({ filePath, error }, 'Failed to delete file');
+            }
+        }
+        /**
+         * Process a metadata update: merge metadata, write to disk, update Qdrant payloads (no re-embed).
+         *
+         * @param filePath - The file whose metadata to update.
+         * @param metadata - The new metadata to merge.
+         * @returns The merged payload, or `null` if the file is not indexed.
+         */
+        async processMetadataUpdate(filePath, metadata) {
+            try {
+                // Read existing enrichment metadata and merge
+                const existing = (await readMetadata(filePath, this.metadataDir)) ?? {};
+                const merged = { ...existing, ...metadata };
+                await writeMetadata(filePath, this.metadataDir, merged);
+                // Update all chunk payloads in Qdrant
+                const baseId = pointId(filePath, 0);
+                const existingPayload = await this.vectorStore.getPayload(baseId);
+                if (!existingPayload)
+                    return null;
+                const totalChunks = typeof existingPayload['total_chunks'] === 'number'
+                    ? existingPayload['total_chunks']
+                    : 1;
+                const ids = [];
+                for (let i = 0; i < totalChunks; i++) {
+                    ids.push(pointId(filePath, i));
+                }
+                await this.vectorStore.setPayload(ids, merged);
+                this.logger.info({ filePath, chunks: totalChunks }, 'Metadata updated');
+                return merged;
+            }
+            catch (error) {
+                this.logger.error({ filePath, error }, 'Failed to update metadata');
+                return null;
+            }
+        }
+        /**
+         * Re-apply inference rules to a file without re-embedding.
+         * Reads file attributes, applies current rules, merges with enrichment metadata,
+         * and updates Qdrant payloads.
+         *
+         * @param filePath - The file to update.
+         * @returns The merged metadata, or `null` if the file is not indexed.
+         */
+        async processRulesUpdate(filePath) {
+            try {
+                const baseId = pointId(filePath, 0);
+                const existingPayload = await this.vectorStore.getPayload(baseId);
+                if (!existingPayload) {
+                    this.logger.debug({ filePath }, 'File not indexed, skipping');
+                    return null;
+                }
+                const ext = node_path.extname(filePath);
+                const stats = await promises.stat(filePath);
+                // Extract frontmatter/json for attribute building (lightweight)
+                const extracted = await extractText(filePath, ext);
+                // Build attributes + apply current rules
+                const attributes = buildAttributes(filePath, stats, extracted.frontmatter, extracted.json);
+                const inferred = applyRules(this.compiledRules, attributes);
+                // Read enrichment metadata (merge, enrichment wins)
+                const enrichment = await readMetadata(filePath, this.metadataDir);
+                const metadata = {
+                    ...inferred,
+                    ...(enrichment ?? {}),
+                };
+                // Update all chunk payloads
+                const totalChunks = typeof existingPayload['total_chunks'] === 'number'
+                    ? existingPayload['total_chunks']
+                    : 1;
+                const ids = [];
+                for (let i = 0; i < totalChunks; i++) {
+                    ids.push(pointId(filePath, i));
+                }
+                await this.vectorStore.setPayload(ids, metadata);
+                this.logger.info({ filePath, chunks: totalChunks }, 'Rules re-applied');
+                return metadata;
+            }
+            catch (error) {
+                this.logger.error({ filePath, error }, 'Failed to re-apply rules');
+                return null;
+            }
+        }
+        /**
+         * Update compiled inference rules for subsequent file processing.
+         *
+         * @param compiledRules - The newly compiled rules.
+         */
+        updateRules(compiledRules) {
+            this.compiledRules = compiledRules;
+            this.logger.info({ rules: compiledRules.length }, 'Inference rules updated');
+        }
+        /**
+         * Create the appropriate text splitter for the given file extension.
+         *
+         * @param ext - File extension.
+         * @param chunkSize - Maximum chunk size in characters.
+         * @param chunkOverlap - Overlap between chunks in characters.
+         * @returns A text splitter instance.
+         */
+        createSplitter(ext, chunkSize, chunkOverlap) {
+            const lowerExt = ext.toLowerCase();
+            if (lowerExt === '.md' || lowerExt === '.markdown') {
+                return new textsplitters.MarkdownTextSplitter({ chunkSize, chunkOverlap });
+            }
+            return new textsplitters.RecursiveCharacterTextSplitter({ chunkSize, chunkOverlap });
+        }
+    }
+
+    /**
+     * A debounced, rate-limited, concurrent event queue.
+     */
+    class EventQueue {
+        debounceMs;
+        concurrency;
+        rateLimitPerMinute;
+        started = false;
+        active = 0;
+        debounceTimers = new Map();
+        latestByKey = new Map();
+        normalQueue = [];
+        lowQueue = [];
+        tokens;
+        lastRefillMs = Date.now();
+        drainWaiters = [];
+        /**
+         * Create an event queue.
+         *
+         * @param options - Queue options.
+         */
+        constructor(options) {
+            this.debounceMs = options.debounceMs;
+            this.concurrency = options.concurrency;
+            this.rateLimitPerMinute = options.rateLimitPerMinute;
+            this.tokens = this.rateLimitPerMinute ?? Number.POSITIVE_INFINITY;
+        }
+        /**
+         * Enqueue an event, debounced per path+priority.
+         *
+         * @param event - The watch event.
+         * @param fn - The processing function to invoke when dequeued.
+         */
+        enqueue(event, fn) {
+            const key = `${event.priority}:${event.path}`;
+            this.latestByKey.set(key, { event, fn });
+            const existing = this.debounceTimers.get(key);
+            if (existing)
+                clearTimeout(existing);
+            const timer = setTimeout(() => {
+                this.debounceTimers.delete(key);
+                const item = this.latestByKey.get(key);
+                if (!item)
+                    return;
+                this.latestByKey.delete(key);
+                this.push(item);
+                this.pump();
+            }, this.debounceMs);
+            this.debounceTimers.set(key, timer);
+        }
+        /**
+         * Start processing events.
+         */
+        process() {
+            this.started = true;
+            this.pump();
+        }
+        /**
+         * Wait for the queue to become idle (no pending debounces, no queued items, no active work).
+         *
+         * @returns A promise that resolves when the queue is drained.
+         */
+        async drain() {
+            if (this.isIdle())
+                return;
+            await new Promise((resolve) => {
+                this.drainWaiters.push(resolve);
+            });
+        }
+        push(item) {
+            if (item.event.priority === 'low')
+                this.lowQueue.push(item);
+            else
+                this.normalQueue.push(item);
+        }
+        refillTokens(nowMs) {
+            if (this.rateLimitPerMinute === undefined)
+                return;
+            const elapsed = Math.max(0, nowMs - this.lastRefillMs);
+            const refillRatePerMs = this.rateLimitPerMinute / 60000;
+            const refill = elapsed * refillRatePerMs;
+            this.tokens = Math.min(this.rateLimitPerMinute, this.tokens + refill);
+            this.lastRefillMs = nowMs;
+        }
+        takeToken() {
+            const now = Date.now();
+            this.refillTokens(now);
+            if (this.tokens < 1)
+                return false;
+            this.tokens -= 1;
+            return true;
+        }
+        nextItem() {
+            return this.normalQueue.shift() ?? this.lowQueue.shift();
+        }
+        pump() {
+            if (!this.started)
+                return;
+            while (this.active < this.concurrency) {
+                const item = this.nextItem();
+                if (!item)
+                    break;
+                if (!this.takeToken()) {
+                    // Put it back at the front of its queue and try later.
+                    if (item.event.priority === 'low')
+                        this.lowQueue.unshift(item);
+                    else
+                        this.normalQueue.unshift(item);
+                    setTimeout(() => {
+                        this.pump();
+                    }, 250);
+                    break;
+                }
+                this.active += 1;
+                void Promise.resolve()
+                    .then(() => item.fn(item.event))
+                    .finally(() => {
+                    this.active -= 1;
+                    this.pump();
+                    this.maybeResolveDrain();
+                });
+            }
+            this.maybeResolveDrain();
+        }
+        isIdle() {
+            return (this.active === 0 &&
+                this.normalQueue.length === 0 &&
+                this.lowQueue.length === 0 &&
+                this.debounceTimers.size === 0 &&
+                this.latestByKey.size === 0);
+        }
+        maybeResolveDrain() {
+            if (!this.isIdle())
+                return;
+            const waiters = this.drainWaiters;
+            this.drainWaiters = [];
+            for (const resolve of waiters)
+                resolve();
+        }
+    }
+
+    /**
+     * Client wrapper for Qdrant vector store operations.
+     */
+    class VectorStoreClient {
+        client;
+        collectionName;
+        dims;
+        /**
+         * Create a new VectorStoreClient.
+         *
+         * @param config - Vector store configuration.
+         * @param dimensions - The embedding vector dimensions.
+         */
+        constructor(config, dimensions) {
+            this.client = new jsClientRest.QdrantClient({
+                url: config.url,
+                apiKey: config.apiKey,
+            });
+            this.collectionName = config.collectionName;
+            this.dims = dimensions;
+        }
+        /**
+         * Ensure the collection exists with correct dimensions and Cosine distance.
+         */
+        async ensureCollection() {
+            try {
+                const collections = await this.client.getCollections();
+                const exists = collections.collections.some((c) => c.name === this.collectionName);
+                if (!exists) {
+                    await this.client.createCollection(this.collectionName, {
+                        vectors: { size: this.dims, distance: 'Cosine' },
+                    });
+                }
+            }
+            catch (error) {
+                throw new Error(`Failed to ensure collection "${this.collectionName}": ${String(error)}`);
+            }
+        }
+        /**
+         * Upsert points into the collection.
+         *
+         * @param points - The points to upsert.
+         */
+        async upsert(points) {
+            if (points.length === 0)
+                return;
+            await this.client.upsert(this.collectionName, {
+                wait: true,
+                points: points.map((p) => ({
+                    id: p.id,
+                    vector: p.vector,
+                    payload: p.payload,
+                })),
+            });
+        }
+        /**
+         * Delete points by their IDs.
+         *
+         * @param ids - The point IDs to delete.
+         */
+        async delete(ids) {
+            if (ids.length === 0)
+                return;
+            await this.client.delete(this.collectionName, {
+                wait: true,
+                points: ids,
+            });
+        }
+        /**
+         * Set payload fields for the specified point IDs.
+         *
+         * This merges the given payload object into each point's existing payload.
+         *
+         * @param ids - Point IDs to update.
+         * @param payload - Payload fields to set.
+         */
+        async setPayload(ids, payload) {
+            if (ids.length === 0)
+                return;
+            await this.client.setPayload(this.collectionName, {
+                wait: true,
+                points: ids,
+                payload,
+            });
+        }
+        /**
+         * Get the payload of a point by ID.
+         *
+         * @param id - The point ID.
+         * @returns The payload, or `null` if the point doesn't exist.
+         */
+        async getPayload(id) {
+            try {
+                const results = await this.client.retrieve(this.collectionName, {
+                    ids: [id],
+                    with_payload: true,
+                    with_vector: false,
+                });
+                if (results.length === 0)
+                    return null;
+                return results[0].payload;
+            }
+            catch {
+                return null;
+            }
+        }
+        /**
+         * Search for similar vectors.
+         *
+         * @param vector - The query vector.
+         * @param limit - Maximum results to return.
+         * @param filter - Optional Qdrant filter.
+         * @returns An array of search results.
+         */
+        async search(vector, limit, filter) {
+            const results = await this.client.search(this.collectionName, {
+                vector,
+                limit,
+                with_payload: true,
+                ...(filter ? { filter } : {}),
+            });
+            return results.map((r) => ({
+                id: String(r.id),
+                score: r.score,
+                payload: r.payload,
+            }));
+        }
+        /**
+         * Scroll through all points matching a filter.
+         *
+         * @param filter - Optional Qdrant filter.
+         * @param limit - Page size for scrolling.
+         * @yields Scrolled points.
+         */
+        async *scroll(filter, limit = 100) {
+            let offset = undefined;
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            while (true) {
+                const result = await this.client.scroll(this.collectionName, {
+                    limit,
+                    with_payload: true,
+                    with_vector: false,
+                    ...(filter ? { filter } : {}),
+                    ...(offset !== undefined ? { offset } : {}),
+                });
+                for (const point of result.points) {
+                    yield {
+                        id: String(point.id),
+                        payload: point.payload,
+                    };
+                }
+                const nextOffset = result.next_page_offset;
+                if (nextOffset === null || nextOffset === undefined) {
+                    break;
+                }
+                if (typeof nextOffset === 'string' || typeof nextOffset === 'number') {
+                    offset = nextOffset;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Filesystem watcher that maps chokidar events to the processing queue.
+     */
+    class FileSystemWatcher {
+        config;
+        queue;
+        processor;
+        logger;
+        watcher;
+        /**
+         * Create a new FileSystemWatcher.
+         *
+         * @param config - Watch configuration.
+         * @param queue - The event queue.
+         * @param processor - The document processor.
+         * @param logger - The logger instance.
+         */
+        constructor(config, queue, processor, logger) {
+            this.config = config;
+            this.queue = queue;
+            this.processor = processor;
+            this.logger = logger;
+        }
+        /**
+         * Start watching the filesystem and processing events.
+         */
+        start() {
+            this.watcher = chokidar.watch(this.config.paths, {
+                ignored: this.config.ignored,
+                usePolling: this.config.usePolling,
+                interval: this.config.pollIntervalMs,
+                awaitWriteFinish: this.config.stabilityThresholdMs
+                    ? { stabilityThreshold: this.config.stabilityThresholdMs }
+                    : false,
+                ignoreInitial: false,
+            });
+            this.watcher.on('add', (path) => {
+                this.logger.debug({ path }, 'File added');
+                this.queue.enqueue({ type: 'create', path, priority: 'normal' }, () => this.processor.processFile(path));
+            });
+            this.watcher.on('change', (path) => {
+                this.logger.debug({ path }, 'File changed');
+                this.queue.enqueue({ type: 'modify', path, priority: 'normal' }, () => this.processor.processFile(path));
+            });
+            this.watcher.on('unlink', (path) => {
+                this.logger.debug({ path }, 'File removed');
+                this.queue.enqueue({ type: 'delete', path, priority: 'normal' }, () => this.processor.deleteFile(path));
+            });
+            this.watcher.on('error', (error) => {
+                this.logger.error({ error }, 'Watcher error');
+            });
+            this.queue.process();
+            this.logger.info({ paths: this.config.paths }, 'Filesystem watcher started');
+        }
+        /**
+         * Stop the filesystem watcher.
+         */
+        async stop() {
+            if (this.watcher) {
+                await this.watcher.close();
+                this.watcher = undefined;
+                this.logger.info('Filesystem watcher stopped');
+            }
+        }
+    }
+
+    /**
+     * Main application class that wires together all components.
+     */
+    class JeevesWatcher {
+        config;
+        configPath;
+        logger;
+        watcher;
+        queue;
+        server;
+        processor;
+        configWatcher;
+        configDebounce;
+        /**
+         * Create a new JeevesWatcher instance.
+         *
+         * @param config - The application configuration.
+         * @param configPath - Optional config file path to watch for changes.
+         */
+        constructor(config, configPath) {
+            this.config = config;
+            this.configPath = configPath;
+        }
+        /**
+         * Start the watcher, API server, and all components.
+         */
+        async start() {
+            const logger = createLogger(this.config.logging);
+            this.logger = logger;
+            let embeddingProvider;
+            try {
+                embeddingProvider = createEmbeddingProvider(this.config.embedding);
+            }
+            catch (error) {
+                logger.fatal({ error }, 'Failed to create embedding provider');
+                throw error;
+            }
+            const vectorStore = new VectorStoreClient(this.config.vectorStore, embeddingProvider.dimensions);
+            await vectorStore.ensureCollection();
+            const compiledRules = compileRules(this.config.inferenceRules ?? []);
+            const processor = new DocumentProcessor(this.config, embeddingProvider, vectorStore, compiledRules, logger);
+            this.processor = processor;
+            const queue = new EventQueue({
+                debounceMs: this.config.watch.debounceMs ?? 2000,
+                concurrency: this.config.embedding.concurrency ?? 5,
+                rateLimitPerMinute: this.config.embedding.rateLimitPerMinute,
+            });
+            this.queue = queue;
+            const watcher = new FileSystemWatcher(this.config.watch, queue, processor, logger);
+            this.watcher = watcher;
+            const server = createApiServer({
+                processor,
+                vectorStore,
+                embeddingProvider,
+                queue,
+                config: this.config,
+                logger,
+            });
+            this.server = server;
+            await server.listen({
+                host: this.config.api?.host ?? '127.0.0.1',
+                port: this.config.api?.port ?? 3458,
+            });
+            watcher.start();
+            this.startConfigWatch();
+            logger.info('jeeves-watcher started');
+        }
+        /**
+         * Gracefully stop all components.
+         */
+        async stop() {
+            await this.stopConfigWatch();
+            if (this.watcher) {
+                await this.watcher.stop();
+            }
+            if (this.queue) {
+                const timeout = this.config.shutdownTimeoutMs ?? 10000;
+                await Promise.race([
+                    this.queue.drain(),
+                    new Promise((resolve) => {
+                        setTimeout(resolve, timeout);
+                    }),
+                ]);
+            }
+            if (this.server) {
+                await this.server.close();
+            }
+            this.logger?.info('jeeves-watcher stopped');
+        }
+        startConfigWatch() {
+            const logger = this.logger;
+            if (!logger)
+                return;
+            const enabled = this.config.configWatch?.enabled ?? true;
+            if (!enabled)
+                return;
+            if (!this.configPath) {
+                logger.debug('Config watch enabled, but no config path was provided');
+                return;
+            }
+            const debounceMs = this.config.configWatch?.debounceMs ?? 10000;
+            this.configWatcher = chokidar.watch(this.configPath, {
+                ignoreInitial: true,
+            });
+            this.configWatcher.on('change', () => {
+                if (this.configDebounce)
+                    clearTimeout(this.configDebounce);
+                this.configDebounce = setTimeout(() => {
+                    void this.reloadConfig();
+                }, debounceMs);
+            });
+            this.configWatcher.on('error', (error) => {
+                logger.error({ error }, 'Config watcher error');
+            });
+            logger.info({ configPath: this.configPath, debounceMs }, 'Config watcher started');
+        }
+        async stopConfigWatch() {
+            if (this.configDebounce) {
+                clearTimeout(this.configDebounce);
+                this.configDebounce = undefined;
+            }
+            if (this.configWatcher) {
+                await this.configWatcher.close();
+                this.configWatcher = undefined;
+            }
+        }
+        async reloadConfig() {
+            const logger = this.logger;
+            const processor = this.processor;
+            if (!logger || !processor || !this.configPath)
+                return;
+            try {
+                const newConfig = await loadConfig(this.configPath);
+                this.config = newConfig;
+                const compiledRules = compileRules(newConfig.inferenceRules ?? []);
+                processor.updateRules(compiledRules);
+                logger.info({ configPath: this.configPath, rules: compiledRules.length }, 'Config reloaded');
+            }
+            catch (error) {
+                logger.error({ error }, 'Failed to reload config');
+            }
+        }
+    }
+    /**
+     * Create and start a JeevesWatcher from a config file path.
+     *
+     * @param configPath - Optional path to the configuration file.
+     * @returns The running JeevesWatcher instance.
+     */
+    async function startFromConfig(configPath) {
+        const config = await loadConfig(configPath);
+        const app = new JeevesWatcher(config, configPath);
+        const shutdown = async () => {
+            await app.stop();
+            process.exit(0);
+        };
+        process.on('SIGTERM', () => void shutdown());
+        process.on('SIGINT', () => void shutdown());
+        await app.start();
+        return app;
+    }
+
+    exports.DocumentProcessor = DocumentProcessor;
+    exports.EventQueue = EventQueue;
+    exports.FileSystemWatcher = FileSystemWatcher;
+    exports.JeevesWatcher = JeevesWatcher;
+    exports.VectorStoreClient = VectorStoreClient;
+    exports.applyRules = applyRules;
+    exports.buildAttributes = buildAttributes;
+    exports.compileRules = compileRules;
+    exports.contentHash = contentHash;
+    exports.createApiServer = createApiServer;
+    exports.createEmbeddingProvider = createEmbeddingProvider;
+    exports.createLogger = createLogger;
+    exports.deleteMetadata = deleteMetadata;
+    exports.extractText = extractText;
+    exports.loadConfig = loadConfig;
+    exports.metadataPath = metadataPath;
+    exports.pointId = pointId;
+    exports.readMetadata = readMetadata;
+    exports.startFromConfig = startFromConfig;
+    exports.writeMetadata = writeMetadata;
+
+})(this["jeeves-watcher"] = this["jeeves-watcher"] || {}, Fastify, node_crypto, promises, node_path, picomatch, chokidar, Ajv, cosmiconfig, googleGenai, pino, textsplitters, cheerio, yaml, mammoth, uuid, addFormats, jsClientRest);