@unbrained/pm-cli 2026.6.19 → 2026.6.21

package/dist/cli-bundle/chunks/{search-AZR2JITW.js → chunk-2PKHRP6G.js}

@@ -5,22 +5,25 @@ import {
   buildEventCorpus,
   buildPlanFlatCorpus,
   buildReminderCorpus,
+  buildSearchCorpus,
   executeEmbeddingRequest,
   executeVectorQuery,
   readVectorizationStatusLedger,
   resolveEmbeddingProviders,
+  resolveSearchCorpusFields,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-NNMBNN6Q.js";
+} from "./chunk-NB3PYLQ6.js";
 import {
   buildContentFilterEcho,
   buildGovernanceMissingFilterEcho,
   collectRuntimeFilterValues,
+  isStatusAllFilterInput,
   matchesRuntimeFilters,
   parseStatusFilterCsv,
   resolveContentFieldFilters,
   resolveMissingMetadataFilters
-} from "./chunk-4BFNWAMQ.js";
+} from "./chunk-6ZXM2XNF.js";
 import {
   hasContentFieldFilter,
   itemMatchesContentFilters
@@ -29,31 +32,30 @@ import {
   hasMissingMetadataFilter,
   itemMatchesMissingMetadata,
   lifecycleClassifierFromStatusRegistry
-} from "./chunk-USKTNI7P.js";
+} from "./chunk-NIGXMNNI.js";
 import {
   parseLimit,
   parsePriority,
   parseType
-} from "./chunk-DYZKSIVX.js";
+} from "./chunk-B473GZWW.js";
 import {
   collectRegisteredItemFieldNames,
   listAllDocumentCandidatesCached,
   listAllFrontMatter,
   toItemRecord
-} from "./chunk-X7RKOJXL.js";
-import "./chunk-5NS6TJ2F.js";
+} from "./chunk-SX75ADBK.js";
 import {
   isTerminalStatus,
   parseItemDocument
-} from "./chunk-QSH34DSQ.js";
+} from "./chunk-QGG32QHW.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-SO2IOH37.js";
+} from "./chunk-FRUFKWNK.js";
 import {
   compareTimestampStrings,
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-MTGMNUMJ.js";
+} from "./chunk-YCJX76PW.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -72,7 +74,7 @@ import {
   runActiveOnReadHooks,
   toNonEmptyString,
   toNonEmptyStringOrUndefined
-} from "./chunk-5QLHQK7V.js";
+} from "./chunk-HMOADQVT.js";
 
 // dist/cli/commands/search.js
 import fs from "node:fs/promises";
@@ -337,11 +339,124 @@ async function rerankCandidatesWithEmbeddings(provider, model, query, candidates
   return scoreById;
 }
 
+// dist/core/search/bm25.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] = "57c1eb74-63b5-5208-abe1-98da8308839d");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_BM25_K1 = 1.2;
+var DEFAULT_BM25_B = 0.75;
+function tokenizeBm25(text) {
+  return tokenizeAlphaNumeric(text);
+}
+function buildTermFrequencies(tokens) {
+  const frequencies = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+  }
+  return frequencies;
+}
+function buildBm25Index(documents) {
+  const stats = [];
+  const documentFrequency = /* @__PURE__ */ new Map();
+  let totalLength = 0;
+  for (const document of documents) {
+    const tokens = tokenizeBm25(document.text);
+    const termFrequencies = buildTermFrequencies(tokens);
+    totalLength += tokens.length;
+    for (const term of termFrequencies.keys()) {
+      documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
+    }
+    stats.push({ id: document.id, termFrequencies, length: tokens.length });
+  }
+  const documentCount = stats.length;
+  return {
+    documents: stats,
+    documentFrequency,
+    documentCount,
+    averageDocumentLength: documentCount > 0 ? totalLength / documentCount : 0
+  };
+}
+function inverseDocumentFrequency(documentCount, termDocumentFrequency) {
+  return Math.log(1 + (documentCount - termDocumentFrequency + 0.5) / (termDocumentFrequency + 0.5));
+}
+function scoreBm25Query(index, queryTokens, params) {
+  const scores = /* @__PURE__ */ new Map();
+  if (index.documentCount === 0 || index.averageDocumentLength === 0) {
+    return scores;
+  }
+  const distinctQueryTerms = [...new Set(queryTokens.filter((token) => token.length > 0))];
+  if (distinctQueryTerms.length === 0) {
+    return scores;
+  }
+  const idfByTerm = /* @__PURE__ */ new Map();
+  for (const term of distinctQueryTerms) {
+    const termDocumentFrequency = index.documentFrequency.get(term);
+    if (termDocumentFrequency === void 0) {
+      continue;
+    }
+    idfByTerm.set(term, inverseDocumentFrequency(index.documentCount, termDocumentFrequency));
+  }
+  if (idfByTerm.size === 0) {
+    return scores;
+  }
+  for (const document of index.documents) {
+    let score = 0;
+    for (const [term, idf] of idfByTerm) {
+      const termFrequency = document.termFrequencies.get(term);
+      if (termFrequency === void 0) {
+        continue;
+      }
+      const lengthNormalization = 1 - params.b + params.b * document.length / index.averageDocumentLength;
+      const denominator = termFrequency + params.k1 * lengthNormalization;
+      score += idf * (termFrequency * (params.k1 + 1) / denominator);
+    }
+    if (score > 0) {
+      scores.set(document.id, score);
+    }
+  }
+  return scores;
+}
+function resolveClampedParam(candidate, fallback, min, max) {
+  if (typeof candidate !== "number" || !Number.isFinite(candidate)) {
+    return fallback;
+  }
+  return Math.min(max, Math.max(min, candidate));
+}
+function flattenSearchCorpusText(corpus) {
+  const collectValueText = (value) => {
+    if (typeof value === "string") {
+      return [value];
+    }
+    if (typeof value === "number") {
+      return [String(value)];
+    }
+    if (Array.isArray(value)) {
+      return value.flatMap(collectValueText);
+    }
+    if (typeof value === "object" && value !== null) {
+      return Object.values(value).flatMap(collectValueText);
+    }
+    return [];
+  };
+  return collectValueText(Object.values(corpus)).join(" ");
+}
+function resolveBm25Params(settings) {
+  const bm25 = settings?.search?.bm25;
+  return {
+    k1: resolveClampedParam(bm25?.k1, DEFAULT_BM25_K1, 0, 1e3),
+    b: resolveClampedParam(bm25?.b, DEFAULT_BM25_B, 0, 1)
+  };
+}
+
 // dist/cli/commands/search.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] = "606dd777-967e-5059-86cf-4766b2a3ce55");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "717039d4-aae7-5501-9069-971b51a36c49");
   } catch (e2) {
   }
 })();
