@dikolab/kbdb 0.3.0 → 0.3.2

package/src/shared/worker-daemon/functions/handle-read-ops.function.ts

@@ -0,0 +1,236 @@
+import {
+   encodeSearchParams,
+   encodeKbidList,
+   encodeIdentifierList,
+   encodeTypeFilterParam,
+   encodeRecallParams,
+   decodePagedSearchResult,
+   decodeSectionRecords,
+   decodeSectionRecordList,
+   decodeDocumentManifest,
+   decodeDocumentManifestList,
+   decodeComposeOutput,
+   decodeKeyValueText,
+   decodeRecallResult,
+} from '../../wasm-codec/index.ts';
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+import { IpcError } from '../classes/ipc-error.class.ts';
+import {
+   getWasmExport,
+   wasmAlloc,
+   wasmWrite,
+   wasmFree,
+   readReturnSlot,
+   callWasmSync,
+   callWasmZeroArg,
+} from './wasm-bridge.function.ts';
+
+/**
+ * Handles `search` and `query` IPC methods.
+ *
+ * Encodes parameters, invokes the `worker_search` token pipeline,
+ * waits synchronously for the result, and decodes the paged result.
+ */
+export function handleSearch(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const query = (params['query'] as string | undefined) ?? '';
+   const mode = (params['mode'] as string | undefined) ?? 'and';
+   const limit = Number(params['limit'] ?? 20);
+   const offset = Number(params['offset'] ?? 0);
+   const encoded = encodeSearchParams(query, mode, limit, offset);
+
+   const searchFn = getWasmExport(ctx.modules, 'worker_search');
+   const ptr = wasmAlloc(ctx.modules, encoded.length);
+   wasmWrite(ctx.modules, ptr, encoded);
+   const token = searchFn(ptr, encoded.length) as number;
+   wasmFree(ctx.modules, ptr, encoded.length);
+
+   const statusFn = getWasmExport(ctx.modules, 'worker_result_status');
+   const status = statusFn(token) as number;
+   if (status === 3) {
+      getWasmExport(ctx.modules, 'worker_get_result')(token);
+      const errBytes = readReturnSlot(ctx.modules);
+      throw new IpcError(-32000, new TextDecoder().decode(errBytes));
+   }
+
+   const getResultFn = getWasmExport(ctx.modules, 'worker_get_result');
+   const rc = getResultFn(token) as number;
+   if (rc === -1) {
+      const errBytes = readReturnSlot(ctx.modules);
+      throw new IpcError(-32000, new TextDecoder().decode(errBytes));
+   }
+   return decodePagedSearchResult(readReturnSlot(ctx.modules));
+}
+
+/**
+ * Handles the `get_result_status` IPC method.
+ */
+export function handleResultStatus(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const token = Number(params['token'] ?? 0);
+   const fn = getWasmExport(ctx.modules, 'worker_result_status');
+   return { status: fn(token) as number };
+}
+
+/**
+ * Handles the `get_result` IPC method.
+ */
+export function handleGetResult(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const token = Number(params['token'] ?? 0);
+   const fn = getWasmExport(ctx.modules, 'worker_get_result');
+   const rc = fn(token) as number;
+   if (rc === -1) {
+      const errBytes = readReturnSlot(ctx.modules);
+      throw new IpcError(-32000, new TextDecoder().decode(errBytes));
+   }
+   return decodePagedSearchResult(readReturnSlot(ctx.modules));
+}
+
+/**
+ * Handles the `readSections` IPC method.
+ */
+export function handleReadSections(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const kbids = (params['kbids'] ?? []) as string[];
+   const encoded = encodeKbidList(kbids);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_read_sections',
+      encoded,
+   );
+   return decodeSectionRecords(bytes);
+}
+
+/**
+ * Handles the `retrieveDocument` IPC method.
+ */
+export function handleRetrieveDoc(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const docid = (params['docid'] as string | undefined) ?? '';
+   const encoded = new TextEncoder().encode(docid);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_retrieve_doc',
+      encoded,
+   );
+   return decodeDocumentManifest(bytes);
+}
+
+/**
+ * Handles the `content` and `compose` IPC methods.
+ */
+export function handleCompose(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const ids = (params['ids'] ?? []) as string[];
+   const encoded = encodeIdentifierList(ids);
+   const bytes = callWasmSync(ctx.modules, 'worker_compose', encoded);
+   const output = decodeComposeOutput(bytes);
+   return { data: output.markdown, total: Number(output.totalChars) };
+}
+
+/**
+ * Handles the `integrityCheck` IPC method.
+ */
+export function handleIntegrityCheck(ctx: HandlerContext): unknown {
+   callWasmZeroArg(ctx.modules, 'worker_check_integrity');
+   const bytes = readReturnSlot(ctx.modules);
+   return decodeKeyValueText(new TextDecoder().decode(bytes));
+}
+
+/**
+ * Handles the `dbStatus` IPC method.
+ */
+export function handleDbStatus(ctx: HandlerContext): unknown {
+   callWasmZeroArg(ctx.modules, 'worker_status');
+   const bytes = readReturnSlot(ctx.modules);
+   return decodeKeyValueText(new TextDecoder().decode(bytes));
+}
+
+/**
+ * Handles the `listByType` IPC method.
+ */
+export function handleListByType(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const typeStr = (params['sectionType'] as string | undefined) ?? '';
+   const encoded = encodeTypeFilterParam(typeStr);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_list_by_type',
+      encoded,
+   );
+   return decodeSectionRecordList(bytes);
+}
+
+/**
+ * Handles the `listDocumentsByType` IPC method.
+ */
+export function handleListDocsByType(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const typeStr = (params['docType'] as string | undefined) ?? '';
+   const encoded = encodeTypeFilterParam(typeStr);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_list_docs_by_type',
+      encoded,
+   );
+   return decodeDocumentManifestList(bytes);
+}
+
+/**
+ * Handles the `recall` IPC method.
+ */
+export function handleRecall(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const kbid =
+      typeof params['kbid'] === 'string' ? params['kbid'] : undefined;
+   const kbids = Array.isArray(params['kbids'])
+      ? (params['kbids'] as string[])
+      : undefined;
+   const depth = Number(params['depth'] ?? 0);
+   const encoded = encodeRecallParams({ kbid, kbids, depth });
+   const bytes = callWasmSync(ctx.modules, 'worker_recall', encoded);
+   return decodeRecallResult(bytes);
+}
+
+/**
+ * Handles the `export` and `exportDb` IPC methods.
+ */
+export function handleExport(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const targetPath =
+      (params['targetPath'] as string | undefined) ??
+      (params['path'] as string | undefined) ??
+      './kbdb-export/';
+   const encoded = new TextEncoder().encode(targetPath);
+   const start = Date.now();
+   const bytes = callWasmSync(ctx.modules, 'worker_export', encoded);
+   const elapsed = Date.now() - start;
+   const kv = decodeKeyValueText(new TextDecoder().decode(bytes));
+   return {
+      path: kv['path'] ?? targetPath,
+      sections_exported: Number(kv['sections_exported'] ?? 0),
+      documents_exported: Number(kv['documents_exported'] ?? 0),
+      elapsed_ms: elapsed,
+   };
+}

