@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/dist/cli-bundle/chunks/{chunk-6HT2F4TK.js → chunk-5IRA6IYD.js}

@@ -1,16 +1,13 @@
-import {
-  resolvePmPackageRootFromModule
-} from "./chunk-EGUGFSNX.js";
 import {
   locateItem,
   readLocatedItem
-} from "./chunk-BUPWJ3IJ.js";
+} from "./chunk-XG7RJYHV.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-WDPXDQFG.js";
+} from "./chunk-4PJQSECJ.js";
 import {
   nowIso
-} from "./chunk-PVNQLCIS.js";
+} from "./chunk-RANZIID5.js";
 import {
   getActiveExtensionRegistrations,
   getSettingsPath,
@@ -19,17 +16,18 @@ import {
   readFileIfExists,
   readSettings,
   removeFileIfExists,
+  resolvePmPackageRootFromModule,
   toErrorMessage,
   toNonEmptyString,
   trimTrailingSlashes,
   writeFileAtomic
-} from "./chunk-LSXGH6NE.js";
+} from "./chunk-SRVKTWPR.js";
 
 // dist/core/search/http-client.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "38ceb1f2-1c32-5e61-9982-cac553c770f4");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "197ad05c-3904-5eed-8de9-def28a40c3f4");
   } catch (e2) {
   }
 })();
@@ -596,7 +594,7 @@ import { basename, dirname, join, resolve } from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "630033f0-5ded-54a9-b9c4-8c28d7c4dd44");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d7830a17-8330-53f9-8d7b-b978e22febf8");
   } catch (e2) {
   }
 })();
@@ -738,6 +736,12 @@ function normalizeVectorDeleteIds(ids) {
 function resolveQdrantDeleteTarget(upsertTarget) {
   return upsertTarget.replace(/\/points\?wait=true$/, "/points/delete?wait=true");
 }
+function buildQdrantJsonHeaders(store) {
+  return {
+    "content-type": "application/json",
+    ...store.api_key ? { "api-key": store.api_key } : {}
+  };
+}
 function getLanceDbLocalTableKey(storePath, table) {
   return getLanceDbSnapshotPath(storePath, table);
 }
@@ -936,10 +940,7 @@ function buildVectorQueryPlan(store, vector, limit) {
     return {
       target,
       method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...store.api_key ? { "api-key": store.api_key } : {}
-      },
+      headers: buildQdrantJsonHeaders(store),
       body: {
         vector: normalizedVector,
         limit: normalizedLimit,
@@ -965,10 +966,7 @@ function buildVectorUpsertPlan(store, records) {
     return {
       target,
       method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...store.api_key ? { "api-key": store.api_key } : {}
-      },
+      headers: buildQdrantJsonHeaders(store),
       body: {
         points: normalizedRecords
       }
@@ -991,10 +989,7 @@ function buildVectorDeletePlan(store, ids) {
     return {
       target,
       method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...store.api_key ? { "api-key": store.api_key } : {}
-      },
+      headers: buildQdrantJsonHeaders(store),
       body: {
         points: normalizedIds
       }
@@ -1414,11 +1409,80 @@ async function scheduleBackgroundSemanticRefresh(pmRoot, itemIds) {
   dispatchRefreshChild(pmRoot);
 }
 
+// dist/core/search/vectorization-metadata.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "918ae1b0-5b96-58f5-b586-3d1dcb074122");
+  } catch (e2) {
+  }
+})();
+function buildVectorizationEmbeddingIdentity(provider, model) {
+  const normalizedProvider = toNonEmptyString(provider);
+  const normalizedModel = toNonEmptyString(model);
+  if (!normalizedProvider || !normalizedModel) {
+    return null;
+  }
+  return {
+    provider: normalizedProvider,
+    model: normalizedModel
+  };
+}
+function normalizeVectorizationEmbeddingMetadata(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Vectorization embedding metadata must be an object when set");
+  }
+  const identity = buildVectorizationEmbeddingIdentity(value.provider, value.model);
+  const vectorDimension = value.vector_dimension;
+  if (!identity || typeof vectorDimension !== "number" || !Number.isInteger(vectorDimension) || vectorDimension <= 0) {
+    throw new Error("Vectorization embedding metadata must include provider, model, and positive vector_dimension");
+  }
+  return {
+    ...identity,
+    vector_dimension: vectorDimension
+  };
+}
+function buildVectorizationEmbeddingMetadata(identity, vectorDimension) {
+  if (!Number.isInteger(vectorDimension) || vectorDimension <= 0) {
+    throw new Error("Vectorization embedding metadata requires a positive vector dimension");
+  }
+  return {
+    provider: identity.provider,
+    model: identity.model,
+    vector_dimension: vectorDimension
+  };
+}
+function hasVectorizationEmbeddingIdentityChanged(metadata, identity) {
+  return !metadata || metadata.provider !== identity.provider || metadata.model !== identity.model;
+}
+function hasVectorizationVectorDimensionChanged(metadata, vectorDimension) {
+  return Boolean(metadata && metadata.vector_dimension !== vectorDimension);
+}
+function inferConsistentVectorDimension(vectors, context) {
+  if (vectors.length === 0) {
+    throw new Error(`${context} returned no vectors`);
+  }
+  const firstVector = vectors[0];
+  const dimension = firstVector.length;
+  if (!Number.isInteger(dimension) || dimension <= 0) {
+    throw new Error(`${context} returned an empty vector`);
+  }
+  for (let index = 1; index < vectors.length; index += 1) {
+    if (vectors[index]?.length !== dimension) {
+      throw new Error(`${context} returned mixed vector dimensions`);
+    }
+  }
+  return dimension;
+}
+
 // dist/core/search/cache.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d04073fd-fa5a-5454-8e71-11bc477005b0");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "5d698c95-b557-5c29-bc3f-caf70b5d6d0f");
   } catch (e2) {
   }
 })();
