@karmaniverous/jeeves-watcher 0.14.0 → 0.15.1

package/dist/index.d.ts

@@ -1637,8 +1637,10 @@ interface ApiServerOptions {
     embeddingProvider: EmbeddingProvider;
     /** The event queue. */
     queue: EventQueue;
-    /** The application configuration. */
+    /** The application configuration (used as initial/fallback value). */
     config: JeevesWatcherConfig;
+    /** Config getter for live config access after hot-reload. */
+    getConfig?: () => JeevesWatcherConfig;
     /** The logger instance. */
     logger: pino.Logger;
     /** The issues manager. */
@@ -1734,9 +1736,7 @@ declare function startFromConfig(configPath?: string): Promise<JeevesWatcher>;
  * Main application orchestrator. Wires components, manages lifecycle (start/stop/reload).
  */
 
-/**
- * Runtime options for {@link JeevesWatcher} that aren't serializable in config.
- */
+/** Runtime options for {@link JeevesWatcher} that aren't serializable in config. */
 interface JeevesWatcherRuntimeOptions {
     /** Callback invoked on unrecoverable system error. If not set, throws. */
     onFatalError?: (error: unknown) => void;

package/dist/index.js

@@ -1561,12 +1561,13 @@ function wrapHandler(fn, logger, label) {
 function createConfigApplyHandler(deps) {
     return wrapHandler(async (request, reply) => {
         const { config: submittedConfig } = request.body;
-        const { candidateRaw, errors } = mergeAndValidateConfig(deps.config, submittedConfig);
+        const config = deps.getConfig();
+        const { candidateRaw, errors } = mergeAndValidateConfig(config, submittedConfig);
         if (errors.length > 0) {
             return await reply.status(400).send({ valid: false, errors });
         }
         await writeFile(deps.configPath, JSON.stringify(candidateRaw, null, 2), 'utf-8');
-        const reindexScope = deps.config.configWatch?.reindex ?? 'issues';
+        const reindexScope = config.configWatch?.reindex ?? 'issues';
         if (deps.triggerReindex) {
             deps.triggerReindex(reindexScope);
         }
@@ -1706,32 +1707,38 @@ function compileRules(rules) {
  * @returns The handler function.
  */
 function createConfigMatchHandler(options) {
-    const { config, logger } = options;
-    // Compile rules once at handler creation time
-    const compiledRules = compileRules(config.inferenceRules ?? []);
-    // Compile watch path matchers
-    const watchMatcher = picomatch(config.watch.paths, { dot: true });
-    const ignoreMatcher = config.watch.ignored?.length
-        ? picomatch(config.watch.ignored, { dot: true })
-        : null;
+    const { getConfig, logger } = options;
+    // Cache compiled artifacts per config reference — recompute only on hot-reload.
+    let cachedConfig;
+    let compiledRules = [];
+    let watchMatcher;
+    let ignoreMatcher;
     const handler = async (req, res) => {
         const body = req.body;
         if (!Array.isArray(body.paths)) {
             res.code(400).send({ error: 'Request body must include "paths" array' });
             return;
         }
+        const config = getConfig();
+        if (config !== cachedConfig) {
+            compiledRules = compileRules(config.inferenceRules ?? []);
+            watchMatcher = picomatch(config.watch.paths, { dot: true });
+            ignoreMatcher = config.watch.ignored?.length
+                ? picomatch(config.watch.ignored, { dot: true })
+                : undefined;
+            cachedConfig = config;
+        }
         const matches = body.paths.map((path) => {
             const attrs = buildSyntheticAttributes(path);
-            // Find matching rules
             const matchingRules = [];
             for (const compiled of compiledRules) {
                 if (compiled.validate(attrs)) {
                     matchingRules.push(compiled.rule.name);
                 }
             }
-            // Check watch scope: matches watch paths and not in ignored
             const normalised = attrs.file.path;
-            const watched = watchMatcher(normalised) && !ignoreMatcher?.(normalised);
+            const watched = (watchMatcher?.(normalised) ?? false) &&
+                !(ignoreMatcher?.(normalised) ?? false);
             return { rules: matchingRules, watched };
         });
         const response = { matches };
@@ -1910,7 +1917,7 @@ function resolveReferences(doc, resolveTypes) {
  */
 function createConfigQueryHandler(deps) {
     const coreHandler = createConfigQueryHandler$1(() => buildMergedDocument({
-        config: deps.config,
+        config: deps.getConfig(),
         valuesManager: deps.valuesManager,
         issuesManager: deps.issuesManager,
         helperIntrospection: deps.helperIntrospection,
@@ -1971,7 +1978,7 @@ function createConfigReindexHandler(deps) {
             });
         }
         const reindexDeps = {
-            config: deps.config,
+            config: deps.getConfig(),
             processor: deps.processor,
             logger: deps.logger,
             reindexTracker: deps.reindexTracker,
@@ -3189,7 +3196,7 @@ function validateInferenceRuleSchemas(parsed) {
 function createConfigValidateHandler(deps) {
     return wrapHandler(async (request) => {
         const { config: submittedConfig, testPaths } = request.body;
-        const { candidateRaw, parsed, errors } = mergeAndValidateConfig(deps.config, submittedConfig);
+        const { candidateRaw, parsed, errors } = mergeAndValidateConfig(deps.getConfig(), submittedConfig);
         if (errors.length > 0) {
             return { valid: false, errors };
         }
@@ -3309,13 +3316,14 @@ function buildFacetSchema(rules, mergeOptions) {
  * @returns Fastify route handler (plain return, compatible with `withCache`).
  */
 function createFacetsHandler(deps) {
-    const { config, valuesManager, configDir } = deps;
+    const { getConfig, valuesManager, configDir } = deps;
     let cached;
-    const mergeOptions = {
-        globalSchemas: config.schemas,
-        configDir,
-    };
     return () => {
+        const config = getConfig();
+        const mergeOptions = {
+            globalSchemas: config.schemas,
+            configDir,
+        };
         // Rebuild schema cache if rules changed
         const currentHash = computeRulesHash(config.inferenceRules);
         if (!cached || cached.rulesHash !== currentHash) {
@@ -3420,7 +3428,7 @@ function getValueType(value) {
  *
  * Unknown properties are allowed.
  */
-function validateMetadataPayload(config, path, metadata) {
+function validateMetadataPayload(config, path, metadata, configDir) {
     const compiled = compileRules(config.inferenceRules ?? []);
     const attrs = buildSyntheticAttributes(path);
     const matched = compiled.filter((r) => r.validate(attrs));
@@ -3431,6 +3439,7 @@ function validateMetadataPayload(config, path, metadata) {
     }
     const merged = mergeSchemas(schemaRefs, {
         globalSchemas: config.schemas ?? {},
+        configDir,
     });
     const details = [];
     for (const [key, value] of Object.entries(metadata)) {
@@ -3451,6 +3460,7 @@ function validateMetadataPayload(config, path, metadata) {
                     return false;
                 const ruleSchema = mergeSchemas(m.rule.schema, {
                     globalSchemas: config.schemas ?? {},
+                    configDir,
                 });
                 return (Object.hasOwn(ruleSchema.properties, key) &&
                     ruleSchema.properties[key].type === expectedType);
@@ -3490,7 +3500,7 @@ function validateMetadataPayload(config, path, metadata) {
 function createMetadataHandler(deps) {
     return wrapHandler(async (request, reply) => {
         const { path, metadata } = request.body;
-        const validation = validateMetadataPayload(deps.config, path, metadata);
+        const validation = validateMetadataPayload(deps.getConfig(), path, metadata, deps.configDir);
         if (!validation.ok) {
             return reply
                 .code(400)
@@ -3594,13 +3604,14 @@ function createRebuildMetadataHandler(deps) {
  * @returns Fastify route handler.
  */
 function createRenderHandler(deps) {
-    const { processor, watch, logger } = deps;
+    const { processor, getWatch, logger } = deps;
     return async (request, reply) => {
         const { path: filePath } = request.body;
         if (!filePath || typeof filePath !== 'string') {
             return reply.status(400).send({ error: 'Missing required field: path' });
         }
-        // Validate path is within watched scope
+        // Validate path is within watched scope (live config)
+        const watch = getWatch();
         if (!isPathWatched(filePath, watch.paths, watch.ignored)) {
             return reply.status(403).send({ error: 'Path is outside watched scope' });
         }
@@ -3786,8 +3797,9 @@ function createSearchHandler(deps) {
     return wrapHandler(async (request) => {
         const { query, limit = 10, offset, filter } = request.body;
         const vectors = await deps.embeddingProvider.embed([query]);
-        if (deps.hybridConfig?.enabled) {
-            return deps.vectorStore.hybridSearch(vectors[0], query, limit, deps.hybridConfig.textWeight, filter);
+        const hybridConfig = deps.getHybridConfig?.();
+        if (hybridConfig?.enabled) {
+            return deps.vectorStore.hybridSearch(vectors[0], query, limit, hybridConfig.textWeight, filter);
         }
         return deps.vectorStore.search(vectors[0], limit, filter, offset);
     }, deps.logger, 'Search');
@@ -3810,7 +3822,7 @@ function createStatusHandler(deps) {
             version: deps.version,
             uptime: process.uptime(),
             collection: {
-                name: deps.collectionName,
+                name: deps.getCollectionName(),
                 pointCount: collectionInfo.pointCount,
                 dimensions: collectionInfo.dimensions,
             },
@@ -3857,7 +3869,7 @@ function createWalkHandler(deps) {
         const normGlobs = globs.map((g) => normalizeSlashes(g));
         const matchGlobs = picomatch(normGlobs, { dot: true, nocase: true });
         const paths = watchedFiles.filter((f) => matchGlobs(normalizeSlashes(f)));
-        const scannedRoots = getWatchRootBases(deps.watchPaths);
+        const scannedRoots = getWatchRootBases(deps.getWatchPaths());
         return {
             paths,
             matchedCount: paths.length,
@@ -4118,6 +4130,59 @@ async function introspectHelpers(config, configDir) {
 function getConfigDir(configPath) {
     return configPath ? dirname(configPath) : '.';
 }
+/**
+ * Tear down and rebuild the filesystem watcher with new config.
+ * Falls back to the old watcher if the new one fails to start.
+ */
+async function rebuildWatcher(newConfig, factories, queue, processor, logger, runtimeOptions, oldState, initialScanTracker, contentHashCache) {
+    try {
+        await oldState.watcher.stop();
+        const { watcher: newWatcher, gitignoreFilter: newGitignoreFilter } = createWatcher(newConfig, factories, queue, processor, logger, runtimeOptions, initialScanTracker, contentHashCache);
+        newWatcher.start();
+        logger.info('Filesystem watcher rebuilt successfully');
+        return { watcher: newWatcher, gitignoreFilter: newGitignoreFilter };
+    }
+    catch (error) {
+        logger.error({ err: normalizeError(error) }, 'Failed to rebuild watcher, restoring previous');
+        try {
+            oldState.watcher.start();
+        }
+        catch (restartError) {
+            logger.error({ err: normalizeError(restartError) }, 'Failed to restart previous watcher');
+        }
+        return oldState;
+    }
+}
+/**
+ * Check whether watch-relevant config fields changed between old and new config.
+ */
+function watchConfigChanged(oldConfig, newConfig) {
+    return (JSON.stringify(oldConfig.watch.paths) !==
+        JSON.stringify(newConfig.watch.paths) ||
+        JSON.stringify(oldConfig.watch.ignored) !==
+            JSON.stringify(newConfig.watch.ignored) ||
+        JSON.stringify(oldConfig.watch.moveDetection) !==
+            JSON.stringify(newConfig.watch.moveDetection) ||
+        (oldConfig.watch.respectGitignore ?? true) !==
+            (newConfig.watch.respectGitignore ?? true));
+}
+/**
+ * Resolve package version from nearest package.json.
+ */
+function resolveVersion(referenceUrl) {
+    try {
+        const pkgDir = packageDirectorySync({
+            cwd: dirname(fileURLToPath(referenceUrl)),
+        });
+        const pkg = pkgDir
+            ? JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8'))
+            : undefined;
+        return pkg?.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 
 /**
  * @module rules/virtualRules
@@ -4223,8 +4288,9 @@ function extractMatchGlobs(rules) {
  * @returns A zero-argument callback suitable for passing to rule registration handlers.
  */
 function createOnRulesChanged(deps) {
-    const { config, configPath, processor, logger, virtualRuleStore, reindexTracker, valuesManager, issuesManager, gitignoreFilter, vectorStore, } = deps;
+    const { getConfig, configPath, processor, logger, virtualRuleStore, reindexTracker, valuesManager, issuesManager, gitignoreFilter, vectorStore, } = deps;
     return () => {
+        const config = getConfig();
         const configRules = config.inferenceRules ?? [];
         const virtualRulesBySource = virtualRuleStore.getAll();
         const allVirtualRules = Object.values(virtualRulesBySource).flat();
@@ -4381,6 +4447,7 @@ class InitialScanTracker {
  */
 function createApiServer(options) {
     const { processor, vectorStore, embeddingProvider, logger, config, issuesManager, valuesManager, configPath, helperIntrospection, virtualRuleStore, gitignoreFilter, version, initialScanTracker, } = options;
+    const getConfig = options.getConfig ?? (() => config);
     const reindexTracker = options.reindexTracker ?? new ReindexTracker();
     const app = Fastify({ logger: false });
     const triggerReindex = (scope) => {
@@ -4389,7 +4456,7 @@ function createApiServer(options) {
             return;
         }
         void executeReindex({
-            config,
+            config: getConfig(),
             processor,
             logger,
             reindexTracker,
@@ -4402,30 +4469,33 @@ function createApiServer(options) {
     const cacheTtlMs = config.api?.cacheTtlMs ?? 30000;
     app.get('/status', withCache(cacheTtlMs, createStatusHandler({
         vectorStore,
-        collectionName: config.vectorStore.collectionName,
+        getCollectionName: () => getConfig().vectorStore.collectionName,
         reindexTracker,
         version: version ?? 'unknown',
         initialScanTracker,
     })));
-    app.post('/metadata', createMetadataHandler({ processor, config, logger }));
-    app.post('/render', withCache(cacheTtlMs, createRenderHandler({ processor, watch: config.watch, logger })));
+    app.post('/metadata', createMetadataHandler({
+        processor,
+        getConfig,
+        logger,
+        configDir: dirname(configPath),
+    }));
+    app.post('/render', withCache(cacheTtlMs, createRenderHandler({
+        processor,
+        getWatch: () => getConfig().watch,
+        logger,
+    })));
     app.get('/search/facets', createFacetsHandler({
-        config,
+        getConfig,
         valuesManager,
         configDir: dirname(configPath),
     }));
-    const hybridConfig = config.search?.hybrid
-        ? {
-            enabled: config.search.hybrid.enabled,
-            textWeight: config.search.hybrid.textWeight,
-        }
-        : undefined;
     app.post('/scan', createScanHandler({
         vectorStore,
         logger,
     }));
     app.post('/walk', createWalkHandler({
-        watchPaths: config.watch.paths,
+        getWatchPaths: () => getConfig().watch.paths,
         fileSystemWatcher: options.fileSystemWatcher,
         logger,
     }));
@@ -4433,7 +4503,12 @@ function createApiServer(options) {
         embeddingProvider,
         vectorStore,
         logger,
-        hybridConfig,
+        getHybridConfig: () => {
+            const hybrid = getConfig().search?.hybrid;
+            return hybrid
+                ? { enabled: hybrid.enabled, textWeight: hybrid.textWeight }
+                : undefined;
+        },
     }));
     app.post('/rebuild-metadata', createRebuildMetadataHandler({
         enrichmentStore: options.enrichmentStore,
@@ -4441,7 +4516,7 @@ function createApiServer(options) {
         logger,
     }));
     app.post('/reindex', createConfigReindexHandler({
-        config,
+        getConfig,
         processor,
         logger,
         reindexTracker,
@@ -4452,9 +4527,9 @@ function createApiServer(options) {
     }));
     app.get('/issues', withCache(cacheTtlMs, createIssuesHandler({ issuesManager })));
     app.get('/config/schema', withCache(cacheTtlMs, createConfigSchemaHandler()));
-    app.post('/config/match', createConfigMatchHandler({ config, logger }));
+    app.post('/config/match', createConfigMatchHandler({ getConfig, logger }));
     app.get('/config', withCache(cacheTtlMs, createConfigQueryHandler({
-        config,
+        getConfig,
         valuesManager,
         issuesManager,
         logger,
@@ -4464,12 +4539,12 @@ function createApiServer(options) {
             : undefined,
     })));
     app.post('/config/validate', createConfigValidateHandler({
-        config,
+        getConfig,
         logger,
         configDir: dirname(configPath),
     }));
     app.post('/config/apply', createConfigApplyHandler({
-        config,
+        getConfig,
         configPath,
         reindexTracker,
         logger,
@@ -4478,7 +4553,7 @@ function createApiServer(options) {
     // Virtual rules and points deletion routes
     if (virtualRuleStore) {
         const onRulesChanged = createOnRulesChanged({
-            config,
+            getConfig,
             configPath,
             processor,
             logger,
@@ -4914,6 +4989,50 @@ class ValuesManager extends JsonFileStore {
     }
 }
 
+/**
+ * @module app/configReload
+ * Config-reload orchestration extracted from JeevesWatcher to follow SRP.
+ */
+/**
+ * Reload config, update rules/templates, optionally rebuild watcher, and trigger reindex.
+ * Mutates `state.config`, `state.watcher`, and `state.gitignoreFilter` in place.
+ */
+async function reloadConfig(state, deps) {
+    const { logger, processor, configPath } = deps;
+    logger.info({ configPath }, 'Config change detected, reloading...');
+    try {
+        const oldConfig = state.config;
+        const newConfig = await deps.factories.loadConfig(configPath);
+        state.config = newConfig;
+        const compiledRules = deps.factories.compileRules(newConfig.inferenceRules ?? []);
+        const reloadConfigDir = getConfigDir(configPath);
+        const { templateEngine: newTemplateEngine, customMapLib: newCustomMapLib } = await buildTemplateEngineAndCustomMapLib(newConfig, reloadConfigDir);
+        processor.updateRules(compiledRules, newTemplateEngine, newCustomMapLib);
+        logger.info({ configPath, rules: compiledRules.length }, 'Config reloaded');
+        // Rebuild filesystem watcher if watch config changed
+        if (watchConfigChanged(oldConfig, newConfig)) {
+            logger.info('Watch config changed, rebuilding filesystem watcher...');
+            const newState = await rebuildWatcher(newConfig, deps.factories, deps.queue, processor, logger, deps.runtimeOptions, { watcher: state.watcher, gitignoreFilter: state.gitignoreFilter }, deps.initialScanTracker, deps.contentHashCache);
+            state.watcher = newState.watcher;
+            state.gitignoreFilter = newState.gitignoreFilter;
+        }
+        // Trigger reindex based on configWatch.reindex setting
+        const reindexScope = newConfig.configWatch?.reindex ?? 'issues';
+        logger.info({ scope: reindexScope }, `Config watch triggering ${reindexScope} reindex`);
+        await executeReindex({
+            config: newConfig,
+            processor,
+            logger,
+            valuesManager: deps.valuesManager,
+            issuesManager: deps.issuesManager,
+            gitignoreFilter: state.gitignoreFilter,
+        }, reindexScope);
+    }
+    catch (error) {
+        logger.error({ err: normalizeError(error) }, 'Failed to reload config');
+    }
+}
+
 /**
  * @module app/configWatcher
  * Watches the config file for changes and triggers debounced reload. Isolated I/O wrapper around chokidar.
@@ -7383,18 +7502,7 @@ class JeevesWatcher {
         this.runtimeOptions = runtimeOptions;
         this.virtualRuleStore = new VirtualRuleStore();
         this.initialScanTracker = new InitialScanTracker();
-        try {
-            const pkgDir = packageDirectorySync({
-                cwd: dirname(fileURLToPath(import.meta.url)),
-            });
-            const pkg = pkgDir
-                ? JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8'))
-                : undefined;
-            this.version = pkg?.version ?? 'unknown';
-        }
-        catch {
-            this.version = 'unknown';
-        }
+        this.version = resolveVersion(import.meta.url);
     }
     /**
      * Start the watcher, API server, and all components.
@@ -7468,6 +7576,7 @@ class JeevesWatcher {
                 this.logger?.warn({ timeoutMs: timeout }, 'Queue drain timeout hit, forcing shutdown');
             }
         }
+        this.enrichmentStore?.close();
         if (this.server) {
             await this.server.close();
         }
@@ -7480,6 +7589,7 @@ class JeevesWatcher {
             embeddingProvider: this.embeddingProvider,
             queue: this.queue,
             config: this.config,
+            getConfig: () => this.config,
             logger: this.logger,
             issuesManager: this.issuesManager,
             valuesManager: this.valuesManager,
@@ -7529,30 +7639,26 @@ class JeevesWatcher {
         const processor = this.processor;
         if (!logger || !processor || !this.configPath)
             return;
-        logger.info({ configPath: this.configPath }, 'Config change detected, reloading...');
-        try {
-            const newConfig = await this.factories.loadConfig(this.configPath);
-            this.config = newConfig;
-            const compiledRules = this.factories.compileRules(newConfig.inferenceRules ?? []);
-            const reloadConfigDir = getConfigDir(this.configPath);
-            const { templateEngine: newTemplateEngine, customMapLib: newCustomMapLib, } = await buildTemplateEngineAndCustomMapLib(newConfig, reloadConfigDir);
-            processor.updateRules(compiledRules, newTemplateEngine, newCustomMapLib);
-            logger.info({ configPath: this.configPath, rules: compiledRules.length }, 'Config reloaded');
-            // Trigger reindex based on configWatch.reindex setting
-            const reindexScope = newConfig.configWatch?.reindex ?? 'issues';
-            logger.info({ scope: reindexScope }, `Config watch triggering ${reindexScope} reindex`);
-            await executeReindex({
-                config: newConfig,
-                processor,
-                logger,
-                valuesManager: this.valuesManager,
-                issuesManager: this.issuesManager,
-                gitignoreFilter: this.gitignoreFilter,
-            }, reindexScope);
-        }
-        catch (error) {
-            logger.error({ err: normalizeError(error) }, 'Failed to reload config');
-        }
+        const state = {
+            config: this.config,
+            watcher: this.watcher,
+            gitignoreFilter: this.gitignoreFilter,
+        };
+        await reloadConfig(state, {
+            configPath: this.configPath,
+            factories: this.factories,
+            queue: this.queue,
+            processor,
+            logger,
+            runtimeOptions: this.runtimeOptions,
+            initialScanTracker: this.initialScanTracker,
+            contentHashCache: this.contentHashCache,
+            valuesManager: this.valuesManager,
+            issuesManager: this.issuesManager,
+        });
+        this.config = state.config;
+        this.watcher = state.watcher;
+        this.gitignoreFilter = state.gitignoreFilter;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jeeves-watcher",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "author": "Jason Williscroft",
   "description": "Filesystem watcher that keeps a Qdrant vector store in sync with document changes",
   "license": "BSD-3-Clause",