package/src/shared/worker-daemon/functions/handle-write-ops.function.ts

@@ -0,0 +1,257 @@
+import {
+   encodeAddSectionParams,
+   encodeUpdateSectionParams,
+   encodeGroupParams,
+   decodeKeyValueText,
+   decodeRemoveFlag,
+   decodeAddSectionResult,
+} from '../../wasm-codec/index.ts';
+import type { AddSectionInput } from '../../wasm-codec/index.ts';
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+import { IpcError } from '../classes/ipc-error.class.ts';
+import {
+   getWasmExport,
+   wasmAlloc,
+   wasmWrite,
+   wasmFree,
+   readReturnSlot,
+   callWasmSync,
+   callWasmZeroArg,
+} from './wasm-bridge.function.ts';
+import { scanNearDuplicates } from './scan-near-duplicates.function.ts';
+
+/**
+ * Handles the `addSection` IPC method.
+ *
+ * Encodes the section input, delegates to `worker_add_section`, and
+ * runs a near-duplicate scan when the WASM result reports none.
+ */
+export function handleAddSection(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const sectionType = (params['sectionType'] ?? 'text') as string;
+   const semanticType =
+      sectionType === 'text' ||
+      sectionType === 'code' ||
+      sectionType === 'image'
+         ? sectionType
+         : 'text';
+   const typeName = sectionType !== semanticType ? sectionType : null;
+   const tags = Array.isArray(params['tags'])
+      ? (params['tags'] as string[])
+      : [];
+   const content = (params['content'] as string | undefined) ?? '';
+   const input: AddSectionInput = {
+      sectionType: semanticType,
+      mimeType: params['mimeType'] as string | undefined,
+      content,
+      title: (params['title'] as string | null) ?? null,
+      description: (params['description'] as string | null) ?? null,
+      docid: (params['docid'] as string | null) ?? null,
+      typeName,
+      sourcePath:
+         typeof params['sourcePath'] === 'string'
+            ? params['sourcePath']
+            : undefined,
+      sourceMtime:
+         typeof params['sourceMtime'] === 'string'
+            ? params['sourceMtime']
+            : undefined,
+      tags,
+      replace: params['replace'] === true,
+   };
+   const encoded = encodeAddSectionParams(input);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_add_section',
+      encoded,
+   );
+   const decoded = decodeAddSectionResult(bytes);
+   const nearDups =
+      decoded.nearDuplicates.length > 0
+         ? decoded.nearDuplicates
+         : scanNearDuplicates(ctx.targetDir, content, decoded.kbid);
+   return {
+      kbid: decoded.kbid,
+      indexed_terms_count: decoded.indexedTermsCount,
+      elapsed_ms: decoded.elapsedMs,
+      superseded: decoded.superseded,
+      warnings: decoded.warnings,
+      near_duplicates: nearDups,
+   };
+}
+
+/**
+ * Handles the `updateSection` IPC method.
+ */
+export function handleUpdateSection(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const oldKbid = (params['kbid'] as string | undefined) ?? '';
+   const updSectionType = (params['sectionType'] ?? 'text') as string;
+   const updSemanticType =
+      updSectionType === 'text' ||
+      updSectionType === 'code' ||
+      updSectionType === 'image'
+         ? updSectionType
+         : 'text';
+   const updTypeName =
+      updSectionType !== updSemanticType ? updSectionType : null;
+   const input: AddSectionInput = {
+      sectionType: updSemanticType,
+      mimeType: params['mimeType'] as string | undefined,
+      content: (params['content'] as string | undefined) ?? '',
+      title: (params['title'] as string | null) ?? null,
+      description: (params['description'] as string | null) ?? null,
+      docid: (params['docid'] as string | null) ?? null,
+      typeName: updTypeName,
+   };
+   const encoded = encodeUpdateSectionParams(oldKbid, input);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_update_section',
+      encoded,
+   );
+   return { kbid: new TextDecoder().decode(bytes) };
+}
+
+/**
+ * Handles the `removeSection` IPC method.
+ */
+export function handleRemoveSection(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const kbid = (params['kbid'] as string | undefined) ?? '';
+   const encoded = new TextEncoder().encode(kbid);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_remove_section',
+      encoded,
+   );
+   return { removed: decodeRemoveFlag(bytes) };
+}
+
+/**
+ * Handles the `groupSections` IPC method.
+ */
+export function handleGroupSections(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const title = (params['title'] as string | undefined) ?? '';
+   const kbids = (params['kbids'] ?? []) as string[];
+   const docType = (params['docType'] as string | undefined) ?? '';
+   const encoded = encodeGroupParams(title, kbids, docType);
+   const bytes = callWasmSync(
+      ctx.modules,
+      'worker_group_sections',
+      encoded,
+   );
+   return { docid: new TextDecoder().decode(bytes) };
+}
+
+/**
+ * Handles the `removeGrouping` IPC method.
+ */
+export function handleRemoveGrouping(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const docid = (params['docid'] as string | undefined) ?? '';
+   callWasmSync(
+      ctx.modules,
+      'worker_remove_grouping',
+      new TextEncoder().encode(docid),
+   );
+   return { ok: true };
+}
+
+/**
+ * Handles the `initDirectory` IPC method.
+ */
+export function handleInitDirectory(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const path = (params['path'] as string | undefined) ?? ctx.targetDir;
+   callWasmSync(
+      ctx.modules,
+      'worker_init_directory',
+      new TextEncoder().encode(path),
+   );
+   return { ok: true };
+}
+
+/**
+ * Handles the `invalidate` IPC method.
+ */
+export function handleInvalidate(
+   ctx: HandlerContext,
+   params: Record<string, unknown>,
+): unknown {
+   const kbid = (params['kbid'] as string | undefined) ?? '';
+   const encoded = new TextEncoder().encode(kbid);
+   const fn = getWasmExport(ctx.modules, 'worker_invalidate');
+   const ptr = wasmAlloc(ctx.modules, encoded.length);
+   wasmWrite(ctx.modules, ptr, encoded);
+   const rc = fn(ptr, encoded.length) as number;
+   wasmFree(ctx.modules, ptr, encoded.length);
+   if (rc === -1) {
+      const errBytes = readReturnSlot(ctx.modules);
+      throw new IpcError(
+         -32000,
+         new TextDecoder().decode(errBytes) || 'invalidate failed',
+      );
+   }
+   return { ok: true };
+}
+
+/**
+ * Handles the `invalidateAll` IPC method.
+ */
+export function handleInvalidateAll(ctx: HandlerContext): unknown {
+   callWasmZeroArg(ctx.modules, 'worker_invalidate_all');
+   return { ok: true };
+}
+
+/**
+ * Handles the `gc` IPC method.
+ */
+export function handleGc(ctx: HandlerContext): unknown {
+   const start = Date.now();
+   callWasmZeroArg(ctx.modules, 'worker_garbage_collect');
+   const bytes = readReturnSlot(ctx.modules);
+   const kv = decodeKeyValueText(new TextDecoder().decode(bytes));
+   return {
+      removed_sections: Number(kv['removed'] ?? 0),
+      removed_bytes: 0,
+      elapsed_ms: Date.now() - start,
+      stale_sources: Number(kv['stale_sources'] ?? 0),
+   };
+}
+
+/**
+ * Handles the `rebuildIndexes` IPC method.
+ */
+export function handleRebuild(ctx: HandlerContext): unknown {
+   const fn = getWasmExport(ctx.modules, 'worker_rebuild_indexes');
+   const rc = fn() as number;
+   if (rc === -1) {
+      const errBytes = readReturnSlot(ctx.modules);
+      const errMsg = new TextDecoder().decode(errBytes);
+      throw new IpcError(-32000, errMsg || 'rebuild failed');
+   }
+   const resultBytes = readReturnSlot(ctx.modules);
+   const reindexed =
+      resultBytes.length >= 4
+         ? new DataView(
+              resultBytes.buffer,
+              resultBytes.byteOffset,
+              resultBytes.byteLength,
+           ).getUint32(0, true)
+         : 0;
+   return { ok: true, sections_reindexed: reindexed };
+}

