@absolutejs/absolute 0.19.0-beta.497 → 0.19.0-beta.499

package/dist/ai/index.js

@@ -4846,6 +4846,12 @@ var normalizeStringArray2 = (value) => {
 };
 var normalizeChunkingOptions = (value) => isMetadataMap(value) ? value : undefined;
 var getNumericStatus = (status) => typeof status === "number" ? status : HTTP_STATUS_OK;
+var getBooleanProperty = (value, key) => {
+  if (!isObjectRecord(value)) {
+    return;
+  }
+  return typeof value[key] === "boolean" ? value[key] : undefined;
+};
 var isRAGDocumentChunk = (value) => isObjectRecord(value) && typeof value.chunkId === "string" && typeof value.text === "string";
 var isRAGDocument = (value) => isObjectRecord(value) && typeof value.text === "string";
 var isRAGDocumentUrl = (value) => isObjectRecord(value) && typeof value.url === "string" && value.url.trim().length > 0;
@@ -4979,6 +4985,7 @@ var ragChat = (config) => {
   const ingestJobs = [];
   const adminActions = [];
   const adminJobs = [];
+  const syncJobs = [];
   const workflowRenderConfig = typeof config.htmx === "object" ? config.htmx.workflowRender ?? config.htmx.workflow?.render : undefined;
   const workflowRenderers = resolveRAGWorkflowRenderers(workflowRenderConfig);
   const createIngestJob = (inputKind, requestedCount) => {
@@ -5012,13 +5019,14 @@ var ragChat = (config) => {
     job.error = error;
     job.extractorNames = extractorNames;
   };
-  const createAdminAction = (action, documentId) => {
+  const createAdminAction = (action, documentId, target) => {
     const record = {
       action,
       documentId,
       id: generateId(),
       startedAt: Date.now(),
-      status: "completed"
+      status: "completed",
+      target
     };
     adminActions.unshift(record);
     if (adminActions.length > MAX_ADMIN_ACTIONS) {
@@ -5026,7 +5034,7 @@ var ragChat = (config) => {
     }
     return record;
   };
-  const createAdminJob = (action, target) => {
+  const createAdminJob = (action, target, bucket = adminJobs) => {
     const job = {
       action,
       id: generateId(),
@@ -5034,9 +5042,9 @@ var ragChat = (config) => {
       status: "running",
       target
     };
-    adminJobs.unshift(job);
-    if (adminJobs.length > MAX_ADMIN_JOBS) {
-      adminJobs.length = MAX_ADMIN_JOBS;
+    bucket.unshift(job);
+    if (bucket.length > MAX_ADMIN_JOBS) {
+      bucket.length = MAX_ADMIN_JOBS;
     }
     return job;
   };
@@ -5066,6 +5074,12 @@ var ragChat = (config) => {
     job.elapsedMs = finishedAt - job.startedAt;
     job.error = error;
   };
+  const buildSyncSources = async () => {
+    if (!indexManager?.listSyncSources) {
+      return [];
+    }
+    return await indexManager.listSyncSources();
+  };
   const toHTMXResponse = (html, status, extraHeaders) => new Response(html, {
     headers: {
       ...HTML_HEADERS,
@@ -5501,6 +5515,12 @@ var ragChat = (config) => {
       }
       failuresByAdminAction.set(job.action, (failuresByAdminAction.get(job.action) ?? 0) + 1);
     }
+    for (const job of syncJobs) {
+      if (job.status !== "failed") {
+        continue;
+      }
+      failuresByAdminAction.set(job.action, (failuresByAdminAction.get(job.action) ?? 0) + 1);
+    }
     return {
       averageChunksPerDocument: documents.length > 0 ? Number((documents.reduce((sum, document) => sum + (document.chunkCount ?? 0), 0) / documents.length).toFixed(2)) : 0,
       duplicateDocumentIds: [...documentIdCounts.entries()].filter(([, count]) => count > 1).map(([id]) => id),
@@ -5546,10 +5566,13 @@ var ragChat = (config) => {
     canClearIndex: Boolean(ragStore?.clear),
     canCreateDocument: Boolean(indexManager?.createDocument),
     canDeleteDocument: Boolean(indexManager?.deleteDocument),
+    canListSyncSources: Boolean(indexManager?.listSyncSources),
     canReindexDocument: Boolean(indexManager?.reindexDocument),
     canReindexSource: Boolean(indexManager?.reindexSource),
     canReseed: Boolean(indexManager?.reseed),
-    canReset: Boolean(indexManager?.reset)
+    canReset: Boolean(indexManager?.reset),
+    canSyncAllSources: Boolean(indexManager?.syncAllSources),
+    canSyncSource: Boolean(indexManager?.syncSource)
   });
   const buildOperationsPayload = async () => {
     const collection = config.collection ?? (ragStore ? createRAGCollection({
@@ -5562,14 +5585,15 @@ var ragChat = (config) => {
     return {
       admin: buildAdminCapabilities(),
       adminActions: [...adminActions],
-      adminJobs: [...adminJobs],
+      adminJobs: [...adminJobs, ...syncJobs].sort((left, right) => right.startedAt - left.startedAt),
       capabilities: collection?.getCapabilities?.(),
       documents: indexManager ? summarizeDocuments(indexedDocuments) : undefined,
       health: await summarizeHealth(indexedDocuments),
       ingestJobs: [...ingestJobs],
       ok: true,
       readiness: buildReadiness(),
-      status: collection?.getStatus?.()
+      status: collection?.getStatus?.(),
+      syncSources: await buildSyncSources()
     };
   };
   const handleStatus = async () => buildOperationsPayload();
@@ -5806,6 +5830,100 @@ var ragChat = (config) => {
       ...normalized
     };
   };
+  const handleSyncSources = async () => {
+    if (!indexManager?.listSyncSources) {
+      return {
+        error: "RAG source sync is not configured",
+        ok: false
+      };
+    }
+    return {
+      ok: true,
+      sources: await indexManager.listSyncSources()
+    };
+  };
+  const handleSyncAllSources = async (options) => {
+    if (!indexManager?.syncAllSources) {
+      return {
+        error: "RAG source sync is not configured",
+        ok: false
+      };
+    }
+    const job = createAdminJob("sync_all_sources", undefined, syncJobs);
+    const action = createAdminAction("sync_all_sources");
+    try {
+      const result = await indexManager.syncAllSources(options);
+      if (result && "ok" in result) {
+        if (!result.ok) {
+          failAdminJob(job, result.error);
+          failAdminAction(action, result.error);
+          return result;
+        }
+        if (result.partial) {
+          const failedSourceIds = "sources" in result ? result.failedSourceIds : undefined;
+          const message = failedSourceIds?.length ? `Partial source sync failure: ${failedSourceIds.join(", ")}` : "Partial source sync failure";
+          failAdminJob(job, message);
+          failAdminAction(action, message);
+          return result;
+        }
+        completeAdminJob(job);
+        completeAdminAction(action);
+        return result;
+      }
+      completeAdminJob(job);
+      completeAdminAction(action);
+      return {
+        ok: true,
+        sources: await buildSyncSources()
+      };
+    } catch (caught) {
+      const message = caught instanceof Error ? caught.message : String(caught);
+      failAdminJob(job, message);
+      failAdminAction(action, message);
+      throw caught;
+    }
+  };
+  const handleSyncSource = async (id, options) => {
+    if (!indexManager?.syncSource) {
+      return {
+        error: "RAG source sync is not configured",
+        ok: false
+      };
+    }
+    if (!id) {
+      return {
+        error: "sync source id is required",
+        ok: false
+      };
+    }
+    const job = createAdminJob("sync_source", id, syncJobs);
+    const action = createAdminAction("sync_source", undefined, id);
+    try {
+      const result = await indexManager.syncSource(id, options);
+      if (result && "ok" in result) {
+        if (!result.ok) {
+          failAdminJob(job, result.error);
+          failAdminAction(action, result.error);
+          return result;
+        }
+        completeAdminJob(job);
+        completeAdminAction(action);
+        return result;
+      }
+      completeAdminJob(job);
+      completeAdminAction(action);
+      const source = (await buildSyncSources()).find((record) => record.id === id);
+      return source ? { ok: true, source } : {
+        error: "sync source not found",
+        ok: false
+      };
+    } catch (caught) {
+      const message = caught instanceof Error ? caught.message : String(caught);
+      failAdminJob(job, message);
+      failAdminAction(action, message);
+      throw caught;
+    }
+  };
   const htmxRoutes = () => {
     if (!config.htmx) {
       return new Elysia2;
@@ -6042,6 +6160,53 @@ var ragChat = (config) => {
       set.status = HTTP_STATUS_NOT_FOUND;
     }
     return result;
+  }).get(`${path}/sync`, async ({ request, set }) => {
+    const result = await handleSyncSources();
+    if (!result.ok) {
+      set.status = HTTP_STATUS_NOT_FOUND;
+    }
+    if (config.htmx && isHTMXRequest(request)) {
+      if (!result.ok) {
+        return toHTMXResponse(workflowRenderers.error(result.error), getNumericStatus(set.status));
+      }
+      return toHTMXResponse(workflowRenderers.mutationResult({
+        ok: true,
+        status: `loaded ${"sources" in result ? result.sources.length : 1} sync sources`
+      }));
+    }
+    return result;
+  }).post(`${path}/sync`, async ({ body, request, set }) => {
+    const background = getBooleanProperty(body, "background");
+    const result = await handleSyncAllSources({ background });
+    if (!result.ok) {
+      set.status = HTTP_STATUS_NOT_FOUND;
+    }
+    if (config.htmx && isHTMXRequest(request)) {
+      const html = result.ok ? workflowRenderers.mutationResult({
+        ok: true,
+        status: background === true ? "source sync queued in the background" : "source sync started and completed successfully"
+      }) : workflowRenderers.error(result.error ?? "Failed to sync sources");
+      return toHTMXResponse(html, getNumericStatus(set.status), {
+        "HX-Trigger": "rag:mutated"
+      });
+    }
+    return result;
+  }).post(`${path}/sync/:id`, async ({ body, params, request, set }) => {
+    const background = getBooleanProperty(body, "background");
+    const result = await handleSyncSource(typeof params.id === "string" ? params.id.trim() : "", { background });
+    if (!result.ok) {
+      set.status = result.error === "sync source id is required" ? HTTP_STATUS_BAD_REQUEST : HTTP_STATUS_NOT_FOUND;
+    }
+    if (config.htmx && isHTMXRequest(request)) {
+      const html = result.ok ? workflowRenderers.mutationResult({
+        ok: true,
+        status: background === true ? "source sync queued in the background" : "source sync started and completed successfully"
+      }) : workflowRenderers.error(result.error ?? "Failed to sync source");
+      return toHTMXResponse(html, getNumericStatus(set.status), {
+        "HX-Trigger": "rag:mutated"
+      });
+    }
+    return result;
   }).post(`${path}/ingest`, async ({ body, request, set }) => {
     const result = await handleIngest(body);
     if (!result.ok) {
@@ -7020,6 +7185,436 @@ var resolveRAGStreamStage = ({
   }
   return "streaming";
 };
+// src/ai/rag/sync.ts
+import { createHash } from "crypto";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname, resolve as resolve2 } from "path";
+var toSyncError = (caught) => caught instanceof Error ? caught.message : String(caught);
+var wait = async (delayMs) => {
+  if (!(delayMs > 0)) {
+    return;
+  }
+  await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+};
+var parseSyncState = (content) => {
+  try {
+    const parsed = JSON.parse(content);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+};
+var createSyncFingerprint = (document) => createHash("sha1").update(document.source ?? "").update(`
+`).update(document.title ?? "").update(`
+`).update(document.text).digest("hex");
+var toManagedSyncDocument = (sourceId, document, syncKey) => ({
+  ...document,
+  metadata: {
+    ...document.metadata ?? {},
+    syncFingerprint: createSyncFingerprint(document),
+    syncKey,
+    syncSourceId: sourceId
+  }
+});
+var isManagedBySyncSource = (document, sourceId) => document.metadata?.syncSourceId === sourceId;
+var getDocumentSyncFingerprint = (document) => typeof document.metadata?.syncFingerprint === "string" ? document.metadata.syncFingerprint : undefined;
+var reconcileManagedDocuments = async (input) => {
+  const prepared = prepareRAGDocuments({
+    documents: input.documents
+  });
+  const nextDocumentIds = new Set(prepared.map((document) => document.documentId));
+  const nextFingerprintById = new Map(prepared.map((document, index) => [
+    document.documentId,
+    createSyncFingerprint(input.documents[index])
+  ]));
+  const existingDocuments = input.listDocuments ? await input.listDocuments() : [];
+  const managedDocuments = existingDocuments.filter((document) => isManagedBySyncSource(document, input.sourceId));
+  const staleDocuments = managedDocuments.filter((document) => !nextDocumentIds.has(document.id));
+  const changedPrepared = prepared.filter((document) => {
+    const existing = managedDocuments.find((entry) => entry.id === document.documentId);
+    if (!existing) {
+      return true;
+    }
+    return getDocumentSyncFingerprint(existing) !== nextFingerprintById.get(document.documentId);
+  });
+  if (input.deleteDocument) {
+    await Promise.all(staleDocuments.map(async (document) => {
+      await input.deleteDocument?.(document.id);
+    }));
+  }
+  if (changedPrepared.length > 0) {
+    await input.collection.ingest({
+      chunks: changedPrepared.flatMap((document) => document.chunks)
+    });
+  }
+  return {
+    chunkCount: prepared.reduce((sum, document) => sum + document.chunks.length, 0),
+    deletedCount: staleDocuments.length,
+    documentCount: prepared.length,
+    updatedCount: changedPrepared.length
+  };
+};
+var toSourceRecord = (source, overrides) => ({
+  description: source.description,
+  id: source.id,
+  kind: source.kind,
+  label: source.label,
+  metadata: source.metadata,
+  status: "idle",
+  target: source.target,
+  ...overrides
+});
+var createRAGDirectorySyncSource = (options) => ({
+  description: options.description,
+  id: options.id,
+  kind: "directory",
+  label: options.label,
+  metadata: options.metadata,
+  retryAttempts: options.retryAttempts,
+  retryDelayMs: options.retryDelayMs,
+  target: options.directory,
+  sync: async ({ collection, deleteDocument, listDocuments }) => {
+    const loaded = await loadRAGDocumentsFromDirectory({
+      baseMetadata: options.baseMetadata,
+      defaultChunking: options.defaultChunking,
+      directory: options.directory,
+      extractors: options.extractors,
+      includeExtensions: options.includeExtensions,
+      recursive: options.recursive
+    });
+    const managedDocuments = loaded.documents.map((document) => toManagedSyncDocument(options.id, document, typeof document.metadata?.relativePath === "string" ? document.metadata.relativePath : document.source ?? document.title ?? ""));
+    const reconciled = await reconcileManagedDocuments({
+      collection,
+      deleteDocument,
+      documents: managedDocuments,
+      listDocuments,
+      sourceId: options.id
+    });
+    return {
+      chunkCount: reconciled.chunkCount,
+      documentCount: reconciled.documentCount,
+      metadata: {
+        deletedCount: reconciled.deletedCount,
+        directory: options.directory,
+        recursive: options.recursive !== false,
+        updatedCount: reconciled.updatedCount
+      }
+    };
+  }
+});
+var createRAGUrlSyncSource = (options) => ({
+  description: options.description,
+  id: options.id,
+  kind: "url",
+  label: options.label,
+  metadata: options.metadata,
+  retryAttempts: options.retryAttempts,
+  retryDelayMs: options.retryDelayMs,
+  target: options.urls.length === 1 ? options.urls[0]?.url : `${options.urls.length} urls`,
+  sync: async ({ collection, deleteDocument, listDocuments }) => {
+    const loaded = await loadRAGDocumentsFromURLs({
+      baseMetadata: options.baseMetadata,
+      defaultChunking: options.defaultChunking,
+      extractors: options.extractors,
+      urls: options.urls
+    });
+    const managedDocuments = loaded.documents.map((document) => toManagedSyncDocument(options.id, document, typeof document.metadata?.sourceUrl === "string" ? document.metadata.sourceUrl : document.source ?? document.title ?? ""));
+    const reconciled = await reconcileManagedDocuments({
+      collection,
+      deleteDocument,
+      documents: managedDocuments,
+      listDocuments,
+      sourceId: options.id
+    });
+    return {
+      chunkCount: reconciled.chunkCount,
+      documentCount: reconciled.documentCount,
+      metadata: {
+        deletedCount: reconciled.deletedCount,
+        updatedCount: reconciled.updatedCount,
+        urlCount: options.urls.length
+      }
+    };
+  }
+});
+var createRAGSyncManager = (options) => {
+  const sourceMap = new Map(options.sources.map((source) => [source.id, source]));
+  const state = new Map(options.sources.map((source) => [source.id, toSourceRecord(source)]));
+  const activeRuns = new Map;
+  let hydrationPromise = null;
+  const persistState = async () => {
+    if (!options.saveState) {
+      return;
+    }
+    await options.saveState([...state.values()]);
+  };
+  const ensureHydrated = async () => {
+    if (!options.loadState) {
+      return;
+    }
+    if (!hydrationPromise) {
+      hydrationPromise = Promise.resolve(options.loadState()).then((records) => {
+        for (const record of records ?? []) {
+          const source = sourceMap.get(record.id);
+          if (!source) {
+            continue;
+          }
+          state.set(record.id, toSourceRecord(source, {
+            ...record,
+            metadata: {
+              ...source.metadata ?? {},
+              ...record.metadata ?? {}
+            }
+          }));
+        }
+      });
+    }
+    await hydrationPromise;
+  };
+  const resolveRetryAttempts = (source) => Math.max(0, source.retryAttempts ?? options.retryAttempts ?? 0);
+  const resolveRetryDelayMs = (source) => Math.max(0, source.retryDelayMs ?? options.retryDelayMs ?? 0);
+  const setSourceState = async (record) => {
+    state.set(record.id, record);
+    await persistState();
+  };
+  const runSource = async (source) => {
+    await ensureHydrated();
+    const existingRun = activeRuns.get(source.id);
+    if (existingRun) {
+      return existingRun;
+    }
+    const previous = state.get(source.id);
+    const retryAttempts = resolveRetryAttempts(source);
+    const retryDelayMs = resolveRetryDelayMs(source);
+    const startedAt = Date.now();
+    const running = toSourceRecord(source, {
+      chunkCount: previous?.chunkCount,
+      consecutiveFailures: previous?.consecutiveFailures ?? 0,
+      documentCount: previous?.documentCount,
+      lastError: undefined,
+      lastStartedAt: startedAt,
+      lastSuccessfulSyncAt: previous?.lastSuccessfulSyncAt,
+      lastSyncedAt: previous?.lastSyncedAt,
+      lastSyncDurationMs: previous?.lastSyncDurationMs,
+      nextRetryAt: undefined,
+      retryAttempts,
+      status: "running"
+    });
+    const runPromise = (async () => {
+      await setSourceState(running);
+      for (let attempt = 0;attempt <= retryAttempts; attempt++) {
+        try {
+          const result = await source.sync({
+            collection: options.collection,
+            deleteDocument: options.deleteDocument,
+            listDocuments: options.listDocuments
+          });
+          const finishedAt = Date.now();
+          const completed = toSourceRecord(source, {
+            chunkCount: result.chunkCount,
+            consecutiveFailures: 0,
+            documentCount: result.documentCount,
+            lastError: undefined,
+            lastStartedAt: startedAt,
+            lastSuccessfulSyncAt: finishedAt,
+            lastSyncedAt: finishedAt,
+            lastSyncDurationMs: finishedAt - startedAt,
+            metadata: result.metadata === undefined ? source.metadata : {
+              ...source.metadata ?? {},
+              ...result.metadata
+            },
+            nextRetryAt: undefined,
+            retryAttempts,
+            status: "completed"
+          });
+          await setSourceState(completed);
+          return completed;
+        } catch (caught) {
+          const message = toSyncError(caught);
+          const finishedAt = Date.now();
+          const hasRetriesRemaining = attempt < retryAttempts;
+          const consecutiveFailures = (previous?.consecutiveFailures ?? 0) + attempt + 1;
+          const failed = toSourceRecord(source, {
+            chunkCount: previous?.chunkCount,
+            consecutiveFailures,
+            documentCount: previous?.documentCount,
+            lastError: message,
+            lastStartedAt: startedAt,
+            lastSuccessfulSyncAt: previous?.lastSuccessfulSyncAt,
+            lastSyncedAt: finishedAt,
+            lastSyncDurationMs: finishedAt - startedAt,
+            nextRetryAt: hasRetriesRemaining ? finishedAt + retryDelayMs : undefined,
+            retryAttempts,
+            status: "failed"
+          });
+          await setSourceState(failed);
+          if (!hasRetriesRemaining) {
+            return failed;
+          }
+          await wait(retryDelayMs);
+        }
+      }
+      return state.get(source.id) ?? toSourceRecord(source, { status: "failed" });
+    })().finally(() => {
+      activeRuns.delete(source.id);
+    });
+    activeRuns.set(source.id, runPromise);
+    return runPromise;
+  };
+  const resolveBackground = (runOptions) => runOptions?.background ?? options.backgroundByDefault ?? false;
+  return {
+    listSyncSources: async () => {
+      await ensureHydrated();
+      return [...state.values()];
+    },
+    syncAllSources: async (runOptions) => {
+      await ensureHydrated();
+      if (resolveBackground(runOptions)) {
+        for (const source of options.sources) {
+          runSource(source);
+        }
+        return {
+          ok: true,
+          sources: [...state.values()]
+        };
+      }
+      const sources = [];
+      const failedSourceIds = [];
+      const errorsBySource = {};
+      for (const source of options.sources) {
+        const record = await runSource(source);
+        sources.push(record);
+        if (record.status === "failed") {
+          failedSourceIds.push(record.id);
+          if (record.lastError) {
+            errorsBySource[record.id] = record.lastError;
+          }
+          if (options.continueOnError === false) {
+            return {
+              errorsBySource,
+              failedSourceIds,
+              ok: true,
+              partial: true,
+              sources
+            };
+          }
+        }
+      }
+      return {
+        errorsBySource: failedSourceIds.length > 0 ? errorsBySource : undefined,
+        failedSourceIds: failedSourceIds.length > 0 ? failedSourceIds : undefined,
+        ok: true,
+        partial: failedSourceIds.length > 0,
+        sources
+      };
+    },
+    syncSource: async (id, runOptions) => {
+      await ensureHydrated();
+      const source = sourceMap.get(id);
+      if (!source) {
+        return {
+          error: `RAG sync source ${id} is not configured`,
+          ok: false
+        };
+      }
+      if (resolveBackground(runOptions)) {
+        const existingRecord = state.get(id);
+        if (existingRecord?.status !== "running") {
+          const running = toSourceRecord(source, {
+            chunkCount: existingRecord?.chunkCount,
+            consecutiveFailures: existingRecord?.consecutiveFailures ?? 0,
+            documentCount: existingRecord?.documentCount,
+            lastError: undefined,
+            lastStartedAt: Date.now(),
+            lastSuccessfulSyncAt: existingRecord?.lastSuccessfulSyncAt,
+            lastSyncedAt: existingRecord?.lastSyncedAt,
+            lastSyncDurationMs: existingRecord?.lastSyncDurationMs,
+            nextRetryAt: undefined,
+            retryAttempts: resolveRetryAttempts(source),
+            status: "running"
+          });
+          await setSourceState(running);
+          runSource(source);
+        }
+        return {
+          ok: true,
+          source: state.get(id) ?? toSourceRecord(source, {
+            status: "running"
+          })
+        };
+      }
+      const record = await runSource(source);
+      if (record.status === "failed") {
+        return {
+          error: record.lastError ?? `RAG sync source ${id} failed`,
+          ok: false
+        };
+      }
+      return {
+        ok: true,
+        source: record
+      };
+    }
+  };
+};
+var createRAGFileSyncStateStore = (path) => {
+  const resolvedPath = resolve2(path);
+  return {
+    load: async () => {
+      try {
+        return parseSyncState(await readFile2(resolvedPath, "utf8"));
+      } catch {
+        return [];
+      }
+    },
+    save: async (records) => {
+      await mkdir(dirname(resolvedPath), { recursive: true });
+      await writeFile(resolvedPath, JSON.stringify(records, null, 2), "utf8");
+    }
+  };
+};
+var createRAGSyncScheduler = (input) => {
+  const timers = new Map;
+  let running = false;
+  const runSchedule = async (schedule) => {
+    if (schedule.sourceIds?.length) {
+      for (const sourceId of schedule.sourceIds) {
+        await input.manager.syncSource?.(sourceId, {
+          background: schedule.background
+        });
+      }
+      return;
+    }
+    await input.manager.syncAllSources?.({
+      background: schedule.background
+    });
+  };
+  return {
+    start: async () => {
+      if (running) {
+        return;
+      }
+      running = true;
+      for (const schedule of input.schedules) {
+        if (schedule.runImmediately) {
+          runSchedule(schedule);
+        }
+        timers.set(schedule.id, setInterval(() => {
+          runSchedule(schedule);
+        }, schedule.intervalMs));
+      }
+    },
+    stop: () => {
+      for (const timer of timers.values()) {
+        clearInterval(timer);
+      }
+      timers.clear();
+      running = false;
+    },
+    isRunning: () => running,
+    listSchedules: () => [...input.schedules]
+  };
+};
 // src/ai/rag/adapters/utils.ts
 var vectorDimensionDefault = 24;
 var createRAGVector = (text, dimensions = vectorDimensionDefault) => {
@@ -7178,7 +7773,7 @@ import { existsSync as existsSync2 } from "fs";
 import { existsSync, readFileSync } from "fs";
 import { createRequire } from "module";
 import { arch, platform } from "os";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 var require2 = createRequire(import.meta.url);
 var PLATFORM_PACKAGE_MAP = {
   "darwin-arm64": {
@@ -7229,7 +7824,7 @@ var resolveAbsoluteSQLiteVec = () => {
   }
   try {
     const packageJsonPath = require2.resolve(`${packageInfo.packageName}/package.json`);
-    const packageRoot = dirname(packageJsonPath);
+    const packageRoot = dirname2(packageJsonPath);
     const libraryPath = join2(packageRoot, packageInfo.libraryFile);
     const packageVersion = readPackageVersion(packageJsonPath);
     if (!existsSync(libraryPath)) {
@@ -8760,6 +9355,41 @@ var createRAGClient = (options) => {
       }
       return parseJson(response);
     },
+    async syncSources() {
+      const response = await fetchImpl(`${basePath}/sync`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage3(response));
+      }
+      return parseJson(response);
+    },
+    async syncAllSources(options2) {
+      const response = await fetchImpl(`${basePath}/sync`, {
+        body: options2?.background === true ? JSON.stringify({ background: true }) : undefined,
+        headers: options2?.background === true ? jsonHeaders : undefined,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage3(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async syncSource(id, options2) {
+      const response = await fetchImpl(`${basePath}/sync/${encodeURIComponent(id)}`, {
+        body: options2?.background === true ? JSON.stringify({ background: true }) : undefined,
+        headers: options2?.background === true ? jsonHeaders : undefined,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage3(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
     async reindexDocument(id) {
       const response = await fetchImpl(`${basePath}/reindex/documents/${encodeURIComponent(id)}`, {
         method: "POST"
@@ -8902,7 +9532,10 @@ export {
   createTextFileExtractor,
   createSQLiteRAGStore,
   createRAGVector,
+  createRAGUrlSyncSource,
   createAIStream as createRAGTransport,
+  createRAGSyncScheduler,
+  createRAGSyncManager,
   createRAGReranker,
   createRAGQueryTransform,
   createRAGPDFOCRExtractor,
@@ -8912,9 +9545,11 @@ export {
   createRAGImageOCRExtractor,
   createRAGHTMXWorkflowRenderConfig,
   createRAGHTMXConfig,
+  createRAGFileSyncStateStore,
   createRAGFileExtractor,
   createRAGEvaluationSuite,
   createRAGEmbeddingProvider,
+  createRAGDirectorySyncSource,
   createRAGCollection,
   createRAGClient,
   createRAGArchiveFileExtractor,
@@ -8955,5 +9590,5 @@ export {
   aiChat
 };
 
-//# debugId=55FD05298CEAFBDB64756E2164756E21
+//# debugId=61173B84573291CC64756E2164756E21
 //# sourceMappingURL=index.js.map