@karmaniverous/jeeves-watcher 0.15.2 → 0.16.1

package/dist/index.js

@@ -1,4 +1,5 @@
 import { join, dirname, resolve, relative, extname, basename, isAbsolute } from 'node:path';
+import { createConfigQueryHandler as createConfigQueryHandler$1, createStatusHandler, getBindAddress, postJson, fetchJson } from '@karmaniverous/jeeves';
 import Fastify from 'fastify';
 import { readdir, stat, writeFile, readFile } from 'node:fs/promises';
 import { parallel, capitalize, title, camel, snake, dash, isEqual, get, omit } from 'radash';
@@ -9,7 +10,6 @@ import { z, ZodError } from 'zod';
 import { jsonMapMapSchema, JsonMap } from '@karmaniverous/jsonmap';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
-import { createConfigQueryHandler as createConfigQueryHandler$1 } from '@karmaniverous/jeeves';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import Handlebars from 'handlebars';
 import dayjs from 'dayjs';
@@ -33,6 +33,7 @@ import * as cheerio from 'cheerio';
 import mammoth from 'mammoth';
 import { MarkdownTextSplitter, RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
 import { QdrantClient } from '@qdrant/js-client-rest';
+import { createRequire } from 'node:module';
 
 /**
  * @module gitignore
@@ -755,7 +756,7 @@ async function executeReindex(deps, scope, path, dryRun = false) {
     let plan;
     if (scope === 'prune') {
         deps.queue?.pause();
-        await deps.queue?.drain();
+        await deps.queue?.waitForIdleWorkers();
         let pruneResult;
         try {
             pruneResult = await computePrunePlan(deps);
@@ -3331,7 +3332,7 @@ function buildFacetSchema(rules, mergeOptions) {
  * @returns Fastify route handler (plain return, compatible with `withCache`).
  */
 function createFacetsHandler(deps) {
-    const { getConfig, valuesManager, configDir } = deps;
+    const { getConfig, valuesManager, configDir, logger } = deps;
     let cached;
     return () => {
         const config = getConfig();
@@ -3339,10 +3340,16 @@ function createFacetsHandler(deps) {
             globalSchemas: config.schemas,
             configDir,
         };
-        // Rebuild schema cache if rules changed
+        // Rebuild schema cache if rules changed (#159: catch schema errors gracefully)
         const currentHash = computeRulesHash(config.inferenceRules);
         if (!cached || cached.rulesHash !== currentHash) {
-            cached = buildFacetSchema(config.inferenceRules, mergeOptions);
+            try {
+                cached = buildFacetSchema(config.inferenceRules, mergeOptions);
+            }
+            catch (err) {
+                logger?.error({ err }, 'facets: failed to build facet schema from inference rules; returning empty facets');
+                return { facets: [] };
+            }
         }
         // Merge with live values
         const allValues = valuesManager.getAll();
@@ -3820,35 +3827,6 @@ function createSearchHandler(deps) {
     }, deps.logger, 'Search');
 }
 
-/**
- * @module api/handlers/status
- * Fastify route handler for GET /status. Returns process health, uptime, and collection stats.
- */
-/**
- * Create handler for GET /status.
- *
- * @param deps - Route dependencies.
- */
-function createStatusHandler(deps) {
-    return async () => {
-        const collectionInfo = await deps.vectorStore.getCollectionInfo();
-        return {
-            status: 'ok',
-            version: deps.version,
-            uptime: process.uptime(),
-            collection: {
-                name: deps.getCollectionName(),
-                pointCount: collectionInfo.pointCount,
-                dimensions: collectionInfo.dimensions,
-            },
-            reindex: deps.reindexTracker.getStatus(),
-            ...(deps.initialScanTracker
-                ? { initialScan: deps.initialScanTracker.getStatus() }
-                : {}),
-        };
-    };
-}
-
 /**
  * @module api/handlers/walk
  * Fastify route handler for POST /walk. Enumerates watched files matching caller-provided globs
@@ -4314,8 +4292,12 @@ function createOnRulesChanged(deps) {
         const configCompiled = compileRules(configRules);
         const virtualCompiled = virtualRuleStore.getCompiled();
         // Rebuild template engine asynchronously with merged rules
-        void buildTemplateEngineAndCustomMapLib({ ...config, inferenceRules: mergedRules }, dirname(configPath)).then(({ templateEngine: newEngine, customMapLib: newMapLib }) => {
+        buildTemplateEngineAndCustomMapLib({ ...config, inferenceRules: mergedRules }, dirname(configPath))
+            .then(({ templateEngine: newEngine, customMapLib: newMapLib }) => {
             processor.updateRules([...configCompiled, ...virtualCompiled], newEngine, newMapLib);
+        })
+            .catch((err) => {
+            logger.error({ err }, 'onRulesChanged: failed to rebuild template engine; processor rules not updated');
         });
         // Auto-trigger rules reindex scoped to newly registered rule globs (Fix 21)
         const matchGlobs = extractMatchGlobs(allVirtualRules);
@@ -4485,13 +4467,28 @@ function createApiServer(options) {
         }, scope);
     };
     const cacheTtlMs = config.api?.cacheTtlMs ?? 30000;
-    app.get('/status', withCache(cacheTtlMs, createStatusHandler({
-        vectorStore,
-        getCollectionName: () => getConfig().vectorStore.collectionName,
-        reindexTracker,
+    const coreStatusHandler = createStatusHandler({
+        name: 'watcher',
         version: version ?? 'unknown',
-        initialScanTracker,
-    })));
+        getHealth: async () => {
+            const collectionInfo = await vectorStore.getCollectionInfo();
+            return {
+                collection: {
+                    name: getConfig().vectorStore.collectionName,
+                    pointCount: collectionInfo.pointCount,
+                    dimensions: collectionInfo.dimensions,
+                },
+                reindex: reindexTracker.getStatus(),
+                ...(initialScanTracker
+                    ? { initialScan: initialScanTracker.getStatus() }
+                    : {}),
+            };
+        },
+    });
+    app.get('/status', withCache(cacheTtlMs, async () => {
+        const result = await coreStatusHandler();
+        return result.body;
+    }));
     app.post('/metadata', createMetadataHandler({
         processor,
         getConfig,
@@ -5240,6 +5237,27 @@ const EMBEDDING_DEFAULTS = {
     rateLimitPerMinute: 300,
     concurrency: 5,
 };
+/** Default init command config template. */
+const INIT_CONFIG_TEMPLATE = {
+    $schema: 'node_modules/@karmaniverous/jeeves-watcher/config.schema.json',
+    watch: {
+        paths: ['**/*.{md,markdown,txt,text,json,html,htm,pdf,docx}'],
+        ignored: ['**/node_modules/**', '**/.git/**', '**/.jeeves-watcher/**'],
+    },
+    configWatch: CONFIG_WATCH_DEFAULTS,
+    embedding: {
+        provider: 'gemini',
+        model: 'gemini-embedding-001',
+        dimensions: EMBEDDING_DEFAULTS.dimensions,
+    },
+    vectorStore: {
+        url: 'http://127.0.0.1:6333',
+        collectionName: 'jeeves-watcher',
+    },
+    stateDir: ROOT_DEFAULTS.stateDir,
+    api: API_DEFAULTS,
+    logging: LOGGING_DEFAULTS,
+};
 
 /**
  * @module config/substituteEnvVars
@@ -5353,7 +5371,9 @@ async function loadConfig(configPath) {
             const errors = error.issues
                 .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
                 .join('; ');
-            throw new Error(`Invalid jeeves-watcher configuration: ${errors}`);
+            throw new Error(`Invalid jeeves-watcher configuration: ${errors}`, {
+                cause: error,
+            });
         }
         throw error;
     }
@@ -5894,6 +5914,8 @@ function computeLineOffsets(fullText, chunks) {
  * @module processor/processingPipeline
  * Extracted embed→chunk→upsert pipeline for DocumentProcessor.
  */
+/** Default number of points to upsert per batch (prevents OOM on large files). */
+const DEFAULT_UPSERT_BATCH_SIZE = 50;
 /**
  * Embed text chunks, upsert to vector store, and clean up orphaned chunks.
  *
@@ -5905,7 +5927,7 @@ function computeLineOffsets(fullText, chunks) {
  * @param fileDates - File creation and modification timestamps (unix seconds).
  */
 async function embedAndUpsert(deps, text, filePath, metadata, existingPayload, fileDates) {
-    const { embeddingProvider, vectorStore, splitter, logger } = deps;
+    const { embeddingProvider, vectorStore, splitter, logger, upsertBatchSize = DEFAULT_UPSERT_BATCH_SIZE, } = deps;
     const oldTotalChunks = getChunkCount(existingPayload);
     const hash = contentHash(text);
     // Chunk text
@@ -5914,7 +5936,7 @@ async function embedAndUpsert(deps, text, filePath, metadata, existingPayload, f
     const offsets = computeLineOffsets(text, chunks);
     // Embed all chunks
     const vectors = await embeddingProvider.embed(chunks);
-    // Upsert all chunk points
+    // Build all points
     const points = chunks.map((chunk, i) => ({
         id: pointId(filePath, i),
         vector: vectors[i],
@@ -5931,7 +5953,11 @@ async function embedAndUpsert(deps, text, filePath, metadata, existingPayload, f
             [FIELD_LINE_END]: offsets[i]?.lineEnd ?? 1,
         },
     }));
-    await vectorStore.upsert(points);
+    // Upsert in batches to avoid OOM on large files (#162)
+    const batchSize = Math.max(1, upsertBatchSize);
+    for (let start = 0; start < points.length; start += batchSize) {
+        await vectorStore.upsert(points.slice(start, start + batchSize));
+    }
     // Clean up orphaned chunks
     if (oldTotalChunks > chunks.length) {
         const orphanIds = chunkIds(filePath, oldTotalChunks).slice(chunks.length);
@@ -6261,6 +6287,7 @@ class EventQueue {
     tokens;
     lastRefillMs = Date.now();
     drainWaiters = [];
+    idleWorkerWaiters = [];
     /**
      * Create an event queue.
      *
@@ -6327,6 +6354,20 @@ class EventQueue {
             this.drainWaiters.push(resolve);
         });
     }
+    /**
+     * Wait until there is no in-flight work.
+     *
+     * Unlike {@link drain}, this does NOT wait for debounced or queued items to be empty.
+     * It's useful when you need to temporarily quiesce outgoing work without losing
+     * or rejecting new enqueues.
+     */
+    async waitForIdleWorkers() {
+        if (this.active === 0)
+            return;
+        await new Promise((resolve) => {
+            this.idleWorkerWaiters.push(resolve);
+        });
+    }
     push(item) {
         if (item.event.priority === 'low')
             this.lowQueue.push(item);
@@ -6378,6 +6419,7 @@ class EventQueue {
                 this.active -= 1;
                 this.pump();
                 this.maybeResolveDrain();
+                this.maybeResolveIdleWorkers();
             });
         }
         this.maybeResolveDrain();
@@ -6397,6 +6439,14 @@ class EventQueue {
         for (const resolve of waiters)
             resolve();
     }
+    maybeResolveIdleWorkers() {
+        if (this.active !== 0)
+            return;
+        const waiters = this.idleWorkerWaiters;
+        this.idleWorkerWaiters = [];
+        for (const resolve of waiters)
+            resolve();
+    }
 }
 
 /**
@@ -6546,7 +6596,7 @@ async function ensureTextIndex(client, collectionName, fieldName, log) {
         log.info({ fieldName }, 'Full-text payload index created');
     }
     catch (error) {
-        throw new Error(`Failed to create text index on "${fieldName}": ${String(error)}`);
+        throw new Error(`Failed to create text index on "${fieldName}": ${String(error)}`, { cause: error });
     }
 }
 /**
@@ -6726,7 +6776,7 @@ class VectorStoreClient {
             }
         }
         catch (error) {
-            throw new Error(`Failed to ensure collection "${this.collectionName}": ${String(error)}`);
+            throw new Error(`Failed to ensure collection "${this.collectionName}": ${String(error)}`, { cause: error });
         }
     }
     /**
@@ -7571,6 +7621,53 @@ const defaultFactories = {
     createApiServer,
 };
 
+/**
+ * @module config/migrateConfigPath
+ *
+ * Auto-migrates legacy flat config path (`jeeves-watcher.config.json`)
+ * to the new namespaced convention (`jeeves-watcher/config.json`).
+ */
+const OLD_FILENAME = 'jeeves-watcher.config.json';
+const NEW_DIR = 'jeeves-watcher';
+const NEW_FILENAME = 'config.json';
+/**
+ * Resolve the config path, migrating from old to new convention if needed.
+ *
+ * When `configDir` is provided (the directory to search for config), the
+ * function checks for the old flat file and the new namespaced directory.
+ *
+ * Migration only runs when using the default/conventional path — an explicit
+ * `-c` flag bypasses this entirely.
+ *
+ * @param configDir - The directory to search for config files.
+ * @returns The resolved config path and migration metadata.
+ * @throws If neither old nor new config path exists.
+ */
+function migrateConfigPath(configDir) {
+    const oldPath = join(configDir, OLD_FILENAME);
+    const newDir = join(configDir, NEW_DIR);
+    const newPath = join(newDir, NEW_FILENAME);
+    const oldExists = existsSync(oldPath);
+    const newExists = existsSync(newPath);
+    if (newExists && oldExists) {
+        return {
+            configPath: newPath,
+            migrated: false,
+            warning: `Both legacy config (${oldPath}) and new config (${newPath}) exist. Using new path. Consider removing the legacy file.`,
+        };
+    }
+    if (newExists) {
+        return { configPath: newPath, migrated: false };
+    }
+    if (oldExists) {
+        mkdirSync(newDir, { recursive: true });
+        renameSync(oldPath, newPath);
+        return { configPath: newPath, migrated: true };
+    }
+    throw new Error(`No jeeves-watcher configuration found in ${configDir}. ` +
+        `Expected ${newPath} or ${oldPath}.`);
+}
+
 /**
  * @module app/shutdown
  * Process signal shutdown orchestration. Installs SIGINT/SIGTERM handlers that invoke a provided async stop function.
@@ -7596,12 +7693,38 @@ function installShutdownHandlers(stop) {
 /**
  * Create and start a JeevesWatcher from a config file path.
  *
- * @param configPath - Optional path to the configuration file.
+ * When no explicit config path is given, auto-migrates the legacy flat
+ * config (`jeeves-watcher.config.json`) to the namespaced convention
+ * (`jeeves-watcher/config.json`) before loading.
+ *
+ * @param configPath - Optional explicit path to the configuration file.
+ *   When provided, the file is loaded as-is (no migration).
  * @returns The running JeevesWatcher instance.
  */
 async function startFromConfig(configPath) {
-    const config = await loadConfig(configPath);
-    const app = new JeevesWatcher(config, configPath);
+    let resolvedPath = configPath;
+    // Auto-migrate only when no explicit path was given.
+    if (!configPath) {
+        try {
+            const result = migrateConfigPath(process.cwd());
+            resolvedPath = result.configPath;
+            if (result.migrated) {
+                console.log(`[jeeves-watcher] Migrated config to ${result.configPath}`);
+            }
+            if (result.warning) {
+                console.warn(`[jeeves-watcher] ${result.warning}`);
+            }
+        }
+        catch (error) {
+            // Migration discovery failed — log and fall through to loadConfig
+            // which will use cosmiconfig's own search.
+            console.warn('[jeeves-watcher] Config migration check failed: ' +
+                (error instanceof Error ? error.message : String(error)));
+            resolvedPath = undefined;
+        }
+    }
+    const config = await loadConfig(resolvedPath);
+    const app = new JeevesWatcher(config, resolvedPath);
     installShutdownHandlers(() => app.stop());
     await app.start();
     return app;
@@ -7749,7 +7872,7 @@ class JeevesWatcher {
             enrichmentStore: this.enrichmentStore,
         });
         await server.listen({
-            host: this.config.api?.host ?? '127.0.0.1',
+            host: this.config.api?.host ?? getBindAddress('watcher'),
             port: this.config.api?.port ?? 1936,
         });
         return server;
@@ -7808,4 +7931,288 @@ class JeevesWatcher {
     }
 }
 
-export { ContentHashCache, DocumentProcessor, EnrichmentStore, EventQueue, FileSystemWatcher, GitignoreFilter, InitialScanTracker, IssuesManager, JeevesWatcher, ReindexTracker, SystemHealth, TemplateEngine, ValuesManager, VectorStoreClient, VirtualRuleStore, apiConfigSchema, applyRules, buildAttributes, buildTemplateEngine, compileRules, configWatchConfigSchema, contentHash, createApiServer, createEmbeddingProvider, createHandlebarsInstance, createLogger, embeddingConfigSchema, extractText, inferenceRuleSchema, issueRecordSchema, jeevesWatcherConfigSchema, loadConfig, loadCustomHelpers, loggingConfigSchema, mergeEnrichment, pointId, registerBuiltinHelpers, resolveTemplateSource, startFromConfig, vectorStoreConfigSchema, watchConfigSchema };
+/**
+ * @module cli/jeeves-watcher/customCommands
+ * Domain-specific CLI commands registered via the descriptor's customCliCommands.
+ * Uses fetchJson/postJson from core instead of hand-rolled API helpers.
+ */
+const DEFAULT_PORT = '1936';
+const DEFAULT_HOST = '127.0.0.1';
+/** Build the API base URL from host and port options. */
+function baseUrl(opts) {
+    return `http://${opts.host}:${opts.port}`;
+}
+/** Add standard --port and --host options to a command. */
+function withApiOptions(cmd) {
+    return cmd
+        .option('-p, --port <port>', 'API port', DEFAULT_PORT)
+        .option('-H, --host <host>', 'API host', DEFAULT_HOST);
+}
+/** Wrap an async action with standard error handling. */
+function handleErrors(fn) {
+    return async () => {
+        try {
+            await fn();
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    };
+}
+/** Print JSON response to stdout. */
+function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+/**
+ * Register all domain-specific commands on the given Commander program.
+ *
+ * @param program - The Commander program from createServiceCli.
+ */
+function registerCustomCommands(program) {
+    // --- search ---
+    withApiOptions(program
+        .command('search')
+        .description('Search the vector store (POST /search)')
+        .argument('<query>', 'Search query')
+        .option('-l, --limit <limit>', 'Max results', '10')).action(async (query, opts) => {
+        await handleErrors(async () => {
+            const result = await postJson(`${baseUrl(opts)}/search`, {
+                query,
+                limit: Number(opts.limit),
+            });
+            printJson(result);
+        })();
+    });
+    // --- enrich ---
+    withApiOptions(program
+        .command('enrich')
+        .description('Enrich document metadata (POST /metadata)')
+        .argument('<path>', 'File path to enrich')
+        .option('-k, --key <key=value...>', 'Metadata key-value pairs (repeatable)', [])
+        .option('-j, --json <json>', 'Metadata as JSON string (e.g., \'{"key":"value"}\')')).action(async (path, opts) => {
+        await handleErrors(async () => {
+            const metadata = parseMetadataArgs(opts.json, opts.key);
+            if (!metadata)
+                return;
+            const result = await postJson(`${baseUrl(opts)}/metadata`, {
+                path,
+                metadata,
+            });
+            printJson(result);
+        })();
+    });
+    // --- scan ---
+    withApiOptions(program
+        .command('scan')
+        .description('Scan the vector store (POST /scan)')
+        .option('-f, --filter <filter>', 'Qdrant filter (JSON string)', '{}')
+        .option('-l, --limit <limit>', 'Max results', '100')
+        .option('-c, --cursor <cursor>', 'Cursor from previous response')
+        .option('--fields <fields>', 'Fields to return (comma-separated)')
+        .option('--count-only', 'Return count only')).action(async (opts) => {
+        await handleErrors(async () => {
+            const filterObj = JSON.parse(opts.filter);
+            const result = await postJson(`${baseUrl(opts)}/scan`, {
+                filter: filterObj,
+                limit: Number(opts.limit),
+                cursor: opts.cursor,
+                fields: opts.fields
+                    ? opts.fields.split(',').map((f) => f.trim())
+                    : undefined,
+                countOnly: opts.countOnly,
+            });
+            printJson(result);
+        })();
+    });
+    // --- reindex ---
+    withApiOptions(program
+        .command('reindex')
+        .description('Trigger a reindex operation (POST /reindex)')
+        .option('-s, --scope <scope>', 'Reindex scope (issues|full|rules|path|prune)', 'rules')
+        .option('-t, --path <paths...>', 'Target path(s) for path or rules scope')).action(async (opts) => {
+        await handleErrors(async () => {
+            if (!VALID_SCOPES.includes(opts.scope)) {
+                console.error(`Invalid scope "${opts.scope}". Must be one of: ${VALID_SCOPES.join(', ')}`);
+                process.exitCode = 1;
+                return;
+            }
+            const body = { scope: opts.scope };
+            if (opts.path) {
+                body.path = opts.path.length === 1 ? opts.path[0] : opts.path;
+            }
+            const result = await postJson(`${baseUrl(opts)}/reindex`, body);
+            printJson(result);
+        })();
+    });
+    // --- rebuild-metadata ---
+    withApiOptions(program
+        .command('rebuild-metadata')
+        .description('Rebuild metadata store from Qdrant (POST /rebuild-metadata)')).action(async (opts) => {
+        await handleErrors(async () => {
+            const result = await postJson(`${baseUrl(opts)}/rebuild-metadata`, {});
+            printJson(result);
+        })();
+    });
+    // --- issues ---
+    withApiOptions(program
+        .command('issues')
+        .description('List current processing issues (GET /issues)')).action(async (opts) => {
+        await handleErrors(async () => {
+            const result = await fetchJson(`${baseUrl(opts)}/issues`);
+            printJson(result);
+        })();
+    });
+    // --- helpers ---
+    withApiOptions(program.command('helpers').description('List available helper functions')).action(async (opts) => {
+        await handleErrors(async () => {
+            const base = baseUrl(opts);
+            const mapPath = encodeURIComponent('$.mapHelpers');
+            const tplPath = encodeURIComponent('$.templateHelpers');
+            const [mapResult, tplResult] = await Promise.all([
+                fetchJson(`${base}/config?path=${mapPath}`),
+                fetchJson(`${base}/config?path=${tplPath}`),
+            ]);
+            const mapData = mapResult.result[0];
+            const tplData = tplResult.result[0];
+            const sections = [];
+            const mapSection = formatHelperSection('JsonMap lib functions', mapData);
+            if (mapSection)
+                sections.push(mapSection);
+            const tplSection = formatHelperSection('Handlebars helpers', tplData);
+            if (tplSection)
+                sections.push(tplSection);
+            if (sections.length === 0) {
+                console.log('No helpers configured.');
+            }
+            else {
+                console.log(sections.join('\n\n'));
+            }
+        })();
+    });
+}
+// --- shared constants and helpers ---
+const VALID_SCOPES = ['issues', 'full', 'rules', 'path', 'prune'];
+/** Parse --json and --key options into a metadata object. Returns null on validation failure. */
+function parseMetadataArgs(json, keys) {
+    let metadata = {};
+    if (json) {
+        try {
+            metadata = JSON.parse(json);
+        }
+        catch {
+            console.error('Invalid JSON:', json);
+            process.exitCode = 1;
+            return null;
+        }
+    }
+    if (Array.isArray(keys) && keys.length > 0) {
+        for (const pair of keys) {
+            const eqIndex = pair.indexOf('=');
+            if (eqIndex === -1) {
+                console.error(`Invalid key-value pair: ${pair}`);
+                process.exitCode = 1;
+                return null;
+            }
+            metadata[pair.slice(0, eqIndex)] = pair.slice(eqIndex + 1);
+        }
+    }
+    if (Object.keys(metadata).length === 0) {
+        console.error('No metadata provided. Use --key or --json.');
+        process.exitCode = 1;
+        return null;
+    }
+    return metadata;
+}
+/** Format a helpers section for display. */
+function formatHelperSection(title, data) {
+    if (!data || Object.keys(data).length === 0)
+        return '';
+    const lines = [`${title}:`];
+    for (const [namespace, entry] of Object.entries(data)) {
+        if (entry.description) {
+            lines.push(`  [${namespace}] ${entry.description}`);
+        }
+        if (entry.exports) {
+            for (const [name, desc] of Object.entries(entry.exports)) {
+                const descPart = desc ? ` - ${desc}` : '';
+                lines.push(`  ${name.padEnd(40)}${descPart}`);
+            }
+        }
+        else {
+            lines.push(`  (no exports introspected)`);
+        }
+    }
+    return lines.join('\n');
+}
+
+/**
+ * @module descriptor
+ * Jeeves Component Descriptor for the watcher service. Single source of truth
+ * consumed by core factories (CLI, plugin tools, HTTP handlers, service manager).
+ */
+/**
+ * Resolve the package root directory using `package-directory`.
+ *
+ * @remarks
+ * Works in both dev (`src/descriptor.ts`) and bundled
+ * (`dist/cli/jeeves-watcher/index.js`) contexts because
+ * `packageDirectorySync` walks upward to find `package.json`.
+ */
+const thisDir = dirname(fileURLToPath(import.meta.url));
+const packageRoot = packageDirectorySync({ cwd: thisDir });
+if (!packageRoot) {
+    throw new Error('Could not find package root from ' + thisDir);
+}
+const require$1 = createRequire(import.meta.url);
+const { version } = require$1(resolve(packageRoot, 'package.json'));
+/**
+ * Watcher component descriptor. Single source of truth for service identity,
+ * config schema, and extension points consumed by core factories.
+ */
+const watcherDescriptor = {
+    // Identity
+    name: 'watcher',
+    version,
+    servicePackage: '@karmaniverous/jeeves-watcher',
+    pluginPackage: '@karmaniverous/jeeves-watcher-openclaw',
+    defaultPort: 1936,
+    // Config
+    configSchema: jeevesWatcherConfigSchema,
+    configFileName: 'config.json',
+    initTemplate: () => ({ ...INIT_CONFIG_TEMPLATE }),
+    // Service behavior — onConfigApply wired at the Fastify layer (api/index.ts)
+    // where it has access to the live reindex tracker and config getter.
+    onConfigApply: async (config) => {
+        await Promise.resolve();
+    },
+    customMerge: (target, source) => {
+        const mergedRules = mergeInferenceRules(target['inferenceRules'], source['inferenceRules']);
+        return {
+            ...target,
+            ...source,
+            inferenceRules: mergedRules,
+        };
+    },
+    startCommand: (configPath) => [
+        'node',
+        resolve(packageRoot, 'dist/cli/jeeves-watcher/index.js'),
+        'start',
+        '-c',
+        configPath,
+    ],
+    // Content — generateToolsContent is wired in the plugin package
+    // (watcherComponent.ts) where it has access to the API URL for menu generation.
+    sectionId: 'Watcher',
+    refreshIntervalSeconds: 71,
+    generateToolsContent: () => '',
+    // Extension points
+    customCliCommands: (program) => {
+        registerCustomCommands(program);
+    },
+    customPluginTools: (api) => {
+        return [];
+    },
+};
+
+export { ContentHashCache, DocumentProcessor, EnrichmentStore, EventQueue, FileSystemWatcher, GitignoreFilter, InitialScanTracker, IssuesManager, JeevesWatcher, ReindexTracker, SystemHealth, TemplateEngine, ValuesManager, VectorStoreClient, VirtualRuleStore, apiConfigSchema, applyRules, buildAttributes, buildTemplateEngine, compileRules, configWatchConfigSchema, contentHash, createApiServer, createEmbeddingProvider, createHandlebarsInstance, createLogger, embeddingConfigSchema, extractText, inferenceRuleSchema, issueRecordSchema, jeevesWatcherConfigSchema, loadConfig, loadCustomHelpers, loggingConfigSchema, mergeEnrichment, pointId, registerBuiltinHelpers, resolveTemplateSource, startFromConfig, vectorStoreConfigSchema, watchConfigSchema, watcherDescriptor };