package/src/shared/worker-daemon/functions/parse-auto-capture-section.function.ts

@@ -0,0 +1,51 @@
+import type { AutoCaptureConfig } from '../../auto-capture/typings/auto-capture-config.interface.ts';
+import { AUTO_CAPTURE_DEFAULTS } from '../../auto-capture/constants/auto-capture-defaults.constant.ts';
+
+/**
+ * Parses key-value pairs from an `[auto_capture]` TOML section
+ * into an `AutoCaptureConfig`.
+ *
+ * Recognised keys: `enabled`, `trigger_after_tool_calls`,
+ * `min_interval_ms`, `max_captures_per_session`, `dry_run`.
+ * Unknown keys are silently ignored. Falls back to
+ * `AUTO_CAPTURE_DEFAULTS` for any absent key.
+ *
+ * @param entries - key-value pairs from inside the
+ *   `[auto_capture]` section
+ */
+export function parseAutoCaptureSection(
+   entries: ReadonlyMap<string, string>,
+): AutoCaptureConfig {
+   const enabled = entries.has('enabled')
+      ? entries.get('enabled') === 'true'
+      : AUTO_CAPTURE_DEFAULTS.enabled;
+
+   const dryRun = entries.has('dry_run')
+      ? entries.get('dry_run') === 'true'
+      : AUTO_CAPTURE_DEFAULTS.dryRun;
+
+   const triggerRaw = entries.get('trigger_after_tool_calls');
+   const triggerAfterToolCalls = triggerRaw
+      ? parseInt(triggerRaw, 10) ||
+        AUTO_CAPTURE_DEFAULTS.triggerAfterToolCalls
+      : AUTO_CAPTURE_DEFAULTS.triggerAfterToolCalls;
+
+   const intervalRaw = entries.get('min_interval_ms');
+   const minIntervalMs = intervalRaw
+      ? parseInt(intervalRaw, 10) || AUTO_CAPTURE_DEFAULTS.minIntervalMs
+      : AUTO_CAPTURE_DEFAULTS.minIntervalMs;
+
+   const capRaw = entries.get('max_captures_per_session');
+   const maxCapturesPerSession = capRaw
+      ? parseInt(capRaw, 10) ||
+        AUTO_CAPTURE_DEFAULTS.maxCapturesPerSession
+      : AUTO_CAPTURE_DEFAULTS.maxCapturesPerSession;
+
+   return {
+      enabled,
+      triggerAfterToolCalls,
+      minIntervalMs,
+      maxCapturesPerSession,
+      dryRun,
+   };
+}