@@ -431,7 +546,7 @@ function buildCompactSearchFilterSummary(params) {
   const { mode, matchMode, options, includeLinked, titleExact, phraseExact, scoreThreshold, hybridSemanticWeight, runtimeFieldFilters } = params;
   const filters = {};
   if (options.status !== void 0) {
-    filters.status = options.status;
+    filters.status = isStatusAllFilterInput(options.status) ? "all" : options.status;
   }
   if (options.type !== void 0) {
     filters.type = options.type;
@@ -505,7 +620,7 @@ function buildVerboseSearchFilters(params) {
   return {
     mode: effectiveMode,
     match_mode: matchMode,
-    status: options.status ?? null,
+    status: isStatusAllFilterInput(options.status) ? "all" : options.status ?? null,
     type: options.type ?? null,
     tag: options.tag ?? null,
     priority: options.priority ?? null,
@@ -708,7 +823,9 @@ var _testOnlySearchCommand = {
   collectExactPhraseFields,
   collectLinkedPaths,
   combineHybridHits,
+  computeBuiltInBm25Hits,
   computeSemanticOrHybridHits,
+  resolveBuiltInBm25Mode,
   countOccurrences,
   dependencyEntries,
   documentContainsExactPhrase,
@@ -1080,9 +1197,10 @@ function buildHitHighlights(document, matchedFields, tokens) {
 }
 function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning, idPrefix, applyCoverageBonus = false) {
   const item = document.metadata;
-  const normalizedId = item.id.trim().toLowerCase();
+  const normalizedId = normalizeSearchPhrase(item.id);
   const normalizedIdPrefix = typeof idPrefix === "string" ? idPrefix.trim().toLowerCase() : "";
-  const normalizedShortId = normalizedIdPrefix.length > 0 && normalizedId.startsWith(normalizedIdPrefix) ? normalizedId.slice(normalizedIdPrefix.length) : normalizedId;
+  const normalizedIdPrefixPhrase = normalizeSearchPhrase(normalizedIdPrefix);
+  const normalizedShortId = normalizedIdPrefixPhrase.length > 0 && normalizedId.startsWith(normalizedIdPrefixPhrase) ? normalizedId.slice(normalizedIdPrefixPhrase.length).trim() : normalizedId;
   if (normalizedQuery === normalizedId || normalizedQuery === normalizedShortId) {
     return {
       item,
@@ -1448,7 +1566,7 @@ function forceExactIdHitsToTop(rankedHits, keywordHits) {
   }));
   return [...promoted, ...remaining];
 }
-function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSemanticWeight) {
+function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSemanticWeight, semanticFieldLabel = "semantic") {
   const keywordScores = new Map(keywordHits.map((entry) => [entry.item.id, entry.score]));
   const keywordMatches = new Map(keywordHits.map((entry) => [entry.item.id, entry.matched_fields]));
   const normalizedSemantic = normalizeScoreMap(semanticScores);
@@ -1465,7 +1583,7 @@ function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSema
     }
     const matchedFields = /* @__PURE__ */ new Set();
     if (semanticScores.has(id)) {
-      matchedFields.add("semantic");
+      matchedFields.add(semanticFieldLabel);
     }
     for (const field of keywordMatches.get(id) ?? []) {
       matchedFields.add(field);
@@ -1477,6 +1595,35 @@ function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSema
     };
   }).filter((entry) => entry !== null);
 }