@@ -1450,6 +1514,7 @@ async function readVectorizationStatusLedger(pmRoot) {
   if (raw === null || raw.trim().length === 0) {
     return {
       entries: {},
+      embedding: null,
       warnings: []
     };
   }
@@ -1459,12 +1524,14 @@ async function readVectorizationStatusLedger(pmRoot) {
   } catch {
     return {
       entries: {},
+      embedding: null,
       warnings: ["search_vectorization_status_ledger_invalid"]
     };
   }
   if (typeof parsed !== "object" || parsed === null || parsed.version !== 1 || !Array.isArray(parsed.items)) {
     return {
       entries: {},
+      embedding: null,
       warnings: ["search_vectorization_status_ledger_invalid"]
     };
   }
@@ -1473,6 +1540,7 @@ async function readVectorizationStatusLedger(pmRoot) {
     if (typeof entry !== "object" || entry === null) {
       return {
         entries: {},
+        embedding: null,
         warnings: ["search_vectorization_status_ledger_invalid"]
       };
     }
@@ -1481,22 +1549,35 @@ async function readVectorizationStatusLedger(pmRoot) {
     if (typeof id !== "string" || id.trim().length === 0 || !isValidUpdatedAt(updatedAt)) {
       return {
         entries: {},
+        embedding: null,
         warnings: ["search_vectorization_status_ledger_invalid"]
       };
     }
     mapped.set(id.trim(), updatedAt);
   }
+  let embedding = null;
+  try {
+    embedding = normalizeVectorizationEmbeddingMetadata(parsed.embedding);
+  } catch {
+    return {
+      entries: {},
+      embedding: null,
+      warnings: ["search_vectorization_status_ledger_invalid"]
+    };
+  }
   return {
     entries: Object.fromEntries([...mapped.entries()].sort((left, right) => left[0].localeCompare(right[0]))),
+    embedding,
     warnings: []
   };
 }
-async function writeVectorizationStatusLedger(pmRoot, entries) {
+async function writeVectorizationStatusLedger(pmRoot, entries, embedding) {
   const normalizedEntries = normalizeVectorizationLedgerEntries(entries);
   const ledgerPath = path2.join(pmRoot, VECTORIZATION_STATUS_LEDGER_PATH);
   const serialized = `${JSON.stringify({
     version: 1,
     generated_at: nowIso(),
+    ...embedding ? { embedding } : {},
     items: Object.entries(normalizedEntries).map(([id, updated_at]) => ({
       id,
       updated_at
@@ -1514,6 +1595,13 @@ function buildVectorPayload(item) {
     updated_at: item.updated_at
   };
 }
+function buildVectorizationIdentityForProvider(provider) {
+  const identity = buildVectorizationEmbeddingIdentity(provider.name, provider.model);
+  if (!identity) {
+    throw new Error("Embedding provider must include a provider name and model");
+  }
+  return identity;
+}
 function buildSkippedSemanticRefreshResult(itemIds, warning) {
   return {
     refreshed: [],
@@ -1576,32 +1664,28 @@ async function collectSemanticRefreshWorkload(pmRoot, idPrefix, preferredFormat,
     warnings
   };
 }
-async function refreshLocatedSemanticVectors(settings, provider, vectorStore, documents) {
-  if (documents.length === 0) {
-    return { refreshed: [], skipped: [], warnings: [] };
-  }
-  try {
-    const corpusInputs = documents.map((entry) => buildSemanticCorpusInput(entry.document, {
-      providerName: provider.name
-    }));
-    const embeddingResult = await executeEmbeddingBatchesWithRetry(provider, settings, corpusInputs);
-    await executeVectorUpsert(vectorStore, documents.map((entry, index) => ({
-      id: entry.id,
-      vector: embeddingResult.vectors[index],
-      payload: buildVectorPayload(entry.document.metadata)
-    })));
-    return {
-      refreshed: documents.map((entry) => entry.id),
-      skipped: [],
-      warnings: embeddingResult.warnings
-    };
-  } catch (error) {
-    return {
-      refreshed: [],
-      skipped: documents.map((entry) => entry.id),
-      warnings: [`search_semantic_refresh_failed:${toErrorMessage(error)}`]
-    };
-  }
+async function embedLocatedSemanticVectors(settings, provider, documents) {
+  const corpusInputs = documents.map((entry) => buildSemanticCorpusInput(entry.document, {
+    providerName: provider.name
+  }));
+  const embeddingResult = await executeEmbeddingBatchesWithRetry(provider, settings, corpusInputs);
+  return {
+    vectors: embeddingResult.vectors,
+    vector_dimension: inferConsistentVectorDimension(embeddingResult.vectors, "Semantic refresh embedding"),
+    warnings: embeddingResult.warnings
+  };
+}
+async function upsertLocatedSemanticVectors(vectorStore, documents, vectors) {
+  await executeVectorUpsert(vectorStore, documents.map((entry, index) => ({
+    id: entry.id,
+    vector: vectors[index],
+    payload: buildVectorPayload(entry.document.metadata)
+  })));
+  return {
+    refreshed: documents.map((entry) => entry.id),
+    skipped: [],
+    warnings: []
+  };
 }
 async function pruneMissingSemanticVectors(vectorStore, missingIds) {
   if (missingIds.length === 0) {
@@ -1657,22 +1741,59 @@ async function refreshSemanticEmbeddingsForMutatedItems(pmRoot, itemIds, options
   }
   const typeRegistry = resolveItemTypeRegistry(runtimeContext.settings, getActiveExtensionRegistrations());
   const workload = await collectSemanticRefreshWorkload(pmRoot, runtimeContext.settings.id_prefix, runtimeContext.settings.item_format, normalizedItemIds, typeRegistry.type_to_folder, runtimeContext.settings.schema);
-  const refreshedResult = await refreshLocatedSemanticVectors(runtimeContext.settings, runtimeContext.provider, runtimeContext.vectorStore, workload.documents);
+  const ledgerRead = workload.documents.length > 0 || workload.missingIds.length > 0 ? await readVectorizationStatusLedger(pmRoot) : { entries: {}, embedding: null, warnings: [] };
+  const embeddingIdentity = buildVectorizationIdentityForProvider(runtimeContext.provider);
+  const nextLedgerBaseEntries = ledgerRead.entries;
+  let refreshedResult = { refreshed: [], skipped: [], warnings: [] };
+  let nextEmbeddingMetadata = ledgerRead.embedding;
+  if (workload.documents.length > 0) {
+    if (ledgerRead.embedding && hasVectorizationEmbeddingIdentityChanged(ledgerRead.embedding, embeddingIdentity)) {
+      refreshedResult = {
+        refreshed: [],
+        skipped: workload.documents.map((entry) => entry.id),
+        warnings: ["search_semantic_refresh_requires_reindex:embedding_identity_changed"]
+      };
+    } else {
+      try {
+        const embedded = await embedLocatedSemanticVectors(runtimeContext.settings, runtimeContext.provider, workload.documents);
+        if (hasVectorizationVectorDimensionChanged(ledgerRead.embedding, embedded.vector_dimension)) {
+          refreshedResult = {
+            refreshed: [],
+            skipped: workload.documents.map((entry) => entry.id),
+            warnings: [...embedded.warnings, "search_semantic_refresh_requires_reindex:vector_dimension_changed"]
+          };
+        } else {
+          nextEmbeddingMetadata = buildVectorizationEmbeddingMetadata(embeddingIdentity, embedded.vector_dimension);
+          const upserted = await upsertLocatedSemanticVectors(runtimeContext.vectorStore, workload.documents, embedded.vectors);
+          refreshedResult = {
+            refreshed: upserted.refreshed,
+            skipped: upserted.skipped,
+            warnings: [...embedded.warnings, ...upserted.warnings]
+          };
+        }
+      } catch (error) {
+        refreshedResult = {
+          refreshed: [],
+          skipped: workload.documents.map((entry) => entry.id),
+          warnings: [`search_semantic_refresh_failed:${toErrorMessage(error)}`]
+        };
+      }
+    }
+  }
   const pruneResult = await pruneMissingSemanticVectors(runtimeContext.vectorStore, workload.missingIds);
   const refreshedIdSet = new Set(refreshedResult.refreshed);
   const refreshedEntries = Object.fromEntries(workload.documents.filter((entry) => refreshedIdSet.has(entry.id)).map((entry) => [entry.id, entry.document.metadata.updated_at]));
   const ledgerWarnings = [];
   if (Object.keys(refreshedEntries).length > 0 || workload.missingIds.length > 0) {
-    const ledgerRead = await readVectorizationStatusLedger(pmRoot);
     const nextEntries = {
-      ...ledgerRead.entries,
+      ...nextLedgerBaseEntries,
       ...normalizeVectorizationLedgerEntries(refreshedEntries)
     };
     for (const missingId of workload.missingIds) {
       delete nextEntries[missingId];
     }
     try {
-      await writeVectorizationStatusLedger(pmRoot, nextEntries);
+      await writeVectorizationStatusLedger(pmRoot, nextEntries, nextEmbeddingMetadata);
     } catch (error) {
       ledgerWarnings.push(`search_vectorization_status_ledger_write_failed:${toErrorMessage(error)}`);
     }
@@ -1767,4 +1888,4 @@ export {
   refreshSemanticEmbeddingsForMutatedItems,
   refreshSearchArtifactsForMutation
 };
-//# sourceMappingURL=chunk-6HT2F4TK.js.map
+//# sourceMappingURL=chunk-5IRA6IYD.js.map