package/src/shared/worker-daemon/functions/parse-catalog-version.function.ts

@@ -0,0 +1,20 @@
+/**
+ * Parses the `version` field from a minimal TOML string.
+ *
+ * Supports only `version = <integer>` syntax. Comment lines are
+ * skipped. Returns `null` when no `version` field is present.
+ *
+ * @param text - raw TOML text from `catalog.toml`
+ * @returns the integer version, or `null` if absent
+ */
+export function parseCatalogVersion(text: string): number | null {
+   for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('#')) continue;
+      const match = /^version\s*=\s*(\d+)/.exec(trimmed);
+      if (match?.[1] !== undefined) {
+         return parseInt(match[1], 10);
+      }
+   }
+   return null;
+}

package/src/shared/worker-daemon/functions/parse-embedding-section.function.ts

@@ -0,0 +1,38 @@
+import type { EmbeddingConfig } from '../../embedding/typings/embedding-config.interface.ts';
+
+/**
+ * Parses key-value pairs from a `[embedding]` TOML section into an
+ * `EmbeddingConfig`.
+ *
+ * Recognises: `provider`, `model`, `endpoint`, `dimensions`.
+ * Unknown keys are silently ignored. Returns `undefined` when the
+ * `provider` key is absent from the supplied entries.
+ *
+ * @param entries - key-value pairs from inside the `[embedding]`
+ *   section
+ */
+export function parseEmbeddingSection(
+   entries: ReadonlyMap<string, string>,
+): EmbeddingConfig | undefined {
+   const provider = entries.get('provider') as
+      | EmbeddingConfig['provider']
+      | undefined;
+
+   if (!provider) {
+      return undefined;
+   }
+
+   const model = entries.get('model');
+   const endpoint = entries.get('endpoint');
+   const dimensionsRaw = entries.get('dimensions');
+   const dimensions = dimensionsRaw
+      ? parseInt(dimensionsRaw, 10) || undefined
+      : undefined;
+
+   return {
+      provider,
+      ...(model !== undefined ? { model } : {}),
+      ...(endpoint !== undefined ? { endpoint } : {}),
+      ...(dimensions !== undefined ? { dimensions } : {}),
+   };
+}