+function resolveBuiltInBm25Mode(params) {
+  const normalized = params.configuredProvider?.trim().toLowerCase();
+  if (normalized === "bm25") {
+    return "explicit";
+  }
+  if (normalized === "auto" && !params.hasEmbeddingProvider && !params.hasExtensionSearchProvider) {
+    return "auto-fallback";
+  }
+  return null;
+}
+function computeBuiltInBm25Hits(params) {
+  const bm25Documents = params.filteredDocuments.map((document) => ({
+    id: document.metadata.id,
+    text: flattenSearchCorpusText(buildSearchCorpus(document, { fields: params.corpusFields }))
+  }));
+  const index = buildBm25Index(bm25Documents);
+  const bm25Scores = scoreBm25Query(index, tokenizeBm25(params.query), params.bm25Params);
+  const filteredById = new Map(params.filteredDocuments.map((document) => [document.metadata.id, document]));
+  if (params.requestedMode === "semantic") {
+    const semanticHits = [...bm25Scores].map(([id, score]) => ({
+      item: filteredById.get(id).metadata,
+      score,
+      matched_fields: ["bm25"]
+    }));
+    return forceExactIdHitsToTop(semanticHits, params.keywordHits);
+  }
+  const hybridHits = combineHybridHits(filteredById, bm25Scores, params.keywordHits, params.hybridSemanticWeight, "bm25");
+  return forceExactIdHitsToTop(hybridHits, params.keywordHits);
+}
 function mergeVectorHitsById(vectorHitGroups) {
   const bestById = /* @__PURE__ */ new Map();
   for (const group of vectorHitGroups) {
@@ -1800,6 +1947,11 @@ async function runSearch(rawQuery, rawOptions, global2) {
   const vectorResolution = resolveVectorStores(settings);
   const extensionSearchProvider = resolveExtensionSearchProvider(settings);
   const extensionVectorAdapter = resolveExtensionVectorAdapter(settings);
+  const bm25Mode = resolveBuiltInBm25Mode({
+    configuredProvider: toOptionalNonEmptyString(settings.search?.provider),
+    hasEmbeddingProvider: providerResolution.active !== null,
+    hasExtensionSearchProvider: extensionSearchProvider !== null
+  });
   const queryExpansion = resolveQueryExpansionConfig(settings, providerResolution.active?.name ?? null);
   const rerank = resolveRerankConfig(settings, providerResolution.active?.model ?? toOptionalNonEmptyString(settings.search?.embedding_model) ?? "text-embedding-3-small");
   const queryExpansionProvider = resolveExtensionSearchProviderByName(queryExpansion.provider ?? void 0);
@@ -1855,7 +2007,22 @@ async function runSearch(rawQuery, rawOptions, global2) {
     applyCoverageBonus
   )).filter((entry) => entry !== null).filter((entry) => matchMode !== "and" || entry.matched_all_terms === true);
   let hits = keywordHits;
-  if (effectiveMode !== "keyword") {
+  const useBuiltInBm25 = bm25Mode !== null && effectiveMode !== "keyword";
+  if (bm25Mode !== null && effectiveMode !== "keyword") {
+    hits = computeBuiltInBm25Hits({
+      requestedMode: effectiveMode,
+      query,
+      filteredDocuments,
+      keywordHits,
+      corpusFields: resolveSearchCorpusFields(settings),
+      bm25Params: resolveBm25Params(settings),
+      hybridSemanticWeight
+    });
+    if (bm25Mode === "auto-fallback") {
+      warnings.push(`search_${effectiveMode}_offline_bm25:no_embedding_provider:using_lexical_bm25`);
+    }
+  }
+  if (effectiveMode !== "keyword" && !useBuiltInBm25) {
     const builtInSemanticWillRun = !extensionSearchProvider && providerResolution.active !== null && (vectorResolution.active !== null || extensionVectorAdapter !== null);
     if (modeWasExplicit && builtInSemanticWillRun) {
       await maybeEmitVectorIndexStaleWarning(pmRoot, filteredDocuments, warnings);
@@ -2050,14 +2217,15 @@ async function runSearch(rawQuery, rawOptions, global2) {
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+
 export {
-  _testOnlySearchCommand,
-  classifyImplicitSemanticFallbackReason,
   collectErrorCauseCodes,
-  resolveHybridSemanticWeight,
+  classifyImplicitSemanticFallbackReason,
+  _testOnlySearchCommand,
   resolveSearchMaxResults,
   resolveSearchScoreThreshold,
+  resolveHybridSemanticWeight,
   resolveSearchTuning,
   runSearch
 };
-//# sourceMappingURL=search-AZR2JITW.js.map
+//# sourceMappingURL=chunk-2PKHRP6G.js.map