package/src/shared/worker-daemon/functions/parse-worker-toml.function.ts

@@ -0,0 +1,104 @@
+import type { DaemonConfig } from '../typings/daemon-config.interface.ts';
+import {
+   DEFAULT_ITEM_LIMIT,
+   DEFAULT_INDEX_LIMIT,
+   DEFAULT_TIMEOUT_MS,
+   DEFAULT_ITEM_TTL_MS,
+} from '../constants/daemon-defaults.constant.ts';
+import { parseEmbeddingSection } from './parse-embedding-section.function.ts';
+import { parseAutoCaptureSection } from './parse-auto-capture-section.function.ts';
+
+interface RootAccum {
+   itemLimit: number;
+   indexLimit: number;
+   timeoutMs: number;
+   itemTtlMs: number;
+}
+
+function applyRootKey(
+   acc: RootAccum,
+   key: string,
+   value: string,
+): void {
+   switch (key) {
+      case 'item_limit':
+         acc.itemLimit = parseInt(value, 10) || DEFAULT_ITEM_LIMIT;
+         break;
+      case 'index_limit':
+         acc.indexLimit = parseInt(value, 10) || DEFAULT_INDEX_LIMIT;
+         break;
+      case 'timeout_ms':
+         acc.timeoutMs = parseInt(value, 10) || DEFAULT_TIMEOUT_MS;
+         break;
+      case 'item_ttl_ms':
+         acc.itemTtlMs = parseInt(value, 10) || DEFAULT_ITEM_TTL_MS;
+         break;
+      default:
+         break;
+   }
+}
+
+/**
+ * Parses a `worker.toml` file body into a partial `DaemonConfig`.
+ *
+ * Handles `[embedding]` sub-sections and root key-value pairs.
+ * Unknown keys are silently ignored.
+ *
+ * @param text - raw content of `worker.toml`
+ * @param contextPath - daemon context directory path
+ */
+export function parseWorkerToml(
+   text: string,
+   contextPath: string,
+): DaemonConfig {
+   let section = '';
+   const embeddingEntries = new Map<string, string>();
+   const autoCaptureEntries = new Map<string, string>();
+   const acc: RootAccum = {
+      itemLimit: DEFAULT_ITEM_LIMIT,
+      indexLimit: DEFAULT_INDEX_LIMIT,
+      timeoutMs: DEFAULT_TIMEOUT_MS,
+      itemTtlMs: DEFAULT_ITEM_TTL_MS,
+   };
+
+   for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed === '[embedding]') {
+         section = 'embedding';
+         continue;
+      }
+      if (trimmed === '[auto_capture]') {
+         section = 'auto_capture';
+         continue;
+      }
+      if (trimmed.startsWith('[')) {
+         section = '';
+         continue;
+      }
+      if (trimmed.startsWith('#') || !trimmed.includes('=')) continue;
+      const eqIdx = trimmed.indexOf('=');
+      const key = trimmed.slice(0, eqIdx).trim();
+      const value = trimmed.slice(eqIdx + 1).trim();
+      if (section === 'embedding') {
+         embeddingEntries.set(key, value);
+         continue;
+      }
+      if (section === 'auto_capture') {
+         autoCaptureEntries.set(key, value);
+         continue;
+      }
+      applyRootKey(acc, key, value);
+   }
+
+   const embedding = parseEmbeddingSection(embeddingEntries);
+   const autoCapture =
+      autoCaptureEntries.size > 0
+         ? parseAutoCaptureSection(autoCaptureEntries)
+         : undefined;
+   return {
+      contextPath,
+      ...acc,
+      ...(embedding !== undefined ? { embedding } : {}),
+      ...(autoCapture !== undefined ? { autoCapture } : {}),
+   };
+}